Bonjour,  
 
est il possible de déclarer un pointeur qui pointerait vers cela ?
 

 
J'avais pensé à quleque chose comme const char ( *[]) [] mais ça ne marche pas...
 
Merci par avance

ou

marchera en C, mais pas

 
Ça montre l’archaïsme du C par rapport à des langages modernes. La même chose en D, avec un tableau a lignes de longueur variables:

import std.stdio, std.array, std.string;
 
int main() {
    string toto[][] = [["aa", "b", "cc"], 
                       ["coucou", "la voila"], 
                       ["coucou", "coucou", "coucou"], 
                       ["end"]];
 
    foreach (i; 0 .. toto.length) {
        foreach (j; 0 .. toto[i].length) 
            write(toto[i][j], "\t" );
        writeln();
    }
    return 0;
}

A+,

salut,
merci pour ta réponse.
Dans le cas 2 :

 
le [2] indique t-il la taille des éléments d'un tableau, où le nombre des tableaux ?
 
Merci

Le nombre de tableaux.
En C, il faut que tu renseignes tous les nombres d'éléments de tableaux afin que la taille d'une ligne (qui doit être constante) puisse être calculée à la compilation. Le nombre de lignes peut lui être déduit de l'initialisation.
Ici, le compilo va savoir calculer la taille d'une ligne: au padding près, c'est celle de deux pointeurs (sur des chars, mais ça, le compilo s'en moque un peu à ce stade).
A+,

salut,
merci pour ta réponse. Cela veut-il donc dire qu'il faut spécifier le nombre de colonnes, mais que le nombre de lignes est calculé automatiquement ?

Pourtant j'aurais cru que

se représentait comme ça :

cad que les tableaux constituent les lignes ?

Je voulais rectifier en 'le nb d'éléments d'une ligne du tableau", pour ma première phrase, mais le serveur était en maintenance à ce moment la.
Le compilo doit pouvoir calculer la taille d'une ligne (constante) puisque pour lui, un tableau est une suite de pointeurs sur des objets qui ont pour taille la taille d'une ligne. Après, que les lignes soient contiguës ou pas en mémoire, le C s'en fout un peu pour ses accès, c'est pas nécessaire (mais ça peut être utile pour une gestion efficace de ces accès à la mémoire).
Donc pour connaitre la taille d'une ligne, il faut 1) qu'il sache le nb d'elements dans une ligne (le 2 ici) et le taille d'un élément de ligne (c'est pour ça que pour un tableau multidimensionnel, il faut aussi qu'il connaisse la taille des autres tableaux. Bref tu peux avoir char *toto[][2][3] mais pas *toto[][][3] ou *toto[][2][].

oui si tu fait l'initialisation en même temps que la déclaration, sinon, il faudra le donner quand tu alloueras ton tableau.
 
char *toto[][3] = { {"aa", "b", "c"}, {"coucou", "la voila", "ici"}, };
correspond à  
{"aa"       , "b"        , "c"},
{"coucou" , "la voila", "ici"}
le 3 indique au compilo qu'il y a 3 pointeurs sur des caractères par ligne, le compilo va déduire qu'il y a deux lignes.  
Bref le compilo sait transformer ceci en  
char *toto[2][3] = { {}, };
et a partir de la il sait comment tout allouer:
Il alloue une zone mémoire de 2 cases mémoires (ie pouvant contenir une adresse mémoire) et toto va être associé à la première
Il alloue 2 zones mémoires de 3 cases mémoires et range leurs adresses dans les 2 cases précédentes,
Il alloue de la place pour "aa", "b", "c" en mémoire (non modifiable si possible) les y copie et range leurs adresses dans la première série de 3 cases précédentes.
Il alloue de la place pour "coucou", "la voila", "ici" en mémoire (non modifiable si possible) les y copie et range leurs adresses dans la seconde série de 3 cases précédentes.
[Bon après, en fait c'est optimisé, il me semble que dans certaines implémentations, il alloue d'un coup et copie "aa\0b\0c\0coucou\0la voila\0ici\0\0" en mémoire non modifiable, et il alloue d'un coup de la place pour 2+2*3 pointeurs et fait les remplissages d'adresse nécessaires]
A+,

merci beaucoup