C++ passage du pointeur à la fonction (Howto) + Manipulation du pointeur C++

Pour déclarer une fonction qui prend un pointeur vers un int:

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 pouvez préférer 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 adresse des opérations.

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

Modifier 3 Réponse:

Bar = & foo signifie: faire pointer la barre vers foo en mémoire

Oui.

* bar = foo signifie changer la valeur que la barre pointe pour égaler tout foo est égal à

Oui.

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

Bar = oof signifie: bar pointe vers le oof pointeur

bar pointera vers ce que oof pointe vers. Ils pointent 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 ne parlons pas de cela... Vous ne pouvez pas assigner un pointeur à un int (eh bien, vous pouvez, mais c'est un détail qui n'est pas en ligne avec le discussion).

* bar = * OOF signifie: changer la valeur que la barre pointe vers la valeur que OOF pointe vers

Oui.

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

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

Pour passer un pointeur sur un int, il devrait ê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;
}

Si vous voulez 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 devraient jamais avoir de type int, ce que vous avez alors dans votre code. Un pointeur vers int a le type int *.

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

Bar = OOF signifie: bar les points à l'absence de pointeur

Cela signifie "faire un point de barre à la même chose oof pointe vers".

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

Ça 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 que la barre pointe vers la valeur qui ouf points à

Oui.

& bar = & OOF signifie: changer la mémoire adresse que les points de barre pour être le même comme l'adresse de mémoire que les points oof à

Non, c'est encore invalide. &bar est un pointeur vers la bar variable, mais c'est ce qu'on appelle un "rvalue" ou "temporaire", et il ne peut pas être attribué. 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 "make bar, qui est une adresse, égale à oof, qui est aussi une adresse". bar = &foo signifie "faire de la barre, qui est une adresse, égale à l'adresse de foo". Si bar = *oof signifiait quelque chose, cela signifierait "make bar, qui est une adresse, égale à *oof, qui est un int". Vous ne pouvez pas.

Alors, & est l'adresse de l'exploitant. Il signifie "l'adresse de l'opérande", donc &foo est l'adresse de foo (j'.e, un pointeur de toto). * est l'opérateur de déréférencement. Cela signifie "la chose à l'adresse donnée par l'opérande". Donc, avoir fait bar = &foo, *bar est foo.

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);

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

Vous permettrait de manipuler le contenu de ce que 'pointeur' pointe en le déréférençant dans la fonction amusante, c'est-à-dire

*Pointer = 1;

Le déclarer comme ci-dessus vous permet également de manipuler des données au-delà de ce qu'il pointe:

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

Dans la fonction, vous pouvez ensuite faire comme *(pointeur + 1) = 12; définir la 2ème 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.

Il pourrait être plus facile pour vous de comprendre en utilisant Functionoids qui sont expressivement plus propre et plus puissant à utiliser, voir cet excellent et fortement recommandé C++ FAQ Lite , en particulier, regardez la section 33.12 et suivantes, mais néanmoins, lisez-le depuis le début de cette section pour en acquérir une compréhension et une compréhension.

Pour répondre À votre question:

typedef void (*foobar)() fubarfn;

void Fun(fubarfn& baz){
   fubarfn = baz;
   baz();
}

Modifier:

• & désigne l'adresse de référence
• * signifie la valeur de ce qui est contenu à l'adresse de référence, appelée de-referencing

Donc, en utilisant la référence, l'exemple ci-dessous, montre que nous passons un paramètre, et le modifions directement.

void FunByRef(int& iPtr){
    iPtr = 2;
}

int main(void){
    // ...
    int n;
    FunByRef(n);
    cout << n << endl; // n will have value of 2
}