Le type de l'expression *(ptrInt+sizeof(int)*x) est int. Le type de l'expression NULL est un type pointeur. Comparer ces deux expressions est le problème signalé par le compilateur.
Je vois plusieurs problèmes. D'abord, puisque ptrInt est de type pointeur de int, il n'y a guère de sens à ajouter un décalage multiplié par sizeof(int). Ensuite, la notation *(pointeur + décalage) est peu lisible, on préfère pointeur[décalage]. Enfin, puisque l'on a un tableau de int, on s'attend éventuellement à y trouver 0, pas NULL.
En conclusion, while (ptrInt[x] != 0) est plus correct, pour autant que le reste du code est aussi correct (je n'ai pas tout vérifié, je te laisse voir).
Comme l'indique Marc Mongenet, pas besoin de multiplier le décalage par sizeof(int). Cela s'applique également ligne 32: pas ptrInt+sizeof(int), mais bien ptrInt+1
- Edité par edgarjacobs 1 août 2021 à 0:43:54
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Vous avez bien raison ici @MarcMongenet & @edgarjacobs :
ptrInt[x]
ptrInt+x
Mais... l'output pour ptrInt[x] != NULL n'est pas le même que l'output pour *(ptrInt+sizeof(int)*x) != NULL Il ne s'agit donc pas d'un équivalent parfait.
Du coup vous n'avez pas raison ici @MarcMongenet :
Il est possible que mon code soit le bon mais qu'il ne corresponde pas a une utilisation habituel ou "classique" du langage ce qui expliquerai que mon IDE le relève. Un avertissement a ne pas prendre en compte ?
t#Étrange, tu testes si c'est différent de un et tu affiches un avant la série de zéros. Est-ce que tu affiches ce que tu testes? Où veux-tu vraiment arrêter? Peut-être qu'il faut changer le test: while(ptrInt[x] >= 1)
Le Tout est souvent plus grand que la somme de ses parties.
Dans l'absolue je veux arréter aux valeurs non initialisé... (mon code fonctionne, je me demandais juste en quoi il n'était pas conventionnel, puisqu'il sort un avertissement)
Dans les fait après la valeur 1.
A première vu aucun test sous la forme ptrInt[x] n'est concluant.
Et d'ailleurs les forme ptrInt[x] ne donne pas les même ouput que les formes ptrInt+x
ptrInt+x n'est pas une valeur mais l'adresse de cette valeur. Essaies *(ptrInt+x) Et tester par rapport à ce qui "n'a pas été initialisé" n'est pas une bonne idée. Même si la plupart du temps, le système place 0 dans les positions non initialisées, il ne faut pas s'y fier. Si tu as bien la valeur 1 dans le tableau, tu es censé la trouver. Et je te repose la question, est-ce que tu affiches ce que tu testes? while(*(ptrInt+x) > 0) { printf("%d\n", *(ptrInt+x)); }
Le Tout est souvent plus grand que la somme de ses parties.
En C, si p est un pointeur et n un entier alors en octets : p+n = adresse de p + (n fois la taille de ce qui est pointé par p en octets). C'est de l'arithmétique de pointeur de base ! Il va falloir revoir ces notions.
De plus la notation p[n] est un sucre syntaxique pour *(p+n) ; ce qui signifie aussi que l'on peut tout aussi bien écrire n[p] pour avoir le même résultat.
Ensuite je ne comprends pas pourquoi tu fais inutilement compliqué dans ton code. Il te faut une fonction qui te calcule le suivant de la séquence, une autre qui l'utilise et remplit la zone de mémoire partagée … et qui vérifie s'il n'y a pas d'overflow !
Lol... sa te remet trop de notion en cause, c'est toi qui halètes
Test le code avec p+n p[n] et *(p+sizeof(int)*n) il n'y a aucune correlation dans l'output entre les 3.
Après je ne sais pas pour quoi je fais si compliqué... Qu'est-ce qui te parait compliqué ? Je test la mémoire partagé POSIX. Simplifie le code montre moi. La consigne de l'exercice c'est le processus1 calcul la série et processus2 imprime la série, utiliser la mémoire partager norme POSIX pour transmettre les informations du processus1 au processus2.
Je te suggère de lire atentivement ce qui suit sur l'arithmétique des pointeurs: http://public.iutenligne.net/informatique/algorithme-et-programmation/priou/LangageC/132_arithmtique_des_pointeurs.html Tu as réservé avec mmap() l'espafce pour 20 entiers (int) partagé entre le processus père et le fils. C'est le fils qui écrit dans l'espace et le père qui le lit. Jusqu'ici, pas de problème. D'abord, tu as choisi le nombre 106, ce qui donne une séquence de 13 nombres se terminant par 1. Si tu avais choisi un autre nombre, la séquence aurait pu dépasser 20 entiers. Tu aurais écrit en dehors de la zone réservée et tu aurais détruit qquelque chose. Comme on ne sait pas quoi, le comportement du programme est imprévisible, c'est ce qu'on appelle indéterminé. Quand tu écris ptrInt+sizeof(int), tu n'avances pas de 4 adresses, mais de 4 entiers, donc 16 adresses. Dans l'exemple, tu as 13 nombres, mais ils sont répartis sur 52 positions, donc en dehors de la zone réservée. Tu étais cohérent dans ton erreur, c'est pourquoi tu as cru que les nombres étaient consécutifs. collatzConjecture(n, ptrInt+sizeof(int)); Ici, tu veux avancer à la case suivante, mais tu avances de 4 cases, ce qui t'amènera rapidement trop loin. Il faut écrire: collatzConjecture(n, ptrInt+1); Tu dois faire le même genre de correction partout dans ton code. Tu pourrais définir un symbole avec #define pour donner le nombre d'entiers à réserver. Et ce nombre pourait être nettement plus grand que 20 sans problème.
Le Tout est souvent plus grand que la somme de ses parties.
Ok @PierrotLeFou. Tout ce que tu as dit est très claire.
Le programme fonctionne a présent avec la syntaxe ptrInt[x] et collatzConjecture(n, ptrInt+1);
Merci beaucoup pour cette correction. Désolé aux autres de ne pas avoir pensé a remettre en cause mon appel récursif ou de vous avoir mal lu.
- Edité par -Crixus- 2 août 2021 à 0:11:57
"Etre vrai, peu le peuvent." Friedrich Nietzsche
Comparaison between ptr and integer
× Après avoir cliqué sur "Répondre" vous serez invité à vous connecter pour que votre message soit publié.
× Attention, ce sujet est très ancien. Le déterrer n'est pas forcément approprié. Nous te conseillons de créer un nouveau sujet pour poser ta question.
"Etre vrai, peu le peuvent."
Friedrich Nietzsche
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
"Etre vrai, peu le peuvent."
Friedrich Nietzsche
Le Tout est souvent plus grand que la somme de ses parties.
"Etre vrai, peu le peuvent."
Friedrich Nietzsche
Le Tout est souvent plus grand que la somme de ses parties.
"Etre vrai, peu le peuvent."
Friedrich Nietzsche
On écrit "j'ai tort", pas "tord" qui est le verbe "tordre" à la 3ème personne de l'indicatif présent
Le Tout est souvent plus grand que la somme de ses parties.
"Etre vrai, peu le peuvent."
Friedrich Nietzsche