que - C++ Pasando el puntero a la función(Cómo)+C++ Manipulación del puntero

que es un apuntador en informatica

Question

Estoy un poco confundido en cuanto a cómo funcionan los punteros de paso.

Digamos que tengo la siguiente función y puntero, y ...

EDITAR :

... Quiero usar un puntero a algún objeto como argumento en la función.

es decir:

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

Entre las notaciones de * Pointer y & Pointer, estoy muy confundido. Sé que * Puntero significa dar lo que apunta.

Pongo void (int * pointer) en la declaración. ¿Qué pasa cuando uso la función?

Su asistencia es apreciada.

EDIT 2:

Bien, ahora entiendo que usar la variable * en una declaración significa que se pasará un puntero. Sin embargo, ¿qué pasa cuando uso la función?

es decir

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

EDIT 3: está bien, corríjame si me equivoco:

Según las convenciones del código anterior:

bar = & foo significa: hacer que la barra apunte a foo en la memoria

* bar = foo significa cambiar el valor al que apunta la barra para que sea igual a lo que foo es igual a

Si tengo un segundo puntero (int * oof), entonces:

barra = oof significa: barra apunta al puntero oof

bar = * oof significa: bar apunta al valor que oof apunta, pero no al puntero oof en sí mismo

* bar = * oof significa: cambia el valor al que apunta la barra al valor que apunta a oof

& bar = & oof significa: cambia la dirección de la memoria que la barra apunta para que sea la misma que la dirección de la memoria que apunta

¿Tengo este derecho?

EDIT 4: Muchas gracias por toda su ayuda (desearía poder aceptar más de una respuesta, pero debo seguir con la primera. No estoy seguro de cómo funciona exactamente una wiki comunitaria, pero lo dejaré así para Edición (siéntase libre de convertirla en una guía de referencia si lo desea).

Answer 1

Es posible que le resulte más fácil comprender el uso de Functionoids que son expresamente más nítidos y más potentes de usar. Consulte este excelente y altamente recomendado Preguntas frecuentes sobre C ++ , en particular, consulte la sección 33.12 en adelante, pero no obstante, léala desde el principio de esa sección. para obtener una comprensión y comprensión de ella.

Para responder tu pregunta:

typedef void (*foobar)() fubarfn;

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

Editar:

• & significa la dirección de referencia
• * significa el valor de lo que está contenido en la dirección de referencia, llamado de-referenciación

Entonces, al usar la referencia, el ejemplo a continuación, muestra que estamos pasando un parámetro y lo modificamos directamente.

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

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

Answer 2

Hay una diferencia en el uso * cuando está definiendo una variable y cuando la está utilizando.

En la declaración,

int *myVariable;

Significa un puntero a un tipo de datos entero. En uso sin embargo,

*myVariable = 3;

Significa eliminar la referencia al puntero y hacer que la estructura a la que apunta sea igual a tres, en lugar de hacer que el puntero sea igual a la dirección de memoria 0x 0003.

Así que en tu función, quieres hacer esto:

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

En la declaración de función, * significa que está pasando un puntero, pero en su cuerpo de código real * significa que está accediendo a lo que apunta el puntero.

En un intento de eliminar cualquier confusión que tenga, entraré brevemente en el símbolo (&)

& significa obtener la dirección de algo, su ubicación exacta en la memoria de la computadora, por lo que

 int & myVariable;

En una declaración significa la dirección de un entero, o un puntero!

Esto sin embargo

int someData;    
pInteger = &someData;

Los medios hacen que el puntero de entrada en sí mismo (recuerde, los punteros son solo direcciones de memoria de lo que señalan) igual a la dirección de ''someData'', por lo que ahora pInteger apuntará a algunos datos, y puede usarse para acceder a ellos cuando lo deferencia:

*pInteger += 9000;

¿Tiene sentido esto para ti? ¿Hay algo más que te parezca confuso?

@ Edit3:

Casi correcto, excepto por tres afirmaciones

bar = *oof;

significa que el puntero de barra es igual a un entero, no a qué barra apunta, lo que no es válido.

&bar = &oof;

El símbolo y es como una función, una vez que devuelve una dirección de memoria que no puede modificar de dónde proviene. Al igual que este código:

returnThisInt("72") = 86; 

No es válido, también lo es el tuyo.

Finalmente,

bar = oof

No significa que "la barra apunta al puntero oof". Más bien, esto significa que la barra apunta a la dirección a la que apunta oof, así que la barra apunta a lo que foo apunta, no la barra apunta a foo que apunta a oof.

Answer 3

Para declarar una función que lleva un puntero a un int:

void Foo(int *x);

Para utilizar esta función:

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

Si quieres un puntero para otro tipo de objeto, es lo mismo:

void Foo(Object *o);

Pero, usted puede preferir utilizar referencias. Son algo menos confusos que los punteros:

// 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 las referencias, aún puede cambiar la x que se pasó a la función (como lo haría con un puntero), pero no tiene que preocuparse por la desreferenciación o la dirección de las operaciones.

Según lo recomendado por otros, echa un vistazo a C++FAQLite . Es un excelente recurso para esto.

Editar 3 respuestas:

bar = & foo significa: hacer que la barra apunte a foo en la memoria

Sí.

* bar = foo significa cambiar el valor al que apunta la barra para que sea igual a lo que foo es igual a

Sí.

Si tengo un segundo puntero (int * oof), entonces:

barra = oof significa: barra apunta al puntero oof

bar apuntará a cualquier punto de oof. Ambos apuntarán a la misma cosa.

bar = * oof significa: bar apunta al valor que oof apunta, pero no al puntero oof en sí mismo

No. No puedes hacer esto (asumiendo que la barra es de tipo int *) Puedes hacer punteros de puntero. (int **), pero no entremos en eso ... No puede asignar un puntero a un int (bueno, sí puede, pero ese es un detalle que no está en línea con la discusión).

* bar = * oof significa: cambia el valor al que apunta la barra al valor que apunta a oof

Sí.

& bar = & oof significa: cambia la dirección de la memoria que la barra apunta para que sea la misma que la dirección de la memoria que apunta

No. No puedes hacer esto porque la dirección del operador devuelve un valor de r. Básicamente, eso significa que no puedes asignarle algo.

Answer 4

Para pasar un puntero a un int se debe void Fun(int* pointer) .

Pasar una referencia a un int se vería así ...

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

Si desea pasar un puntero a int en su función,

Declaración de función (si la necesita):

void Fun(int *ptr);

Definición de función:

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
}

Uso de la función:

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

Tenga en cuenta que, como regla general, las variables llamadas Ptr o Pointer nunca deben tener el tipo int , que es lo que tiene en su código. Un puntero a int tiene el tipo int * .

Si tengo un segundo puntero (int * oof), entonces:

barra = oof significa: barra apunta al puntero oof

Significa "hacer que la barra apunte a la misma cosa que los puntos".

bar = * oof significa: bar apunta al valor que oof apunta, pero no al puntero oof en sí mismo

Eso no significa nada, es inválido. bar es un puntero *oof es un int. No puedes asignar una a la otra.

* bar = * oof significa: cambia el valor al que apunta la barra al valor que apunta a oof

Sí.

& bar = & oof significa: cambia la dirección de la memoria que la barra apunta para que sea la misma que la dirección de la memoria que apunta

No, eso es inválido otra vez. &bar es un puntero a la variable de bar , pero es lo que se llama "rvalue" o "temporal", y no se puede asignar. Es como el resultado de un cálculo aritmético. No puedes escribir x + 1 = 5 .

Podría ayudarte a pensar en los punteros como direcciones. bar = oof significa "make bar, que es una dirección, igual a oof, que también es una dirección". bar = &foo significa "make bar, que es una dirección, igual a la dirección de foo". Si bar = *oof significaba algo, significaría "make bar, que es una dirección, igual a *oof , que es un int". Usted no puede

Entonces, & es la dirección del operador. Significa "la dirección del operando", por lo que &foo es la dirección de foo (es decir, un puntero a foo). * Es el operador de referencia. Significa "la cosa en la dirección dada por el operando". Así que habiendo hecho bar = &foo , *bar es foo .

Answer 6

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
}

* antes del puntero significa el contenido del puntero (excepto en las declaraciones!)

& antes del puntero (o cualquier variable) significa la dirección

EDITAR:

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

Answer 7

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

le permitiría manipular el contenido de lo que apunta ''Pointer'' al eliminar la referencia dentro de la función Fun, es decir

*Pointer = 1;

declararlo como arriba también le permite manipular datos más allá de lo que apunta a:

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

en la función puedes hacer como * (Pointer + 1) = 12; estableciendo el segundo valor de la matriz.

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

puede modificar a qué referencias de puntero, sin embargo, en este caso, no puede acceder a nada más allá de las referencias de puntero.