C++ Passing Pointer to Function (Howto) + Manipolazione puntatore C++

Question

Sono un po 'confuso su come funzionano i puntatori di passaggio.

Diciamo che ho la seguente funzione e il puntatore, e ...

EDIT:

... voglio usare un puntatore a un oggetto come argomento nella funzione.

cioè .:

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

Tra il * Puntatore e & notazioni Pointer, sono molto confuso. So che * Puntatore significa dare qualunque cosa punti.

Inserisco void (int * pointer) nella dichiarazione. Che dire quando uso la funzione?

La vostra assistenza è apprezzata.

EDIT 2:

Ok, ora capire che utilizzando * variabile in una dichiarazione significa che dovrà essere passato un puntatore. Tuttavia, che dire quando uso la funzione?

cioè

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

EDIT 3: Okay, mi corregga se sbaglio:

Secondo le convenzioni del codice di cui sopra:

bar = & mezzi foo : Rendi in memoria il punto della barra

* bar = foo significa Cambia t egli Valore che punti a barre per eguagliare qualunque foo pari

Se ho un secondo puntatore (int * oof), quindi:

bar = oof significa: punti a barre per il puntatore oof

bar = * oof significa: barra indica il valore che punti oOF, ma non al puntatore oOF stessa

* bar = * oof significa: modificare il valore che i punti di barre per il valore che i punti oOF a

& bar = & oof significa: cambia l'indirizzo di memoria che i punti della barra sono uguali all'indirizzo di memoria che non fa riferimento a

Ho diritto?

EDIT 4: Grazie mille per tutto il vostro aiuto (vorrei poter accettare più di una risposta, ma devo andare con la prima. in questo modo per il montaggio (sentiti libero di trasformarlo in una guida di riferimento se ti piace).

Answer 1

C'è una differenza nell'uso * quando si definisce una variabile e quando lo si utilizza.

In dichiarazione,

int *myVariable; 

intende un puntatore a un tipo di dati integer. Nell'uso tuttavia,

*myVariable = 3; 

Mezzi deferenza il puntatore e rendere la struttura si sta puntando pari a tre, piuttosto che fare il puntatore uguale all'indirizzo di memoria 0x 0003.

Quindi nel tuo funzione, vuole fare questo:

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

nella dichiarazione di funzione, * significa che si sta passando un puntatore, ma nel suo corpo codice vero e proprio * significa che si sta accedendo ciò che il puntatore sta puntando.

Nel tentativo di onda via qualsiasi confusione avete, io brevemente andare in la e commerciale (&)

& mezzi ottenere l'indirizzo di una cosa, la sua posizione esatta nella memoria del computer, in modo da

int & myVariable; 

In una dichiarazione si intende l'indirizzo di un numero intero o un puntatore!

Questo però

int someData;  
pInteger = &someData; 

Mezzi rendono il puntatore pInteger stessa (ricordate, i puntatori sono solo gli indirizzi di memoria di ciò che puntano a) pari all'indirizzo del 'someData' - così ora pInteger punterà ad alcuni dati e può essere utilizzato per accedervi quando lo si deferenza:

*pInteger += 9000; 

Questo ha senso per voi? C'è qualcos'altro che trovi confuso?

@ Edit3:

Quasi corretto, tranne per tre dichiarazioni

bar = *oof; 

significa che il puntatore bar è uguale ad un numero intero, non ciò bar a punti, che è valido.

&bar = &oof;

La e commerciale è come una funzione, una volta che restituisce un indirizzo di memoria non è possibile modificare da dove proviene. Proprio come questo codice:

returnThisInt("72") = 86; 

Non valido, così è tuo.

Infine,

bar = oof 

non significa che "a barre indica il puntatore oof" Questo significa che a barre indica l'indirizzo che punti fuori sede a, quindi i punti bar a qualsiasi foo sta indicando - Not Bar punta a pippo che punta a zero.

Answer 2

Potrebbe essere più facile da capire utilizzando i Functionoid che sono espressivamente più nitidi e più potenti da usare, vedere questo eccellente e altamente raccomandato C++ FAQ lite, in particolare, guardare la sezione 33.12 in poi, ma comunque leggerlo dall'inizio di quella sezione per ottenere una comprensione e comprensione di esso.

Per rispondere alla tua domanda:

typedef void (*foobar)() fubarfn; 

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

Edit:

• & significa che l'indirizzo di riferimento
• * intende il valore di ciò che è contenuto all'indirizzo di riferimento, chiamato de- referencing

Quindi utilizzando il riferimento, nell'esempio seguente, viene mostrato che stiamo passando un parametro e lo si modifica direttamente.

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

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

Answer 3

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 
} 

* prima che il puntatore significa che il contenuto del puntatore (tranne che nelle dichiarazioni!)

& prima che il puntatore (o qualsiasi variabile) significa che l'indirizzo

EDIT:

int someint=15; 
//to call the function 
Fun(&someint); 
//or we can also do 
int *ptr; 
ptr=&someint; 
Fun(ptr); 

Answer 4

Per passare un puntatore a un numero deve essere void Fun(int* pointer).

Passare un riferimento a un int sarebbe simile a questa ...

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

Answer 5

Se si vuole passare un puntatore a int nella vostra funzione,

Dichiarazione di funzione (se ne avete bisogno):

void Fun(int *ptr); 

Definizione della funzione:

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 
} 

Utilizzo della funzione:

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

Nota come regola generale, le variabili chiamate Ptr o Pointer non devono mai avere il tipo int, che è ciò che si ha nel codice. Un puntatore a int ha tipo int *.

Se ho un secondo puntatore (int * oof), quindi:

bar = oof significa: barra grafica al OOF puntatore

Significa "fare punto bar per la stessa cosa di cui "".

bar = * oof significa: barra indica il valore che punti fuori sede, ma non il puntatore fuori sede stessa

Ciò non significa nulla, è valido. bar è un puntatore *oof è un int. Non puoi assegnarne uno all'altro.

* bar = * oof significa: cambiare il valore che i punti a barre per il valore che i oof punti per

Sì.

& bar = & oof significa: cambiare l'indirizzo di memoria che barra grafica per essere lo stesso come l'indirizzo di memoria che punti OOF a

No, che è ancora valido. &bar è un puntatore alla variabile bar, ma è ciò che viene chiamato "rvalue" o "temporaneo" e non può essere assegnato a. È come il risultato di un calcolo aritmetico. Non è possibile scrivere x + 1 = 5.

Potrebbe aiutarti a pensare ai puntatori come indirizzi. bar = oof significa "make bar, che è un indirizzo, uguale a oof, che è anche un indirizzo". bar = &foo significa "make bar, che è un indirizzo, uguale all'indirizzo di foo". Se bar = *oof significasse qualcosa, significherebbe "make bar, che è un indirizzo, uguale a *oof, che è un int". Non puoi

Quindi, & è l'indirizzo di operatore. Significa "l'indirizzo dell'operando", quindi &foo è l'indirizzo di foo (cioè, un puntatore a foo). * è l'operatore di dereferenziazione. Significa "la cosa all'indirizzo indicato dall'operando". Quindi aver fatto bar = &foo, *bar è foo.

Answer 6

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

permetterebbe di manipolare il contenuto di ciò che punti 'puntatore' dereferenziando all'interno della funzione di divertimento cioè

*Pointer = 1; 

dichiarandolo come sopra permette anche di anche di manipolare i dati al di là di quello che punta a:

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

nella funzione che è possibile eseguire come * (Puntatore + 1) = 12; impostazione del 2 ° valore dell'array.

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

è possibile modificare ciò Pointer riferimenti, tuttavia in questo caso non si può accedere a qualsiasi cosa al di là di ciò che i riferimenti puntatore a.

Answer 7

per dichiarare una funzione che prende un puntatore ad un int:

void Foo(int *x);

Per utilizzare questa funzione:

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

Se si desidera un puntatore per un altro tipo di oggetto, è molto lo stesso:

void Foo(Object *o);

Ma potresti preferire usare i riferimenti. Essi sono un po 'meno confusione di puntatori:

// 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. 

Con riferimenti, è ancora ottenere di cambiare la x che è stato passato alla funzione (come si farebbe con un puntatore), ma non dovete preoccuparvi di dereferenziazione o indirizzo delle operazioni.

Come consigliato da altri, controllare C++FAQLite. È una risorsa eccellente per questo.

Edit 3 risposta:

bar = & foo significa: fare il punto bar a foo in memoria

Sì.

* bar = foo significa cambiamento del valore che i punti a barre per eguagliare qualunque foo uguale

Sì.

Se ho un secondo puntatore (int * oof), quindi:

bar = oof significa: punti a barre per il puntatore oof

barra punterà a qualsiasi punti fuori sede a. Entrambi indicheranno la stessa cosa.

bar = * oof significa: barra grafica per il valore che punti OOF, ma non al puntatore OOF stessa

No. Non è possibile farlo (supponendo bar è di tipo int *) Puoi fare puntatori del puntatore. (int **), ma non entriamo in questo ... Non puoi assegnare un puntatore a un int (beh, puoi, ma questo è un dettaglio che non è in linea con la discussione).

* bar = * oof significa: cambiare il valore che i punti a barre per il valore che i punti fuori sede per

Sì.

& bar = & oof significa: cambiare l'indirizzo di memoria che i punti a barre per essere lo stesso l'indirizzo di memoria che punti fuori sede per

No. Non è possibile fare questo perché l'indirizzo dei rendimenti operatore un valore. Fondamentalmente, ciò significa che non puoi assegnargli qualcosa.