C/C++ apuntadores en C?

[remphenter]

Al hacer un ejercicio que me pide "incremente en 1 la posición de memoria a la que apunta (empleando malloc y validar la nueva posición)" Sé que en los punteros está la ubicación de memoria y el valor, pero al parecer el enunciado habla de la memoria entonces el código quedaría así:

[FONT=&amp]#include <stdio.h> [/FONT]
[FONT=&amp]#include <stdlib.h> [/FONT]


[FONT=&amp]int main() { [/FONT]
[FONT=&amp]int *x; [/FONT]


[FONT=&amp]x = malloc(sizeof(int)); [/FONT]


[FONT=&amp]printf("%d",*x); [/FONT]


[FONT=&amp]return 0; [/FONT][FONT=&amp]} [/FONT]

Para incrementar en 1 tendría que usar las operaciones aritméticas ++ y -- mi pregunta es ¿en que parte del código tendría que agregar el x++? además tengo entendido que las ubicaciones de memoria consecutivas solo se pueden apreciar en arreglos.

[Julián]

Re: apuntadores en C?

¿en que parte del código tendría que agregar el x++?

Luego de reservar dinámicamente la memoria, es decir, luego de malloc()

Debes entender que cuando se reserva una variable y no se inicializa, su valor es basura, es decir, cualquier cosa.

Si corres este código

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

    int variable; // definimos una variable local
    
    printf("Muestra cualquier cosa: %d \n", variable); //acá mostará cualquier cosa, lo que halla en esa dirección de memoria
    
    variable= 5;
    
    printf("Muestra algo: %d \n", variable); //acá mostrará 5
    
    int var=25;
    variable=var; 
    
    printf("Mustra algo: %d\n", variable);// acá mostará lo que halla en var(si se pasó argumento al programa)
    return 0;
}

Ahora si se inicializa, es decir, si cuando se define se le asigna algo. Ahí no hay problema.

Lo mismo pasa con los punteros. Si yo defino un puntero:

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char *argv[]){

    int *p; 
    printf("Aca muestra basura: %p\n", p); //acá mostrará un valor basura

    int a=25;
    p=&a; 
    printf("Aca muestra la direccion de memoria de a: %p\n ", p); //acá mostrará la dirección de memoria de la variable a

    printf("Direccion de memoria de a +1: %p \n", p+1); //acá mostrará la dirección de memoria siguiente o contigua de la variable

    printf("Valor de a: %d\n", *p); // acá mostrará el valor de la variable a

  return 0;
}

Es por esto que siempre un código robusto, si defines una variable debes inicializarla y más si es un puntero.

Directamente cuando lo llamas le asignas una dirección de memoria o sino le asignas null.

int *p=NULL;

Para luego asignarle algo una dirección de memoria estática, como por ejemplo:

p = &variable

O una dirección de memoria dinámica

p = malloc(sizeof(int));

Nuevamente antes del malloc(), donde le reservas una dirección de memoria correspondiente a un entero, el puntero tiene un valor basura.

Sé que en los punteros está la ubicación de memoria y el valor

No, un puntero es una variable cuya longitud corresponde al valor máximo de direcciones de la arquitectura que estés usando. Por ejemplo en una PC un puntero tendrá una longitud de 64 bits. Si en cambio trabajas con una arquitectura de 32 bit será de longitud de 32 bits. Eso lo maneja el compilador.

Ahora es posible hacer referencia al contenido de esa dirección de memoria con el operador *. O asignar una dirección de memoria con el operador & o dinamicamento con malloc o calloc.

Ejemplo;

#include <stdio.h>
#include <stdlib.h>


int main(int argc, char *argv[]){


    int *p= NULL;
 
    printf("Aca muestra el valor null: %p\n", p); //acá mostrará un valor 0


    p = (int *)malloc (5*sizeof(int)); //reservo 5 direcciones de memoria
    
    int i;
    for (i=0;i<5;i++){
    *(p+i)= i;
    }
    
    printf("Valor de primera direccion: %p\n", p); // valor de la primera dirección reservada


    for (i=0;i<5;i++){
    printf ("Direccion numero %d reservada es %p\n ", i+1, p+i);
    }


    for (i=0;i<5;i++){
    printf("valor en la posicion %d es: %d\n", i+1, *(p+i));
    }


  return 0;
}

Ejecuta estos códigos y te darás cuenta.

Debo decir que hace tiempo que no trabaja en este bajo nivel, teniendo en cuenta las direcciones de memoria. Sin lugar a dudas lenguajes de programación de alto nivel se abstraen completamente de la arquitectura del ordenador.