Discussion :

[laclac]

Bonjour,

Je débute un peu en C/C++ et j'ai une question sur les pointeurs.
J'ai fais un rapide code ci dessous (il y a peut etre des fautes ).

Quand j'affiche le résultat, je ne sais pas ce qu'il est censé m'afficher :
- Si il affiche "1" le contenu du pointeur
- l'adresse du pointeur (auquel cas pourquoi il affiche l'adresse vu qu'il n'y a pas de &)

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
int main(void)
{
  int* ptr;  /* déclare le ptr */
  *ptr = 1; /* Le pointeur pointe sur 1 */
  test(&a); /* passe l'adresse en paramètre
}
 
void test(int* _ptr){  /* récupère le pointeur */
   printf( "%d",_ptr); /* Question ? */
}

Seconde question :si je fais ptr + 3 de combien d'octet mon pointeur avance ?

Merci davance

[Emmanuel Delahaye]

Je débute un peu en C/C++

Il n'y a pas de C/C++. Il y a C et il y a C++. Ce sont deux langages différents. Comme tu es sur le forum C, je considère que tu codes en C.

Code :

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

1
2
3
4
5
 
int main(void)
{
  int* ptr;  /* déclare le ptr */
  *ptr = 1; /* Le pointeur pointe sur 1 */

Stop Comportement indéfini. ptr n'est pas initialisé. Sa valeur est donc indéterminée. *ptr invoque donc un comportement indéfini. Tout peut arriver. C'est un bug grave dont l'effet n'est pas forcément visible (ce qui le rend sournois et donc très dangereux).

Code :

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

Seconde question :si je fais ptr + 3 de combien d'octet mon pointeur avance ?

Ca dépend de l'implémentation. On ne raisonne pas en terme d'octets, mais de taille de type. Ici, c'est un int, donc la progression est de sizeof (int) * 3, ce qui donne un certain nombres de bytes.

Rappel : un byte (la plus petite unité mémoire adressable d'une architecture donnée) n'a pas forcément la taille d'un octet, qui lui, fait exactement 8-bit. Il peut être plus grand. Tout dépend de l'architecture...

[Médinoc]

1. Si tu as de la chance, ce code est censé planter: Tu tentes d'écrire à l'adresse pointée alors que le pointeur n'est pas initialisé: Il pointe dans le vide.
2. Le décalage sera de 3*sizeof(int) bytes.

[Thierry Chappuis]

ptr n'a pas été initialisé, il ne contient par conséquent pas une adresse valide. Lorsqu'à la 4ème ligne de ton programme, tu le déréférence pour placer la valeur 1 à l'adresse invalide pointée par ptr, tu as un comportement indéfini.

Il est conseillé d'initialiser tous les pointeurs à la valeur NULL. Ensuite, si tu désire utiliser un pointeur pour traiter des données, il faut que ce dernier pointe sur un espace mémoire valide (tableau ou variable alloué sur la pile, espace mémoire alloué dynamiquement avec malloc(), etc.).

Thierry

EDIT: super grilled

[Emmanuel Delahaye]

Il est conseillé d'initialiser tous les pointeurs à la valeur NULL.

Pas forcément. On peut aussi donner tout de suite une valeur valide, genre

Code :

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

1
2
3
 
int a;
int *p = &a;

[Sve@r]

Bonjour,

Je débute un peu en C/C++ et j'ai une question sur les pointeurs.
J'ai fais un rapide code ci dessous (il y a peut etre des fautes ).

1. Si tu as de la chance, ce code est censé planter: Tu tentes d'écrire à l'adresse pointée alors que le pointeur n'est pas initialisé: Il pointe dans le vide.

Petite rectifiction => il pointe pas dans le vide mais quelque part en mémoire de façon hasardeuse. Et si t'as pas de chance, ton code marchera pendant un certain temps (définition d'un comportement "indéterminé" => parfois ça fonctionne) puis tu le modifieras et là, il plantera. Et tu t'arracheras les cheveux à chercher l'erreur dans ce que t'as rajouté alors qu'elle se situe ici.

Forme toi avec les cours et tutoriels C : http://c.developpez.com/cours/ et aussi la FAQ C : http://c.developpez.com/faq/
Ensuite tu pourras aller sur ce site http://emmanuel-delahaye.developpez.com qui te détaille le C de façon plus poussée et plus rigoureuse...

[diogene]

Quand j'affiche le résultat, je ne sais pas ce qu'il est censé m'afficher :
- Si il affiche "1" le contenu du pointeur
- l'adresse du pointeur (auquel cas pourquoi il affiche l'adresse vu qu'il n'y a pas de &)

Le contenu d'un pointeur doit être l'adresse d'un objet (valide) ou NULL. Ce ne peux être 1.
Les arguments d'une fonction sont des valeurs. Tu affiches donc la valeur de l'objet ptr : La valeur d'un pointeur étant une adresse d'objet (ou NULL) , tu affiches cette adresse. Si tu veux afficher la valeur de l'objet dont l'adresse est dans le pointeur, l'argument doit être *ptr

[Thierry Chappuis]

Pas forcément. On peut aussi donner tout de suite une valeur valide, genre

Code :

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

1
2
3
 
int a;
int *p = &a;

Certes! J'aurais dû préciser qu'à défaut d'être en mesure de l'initialiser avec une adresse valide, il est conseillé de l'initialiser avec une adresse invalide testable, à savoir NULL.

Thierry

[Davidlouiz]

Ton poiteur doit pointer une variable.
Tu commence par déclarer une variable

Code C :

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

int variable;

Ensuite, tu déclare un pointeur du même type de ta variable. Sinon, le compilateur ne saurra pas comment interpréter la valeur pointé par ton pointeur.

Code c :

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

int *pointeur;

Maintenant, ce qu'il faut bien comprendre, c'est que :

Code c :

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

1
2
3
4
5
pointeur // est une adresse (la valeur du pointeur est une adresse)
*pointeur // est la valeur pointé par l'adresse.
 
variable // est une valeur (valeur de variable)
&variable // est une adresse (l'adresse de variable).

Pour que le pointeur pointe sur la variable, il faut lui affecter son adresse :

Code c :

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

pointeur = &variable;

Maintenant, ce qu'il faut bien comprendre, c'est que poiteur est une adresse et que *pointeur est la valeur pointé par le pointeur (ici, la valeur de variable)

Si tu fait :

Code c :

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

*pointeur = 4; // On met 4 à l'adresse pointé par le pointeur (l'adresse de variable)

C'est comme si tu faisait :

Code c :

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

variable = 4; // On met 4 dans variable

Maintenant, revenons à ton code.

test est une fonction qui prend en paramettre une adresse.

Pour mettre l'adresse dans le pointeur déclaré en paramettre, tu a fait :

Code c :

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

void test(int* ptr);

ptr est un pointeur qui pointe sur le int de l'adresse qu'il contient.

Pour y passer l'adresse d'une variable dans main, tu peux soit passer en paramettre le pointeur (vu qu'un pointeur est une adresse) soit l'adresse ta ta variable avec l'esperluette.

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
int main(void)
{
  int var;
  int *ptr;
 
  ptr = &var;
 
  test(ptr); // ou test(&var)
}
 
void test(int* ptr)
{
   printf( "%d", ptr); // On affiche la valeur du int pointé par l'adresse du pointeur
}

L'étoile devant un pointeur signifie : "valeur de la variable pointé par le pointeur".

[Thierry Chappuis]

Ensuite, tu déclare un pointeur du même type de ta variable.

J'aurais dis: "tu déclares un pointeur sur un élément du même type que ta variable". pointeur (de type pointeur sur int) et variable (de type int) sont de deux types distincts. A mon avis, ta phrase est un peu confuse.

Thierry

[diogene]

Davidlouiz :

*pointeur est la valeur pointé par le pointeur ... L'étoile devant un pointeur signifie : "valeur de la variable pointé par le pointeur".

Plus précisément " *pointeur est la variable pointée par le pointeur...L'étoile devant un pointeur signifie : " variable pointée par le pointeur" Si *ptr était une valeur, on ne pourrait pas écrire *ptr = ...

[Sve@r]

Si *ptr était une valeur, on ne pourrait pas écrire *ptr = ...

Non. L'étoile signifie "endroit de la mémoire correspondant à la valeur contenue dans ptr". Et donc on peut très bien écrire "*ptr=..." puisque cela veut dire qu'à cette adresse mémoire, on va y mettre une valeur comme on en a tout à fait le droit...

[diogene]

Sve@r :

Non. L'étoile signifie "endroit de la mémoire correspondant à la valeur contenue dans ptr".

Si c'est "un endroit de la mémoire", c'est un objet (une variable si tu préfères) (en prenant le terme "correspondant" dans le sens que je suppose tu lui donnes). Moi je traduit cela en " objet dont l'adresse est la valeur de ptr"

Et donc on peut très bien écrire "*ptr=..."

C'est ce que je dis et qui prouve que *ptr est un objet (lvalue)
En clair : on dit, je crois, la même chose avec des termes différents

[Sve@r]

En clair : on dit, je crois, la même chose avec des termes différents

Ouaip, parfois ça arrive (le français, le sens des mots, toussa...)