Variable globale locale erreur ?

Version imprimable

Bonjour,

Pourriez-vous me dire pourquoi ce code focntionne :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
int main()
 
{
 
char toto[50][50];
 
void *tc = &toto;
char **tutu = tc;
 
strcpy((tutu[0]), "Test");
 
return 0;
 
}

Alors que ce code plante :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
char toto[50][50];
 
int main()
 
{
 
void *tc = &toto;
char **tutu = tc;
 
strcpy((tutu[0]), "Test");
 
return 0;
 
}

Je vous remercie.

25/04/2012, 23h39
kwariz

Salut,

donne plus de précision ... environnement, compilo, option de compilation ...

Si ça peut te rassurer les deux codes segfaultent chez moi.
26/04/2012, 00h45
Obsidian

Bonjour,

Les deux sont incorrects, mais l'un des deux doit « tomber en marche », comme on dit.

Un tableau à deux dimensions n'est pas un tableau de pointeurs, et un tableau unidimensionnel n'est pas doté non plus d'un pointeur additionnel en mémoire. Lorsque tu écris « char toto [50][50] », sachant qu'un char mesure un byte par définition et qu'un byte correspond pratiquement toujours à un octet sur les machines courantes, tu alloues exactement 2500 octets contigus en mémoire. Pas un de plus, pas un de moins.

Ce sont les expressions qui se réfèrent aux différentes entrées du tableau qui sont résolues en l'adresse de l'entrée sélectionnée par les deux index, soit à l'exécution, soit directement par le compilateur.

Seulement, si tu castes cela en « char ** », tu transtypes cette adresse en pointeur sur un pointeur sur un char. En faisant tutu[0], tu déréférences tutu et le compilateur s'attend à trouver derrière… un autre pointeur qui, lui, est censé contenir l'adresse de ton buffer. Et bien sûr, ce n'est pas le cas : tutu[0] pointe le début de ton tableau, dont le contenu est indéterminé.

L'expression est donc valide mais le résultat que tu obtiens n'a aucun sens, et ton pointeur pointe n'importe où.

Maintenant, pour pousser le diagnostic encore un peu plus loin, l'un de tes tableaux est déclaré dans la pile, l'autre dans le tas. Ceci suffit déjà à faire varier les effets de bords, mais le plus probable est que le code qui fonctionne est celui dont le tableau est déclaré en local à l'intérieur de ta fonction et qui disparaîtra donc avec elle : le compilateur doit faire des optimisations en se rendant compte que tu ne lis jamais ton tableau avant la fin de ta fonction et qu'il est inutile de le remplir. Donc, le bug n'aura pas lieu. En revanche, il ne peut faire la même hypothèse avec un tableau en variable globale, d'autant que celle-ci peut éventuellement être lue par un code extérieur à ton module. Il est donc obligé d'honorer le contenu de ta fonction et le plantage se produit.
26/04/2012, 06h50
bpy1401

Bonjour

Obsidian à raison, ton code est faux. Dans le premier cas tu va planter car tu jardinne dans la pile. Dans le deuxième cas, tu jardinne dans la mémoire dite globale. Comme ta pile sert aussi à sauvegarder des valeurs de registre et adresse de retour, tu casse toutes ces informations, et donc plantage. En globale, tu risque uniquement de détruire tes données.
26/04/2012, 09h45
diogene
Pour poursuivre l'explication d'Obsidian, quelle est la différence que fait le C entre écrire
Code:

1 2 3 strcpy((tutu[0]), "Test"); // et strcpy((toto[0]), "Test");
avec pour mémoire
Code:

1 2 3 char toto[50][50]; void *tc = &toto; char **tutu = tc;
Même si les adresses correspondant à toto et tutu semblent les mêmes, leur type différent a des conséquences

- tutu est un pointeur, alors tutu[0] est le contenu de l'adresse tutu. En pratique, cela correspondra au contenu des premiers bytes du tableau toto interprétés comme une adresse (et comme ce n'est pas une adresse légale, on écrira n'importe où).

- Alors que toto[0] est un tableau. Alors toto[0] désigne ici l'adresse du début du tableau, et non pas le contenu du début du tableau.
26/04/2012, 09h52
Fl0r3nt

Bonjour,

Merci à vous pour ces réponses.

En réalité j'essayais d'implémenter une fonction liée à SQLITE.

J'appelle cette fonction depuis mon main :

Code:

sqlite3_exec(db, pSQL[0], callback_user2, pbla, &zErrMsg);

La 4ème variable (pbla) sera récupérée dans la fonction callback_user2 dans le pointeur void* NotUsed.

callback_user2 est une fonction :

Code:

static int callback_user(void *NotUsed, int argc, char **argv, char **azColName)

Je n'ai pas la main sur squilite3_exec pour surcharger callback_user2 car elle est définie dans une librairie.

pbla est en fait un pointeur sur un tableau a deux dimensions.

Je dois donc transtyper mon tableau

Citation:

char bla[50][50]

en void*.
Pour cela, j'ai pensé faire cette opération :

Citation:

void* pbla = &bla;

Par contre, une fois dans la fonction,

Citation:

pbla

est devenu

Citation:

void* NotUsed

, je ne sais plus comment utiliser mon tableau .

C'est pourquoi j'ai pensé réaliser l'opération que je vous est décrit ci-dessus.

Savez-vous comment je peux implémenter ?

Je vous remercie.
26/04/2012, 10h28
diogene
Tu veux passer comme 4ieme argument à sqlite3_exec() le tableau bla là où est attendu un void *. Il suffit d'avoir :

Code:

sqlite3_exec(db, pSQL[0], callback_user2, bla, &zErrMsg);

La valeur passée est alors l'adresse du début du tableau bla, de type "adresse d'un tableau de 50 char" , char (*)[50], transtypée implicitement en void*, le type de l'argument attendu.

Cette valeur est récupérée par callback_user2() dans le paramètre NotUsed de type void *. Pour utiliser ce paramètre, il faut commencer par rétablir son type exact :
Code:

1 2 char (*tab)[50] = NotUsed; // on accède aux éléments du tableau comme d'habitude par tab[i][j]
26/04/2012, 11h37
Fl0r3nt
Citation:
Envoyé par diogene

Tu veux passer comme 4ieme argument à sqlite3_exec() le tableau bla là où est attendu un void *. Il suffit d'avoir :

Code:

sqlite3_exec(db, pSQL[0], callback_user2, bla, &zErrMsg);

La valeur passée est alors l'adresse du début du tableau bla, de type "adresse d'un tableau de 50 char" , char (*)[50], transtypée implicitement en void*, le type de l'argument attendu.

Cette valeur est récupérée par callback_user2() dans le paramètre NotUsed de type void *. Pour utiliser ce paramètre, il faut commencer par rétablir son type exact :

Code:

1 2 char (*tab)[50] = NotUsed; // on accède aux éléments du tableau comme d'habitude par tab[i][j]
Le code ne semble pas fonctionner :
Code:

1 2 main.cpp: In function `int callback_user2(void*, int, char**, char**)': main.cpp:61: error: invalid conversion from `void*' to `char (*)[50]'
J'ai également essayé :

Code:

char (*tab)[50][50] = NotUsed;

merci.
26/04/2012, 12h42
diogene

Citation:

Le code ne semble pas fonctionner :

Tu compiles en C++, pas en C.
En C++, les conversions avec void* ne sont pas implicites et il faut mettre un opérateur de cast.

Citation:

J'ai également essayé :

Il ne faut pas faire des choses au hasard jusqu'à ce qu'on croit que ça marche
26/04/2012, 13h51
Fl0r3nt

Citation:

Envoyé par diogene

Tu compiles en C++, pas en C.
En C++, les conversions avec void* ne sont pas implicites et il faut mettre un opérateur de cast.

Il ne faut pas faire des choses au hasard jusqu'à ce qu'on croit que ça marche

Oui, je vois que je les cumules en fait. Mon devcpp a créé le projet SQLITE en cpp et non en c. Je n'ai pas fait attention.

Sur le principe, ce développement me permets de mettre en application, des concepts lus dans des livres de c et c++. Les bouquins pour les nuls survolent, les autres sont trop compliqués sans explications oral ou pratique.
J'essaye donc, pour voir le résultat, voir quel message j'obtiens.

En tout cas, merci. Ces explications liées à un cas pratique et compréhensible pour moi (même si je vais mettre un petit moment pour comprendre l'explication d'Obsidian) est très instructif.