Duda de punteros

[Drewermerc]

hola a todos.
bueno esta programando y me encontre con esto y no se a que se deba si alguien me puede explicar.
es que me di cuentas que si declaro un puntero global asi:
char a[20];
y lo imprimo tanto en una funcion como en la funcion principal main se matiene su valor.
pero su declaro un puntero asi:
char *b;
el valor solo se matiene en la funcion y cuando imprimo su valor en main aparece sin valor (NULL).
Mi pregunta es ¿por que en uno si se queda su valor y en el otro no?

Código C:

#include <stdio.h>
char a[10], *b; 
int prueba (char a[10], char *b);
int main ()
{
    prueba(a, b);
    printf("\n en la funcion main el valor de la variable a es:\n%s de la varible b es: \n %s", a, b);
}
int  prueba (char a[10], char *b)
{
    char mensaje[30]="hola como estas";
    b = mensaje;
    printf("introduce un texto \n");
    fgets(a, 10, stdin);
    
    printf("el valor de la variable a es:\n %s \n varibale b es :\n %s", a, b);
}
 

[CalgaryCorpus]

Estas ejercitando el paso por valor.

Cuando pasas 'a' no modificas el valor de a. 'a' sigue apuntando al espacio de memoria que contiene 10 enteros.

Cuando pasas 'b' intentas modificarla y aparentemente lo logras, pero es una ilusion porque estas modificando una copia que has decidido nombrar igual.

Tal vez se siplificaria la explicacion si en tu ejemplo cambiaras el nombre de los parametros a 'x' e 'y'. Ahi seria mas claro que estas haciendo copias.

Cuando llamas los parametros con el mismo nombre hay 2 'a' y 2 'b' lo que para el lenguaje esta bien porque unas viven dentro de la funcion y las otras fuera.

[Drewermerc]

hola CalgaryCorpus:
gracias por tu explicacion.
entonces cuando se usa eeste tipo de puntero *b lo asignado no se guerda en memoria como este a[10] que si ocupa un certo numero de espacios en la memoria y e otro solo es como una ilucion y trabaja en local.

[CalgaryCorpus]

a y b son punteros, a es constante y b no.

Pero como los punteros son una cosa tal vez extraña, permiteme explicarlo asi:

olvidemos un rato que "puntero" = "direccion de memoria"

y para entenderlo mejor digamos que

puntero = papel con la direccion de una casa, edificio o monumento de la ciudad.

Ahora si te quedas conmigo en esta explicacion, tal vez tenga mas sentido lo que pasa con la funcion de arriba.

a = papel con la direccion de un edificio con 10 pisos, papel que por alguna razon no podemos borrar
b = papel sin direccion inicial, el que si podemos borrar!!!

invocas la funcion, y para no usar tu funcion con nombres malos, usare la que recomendé, una linda funcion con 2 papeles, llamados "x" e "y"

Invóquese la funcion entonces:

el papel "x" COPIA y escribe lo que a tiene, x entonces tiene la direccion de un edificio de 10 pisos
el papel "y" COPIA escribe lo que b tiene, o sea basura, o nada, como quieras.

el papel "x" usa la informacion que tiene para IR a la direccion del edificio y pintarlo, si quiere.
el papel "y" modifica lo que "b" le paso y escribe OTRA direccion, por ejemplo, de un monumento en la ciudad.

El papel "b" desde afuera, enojado, indica que no lo han modificado y claro, el papel "y" no se preocupa por que él tiene su propia informacion y hace lo que quiere con ella.
Por qué el papel "y" modificaría a "b", si en este lenguaje lo unico que tenemos son COPIAS????

Ahora no es tan cierto que lo UNICO que tenemos son copias, pero tu en tu funcion eso es lo que estas ejercitando. Las copias.

Fin.

p.s. No tiene relevancia el que "a" sea constante ( y no se puede modificar ) y que b si se pueda. Ambos son pasados por valor y se copian las direcciones que ellas guardan.

[Drewermerc]

hola CalgaryCorpus.
gracias muy buena explicacion ahora si ya me quedo mas claro.
muchas gracias.

[vangodp]

Código C++:

#include <stdio.h>
//a =(es igual) papel con la dirección de un edificio con 10 pisos!!Recuerda lo!!! no vive nadie en el edificio aun
char a[10]; // a es puntero que apunta a la dirección a[0] ya que no puede apuntar a a[1], a[2], [3].... todos a la vez XD
//b =(es igual) papel sin dirección inicial, el que si podemos borrar!!!
char * b;   // b es un puntero que "nunca" ha apunto nada ¡Correcto! ¡recuérdelo! ;)
 
int prueba ( char a[10], char * b ); //prototipo... no voy a comentar aquí sino mas abajo ;)
 
int main () {
    prueba ( a, b ); // pasamos a y b que son punteros recuérdelo ninguno de los 2 tiene nada aun pero a apunta a[0], b es null;)
    //Aqui en esta linea se va a pegar todo lo de la función "prueba" ve hacia ella antes de seguir.
    
    //Ahora aquí imprimimos a y b, como dije x estaba conectada con a[] y imprimirá lo que se guardo.
    //B como antes de apuntar nada se había roto la conexión con *Y(puntero y) que paso a apuntar hacia "mensaje" dejando b intacto.
    printf ( "\n en la función main el valor de la variable a es:\n%s de la varible b es: \n %s", a, b );
    //En realidad b nunca apunto nada, siempre estuvo (null).
}
 
//Vamos a renombrar esto por que el lio es por que se llaman igual que las globales pero en realidad creas nuevas variables
//x recibe lo que tiene a, x ahora tiene la dirección de un edificio de 10 pisos que no vive nadie XD.
//y recibe lo que tiene b, pero b no tiene nada (null).
int  prueba ( char x[10], char * y ) {
    char mensaje[30] = "hola como estas";
    y = mensaje;                         //y ahora apunta hacia mensaje[0], se desvincula de b ^^, b ya no le ocurre nada mas aquí XD
    printf ( "introduce un texto \n" );
    fgets ( x, 10, stdin );              //x recibe los inquilinos pero x sigue conectado con a[], los inquilinos en realidad ahora viven en a[] por que todo lo que pase a x[] le va pasar a a[].
    
    //Aqui en en la funcion se imprime x, que esta conectada a a[], b perdio la coneccion con y cuando ese apunto hacia "mensaje".
    printf ( "el valor de la variable x es:\n %s \n varibale y es :\n %s", x, y );
}
 

Corrija me si me equivoco ^^