Resultados 1 al 2 de 2

Hilo: apuntadores en C?

  1. #1
    Registro
    Nov 2018
    Posts
    1
    Nivel
    Universidad (Matemáticas)
    ¡Gracias!
    0 (0 msgs.)

    Predeterminado apuntadores en C?

    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í:

    Código:
    #include <stdio.h> 
    #include <stdlib.h> 
    
    
    int main() { 
    int *x; 
    
    
    x = malloc(sizeof(int)); 
    
    
    printf("%d",*x); 
    
    
    return 0; } 
    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.

  2. #2
    Registro
    Feb 2010
    Ubicación
    Argentina
    Posts
    1 640
    Nivel
    Universidad (Ingeniería)
    Artículos de blog
    3
    ¡Gracias!
    477 (432 msgs.)

    Predeterminado 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

    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:

    Código:
    #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;

    Código:
    #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.
    Última edición por Julián; 04/11/2018 a las 01:48:55. Razón: agregar ; a linea de código.
    AB * {Log}_{2} (1+\dst \frac{S}{N })

  3. El siguiente usuario da las gracias a Julián por este mensaje tan útil:

    Maq77 (03/11/2018)

Información del hilo

Usuarios viendo este hilo

Ahora hay 1 usuarios viendo este hilo. (0 miembros y 1 visitantes)

Etiquetas para este hilo

Permisos de publicación

  • No puedes crear hilos
  • No puedes responder
  • No puedes adjuntar archivos
  • No puedes editar tus mensajes
  •