comparer la valeur d'un pointeur

Bonjour à tous,

Me revoila encore avec mes tableaux doubles entrées...

Alors voila, j'ai un tableau de 255 lignes et 255 colonnes qui est déja rempli. j'ai deux variables int u et v et je voudrais faire une action à chaque fois que tableau[u][v] est supérieur à 10 par exemple.

Voila le code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13

int* tab_reference[255][255]; int u=0; int v=0; u=ess.val[1]; v=ess.val[2];   printf("u=%d et v=%d\n",u,v); printf("tab reference = %d\n",tab_reference[u][v]); if(*(tab_reference[u][v]) > 5) { //faire quelque chose }

---

Alors voila il ya plusieurs choses que je comprends pas : on m'a appris que lorsque l'on déclarait un pointeur avec une étoile comme ca :

Code:

---

int* tab_reference[255][255];

---

pour obtenir la valeur de mon pointeur (son contenu pas son adresse ) il fallait mettre une étoile devant, or le printf marche très bien...:?

Ensuite j'ai d'abord fais une condition :

Code:

---

if((tab_reference[u][v]) !=0)

---

et la tout marchait bien. Puis j'ai voulu la modifier et mettre :

Code:

---

if((tab_reference[u][v])>5)

---

et c'est la que les ennuis ont commencé... j'ai obtenu l'erreur

Code:

---

error C2446: '>'*: pas de conversion de 'int' en 'int *'

---

Code:

---

error C2040: '>'*: les niveaux d'indirection de 'int *' et de 'int' sont différents

---

...
C'est pour ca que j'ai mis une étoile dans le code en haut dans ma condition. Ainsi le programme compile très bien mais dès que j'execute, le programme cesse de fonctionner sans aucune explication...:cry:

J'espère avoir été assez claire... désolée pour l'édit,erreur de manip.

Merci pour vos réponses :)

Code:

---

int* tab_reference[255][255];

---

est un tableau à 2 dimensions de pointeurs sur des entiers !

Le test suivant :

Code:

---

if((tab_reference[u][v]) !=0)

---

porte sur le pointeur et non sur le contenu pointé, il est d'ailleurs équivalent à :

Code:

---

if((tab_reference[u][v]) !=NULL)

---

Quand tu écris :

Code:

---

if(*(tab_reference[u][v]) > 5)

---

tu testes le contenu pointé (= contenu à l'adresse référencée par le pointeur).

Dans le cas de ton tableau, que tu n'as pas initialisé, les pointeurs indiquent n'importe quelles valeurs(= adresses) : il devient donc risqué de regarder les valeurs présentes aux emplacements pointés. Tu vois ce que je veux dire ? :roll:

Merci pour ta réponse,

Mais si si mon tableau est initialisé (par une fonction un peu avant dans mon programme)

pour être exacte

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

int* tab_reference[255][255];   //fonction qui initialise tab_reference; int u=0; int v=0; u=ess.val[1]; v=ess.val[2];   printf("u=%d et v=%d\n",u,v); printf("tab reference = %d\n",tab_reference[u][v]); if(*(tab_reference[u][v]) > 5) { //faire quelque chose }

---

Alors ce que je ne comprends pas et ce qui m'énerve de ne pas comprendre c'est : si tab_reference[u][v] porte sur le pointeur et non le contenu pointé pourquoi

Code:

---

printf("tab reference = %d\n",tab_reference[u][v]);

---

me renvoie bien les valeurs que je veux, c'est à dire les valeurs que j'ai initialement mis dans mon tableau???(en fait j'ai fais ce printf pour voir si j'avais bien initialisé mon tableau...)

Merci en tout cas

Tu as mis le même bout de code que tout à l'heure qui ne contient aucune initialisation.
Après tu as initialisé ton tableau en fixant les valeurs de tab_reference[u][v] directement à des entiers, c'est qu'il faut vraiment que tu ailles revoir tes cours.

En effet :

Code:

---

printf("tab reference = %d\n",tab_reference[u][v]);

---

permet d'afficher les adresses des variables pointées (= contenu du pointeur) et non leur contenu ...

Citation:

---

Envoyé par suzan_

Alors ce que je ne comprends pas et ce qui m'énerve de ne pas comprendre c'est : si tab_reference[u][v] porte sur le pointeur et non le contenu pointé pourquoi

Code:

---

printf("tab reference = %d\n",tab_reference[u][v]);

---

me renvoie bien les valeurs que je veux, c'est à dire les valeurs que j'ai initialement mis dans mon tableau???(en fait j'ai fais ce printf pour voir si j'avais bien initialisé mon tableau...) Merci en tout cas

---

Parce que, syntaxiquement, printf() ne peut pas savoir à l'avance si le paramètre que tu lui passes correspond bien au jeton que tu as placé dans ta chaîne de formatage. Ceci ne concerne que la bibliothèque C à l'exécution et même là, on est obligé de faire confiance à l'utilisateur. Certains compilateurs « intelligents » incluent des contrôles spéciaux sur les fonctions standard les plus connues et sont à même de générer des avertissements quand même mais il ne faut pas compter dessus.

D'autre part, tu as probablement rempli ton tableau de pointeurs avec des entiers. Étant donné qu'une adresse mémoire est en elle-même un nombre entier et qu'elle a généralement le même format. Il est très facile de transtyper un nombre entier en pointeur en mémoire. Cela revient simplement à dire au compilo « le nombre 123456 est une adresse mémoire, celle de ma variable xxxx ». Et comme le type de chaque côté de l'affectation « = » est connu, le transtypage devait être implicite.

Le compilateur t'a donc fait confiance et considéré l'opération comme légale, mais il n'en reste pas moins qu'officiellement, ce sont des pointeurs qu'il te sert et pas des nombres entiers. Tant que tu peux les convertir ou que tu utilises des opérations qui sont applicables aux deux, pas de problème. Dès que tu commences à faire des calculs, évidement, les problèmes vont surgir.

Citation:

---

Envoyé par TheGzD

Tu as mis le même bout de code que tout à l'heure qui ne contient aucune initialisation.
Après tu as initialisé ton tableau en fixant les valeurs de tab_reference[u][v] directement à des entiers, c'est qu'il faut vraiment que tu ailles revoir tes cours.

---

désolé, mais le code est bien différent ^^. j'avais rajouté un petit commentaire pour dire ://ici j'ai une initialisation de mon tableau. je veux bien mettre la fonction qui fais ça même si je pense que ça n'a pas d'importance...

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

int* tab_reference[255][255];   //fonction qui initialise tab_reference; reference_matrix("myfile.txt");   int u=0; int v=0; u=ess.val[1]; v=ess.val[2];   printf("u=%d et v=%d\n",u,v); printf("tab reference = %d\n",tab_reference[u][v]); if(*(tab_reference[u][v]) > 5) { //faire quelque chose }

---

et la fonction d'initialisation :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void reference_matrix(const char* filename) { int i=0; int j=0; FILE* file=NULL; file =fopen(filename,"r"); if(file != NULL){ for (i=0 ;i<255;i++){ for(j=0;j<255;j++){ fscanf(file,"%d ",&tab_reference[i][j]); } } fclose(file); }   }

---

tab_reference est une variable globale, définie en dehors du main.

Citation:

---

En effet :

Code:

---

1 2	printf("tab reference = %d\n",tab_reference[u][v]);

---

permet d'afficher les adresses des variables pointées (= contenu du pointeur) et non leur contenu ...

---

d'accord donc je suis censé mettre :

Code:

---

1 2	printf("tab reference = %d\n",*tab_reference[u][v]);

---

le problème c'est qu'avec l'étoile le programme ne se lance plus, il me dit à arrêter de fonctionner...
Donc je suis d'accord : pour acceder à la valeur contenu dans mon tab_reference je devrai en théorie faire *tab_reference[u][v] mais pourquoi le programme ne se lance pas??? :cry:
Est-ce qu'il y a une erreur dans l'initialisation??

Merci de m'aider :ccool: (et désolé pour la pause déjeuner!!)

Citation:

---

Est-ce qu'il y a une erreur dans l'initialisation??

---

le problème est celui que l'on t'as énoncé précédemment : tu initialises les pointeurs avec un int au lieu de l'adresse d'un int !

Citation:

---

Envoyé par TheGzD

le problème est celui que l'on t'as énoncé précédemment : tu initialises les pointeurs avec un int au lieu de l'adresse d'un int !

---

Tu veux dire dans cette ligne la?? :

Code:

---

1 2	fscanf(file,"%d ",&tab_reference[i][j]);

---

comment je suis censée mettre l'adresse du int fscanf? fscanf va lire un int et le mettre dans le tableau. Je devrais faire un truc comme ça ? :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

void reference_matrix(const char* filename) { int i=0; int j=0; int * buffer=NULL; FILE* file=NULL; file =fopen(filename,"r"); if(file != NULL){ for (i=0 ;i<255;i++){ for(j=0;j<255;j++){ fscanf(file,"%d ",&buffer); tab_reference[i][j]=buffer; } } fclose(file); }   }

---

EDIT : j'ai toujours l'erreur, le programme cesse de fonctionner...

Ce que tu as fait pour tenter de corriger est strictement équivalent à ce que tu avais avant. :aie:
Il te faut plutôt quelque chose du genre :

Code:

---

1 2	tab_reference[i][j] = (int *)malloc(sizeof(int)); //j'alloue un int dont je stocke l'adresse dans tab_reference[i][j] fscanf(file,"%d ",tab_reference[i][j]); //j'utilise l'adresse du int précédemment alloué pour y stocker la valeur lue

---

Il te faudra bien évident faire autant d'appel à free qu'il y aura eu à malloc pour ne pas te retrouver avec des fuites mémoire.

Citation:

---

il faut vraiment que tu ailles revoir tes cours

---

:aie:

Code:

---

int* tab_reference[255][255];

---

Ce tableau est un tableau de pointeurs sur des entiers.
Chaque case est donc censé contenir une adresse et non pas un entier.
Et il faut que ces adresses soit valide c'est a dire qu'elle pointe sur un emplacement mémoire réservé pour un entier.

Citation:

---

Envoyé par TheGzD

Ce que tu as fait pour tenter de corriger est strictement équivalent à ce que tu avais avant. :aie:
Il te faut plutôt quelque chose du genre :

Code:

---

1 2	tab_reference[i][j] = (int *)malloc(sizeof(int)); //j'alloue un int dont je stocke l'adresse dans tab_reference[i][j] fscanf(file,"%d ",tab_reference[i][j]); //j'utilise l'adresse du int précédemment alloué pour y stocker la valeur lue

---

Il te faudra bien évident faire autant d'appel à free qu'il y aura eu à malloc pour ne pas te retrouver avec des fuites mémoire.

---

D'accord je vais essayer.
Petite question : pourrais -je éviter l'utilisation des malloc si je déclare mon tableau sans pointeur :

Code:

---

int tab_reference[255][255]

---

du coup à l'initialisation je le remplis d'entier en faisant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16

void reference_matrix(const char* filename) { int i=0; int j=0; FILE* file=NULL; file =fopen(filename,"r"); if(file != NULL){ for (i=0 ;i<255;i++){ for(j=0;j<255;j++){ fscanf(file,"%d ",&tab_reference[i][j]); } } fclose(file); }   }

---

Je vais essayer aussi.

Ah oui ! Concernant le

Citation:

---

il faut vraiment que tu ailles revoir tes cours

---

. Je n'avais pas commenté la première fois mais je trouve ça plutôt moyen de la part d'un modérateur. Je ne suis pas une experte en C et si je viens ici c'est justement car je n'ai jamais eu aucun cours et que j'apprends par moi même. Ce n'est pas mon domaine d'expertise loin de la, et je ne compte pas en faire mon métier. ;)

Merci en tout cas :)

Super ça marche! (la méthode avec les malloc pas la mienne...:?)

Merci encore :ccool:

Citation:

---

Petite question : pourrais -je éviter l'utilisation des malloc si je déclare mon tableau sans pointeur :

Code:

---

int tab_reference[255][255]

---

---

oui, mais pourquoi avoir utilisé des pointeurs initialement ? En effet l'exemple que tu nous fournis utilise les pointeurs dans un but pédagogique : ils rendent le code plus difficile, moins performant et le programme sera plus gourmand en RAM ... mais au moins tu es sensé avoir compris à quoi ils servent et comment les utiliser ...

Citation:

---

Je n'avais pas commenté la première fois mais je trouve ça plutôt moyen de la part d'un modérateur. Je ne suis pas une experte en C et si je viens ici c'est justement car je n'ai jamais eu aucun cours et que j'apprends par moi même.

---

oui, mais non! Si quelqu'un a pris la peine de faire des tutos c'est aussi pour qu'ils soient utilisés. A ce titre petit rappel : Règle 4.8

Aller au moins jeter un œil aux tutos ou à la FAQ t'éviteras peut-être de poster un copier-coller que tu ne comprends pas ... et qui au final ne t'as rien apporté (hormis peut-être la fait qu'on t'as fait le boulot)

Oui j'entends bien mais alors à quoi bon faire un sous-forum débutant si toutes les questions qui sont posées peuvent être résolu en lisant les tutos?? ^^

Désolé j'aime bien me défendre...

Cependant j'ai bien compris ta solution, et tu as raison j'ai essayé en déclarant mon tableau sans pointeur et ça marche aussi...
C'est juste que je pense comme tout débutant, je suis moyen à l'aise avec les malloc...C'est le genre de truc que j'ai lu 10 fois, compris 10 fois et oublié 10 fois ...

Merci en tout cas ;)

en faite le probleme n'est pas au niveau de malloc mais plutot de la comprehension de ce qui se passe avec les pointeurs.
dans ton cas l'utilisation d'un pointeur n'a qu'une utilite, PEDAGOGIE, sinon c'est meme une plaie pour ton programme.
Mais ne t'enfais pas avec certain type de programme tu t'habitueras tres vite et comprendras au fur et a messure.
Pour le modo, il parle il parle mais si vraiment ta question meritait pas reponse il aurait ete le premier a te sortir une reponse tres coute et tres enervante

Citation:

---

lire la FAQ ou Google est ton ami

---

remarque qu'il repond d'abort et te taquine ensuite, ne le prend pas mal.

tu dis ne pas vouloir faire un metier du C et tu as appris tout seul c'est bien donc ca me donne envie de t'aider. pourquoi avec ton pointeur sans malloc ca marche pas?
vois la chose comme suit:

Code:

---

1 2 3

int *p; *p=10; printf("%d\n",*p);

---

ok p est declare pointeur, puis tu luis donne une valeur. ce code compile et "marche" mais c'est pas sur qu'il marche partout et meme pas sure qu'il marche 10fois consecutivement sur la meme machine. en faite il peut marcher pendant 10ans et puis un beau jours il plante. parceque P est un pointeur qui a une adresse, et a sa declaration il pointe vers quelques part de totalement alleatoire, donc tu assignes une valeur dans ce quelque part puis tu consultes ce quelque part.
si par hasard ce quelque part est un endroit bien (chose souvent possible) ton programme marche apres le premier essaies et tu ris de joie mais la prochaine fois il se peut que se quelque part soit sal donc tu as segfault ou autre erreur a l'execusion. c'est pour cela que malloc est necessaire pour que le system donne une adresse propre a P.
quand tu fait:

Code:

---

1 2	int a=10; int *P = &a;

---

tu n'as pas fait de malloc mais c'est propre car P pointe vers une adresse propre car 10 est place dans 'a' a l'adresse &a par le systeme au demarrage de ton programme. donc P pointe vers un lieu sur.
je sais pas si mon explication te conviens.

Si Merci énormément lilington :D.
En fait ça m'est arrivé plusieurs fois d'avoir fais un executable qui marche et j'éteins mon ordi je reviens l'aprem et plus rien ne marchais!! Je croyais être maudite ou qu'un mauvais lutin de l'ordinateur m'en voulait :mouarf:!

Maintenant j'ai vraiment saisi l'importance de ce truc!! Je ferai attention à l'avenir . Mais petite question : pourquoi si ça engendrera forcément des erreurs dans le futur, le compilateur ne l'interdit pas ? diantre!!!

Citation:

---

Mais petite question : pourquoi si ça engendrera forcément des erreurs dans le futur, le compilateur ne l'interdit pas ? diantre!!!

---

Parce que c'est syntaxiquement correct. En langage C, le compilateur suppose toujours que le programmeur sait ce qu'il fait. Un compilateur bien réglé devrait néanmoins émettre un avertissement (warning) à la compilation, et avec des réglages strictes il peut même générer une erreur à la place de certains warnings. Une raison que pourrait se faire le compilateur dans le cas du déréférencement du pointeur non initialisé par exemple est que tu l'as peut-être déjà initialisé sans qu'il le sache. Considèrons le code suivant par exemple :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18

#include <stdio.h> #include <stdlib.h>   int main() { int *ptr; int *tmp;   printf("Avant malloc, ptr = %p\n", ptr); (&tmp)[1] = malloc(sizeof(int *)); printf("Apres malloc, ptr = %p\n", ptr);   *ptr = 10; printf("Valeur a l'adresse %p : %d\n", ptr, *ptr); free(ptr);   return 0; }

---

Comme tu peux le voir, ptr "n'a jamais été initialisé". Pourtant si ! Exécuté sur un PC, ce code initialise parfaitement ptr avec le malloc ! Tu peux le tester. Mais évidemment, c'est très obscur. Personne ne coderait réellement ainsi. Tout ce que je veux te dire, c'est que le C permet tellement de choses que le compilateur ne doit rien refuser de la part du programmeur du moment que ce qu'il écrit est syntaxiquement correct.

bien dit