pointeur sur structures

1 Un pointeur n'est qu'une variable... un peu particulière
=> je dirais oui et c'est une variable qui contient l'adresse d'une autre variable.
ex:
int * toto, *tutu; // toto est un pointeur sur int
toto = &tutu; //=> toto reçoit l'adresse de tutu
*toto = 12; // tutu se voit aussi être modifié

2. La valeur d'un pointeur est en réalité l'adresse à laquelle on trouvera la variable correspondant au type du pointeur
=> oui
exemple :
oto = &tutu; //=> toto reçoit l'adresse de tutu et ils doivent aussi être du même type

3.Un pointeur n'a aucune utilité à être utilisé comme variable dans une structure
=> je peux dire faux?

vu le débat de ce matin, les pointeurs de structures illustrent bien la scène

4.Le pointeurs sont d'un grand secours, entre autres, quand il sont passés comme arguments de fonction
=> pour cause ils permettent de modifiers les objets passés en argument de la fonction
ex: si on ecris seulement la fonction bouger_x(p,q); avec la fonction
bouger_x(int x, int y){
new_x = x;
new_y = y;
}
là on ne pourra pas modofier les arguments p et q

il faut donc écrir une fonction avec des pointeurs en paramètre ou passer des arguments de pointeurs &p et &q

5. Il n'y a aucune précaution particulière à prendre avant d'utiliser un pointeur
=> si j'ai bien comprris un pointeur est une variable., donc faut l'initialiser. sinon il va pointer sur un emplacement mémoire inconnu

6.Un pointeur peut prendre l'adresse d'un objet qui survivra à la sortie d'une fonction
> je sèche => mais étant que les objets meurent à la fin d'une fonction , j'ai un doute...

7.un pointeur ne peut pas prendre l'adresse d'un objet qui survivra à la sortie d'une fonction

=> bon là je sèche ( que deviennent les objets à la fin d'une fonction? ......)

8.a taille d'un pointeur est toujours fixe et connue d'avance, quel que soit le type qu'il représente

=> faux, c le compilo qui définira la taille non?

9. l'utilisation "dynamique" d'un pointeur est souvent plus intéressante que la création d'un tableau de taille fixe
=> clair, la taille est allouée dynamiquement donc fini les définitions des tailles grotesques qd on ne connait pas la taille d'une chaine par exemple


10 l'utilisation d'un pointeur n'a strictement rien à voir avec les tableaux
=> au contraire , ils sont lié

char toto[];
et
char *toto;

sont pareil

voilà prof.... 8-)

Ben ca va encore, tu n'as que quatre erreurs:

Citation:

---

3.Un pointeur n'a aucune utilité à être utilisé comme variable dans une structure:

---

Cela dépend des structures, mais certaines d'entres elles ont absolument besoin de pointeur pour pouvoir travailler correctement:

Code:

---

1 2 3 4 5 6 7

typedef struct s_personne { char nom[25]; char prenom[20]; struct s_personne* suivante; }personne

---

te permettra de créer les personnes au fur et à mesure de tes besoins, et c'est le pointeur (qui prendra l'adresse de la personne suivante) qui te permettra de relier les personnes entre elles.

Citation:

---

5. Il n'y a aucune précaution particulière à prendre avant d'utiliser un pointeur

---

Je n'ai pas compté la réponse comme fausse, mais retiens toujours bien que, si le pointeur n'est pas initialisé sur l'adresse d'une variable valide, toute modification de ce vers quoi il pointe risque de provoquer des erreurs irrémédiables...

Si tu n'initialise pas un entier, finalement, les erreurs ne poseront problème que parce que a*4 ne donnera pas 20...

Mais si tu n'initialise pas le pointeur:

Code:

---

1 2	int *ptr; *ptr=40;

---

risque de faire énormément de dégats :P

Citation:

---

6.Un pointeur peut prendre l'adresse d'un objet qui survivra à la sortie d'une fonction
et
7.un pointeur ne peut pas prendre l'adresse d'un objet qui survivra à la sortie d'une fonction:

---

En fait, il y a des variables qui peuvent survivre à la sortie de la fonction dans laquelle elles sont déclarées. Ce sont des variables déclarées "dynamiquement" (avec les instructions *alloc). Elle survivent jusqu'à ce que tu décide explicitement de les détruire avec free... Et un pointeur est juste ce qu'il faut pour en garder une trace ;)

Citation:

---

8.a taille d'un pointeur est toujours fixe et connue d'avance, quel que soit le type qu'il représente:

---

Meme si c'est une question qui se résoud entre le compilateur et l'architecture du processeur, la taille d'un pointeur sera toujours fixe, sur une architecture et un compilateur donné.

En effet, un pointeur aura toujours une taille suffisante pour représenter n'importe quelle adresse mémoire (du moins si tu ne travaille pas avec un compilateur "antédiluvien":P

Le type de la variable pointé n'aura strictement aucune incidence sur cette taille, ainsi que le montre le code suivant:

Code:

---

1 2 3 4 5 6 7 8

#include<stdio.h>   int main() { printf("la taille d'un char* est de %d\n",sizeof(char*)); printf("la taille d'un int* est de %d\n",sizeof(int*)); return 0; }

---

Citation:

---

Envoyé par koala01

Allez, un petit "quiz" vite fait (il s'adresse principalement à Seimaya, les autres auront j'espère la gentillesse de lui laisser le temps de répondre ;):D)

---

Je peux répondre? :mrgreen:

Citation:

---

Parmi ces différentes affirmations, lesquelles sont vraies, et lesquelles sont fausses :question: (si en plus, tu peux justifier, ne te prive pas ;))[*]Un pointeur n'est qu'une variable... un peu particulière

---

Faux. Est-ce qu'on dirait qu'un int n'est qu'une variable? pointeur désigne d'abord et avant tout une famille de type. Ensuite, par abus de langage , le mot désigne aussi les valeurs de ce type et les variables ayant ce type.

Citation:

---

[*]La valeur d'un pointeur est en réalité l'adresse à laquelle on trouvera la variable correspondant au type du pointeur

---

Faux. Une valeur de type pointeur peut ne désigner aucun objet (le pointeur nul) ou des objets non nommés (quand on a utilisé l'allocation dynamique).

Citation:

---

[*]Un pointeur n'a aucune utilité à être utilisé comme variable dans une structure

---

Faux. Une de ses utilités est justement la constructeur de structures dynamiques et là les membres de type pointeur sont nécessaires.

Citation:

---

[*]Le pointeurs sont d'un grand secours, entre autres, quand il sont passés comme arguments de fonction

---

Vrai. En passant un pointeur vers un objet plutôt que l'objet, on peut le modifier.

Citation:

---

[*]Il n'y a aucune précaution particulière à prendre avant d'utiliser un pointeur

---

Vrai.

Citation:

---

[*]Un pointeur peut prendre l'adresse d'un objet qui survivra à la sortie d'une fonction

---

Vrai. Mais ce n'est pas parce qu'on a pris et conservé un pointeur vers une variable locale qu'elle se mettra à survivre à la fin de la fonction.

Citation:

---

[*]un pointeur ne peut pas prendre l'adresse d'un objet qui survivra à la sortie d'une fonction

---

Faux.

Citation:

---

[*]la taille d'un pointeur est toujours fixe et connue d'avance, quel que soit le type qu'il représente

---

Faux. La taille des pointeurs est fixe mais peut varier suivant l'objet pointé. En pratique, on a les contraintes suivantes:
- void* et les différents char* sont de la même taille (et on la même représentation)
- les pointeurs vers des struct ont la même taille

Citation:

---

[*]l'utilisation "dynamique" d'un pointeur est souvent plus intéressante que la création d'un tableau de taille fixe

---

Je ne comprends pas la question.

Citation:

---

[*]l'utilisation d'un pointeur n'a strictement rien à voir avec les tableaux

---

Je crois que j'ai assez écrit sur le sujet des tableaux...

koala01, tu m'as l'air de confondre variable et objet. Les variables sont des objets nommés et les membres de structures ne sont pas non plus des variables.

Citation:

---

Envoyé par koala01

Citation:

---

8.a taille d'un pointeur est toujours fixe et connue d'avance, quel que soit le type qu'il représente:

---

Meme si c'est une question qui se résoud entre le compilateur et l'architecture du processeur, la taille d'un pointeur sera toujours fixe, sur une architecture et un compilateur donné.

En effet, un pointeur aura toujours une taille suffisante pour représenter n'importe quelle adresse mémoire (du moins si tu ne travaille pas avec un compilateur "antédiluvien":P

Le type de la variable pointé n'aura strictement aucune incidence sur cette taille

---

Ah!

Je suis entierement d'accord avec toi sur le fait qu'il n'y a pas de correlation entre la taille d'un type et celle d'un pointeur sur ce type.
Tout comme la donnee situee a l'adresse contenue dans le pointeur (element simple, tableau de n elements, etc.) ne change en rien la taille du pointeur.

Par contre je ne vois rien dans la norme qui impose que tout les pointeurs aient la meme taille.
Qu'est ce qui empecherait une implementation de d'utiliser des pointeurs de taille differente (par exemple une paritition pointeur de fonction/pointeur de variable, pointeur "const"/pointeur non const, void*/autre type, etc.) ?

Citation:

---

Envoyé par gl

Par contre je ne vois rien dans la norme qui impose que tout les pointeurs aient la meme taille.

---

Comme je l'ai écrit, il n'y a rien.

Citation:

---

Qu'est ce qui empecherait une implementation de d'utiliser des pointeurs de taille differente (par exemple une paritition pointeur de fonction/pointeur de variable, pointeur "const"/pointeur non const,

---

Mais je crois qu'un pointeur vers T et un vers T const doivent avoir la même représentation.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Citation:

---

Envoyé par gl

Par contre je ne vois rien dans la norme qui impose que tout les pointeurs aient la meme taille.

---

Comme je l'ai écrit, il n'y a rien.

---

On est bien d'accord (pour information, au moment ou je redigeais ma reponse, je n'avais pas encore vu la tienne).

Citation:

---

Envoyé par Jean-Marc.Bourguet

Citation:

---

Qu'est ce qui empecherait une implementation de d'utiliser des pointeurs de taille differente (par exemple une paritition pointeur de fonction/pointeur de variable, pointeur "const"/pointeur non const,

---

Mais je crois qu'un pointeur vers T et un vers T const doivent avoir la même représentation.

---

Je n'ai rien vu non plus a ce sujet. Aurais-tu des references ?

Citation:

---

Envoyé par gl

Je n'ai rien vu non plus a ce sujet. Aurais-tu des references ?

---

Question idiote de ma part. C'est implicite puisque c'est le meme type pointe (au qualifieur pres). Donc forcement les tailles sont egales.

Citation:

---

Envoyé par gl

Question idiote de ma part. C'est implicite puisque c'est le meme type pointe (au qualifieur pres). Donc forcement les tailles sont egales.

---

Je ne vois pas de bonnes raisons pour que ce ne soit pas le cas, mais j'ai pas trouvé de clauses l'imposant.

Citation:

---

Envoyé par Jean-Marc.Bourguet

Je ne vois pas de bonnes raisons pour que ce ne soit pas le cas

---

Personellement, je ne vois deja pas de bonnes raisons pour que les pointeurs sur les types "primitifs" (char, int, long, etc.) n'aient pas la meme representation.

Citation:

---

Envoyé par Jean-Marc.Bourguet

mais j'ai pas trouvé de clauses l'imposant.

---

Peut etre le point 26 de §6.2.5

Citation:

---

Similarly, pointers to qualified or unqualified versions of
compatible types shall have the same representation and alignment requirements.

---

Citation:

---

Envoyé par gl

Personellement, je ne vois deja pas de bonnes raisons pour que les pointeurs sur les types "primitifs" (char, int, long, etc.) n'aient pas la meme representation.

---

Sur une machine adressable par mot, on peut vouloir avoir char* qui est un pointeur vers le mot + une indication de quel char dans le mot. C'est le cas sur un PDP-10 par exemple (mais si j'ai bonne mémoire, l'implémentation que j'ai utilisée n'avait pas besoin de cela, les pointeurs prenaient plus de place que nécessaire pour des raisons de performance)

Les implémentations pour les machines adressables par mot récente ont à ma connaissance fait le choix de sizeof char == sizeof int. Mais elles n'ont pas vocation à être à usage général.

vhui content d'être audessus de la moyenne sur les pointeurs :D :yaisse2:

donc pour revenir à ma petite histoire.

toutes ses définitions sont bien cool mais sans exemple concret de réalisation d'un soft par exemple je ne vois pas comment je vais pouvoir en voir l'utiliter.
C'est bien la méthodologie d'apprentissage du C que je remet en cause.
j'ai pour la peine arrêté Educatel et vais m'arranger avec Emmanuel pour des cours CONCRET, ptet qu'avec ça je progresserais.

le concept on peut le saisir mais sans réalisation d'un cas concret c nul. le code du mplayer par exemple c du chinois et pourtant ils emploient bcp de structures et pointeurs.

Proposer de bout de code c bien mais réaliser quelque chose permet d'offir à ceux qui apprend de bien utiliser ce qu'ils apprennent.
:?
je ne sais pas si je me fais comprendre.

Pour info, ça fait deux mois que je fais du C et j'ai l'impression de ne rien apprendre. car là je ne sais rien faire de concret.

tiens, à ce propos

je vois dans mes cours un char **champs=NULL;
un pointeur c avec un * et les ** c quoi? à quoi ça sert? pour quel uilité?
vraiment nul ce cours ils expliquent même pas à koi ça correspond. :(

Citation:

---

Envoyé par Seimaya

tiens, à ce propos

je vois dans mes cours un char **champs=NULL;
un pointeur c avec un * et les ** c quoi? à quoi ça sert? pour quel uilité?

---

C'est un pointeur de pointeur (un pointeur qui contiendra l'adresse d'un autre pointeur).

Il y a plusieurs utilisation :
* modifier un pointeur (et non la variable qu'il pointe) dans une fonction
* creer des tableaux dynamique de tableau dynamique
* etc...