He fragmento de código que no puedo entender cómo es que funciona, porque de una línea que hace un doble eliminar. El código es el siguiente:

void afunction(int**x){
    *x = malloc(2 * sizeof(int));
    **x = 12;
    *(*x + 1) = 13;
}

int main(){
    int *v = 10;
    afunction(&v);

    printf("%d %d\n", v[0], v[1]);
    return 1;
}

Entiendo que el primer elemento del puntero a puntero obtiene el valor de 12, pero la línea después de que me parece que no puede entender. ¿El segundo elemento en el primer puntero obtener el valor 13?

  • entonces, ¿qué hace su salida de decirle?
  • Este código produce un error en tiempo de ejecución
  • Dentro de la función, x tiene el tipo int **. Por lo tanto *x tiene el tipo int *, y *x + 1 es aritmética de punteros: el resultado es un puntero a un elemento del pasado **x. *(*x + 1) designa el int en esa posición; es, por definición, exactamente equivalente a (*x)[1]. Así que sí, la última línea de la función establece el segundo int en la asignación dinámica de bloque 13.
  • no (salvo que v no es libre d). Hay un error de tiempo de compilación que theere es un error de inicialización de v en la principal.
  • Suponiendo un moder OS es liberado por el sistema.
  • hmm, corriendo aquí dar salida así como el error de tiempo de ejecución
  • ¿dónde está el error en tiempo de ejecución?…
  • Bien; yo lo veo: es debido a regresar a 1 en principal.
  • … y ideone es inusual en la clasificación que como un error en tiempo de ejecución.
  • En cualquier caso, el fraseo de la pregunta, sugiere un posible malentendido: la memoria para que un puntero que señala que no es «en» o en cualquier forma parte de ese puntero. Un puntero no tiene elementos, un solo valor, pero ese valor puede apuntar a un espacio que alberga en su interior uno o más objetos del puntero del tipo de destino.

1 Comentario

  1. 3

    El código es más fácil de entender si se utiliza una variable temporal, por ejemplo:

    void afunction(int**x)
    {
        int* t = *x;
    
        t = malloc(2 * sizeof(int));
        *t = 12;
        *(t+1) = 13;
    }

    así:

    • x es un puntero a un puntero a int
    • *x produce un int* (puntero a int)
    • **x = es como *(*x) = por lo que primero se obtenga el puntero a int entonces por eliminar usted es capaz de establecer el valor en la dirección

    La última parte *(*x+1) = puede ser descompuesto:

    int* pointerToIntArray = *x;
    int* secondElementInArray = pointerToIntArray + 1;
    *secondElementInArray = 13;

    El propósito de utilizar un puntero a puntero de aquí es que usted puede pasar la dirección a un int* a la función y dejar que la función de asignar la memoria y llenarlo con los datos. Con el mismo propósito, se podría hacer mediante la devolución de un int*, por ejemplo:

    int* afunction() {
      int* x = malloc(sizeof(int)*2);
      *x = 12;
      *(x+1) = 13;
      return x;
    }
    
    int main() {
      int* v = afunction();
      return 0;
    }

Dejar respuesta

Please enter your comment!
Please enter your name here