bueno resulta que estoy en la etapa de estudio de lista, pila y cola pero en medio  del tema me doy cuenta que el conocimiento que tenia sobre los punteros no era suficiente y hace que me tranque al tratar de aprender sobre esas estructuras de dato, ahora la duda que tengo es la siguiente:

tengo un puntero (A) en la funcion principal que al principio lo hago apuntar a NULL ahora al llamar a una funcion le paso como argumento el puntero (A) para que la funcion modifique el valor apuntado por el puntero (A) pero resulta que despues de que cambio el valor apuntado por el puntero (A) y termina de ejecutarse el llamado a la funcion cuando reviso el valor apuntado por el puntero (A) resulta que sigue apuntando a NULL es decir que no modifico el valor apuntado por el puntero original


Funcion Principal en donde creo el puntero VALOR y le paso el valor apuntado originalmente a NULL a la funcion noHaceNada


luego en la funcion hago que la funcion ptr apunte a donde apunta temp que seria la direccion de memoria en donde se reservo memoria para el elemento int


pero resulta que al acabar el llamado a la funcion la variable valor sigue apuntando a NULL y esa es mi duda porque sigue apuntando a NULL si en la funcion le digo que apunte a donde apunta temp

saludos

En las funciones de C no se puede modificar el valor de las variables, por eso se usan los punteros, pero no se usan así. No modificas la dirección a la que apunta el puntero, sino la información que hay en esa dirección. Así:

#include <stdio.h>
#include <stdlib.h>
 
int haceAlgo(int *n){
  *n += 2;
  return 0;
}
 
int main (){
  int *modificable = malloc(sizeof(int));
  *modificable = 0;
  haceAlgo(modificable);
  printf("%d\n", *modificable);
  return 0;
}

Sin embargo, como ves, en "main" no se ve la modificación que se hace a "modificable", puesto que se hace en otra función que podría estar en otro fichero e incluso no tener disponible el código fuente. Por eso es mejor usar los retornos de las funciones cuando sea posible. Este ejemplo que he puesto es de juguete y por eso es posible. Sería así:

#include <stdio.h>
 
int haceAlgo(int n){
  return n+2;
}
 
int main (){
  int modificable = 0;
  modificable = haceAlgo(modificable);
  printf("%d\n", modificable);
  return 0;
}

Sigue leyendo acerca de punteros y verás que todo tiene sentido.

Con que no se ve quiero decir que el programador no lo ve, hace el código un poco más oscuro, por eso es mejor usar el retorno de la función y no modificar los parámetros que se le pasan cuando sea posible. A veces esto no es suficiente y hay que recurrir a punteros o parámetros por referencia, y es algo que hay que usar, pero no hay que abusar de ello.

En un mundo ideal en que el código está bien documentado y la gente mira la documentación no habría problema, pero en el mundo real un programador puede perder muchas horas antes de descubrir que hay una función que le está modificando una variable y la forma en que la modifica.

Simplemente, aprovechando que se ha preguntado esto he decidido acotar el alcance de la respuesta, porque al que tiene un martillo todo le parecen clavos.

Por otro lado, creo que con los ejemplos que he puesto sería suficiente para que darkxxx pudiera extrapolar al suyo, pero sólo es mi opinión.