Discussion :

[chris7522]

Bonjour à toutes et à tous,

D'abord le code, puis ensuite ma question.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
#include <stdio.h>
 
int main()
{
    char pres[4][2][11] = {
        "George", "Washington",
        "John", "Adams",
        "Thomas", "Jefferson",
        "James", "Monroe"
    };
    int loop;
 
    for(loop=0;loop<4;loop++)
        printf("%-6s %-10s\n",pres[loop][0],pres[loop][1]);
 
    return(0);
}

Pour l'initialisation de ce tableau, à quoi correspond le dernier nombre entre crochets [11] du tableau pres ?
Pour le printf, pres[loop][0],pres[loop][1]) se charge respectivement d'afficher quoi ?
D'avance merci de votre aide

[foetus]

Tu es sûr que ton code est valide ?

Parce que le [11] ne permet pas de faire un tableau à 3 dimensions (*), mais de dire que dans ta matrice de 4 lignes - 2 colonnes, tu vas stocker des chaînes d'au plus 11 caractères (char[11])

Et pour ta deuxième question, c'est du code ultra trivial de parcours d'une matrice : on parcourt chaque ligne (de 0 à 3) et pour chaque ligne, comme on sait qu'on n'a que 2 valeurs ([loop][0] et [loop][1]) on les affiche.



* : tu as une matrice 4 lignes - 2 colonnes, que tu as 11 fois.
En C tu peux avoir des tableaux à plusieurs dimensions , mais comme la représentation mémoire est toujours en ligne (un vecteur en somme) cela ne sert à que dalle d'utiliser des tableaux de plus de 2 dimensions (sauf si tu veux te faire un nœud au cerveau )

[Sve@r]

Bonjour

Tu es sûr que ton code est valide ?

Il ne l'est pas mais à mon grand étonnement, le compilo rattrappe le coup. Juste un warning mentionnant les accolades manquantes avec -Wall

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char pres[4][2][11] = {
	"George", "Washington",
	"John", "Adams",
	"Thomas", "Jefferson",
	"James", "Monroe"
};

Manque des accolades aux lignes

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
char pres[4][2][11] = {
	{"George", "Washington"},
	{"John", "Adams"},
	{"Thomas", "Jefferson"},
	{"James", "Monroe"},
};

Ainsi tu as bien 4 lignes, avec 2 mots par lignes et 11 caractères par mots ce qui répond ainsi à la fois à ton code et à ta première question. Accessoirement définir 11 caractères pour chaque mot alors que (semble-t-il) ces mots sont destinés à être invariants est un peu dommage. Tu définirais 4 lignes avec 2 pointeurs par lignes, pointeurs pointant vers des zones statiques contenant lesdits noms serait plus adéquat. En plus tu pourrais rajouter des pointeurs particuliers permettant de ne plus te limiter à 4

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <stdio.h>
 
int main()
{
	char *pres[][2] = {
		{"George", "Washington"},
		{"John", "Adams"},
		{"Thomas", "Jefferson"},
		{"James", "Monroe"},
		{NULL, NULL},
	};
	int loop;
 
	for(loop=0; pres[loop][0] != NULL; loop++)
		printf("%-6s %-10s\n",pres[loop][0],pres[loop][1]);
 
	return(0);
}

Ainsi, si tu rajoutes ensuite d'autres présidents, tu n'as pas à modifier ta boucle.
Par exemple, Grover Cleveland est le seul et unique président des EU a avoir 2 numéros. Il a battu Blaine en 1884 et Harrison en 1892 mais ayant été battu en 1888, il a été alors le 22° et 24° président des EU. Donc tu pourras le mettre 2 fois.

Pour le printf, pres[loop][0],pres[loop][1]) se charge respectivement d'afficher quoi ?

Ben ça affiche pres[loop][0] et pres[loop][1] comme c'est écrit

[chris7522]

Bonsoir ,

Merci a tous les deux d'avoir pris le temps de me repondre .
J'ai recompilé le code avec gcc et pas de message d'erreur pour moi , c'est curieux tout de meme !

Merci de vos explications a tous les deux , j'ai bien compris , a part une chose :

Comme vous me l'expliquez , les deux premier nombres entre crochet indique respectivement le nombre de lignes et de mots par ligne . Ca , j'ai bien compris . Mon tableau est de type char car ce sont des chaines de caracteres mais le dernier crochet [11] lui , indique le nombre maximun de caractere par mot . C'est un entier , il ne devrai pas etre ailleurs du coup ?

[foetus]

Mon tableau est de type char car ce sont des chaines de caracteres mais le dernier crochet [11] lui , indique le nombre maximun de caractere par mot . C'est un entier , il ne devrai pas etre ailleurs du coup ?

Non tu te trompes, ton tableau est de type char*

Pour déclarer une variable X de type "chaîne de caractères de 11 caractères", c'est comme cela char X[12]; (<- Note le +1 pour le caractère final '\0')
C'est pour cela que je suis assez impressionné que le compilateur ait compris que le 11 est la taille des chaînes et non pas une 3^ième dimension, parce que pour moi le stockage risque d'être différent (<- mais à vérifier)

Après, il faut lire tes cours, ta documentation mais :

• Le type string n'existe pas en C, et c'est souvent une critique/ une difficulté pour les débutants. C'est un tableau/ pointeur. Et en plus, c'est juste de l'ASCII
• Lorsque tu codes char X[11] = "Bonjour"; (<- une chaîne de caractères statique que tu ne peux ni modifier ni étendre), la longueur (11) n'a pas besoin d'être spécifiée (donc char X[] = "Bonjour";) parce que le compilateur la calcule et la met à ta place. Donc pas de risque d'erreurs. Et en plus le compilateur ajoute automatiquement le caractère final '\0'.
• La taille n'est utilisée que par les fonctions dans le même fichier source (peut être unité de compilation avec les include), mais rapidement le compilateur dégrade ta chaîne de caractères en pointeur. C'est pour cela qu'à chaque fois, la taille doit être fournie avec une chaîne de caractères et c'est quasi obligatoire (ou alors on va passer son temps à parcourir sa chaîne jusqu'à la sentinelle '\0' pour les calculs (ou bien appeler la fonction strlen (<- lien cplusplus en anglais)))

[Sve@r]

Mon tableau est de type char

Non, il est de type char [][][] et ce n'est pas la même chose. On peut (pour essayer de schématiser le truc) dire que "pres" est l'adresse de l'adresse de l'adresse d'un char autrement dit un "char ***" mais c'est vraiment pour faire une analogie très simplifiée car un tableau ce n'est pas un pointeur et si on peut représenter un tableau avec un pointeur, c'est seulement vrai pour les tableaux 1D.

car ce sont des chaines de caracteres

Non. Ce sont des tableaux de caractères. Le type "chaine" n'existe pas en C. C'est vrai que les habitués du C peuvent parler parfois de "chaine" mais c'est un abus de langage utilisé pour aller plus vite et qui doit être alors mentalement corrigé quand on veut convertir les paroles en code.

mais le dernier crochet [11] lui , indique le nombre maximun de caractere par mot

Non. Il indique le nombre de caractères exact de chaque mot. Parce que même "John" a été stocké dans un char[11]. D'où ma remarque sur le fait que c'était un peu dommage.

C'est un entier , il ne devrai pas etre ailleurs du coup ?

Parce que "4" et "2" ne sont pas des entiers ???

[chris7522]

Ok bien compris ! Pas toujours évident pour un débutant de comprendre tout ca , l' apprentissage suis son cours , doucement mais surement .
Encore merci de votre aide
Bon week-end a tous (sans trop d'excès)

[foetus]

C'est pour cela que je suis assez impressionné que le compilateur ait compris que le 11 est la taille des chaînes et non pas une 3^ième dimension, parce que pour moi le stockage risque d'être différent (<- mais à vérifier)

Je me suis trompé. C'est sûrement parce que je n'utilise pas de tableaux de dimension de plus de 2. Et aussi parce que je pense à la représentation mathématiques.

(Un coup de Google plus tard) en C, les crochets se lisent/ s'interprétent de gauche à droite.

*) XXX tab[5][7] veut dire qu'on veut 5 ensembles contenant chacun 7 éléments de type XXX.
*) XXX tab[4][8][9] veut dire qu'on veut 4 ensembles contenant chacun 8 ensembles, ces derniers contenant chacun 9 éléments de type XXX

Donc char pres[4][2][11] est bien, 4 ensembles contenant chacun un couple (2 ensembles), ces derniers contenant des chaînes de 10 caractères (+ 1 avec le caractère final '\0')

Et ton oubli des accolades dans ta définition ne dérange pas le compilateur parce que je pense qu'il fait un truc ultra trivial :
1) Il crée un stockage contigu de la taile qui est la multiplication de toutes les tailles (fournies ou calculées). Dans ton code, taille = 4*2*11 octets
2) Il prend les éléments 1 par 1 et il les place les 1 à la suite des autres.

un tableau ce n'est pas un pointeur et si on peut représenter un tableau avec un pointeur, c'est seulement vrai pour les tableaux 1D.

Si un tableau c'est un pointeur avec un offset.
La grosse différence, c'est qu'on peut créer un pointeur avec un type incomplet contrairement à un tableau.

Si tu as XXX array[dim_0][dim_1]...[dim_n] alors la valeur située à la case array[val_0][val_1]...[val_n] correspond à *(array + offset).
Avec offset = [somme pour X allant de 0 à n-1, de val_X*dim_(X + 1) * ... * dim_n)]+ val_n (<- si je ne me trompe pas)

Avec ton tableau pres[A][B][ C ] correspond à *(pres + A * 2 * 11 + B * 2 + C).

Mais ne te prends pas la tête tu peux coder ceci (en mode délire) :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
#include <stdio.h>
 
#define STR_MAX_LEN 11
#define STR_NUMBER   3
 
/* do not forget final %c */
char* g_STR_FORMAT[STR_NUMBER] = {"%-6s%c", "%-20s%c", "%-2s%c"};
 
 
int main (int argc, char** argv)
{
    char* str;
    size_t count;
 
    char tab[][STR_NUMBER][STR_MAX_LEN] = {
        {"George", "Washington", "1"},
        {"John",   "Adams",      "2"},
        {"Thomas", "Jefferson",  "3"},
        {"James",  "Monroe",     "5"},
        {"Grover", "Cleveland",  "2X"},
        {"\0", "\0", "\0"}
    };
 
    str = tab[0][0];
    count = 0;
 
    for(;*(str) != '\0'; str+=STR_MAX_LEN) {
        if (count < (STR_NUMBER - 1)) {
            printf(g_STR_FORMAT[count], str, ' ');
            ++count;
        } else {
            count = 0; /* update count in first */
            printf(g_STR_FORMAT[count], str, '\n');
        }
    }
 
    return 0;
}

[Sve@r]

Pas toujours évident pour un débutant de comprendre tout ca

Ben le souci c'est que tu t'attaques direct à un tableau 3D. Déjà même au naturel c'est assez rare de manipuler des trucs rangés en cube (et au delà). Par exemple ici, ton truc moi je l'aurais mis dans un tableau de structures (je sais pas si tu connais mais grosso-modo ça te permet d'associer ensemble des trucs hétérogènes comme par exemple un nom et un age) ce qui aurait transformé ce tableau 3D en tableau 1D. Or le tableau 1D c'est super intéressant car ça calque la mémoire (qui n'est qu'une grande suite de cases 1D).

Et ton oubli des accolades dans ta définition ne dérange pas le compilateur parce que je pense qu'il fait un truc ultra trivial :
1) Il crée un stockage contigu de la taile qui est la multiplication de toutes les tailles (fournies ou calculées). Dans ton code, taille = 4*2*11 octets
2) Il prend les éléments 1 par 1 et il les place les 1 à la suite des autres.

Oui t'as raison. Je viens d'essayer ceci (et avant que tout le monde se mette à rire, je tiens à préciser que j'ai pas bêtement tapé les nombres mais les ai générés avec un coup de seq 120 )

Code c :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
int main() {
	int x[2][3][4][5]={1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 118, 119, 120};
 
	return(0);
}

et ça ne l'a même pas inquiété ce con là !!! A se demander pourquoi on se casse le luc depuis des années à bien ranger ses éléments dans des accolades imbriquées

Mais ne te prends pas la tête

dit-il juste avant de nous montrer un code où on se prend la tête grave !!!

tu peux coder ceci (en mode délire)

Ouaip. C'est ça !!! Surtout que le "%c" dans char* g_STR_FORMAT[] = {"%-6s%c", "%-20s%c", "%-2s%c"} est quand-même bel et bien inutile si tu rajoutes des fputc() adéquats directement dans la boucle. Et tu remarqueras aussi qu'il est inutile de préciser le nb d'éléments dans ce tableau 1D

Et c'est dommage ces "for" sans initialisation. Là où je t'ai vu faire preuve d'élégance dans le cast des deux opérandes d'une division, ce "for" qui commence par un bête point-virgule me parait plutôt bancal. Alors qu'un for(str=tab[0][0]; *str != '\0'; str+=STR_MAX_LEN) eut été tellement plus harmonieux...

[chris7522]

Une derniere question de bon gros debutant : quel difference entre char , char* , char** ?

[gerald3d]

Bonjour.

• char : variable de type entier pouvant aller de -127 à +128
• char* : pointeur d'adresse sur une variable de type char
• char ** : pointeur d'adresse sur l'adresse d'une variable de type char

[Sve@r]

quel difference entre char , char* , char** ?

Autant qu'entre "int", "float" ou "double". Même si leurs noms semblent en partie identiques, ce sont tous des types entièrement différents et tu ne dois jamais confondre l'un avec l'autre sous peine de ne jamais réussir un seul programme de ta vie.

Le char c'est le caractère. Un nombre compris entre 0 et 255 et qui, s'il est affiché avec le bon format, donnera un caractère au final. Mais sa qualité de nombre permet d'y effectuer des opérations. Ainsi tu as parfaitement le droit d'écrire 'a' + 1 qui est équivalent à 97 + 1. Toutefois la première écriture est plus explicite car elle s'adapetera à l'évolution du codage (si demain 'a' ne vaut plus 97 mais autre chose dans un autre codage, le compilateur adaptera ton programme automatiquement).
Accessoirement '5' - '0' donne 5 (parce que dans la plage ascii, le caractère '5' est à 5 rangs du '0') ce qui est un bon truc pour convertir un caractère représentant un chiffre dans ledit chiffre et on peut raisonnablement supposer que quelle que soit l'évolution du codage, les grands penseurs qui y travaillent ne seront jamais assez cons pour changer cet état de fait sinon le bug de l'an 2000 sera du pipi de chat en comparaison

Le char étoile représente une adresse mémoire. C'est à dire un nombre et à l'endroit de la mémoire représentée par ce nombre, il y a un char. Si tu imagines la mémoire comme une grosse suite de cases (ce qui est d'ailleurs le cas), tu as par exemple la case d'adresse 1000 qui contient le caractère 'a' ben avec un char étoile tu as une seconde case d'adresse (par exemple 2000) qui contient 1000.
Tu remaqueras que ça reste toutefois un nombre. Donc tu pourrais te dire "c'est idiot, je peux parfaitement ranger ce 1000 dans un int" et tu n'aurais pas tort. Toutefois, si tu fais ça, tu n'auras aucun moyen de distinguer la case "1000" de la case "1001" ou "999". En effet, les typages C peuvent être sur plusieurs cases (float=4 cases, double=8 cases etc).
Donc imagine la situation suivante: tu écris double d=3.1416. Ce "3.1416" s'étalera en binaire de la case (par exemple) 1000 jusqu'à 1007. Mais "d" est juste associé à "1000". Et si tu écris ensuite int adr=1000 le compilo ne saura pas que ce "1000" va avec les autres cases jusqu'à 1007.
Donc pour que le compilo puisse s'en sortir, il faut lui dire "l'adresse 1000 représente un double" ce qu'on fait dans l'écriture double *adr=1000. On donne ainsi deux indications

• "adr" est une adresse qui contient le nombre 1000
• à cette adresse 1000, il faudra chercher un double donc 8 octets donc regrouper les cases 1000 à 1007 ensembles pour pouvoir récupérer 3.1416 dans son intégralité

=> ce qui se résume en "adr est l'adresse d'un double" => "adr est un double étoile". Et puisque "1000" c'est l'adresse de "d", on peut alors condenser en double *adr=&d.
Et tout ça vaut bien entendu aussi pour les int, les float ou les char dans leur codage équivalent.

Le char étoile étoile (tu remarqueras que je précise bien le mot "étoile" autant de fois qu'il le faut) n'est qu'une indirection de plus. C'est une adresse qui contient une adresse qui contient un char. Mais bien entendu, même si intrinsèquement tout ça reste du nombre, le char étoile étoile n'est pas équivalent au char étoile.
Ainsi je peux étendre l'exemple précédent avec double **adr2=&adr ce qui signifiera

• "adr2" est une adresse qui contient le nombre 2000
• à cette adresse 2000, il faudra chercher une autre adresse (donc un nombre entier donc 4 octets) donc regrouper les cases 2000 à 2003 ensembles pour récupérer le nombre "1000" et le traiter comme l'adresse d'un double
• à cette adresse 1000, il faudra chercher un double donc 8 octets donc regrouper les cases 1000 à 1007 ensembles pour pouvoir récupérer 3.1416 dans son intégralité

Une derniere question de bon gros debutant :

Effectivement, cette question termine ton état de débutant et devient la toute première de ton entrée dans le vrai monde du C...

[chris7522]

Merci beaucoup , c'est vraiment très sympa de m'expliquer tout ca ! Il va me falloir plusieurs lecture pour digérer tes explications . Je pense qu' un gars qui code ne peut pas etre complètement mauvais , car dans le milieu l'entraide est réel ! :