Cambiar la dirección contenida por el puntero usando la función

Si he declarado un puntero p como int *p ; en el módulo principal, puedo cambiar la dirección contenida por p asignando p=&a; donde a es otra variable entera ya declarada. Ahora quiero cambiar la dirección usando una función como ::

 void change_adrs(int*q) { int *newad; q=newad; } 

Si llamo a esta función desde el módulo principal

 int main() { int *p; int a=0; p=&a; // this changes the address contained by pointer p printf("\n The address is %u ",p); change_adrs(p); printf("\n the address is %u ",p); // but this doesn't change the address return 0; } 

el contenido de la dirección no se modifica. ¿Qué hay de malo con usar una función para la misma tarea?

En C, los argumentos de funciones se pasan por valor. Por lo tanto, se realiza una copia de su argumento y el cambio se realiza en esa copia, no en el puntero real que espera ver modificado. Tendrá que cambiar su función para aceptar un argumento de doble puntero y hacer el cambio al argumento desreferenciado si desea hacer esto. Por ejemplo

  void foo(int** p) { *p = 0; /* set pointer to null */ } void foo2(int* p) { p = 0; /* makes copy of p and copy is set to null*/ } int main() { int* k; foo2(k); /* k unchanged */ foo(&k); /* NOW k == 0 */ } 

Si tiene el lujo de usar C ++, una forma alternativa sería cambiar la función para aceptar una referencia a un puntero.

En C, las variables se pasan por valor: se pasa una copia del puntero a la función. Use otro puntero al puntero en su lugar:

 void change(int **p, int *someOtherAddress) { *p = someOtherAddress; } int a = 1, b = 2; int *p = &a; printf("*p = %d\n", *p); change(&p, &b); printf("*p = %d\n", *p); 

Esto imprime

 *p = 1 *p = 2 

Si desea alterar el contenido de una variable en una función en C, el puntero es también una especie de variable, debe pasarlo por puntero o referencia indirecta utilizando los operadores siempre & dirección y * desreferencia. Quiero decir * operador siempre se usa y es precedido cuando se cambia el valor de una variable.

 #include  #include  void changeIntVal(int *x) { *x = 5; } void changePointerAddr(int **q) { int *newad; *q = newad; } void changePPAddr(int ***q) { int **dummy; *q = dummy; } int main() { int *p; int **pp; int *tempForPP; int a = 0; printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a); p = &a; pp = &tempForPP; printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a); changeIntVal(&a); // ---- // |--- changePointerAddr(&p); // ---- |----> parts of what I mean // |--- changePPAddr(&pp); // ---- printf("\n The address pointing by p -> %p, pp -> %p, value of a -> %d ", p, pp, a); return 0; } 

Para un tipo de datos primitivo como int , los punteros dobles no son necesarios. Puede escribir directamente en la dirección donde se almacena el int , tratando su dirección como un puntero en la función a la que se llama. Esto es diferente de una matriz de caracteres (“cadena”) donde el tamaño de lo que se señala es variable y, por lo tanto, debe usar otro nivel de direccionamiento indirecto al cambiarlo desde una función llamada. Prueba esto:

 void foo(int *oldVal) { int newVal = 99; // or whatever you want *oldVal = newVal; } int main(int argc, char *argv[]) { int someVal = 0; foo(&someVal); // we send its address to foo() printf("someVal is now %d.\n", someVal); return EXIT_SUCCESS; } 

Esto no cambiará el valor real de p porque la función q en es local a eso y el cambio en esa función no se reflejará en main así que pase la dirección de p lugar de pasar p por valor

Use esta syntax a continuación

  void change_adrs(int **q) { int * otheraddess; *q = otheraddress; } 

y llame así a este change_adrs(&p);

O bien, tiene otro camino: cambie el tipo de función de retorno y capture la dirección devuelta.

 int* change_adrs(int *q) { int * otheraddess; q = otheraddress; return q; } int main() { p=change_adrs(p); return 0; }