Re: OFF-TOPIC:Ayuda con programacion en C

["HUGO NU@EZ BRISE@O" <hugonb en bital com mx>]

Ok..... hay te va un pequeño rollito mareador:

En hay varios tipos de declarar una variable: memoria estática o memoria
dínamica. A que me refiero?? al hecho de como se asigna la memoria al
momento de compilación. Cuando declaras una variable de tipo estática, el
compilador reserva el espacio de memoria suficiente para albergar los datos
en esa variable. Pero ojo, eso depende del ámbito de la variable, ya que si
la declaras global siempre estrá presente durante la ejecución de todo tu
programa pero si la declaras local, entonces solo existirá mientras la
función a la cual pertenece esté ejecutando. El "programa" se encarga de
asignar y liberar la memoria ocupada por esta variable. En los apuntadores
(en ANSI C), la memoria reservada por el compilador solo comprende la
necesaria para almacenar una dirección del tipo del apuntador. Tu eres
responsable de asignar, manejar y liberar la memoria ocupada por el
apuntador, no importando si es local o global. Ahora bien, como te
mencione, los apuntadores solo almacenan una dirección (0x00a por ejemplo)
pero para poder accesar la información al área de memoria a la cual están
apuntando (ya sea para leer o escribir) tienes que utilizar una sintaxis
algo diferente y esta sintaxis depende de donde esté el apuntador. Estos
son unos ejemplos:

int *myPointer;  //apuntador hacia un entero
int *myVal; //Apuntador hacia un entero
struct thetime {
            int hour;
            int minute;
            int seconds;
};

thetime myTime;  //Estructura con memeoria estática
thetime *myTime; //Estructura con memoria dínamica

La forma de accesa myPointer es:

myPointer = (int *) malloc( sizeof(int) ); //Reserva memoria para el
apuntador para albergar un entero
myVal = (int *) malloc(sizeof(int) ); //Reserva memoria para albergar un
entero
*myPointer = 5;   //Guarda el valor 5 en el área reservada de memoria
*myVal  = *myPointer; //Pasa el valor apuntado por myPointer a myVal
free( myPointer ); //Libera la memoria
free( myVal ); //Libera la memoria

Ahora bien:

myPointer = (int *) malloc( sizeof(int) ); //Reserva memoria para el
apuntador para albergar un entero
*myPointer = 5;   //Guarda el valor 5 en el área reservada de memoria
myVal  = myPointer; //Pasa la dirección apuntada por myPointer a myVal (no
pasa el valor 5)
free( myPointer ); //Libera la memoria
free( myVal ); //Libera la memoria

Y te preguntaras... Y esto a que viene con mi pregunta??? Debido a que esto
mismo se aplica a las estructuras: Cuando accesas a una variable miembro de
la una estructura, primero debes saber de que tipo de estructura estamos
manejando. Así, tomando el ejemplo anterior:

struct thetime {
            int hour;
            int minute;
            int seconds;
};

thetime myTime;  //El programa reserva automáticamente la memoria para la
estructura
thetime *myTime; //El programador debe reservar la memoria para esta
estructura


Para accesar las variables miembro (por default públicas):
//Para el primer caso
theTime.hour = 12;
theTime.minute = 53;
theTime.seconds = 48;

//Para el segundo caso. (Ojo: debes reservar memoria primero al apuntador
antes de accesar las variables)
theTime->hour = 12;
theTime->minute = 53;
theTime->seconds = 48;

En caso de tener un apuntador dentro de la estructura, necesitas reservale
memoria de igual manera que cuando es una variable "suelta"

struct thetime {
            int hour;
            int minute;
            int seconds;
            int *myPointer;
};

thetime myTime;  //El programa reserva automáticamente la memoria para la
estructura
thetime *myTime; //El programador debe reservar la memoria para esta
estructura

theTime.myPointer = (int *) malloc( sizeof(int) );
theTime->myPointer = (int *) malloc( sizeof(inf) );

*theTime.myPointer = 5;
*theTime->myPointer = 5;

Espero que esto te ayude a aclarar tus dudas. Pero realmente me gustaría
que te surgieran más (debido a que deseas entonces conocer mas a fondo el
tema). Te recomiendo que leas un libro de programación básica con
apuntadores en C y C++.

Saludos.

Atte.
Hugo Núñez Briseño


Nota: Cuando utilizas memoria dinámica no sólo debes reservar la memoria,
sino verificar que se haya reservado correctamente y después de utilizarla,
debes liberarla.


root wrote:

> Hola a todos
> tengo el siguiente problema
>  si tengo ( en C );
>
> typedef struct {
>         int     variable;
>         int     *puntero;
> } estructura;
>
> y luego en una funcion declaro
>
> estructura      mi_estructura;
>
> aqui estoy un poco confundido...
> como le hago para;
>
> que 'mi_estructura.puntero' apunte a un valor
> que mediante 'mi_estructura.puntero' pueda modificar un valor de otra
> variable (del mismo tipo, claro) y que mediante 'mi_estructura.puntero'
> accese a valores de otras variables.
>
> y me confundo aun peor cuando se necesita hacer eso con punteros a
> estructuras
> como 'tu_estructura->puntero' y cosas por el estilo.
>
> grachie a todos
>
> +++++
> +T.O+
> +++++