web-dev-qa-db-fra.com

C ++ Passing Pointer to Function (Howto) + C ++ Pointer Manipulation

Je suis un peu confus quant au fonctionnement des pointeurs.

Disons que j'ai la fonction et le pointeur suivants, et ...

MODIFIER :

... Je veux utiliser un pointeur sur un objet comme argument dans la fonction.

c'est à dire.:

void Fun(int Pointer){
    int Fun_Ptr = ---Passed Pointer---; 
    //So that Fun_Ptr points to whatever ---Passed Pointer points to

Entre les notations * Pointer et & Pointer, je suis très confus. Je sais que * Pointer signifie donner tout ce qu'il indique.

Dois-je mettre void (int * pointer) dans la déclaration. Et quand j'utilise la fonction?

Votre aide est appréciée.

MODIFIER 2:

D'accord, je comprends maintenant que l'utilisation de la variable * dans une déclaration signifie qu'un pointeur sera passé. Mais qu'en est-il lorsque j'utilise la fonction?

c'est à dire.

int main(){
    int foo;
    int *bar;
    bar = foo;
    Fun(bar);
}

EDIT 3: D'accord, corrigez-moi si je me trompe:

Selon les conventions du code ci-dessus:

bar = & foo signifie: faire en sorte que la barre pointe vers foo en mémoire

* bar = foo signifie Modifier la valeur vers laquelle la barre pointe pour qu'elle soit égale à foo

Si j'ai un deuxième pointeur (int * oof), alors:

bar = oof signifie: la barre pointe vers le pointeur oof

bar = * oof signifie: bar pointe vers la valeur vers laquelle oof pointe, mais pas vers le pointeur oof lui-même

* bar = * oof signifie: changer la valeur vers laquelle la barre pointe vers la valeur vers laquelle oof pointe

& bar = & oof signifie: changez l'adresse mémoire vers laquelle la barre pointe pour être la même que l'adresse mémoire vers laquelle pointe ofof

Ai-je ce droit?

EDIT 4: Merci beaucoup pour toute votre aide (j'aimerais pouvoir accepter plus d'une réponse, mais je dois aller avec la première. Je ne sais pas comment un wiki communautaire fonctionne exactement, mais je vais le laisser de cette façon pour retouche (n'hésitez pas à en faire un guide de référence si vous le souhaitez).

c++pointersfunctionarguments
25
Biosci3c

Il y a une différence dans l'utilisation * lorsque vous définissez une variable et lorsque vous l'utilisez.

En déclaration,

int *myVariable;

Signifie un pointeur vers un type de données entier. En utilisation cependant,

*myVariable = 3;

Signifie déréférencer le pointeur et rendre la structure vers laquelle il pointe égale à trois, plutôt que de rendre le pointeur égal à l'adresse mémoire 0x 0003.

Donc, dans votre fonction, vous voulez faire ceci:

void makePointerEqualSomething(int* pInteger)
{
    *pInteger = 7;
}

Dans la déclaration de fonction, * signifie que vous passez un pointeur, mais dans son corps de code réel * signifie que vous accédez à ce que pointe le pointeur.

Dans le but d'éliminer toute confusion que vous avez, je vais brièvement entrer dans l'esperluette (&)

& signifie obtenir l'adresse de quelque chose, son emplacement exact dans la mémoire de l'ordinateur, donc

 int & myVariable;

Dans une déclaration signifie l'adresse d'un entier ou d'un pointeur!

Mais cela

int someData;    
pInteger = &someData;

Les moyens font que le pointeur pInteger lui-même (rappelez-vous, les pointeurs ne sont que des adresses mémoire de ce qu'ils pointent) égal à l'adresse de 'someData' - alors maintenant pInteger pointera sur certaines données, et peut être utilisé pour y accéder lorsque vous le déférerez:

*pInteger += 9000;

Est-ce que cela a du sens pour vous? Y a-t-il autre chose que vous trouvez déroutant?

@ Edit3:

Presque correct, sauf pour trois déclarations

bar = *oof;

signifie que le pointeur de la barre est égal à un entier, et non à la barre pointée, qui n'est pas valide.

&bar = &oof;

L'esperluette est comme une fonction, une fois qu'elle renvoie une adresse mémoire, vous ne pouvez pas modifier d'où elle vient. Tout comme ce code:

returnThisInt("72") = 86;

N'est pas valide, tout comme le vôtre.

Finalement,

bar = oof

Cela ne signifie pas que "la barre pointe vers le pointeur oof". Au contraire, cela signifie que la barre pointe vers l'adresse vers laquelle pointe ofof, donc la barre pointe vers tout ce que foo pointe - pas la barre pointe vers foo qui pointe vers oof.

45
Tomas

Pour déclarer une fonction qui prend un pointeur sur un entier:

void Foo(int *x);

Pour utiliser cette fonction:


int x = 4;
int *x_ptr = &x;
Foo(x_ptr);
Foo(&x);

Si vous voulez un pointeur pour un autre type d'objet, c'est à peu près la même chose:

void Foo(Object *o);

Mais vous préférerez peut-être utiliser des références. Ils sont un peu moins déroutants que les pointeurs:


// pass a reference
void Foo(int &x)
{
  x = 2;
}

//pass a pointer
void Foo_p(int *p)
{
   *x = 9;
}

// pass by value
void Bar(int x)
{
   x = 7;
}
int x = 4;
Foo(x);  // x now equals 2.
Foo_p(&x); // x now equals 9.
Bar(x);  // x still equals 9.

Avec les références, vous pouvez toujours changer le x qui a été passé à la fonction (comme vous le feriez avec un pointeur), mais vous n'avez pas à vous soucier du déréférencement ou de l'adresse des opérations.

Comme recommandé par d'autres, consultez le C++ FAQLite . C'est une excellente ressource pour cela.

Modifier la réponse 3:

bar = & foo signifie: faire en sorte que la barre pointe vers foo en mémoire

Oui.

* bar = foo signifie Modifier la valeur vers laquelle la barre pointe pour qu'elle soit égale à foo

Oui.

Si j'ai un deuxième pointeur (int * oof), alors:

bar = oof signifie: la barre pointe vers le pointeur oof

la barre pointera sur tout ce qui pointe vers. Ils pointeront tous les deux vers la même chose.

bar = * oof signifie: bar pointe vers la valeur vers laquelle oof pointe, mais pas vers le pointeur oof lui-même

Non. Vous ne pouvez pas faire cela (en supposant que la barre est de type int *) Vous pouvez créer des pointeurs de pointeur. (int **), mais n'entrons pas dans les détails ... Vous ne pouvez pas affecter un pointeur à un int (enfin, vous pouvez, mais c'est un détail qui n'est pas conforme à la discussion).

* bar = * oof signifie: changer la valeur vers laquelle la barre pointe vers la valeur vers laquelle oof pointe

Oui.

& bar = & oof signifie: changez l'adresse mémoire vers laquelle la barre pointe pour être la même que l'adresse mémoire vers laquelle pointe ofof

Non. Vous ne pouvez pas faire cela car l'adresse de l'opérateur renvoie une valeur r. Fondamentalement, cela signifie que vous ne pouvez pas lui attribuer quelque chose.

15
JoshD

Pour passer un pointeur à un int, il doit être void Fun(int* pointer).

Passer une référence à un int ressemblerait à ceci ...

void Fun(int& ref) {
   ref = 10;
}

int main() {
   int test = 5;
   cout << test << endl;  // prints 5

   Fun(test);
   cout << test << endl;  // prints 10 because Fun modified the value

   return 1;
}
3
dgnorton

Si vous souhaitez passer un pointeur vers int dans votre fonction,

Déclaration de fonction (si vous en avez besoin):

void Fun(int *ptr);

Définition de la fonction:

void Fun(int *ptr) {
    int *other_pointer = ptr;  // other_pointer points to the same thing as ptr
    *other_ptr = 3;            // manipulate the thing they both point to
}

Utilisation de la fonction:

int main() {
    int x = 2;
    printf("%d\n", x);
    Fun(&x);
    printf("%d\n", x);
}

Notez en règle générale que les variables appelées Ptr ou Pointer ne doivent jamais avoir le type int, ce que vous avez alors dans votre code. Un pointeur vers un objet de type int *.

Si j'ai un deuxième pointeur (int * oof), alors:

bar = oof signifie: la barre pointe vers le pointeur oof

Cela signifie "faire pointer la barre vers la même chose que vers".

bar = * oof signifie: bar pointe vers la valeur vers laquelle oof pointe, mais pas vers le pointeur oof lui-même

Cela ne veut rien dire, c'est invalide. bar est un pointeur *oof est un int. Vous ne pouvez pas attribuer l'un à l'autre.

* bar = * oof signifie: changer la valeur vers laquelle la barre pointe vers la valeur vers laquelle oof pointe

Oui.

& bar = & oof signifie: changez l'adresse mémoire vers laquelle la barre pointe pour être la même que l'adresse mémoire vers laquelle pointe ofof

Non, c'est encore invalide. &bar est un pointeur sur la variable bar, mais c'est ce qu'on appelle une "rvalue" ou "temporaire", et elle ne peut pas être affectée à. C'est comme le résultat d'un calcul arithmétique. Vous ne pouvez pas écrire x + 1 = 5.

Cela pourrait vous aider à considérer les pointeurs comme des adresses. bar = oof signifie "faire une barre, qui est une adresse, égale à oof, qui est aussi une adresse". bar = &foo signifie "faire une barre, qui est une adresse, égale à l'adresse de foo". Si bar = *oof signifiait n'importe quoi, cela signifierait "make bar, qui est une adresse, égale à *oof, qui est un int ". Vous ne pouvez pas.

Ensuite, & est l'adresse de l'opérateur. Cela signifie "l'adresse de l'opérande", donc &foo est l'adresse de foo (c'est-à-dire un pointeur sur foo). * est l'opérateur de déréférencement. Cela signifie "la chose à l'adresse donnée par l'opérande". Donc, après avoir fait bar = &foo, *bar est foo.

3
Steve Jessop
void Fun(int *Pointer)
{
  //if you want to manipulate the content of the pointer:
  *Pointer=10;
  //Here we are changing the contents of Pointer to 10
}

* avant le pointeur signifie le contenu du pointeur (sauf dans les déclarations!)

& avant le pointeur (ou toute variable) signifie l'adresse

MODIFIER:

int someint=15;
//to call the function
Fun(&someint);
//or we can also do
int *ptr;
ptr=&someint;
Fun(ptr);
1
Gustavo Puma
void Fun(int* Pointer)   -- would be called as Fun( &somevariable )

vous permettrait de manipuler le contenu de ce que 'Pointer' pointe en le déréférençant à l'intérieur de la fonction Fun i.e.

*Pointer = 1;

le déclarer comme ci-dessus vous permet également de manipuler les données au-delà de ce qu'elles indiquent:

int foo[10] = {0};
Fun(foo);

dans la fonction, vous pouvez alors faire comme * (Pointer + 1) = 12; définissant la 2e valeur du tableau.

void Fun(int& Pointer)  -- would be called Fun( somevariable )

vous pouvez modifier les références du pointeur, mais dans ce cas, vous ne pouvez pas accéder à quoi que ce soit au-delà des références du pointeur.

1
Anders