Yo había estado escribiendo cosas como

char *x=NULL;

en el supuesto de que

 char *x=2;

crearía un char puntero a la dirección 2.

Pero, en El C de GNU Tutorial de Programación dice que int *my_int_ptr = 2; almacena el valor entero 2 a cualquiera de las direcciones aleatorias es en my_int_ptr cuando se le asignan.

Esto implicaría que el de mi propia char *x=NULL es la asignación de cualquiera que sea el valor de NULL arrojado a un char es aleatoria dirección en la memoria.

Mientras

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

int main()
{
    char *x=NULL;

    if (x==NULL)
        printf("is NULL\n");

    return EXIT_SUCCESS;
}

de hecho, la impresión

es NULO

al compilar y ejecutar, me preocupa que estoy confiando en un comportamiento indefinido, o al menos bajo un comportamiento específico, y que yo debería escribir

char *x;
x=NULL;

lugar.

  • Hay una muy confuso diferencia entre lo que int *x = whatever; ¿ y qué int *x; *x = whatever; hace. int *x = whatever; en realidad se comporta como int *x; x = whatever;, no *x = whatever;.
  • Este tutorial parece haber conseguido que la confusa distinción mal.
  • Lo siento, me llamó la conclusión demasiado temprano. Tienes razón, bien visto. +1, esta es una pregunta útil, gracias por preguntar.
  • Ah nvm, de hecho thsis tutorial lo tiene completamente al revés 😀
  • Así que muchos de mierda tutoriales en la web! Dejar de leer de inmediato. Realmente necesitamos una lista negra donde podemos públicamente la vergüenza de mierda, libros…
  • La mayoría de las publicaciones tienen un par de errores (de hecho, es poco habitual que un ser completamente libre de errores) , así que no me juzgan en base a un caso; en realidad en este caso es un buen candidato para ser algún tipo de error tipográfico , como la manera en que el texto está escrito sugiere que el autor tiene la intención de trazar la distinción entre la inicialización y asignación de
  • Toda la página vinculada es completa basura, no sólo es el autor de falta de la flagrante violación de la restricción de problema, sino que además no hablar de que los «valores de basura» como bien podría ser la trampa de las representaciones. Y no mencionan que un puntero y int pueden tener distintos tamaños y representaciones.
  • sí, bueno, es bastante claro que es sólo la intención de aplicar para el uso de gcc en la década de 1980 los sistemas GNU/Linux
  • Lo que no la hace menos mierda en el año 2017. Dada la evolución de los compiladores y los equipos desde los años 80, que es básicamente la misma cosa, como si yo fuera un médico y la lectura de la medicina de libros escritos durante el siglo 18.
  • Hacer una lista blanca, a su realidad, órdenes de magnitud más pequeñas, y oh, tenemos que (stackoverflow.com/questions/562303), que también contiene algunos de los mejores de la lista negra de los contendientes…
  • Lamento que contribuyen a que la lista de libros, debe ser cenizas desde el sitio. Un montón de mierda que hay, comenzando con K&R. Es una mala lista y nada ASÍ que deben estar orgullosos de.
  • No creo que este tutorial califica como «La C de GNU Tutorial de Programación»…
  • Esto es un desastre, ¿qué tipo de información a las personas que están poniendo en línea para los nuevos programadores? hmmm.
  • No veo K&R como ‘basura’, incluso si no es una buena manera de aprender contemporánea C.
  • Si usted lee y se centran en su estilo de codificación y la (falta de) el diseño del programa, te das cuenta de que nunca fue un buen libro. Tiene una inmerecida buena reputación, porque 1) por un largo tiempo fue el único libro y también C de canon hasta C90, y 2) a causa de la nostalgia, Dennis Ritchie de culto y otros motivos religiosos.
  • Estoy de acuerdo con el punto que estamos haciendo, pero si usted sigue el «hasta» enlaces en esa página, se llega a algo claramente titulado como «La C de GNU Tutorial de Programación». El mismo contenido se puede encontrar en markburgess.org/CTutorial/GNU-ctut.pdf, por Burgess y Hale-Evans, que dice que los derechos de Autor 2002 Fundación para el Software Libre.
  • Deje de usar al azar tutoriales en internet para aprender C, y se consigue una adecuada, peer-reviewed libro. Egads.
  • «crasseux.com» («crasseux» ~ «sucia» En inglés) parece ser una basura sitio web. Dice: «Este es un archivo de abandonware, mp3, appz y otro tipo de basura, disfrutar». La mejor manera de evitar esto.

InformationsquelleAutor fagricipni | 2017-04-11

9 Comentarios

  1. 111

    Es posible inicializar un C puntero a NULL?

    TL;DR Sí, mucho.


    El real de la afirmación hecha en la guía lee como

    Por otro lado, si se utiliza sólo el único asignación inicial, int *my_int_ptr = 2;, el programa tratará de llenar el contenido de la posición de memoria apuntada por my_int_ptr con el valor 2. Desde my_int_ptr está llena de basura, puede ser cualquier dirección. […]

    Bien, que son mal, está a la derecha.

    Para la declaración, ignorando, por ahora, el hecho de que el puntero a entero de conversión es una aplicación definida por el comportamiento)

    int * my_int_ptr = 2;

    my_int_ptr es una variable de tipo puntero a int), tiene una dirección propia (tipo: dirección del puntero a entero), se va a almacenar un valor de 2 en que dirección.

    Ahora, my_int_ptr, siendo un tipo de puntero, podemos decir, que puntos a el valor de «tipo» en la ubicación de memoria señalado por el valor que se celebró en my_int_ptr. Así que, básicamente se está asignando el valor de la variable de puntero, no el valor de la posición de memoria apuntada por el puntero.

    Así, para la conclusión

     char *x=NULL;

    inicializa la variable de puntero x a NULL, no la valor en la dirección de memoria apuntada por el puntero.

    Este es el mismo como

     char *x;
     x = NULL;    

    De expansión:

    Ahora, estrictamente conforme, una declaración como

     int * my_int_ptr = 2;

    es ilegal, ya que implica la violación de la restricción. Para ser claros,

    • my_int_ptr es un puntero a variable de tipo int *
    • una constante entera, 2 tiene el tipo int, por definición.

    y que no son «compatibles» tipos, por lo que esta inicialización no es válido porque es violar las reglas de asignación simple, mencionado en el capítulo §6.5.16.1/P1, descrito en Lundin la respuesta.

    En caso de que alguien está interesado en cómo la inicialización está vinculado a la simple asignación de restricciones, citando C11, capítulo §6.7.9, P11

    El inicializador de un escalar debe ser una sola expresión, opcionalmente encerrado entre llaves. El
    valor inicial del objeto es el de la expresión (después de la conversión); el mismo tipo de
    las restricciones y las conversiones, como para la asignación simple de aplicar, tomando el tipo de escalar
    para ser el incompetente versión de su tipo declarado.

    • Se son mal. He citado la parte relacionada en mi respuesta, por favor me corrija si de otra manera. Ah, y el énfasis intencional.
    • «… es ilegal, ya que implica la violación de la restricción. … un literal entero, 2 es de tipo int, por definición.» es problemático. Suena como porque 2 es un int, la asignación es un problema. Pero es más que eso. NULL también puede ser una int, un int 0. Es sólo que char *x = 0; está bien definido y char *x = 2; no lo es. 6.3.2.3 Punteros 3 (por CIERTO: C no define un literal entero, sólo literal de cadena y compuesto literal. 0 es un integer constante)
    • Eres muy correcta, pero no es char *x = (void *)0;, a estar de acuerdo? o es solo con otras expresiones que se obtiene un valor 0?
    • las constantes de enteros con valor 0 son especiales: convertir implícitamente a los punteros null por separado de las reglas habituales para explícitamente casting general expresiones entero a los tipos de puntero.
    • El lenguaje descrito por la 1974 C Manual de Referencia no se permiten declaraciones para especificar la inicialización de las expresiones, y la falta de tales expresiones hace de la «declaración de los espejos de uso» mucho más práctico. La sintaxis int *p = somePtrExpression en mi humilde opinión es bastante horrible, ya que se ve como es la configuración del valor de *p pero, en realidad, de establecer el valor de p.
    • Supongo que la confusión puede surgir de la char *hola= «hola»; como esto no inicializar el char * a un bloque de memoria con «hola» en ella

  2. 53

    El tutorial está mal. En ISO C, int *my_int_ptr = 2; es un error. En C de GNU, que significa lo mismo que int *my_int_ptr = (int *)2; . Esto convierte el entero 2 a una dirección de memoria, en cierto modo, como determinado por el compilador.

    No intenta guardar nada en la ubicación dirigida por la dirección (si la hubiere). Si usted pasó a escribir *my_int_ptr = 5;, entonces se trataría de almacenar el número 5 en la ubicación dirigida por la dirección.

    • Yo no sabía que entero para puntero de conversión es definido por la implementación. Gracias por la información.
    • Por favor, tenga en cuenta que hay una conversión sólo en el caso de la fuerza por parte de un elenco, como en esta respuesta. Si no fuera por el elenco, el código no debe compilar.
    • Sí, el de varias conversiones en C son bastante confuso. Este Q tiene información muy interesante sobre las conversiones: C: Cuando es el casting entre los tipos de puntero no un comportamiento indefinido?.
  3. 17

    Para aclarar el motivo por el tutorial está mal, int *my_int_ptr = 2; es una «violación de la restricción», es el código que no está permitido compilar y el compilador debe dar un diagnóstico en caso de encontrarse con él.

    Como por 6.5.16.1 asignación Simple:

    Restricciones

    Uno de los siguientes deberán tener:

    • la izquierda el operando tiene atómica, cualificados o no cualificados aritmética tipo, y el de la derecha tiene aritmética tipo;
    • la izquierda el operando tiene una atómica, cualificados o no cualificados versión de una estructura o tipo de unión compatible con el tipo de la derecha;
    • la izquierda el operando tiene atómica, cualificados o no cualificados tipo de puntero, y (teniendo en cuenta el tipo de la izquierda el operando tendría después de lvalue
      la conversión) ambos operandos son punteros a calificado o no calificado
      versiones de tipos compatibles, y el tipo señalado por la izquierda ha
      todos los partidos de clasificación del tipo señalado por la derecha;
    • la izquierda el operando tiene atómica, cualificados o no cualificados tipo de puntero, y (teniendo en cuenta el tipo de la izquierda el operando tendría después de lvalue
      la conversión) uno de los operandos es un puntero a un tipo de objeto, y el otro
      es un puntero a un técnico cualificado o no cualificado, la versión de vacío, y la
      tipo señalado por la izquierda, que tiene toda la fase de clasificación del tipo de punta
      por el derecho;
    • la izquierda el operando es atómico, cualificados o no cualificados puntero, y el derecho es un puntero null constante; o
    • la izquierda el operando es de tipo atómico, cualificados o no cualificados _Bool, y el derecho es un puntero.

    En este caso la izquierda el operando es un rotundo puntero. En ninguna parte se menciona que el operando derecho es permitido ser un número entero (aritmética tipo). Para que el código se viola el estándar de C.

    GCC se sabe que se comportan mal a menos que explícitamente dicen que para ser un compilador de C estándar. Si se compila el código como -std=c11 -pedantic-errors, va correctamente dar un diagnóstico de como se debe hacer.

    • upvoted para sugerir -pedante-errores. Aunque yo más probable es que se use -Wpedantic .
    • Una excepción a su declaración de que el operando derecho no está permitido ser un número entero: en el Apartado 6.3.2.3 dice, «Un entero constante de la expresión con el valor 0, o tal expresión emitidos a tipo de void *, se llama a un puntero nulo constante.» Aviso de la segunda hasta la última viñeta en su cotización. Por lo tanto, int* p = 0; es una forma legal para escribir int* p = NULL;. Aunque este último es más claro y más convencional.
    • Lo que hace que la anatomía patológica de ofuscación int m = 1, n = 2 * 2, * p = 1 - 1, q = 2 - 1; legal también.
    • cubierto por la viñeta 5 de la norma de cita en esta respuesta (de acuerdo en que el resumen después probablemente se debe mencionar, sin embargo)
    • Yo creo que una bien formada que programa se necesita para convertir un intptr_t explícitamente a uno de los tipos permitidos en el lado derecho. Es decir, void* a = (void*)(intptr_t)b; es legal por el punto 4, pero (intptr_t)b es ni compatible tipo de puntero, ni un void*, ni un puntero nulo constante, y void* a no es ni una media aritmética tipo ni _Bool. La norma dice que la conversión es legal, pero no se que es implícito.
    • b; no es válido C, probarlo en una norma conforme con el compilador de C. 7.20.1.4/1 sólo dice que estos tipos pueden ser usados para convertir de un tipo de puntero y la espalda. Pero el código void *a = (intptr_t) b; no causa una conversión de intptr_t a void*, porque el operando derecho de = se convierte en el tipo de la expresión de asignación (6.1.16.1/2) si la citada restricciones (6.1.16.1/1) se cumplen. Usted tendría que tipo de void *a = (void*)(intptr_t)b; para desencadenar una conversión explícita.
    • La norma dice que 0 es un puntero null constante (punto 5). Esto no se extiende a los números enteros en general.

  4. 15

    int *my_int_ptr = 2

    almacena el valor entero de 2 a cualquiera de las direcciones aleatorias es en my_int_ptr cuando se le asignan.

    Esto es completamente erróneo. Si esto realmente está escrito a continuación, por favor, obtener una mejor libro o tutorial.

    int *my_int_ptr = 2 define un número entero de puntero que apunta a la dirección 2. Lo más probable es obtener un bloqueo si se intenta acceder a la dirección de 2.

    *my_int_ptr = 2, es decir, sin la int en la línea, almacena el valor de dos a cualquiera de las direcciones aleatorias my_int_ptr está señalando. Haber dicho esto, usted puede asignar NULL a un puntero cuando se define. char *x=NULL; es perfectamente válido C.

    Edit: Mientras escribía esto, no sabía que entero para puntero de conversión es definido por la implementación de comportamiento. Por favor, consulte las buenas respuestas por @M. M y @SouravGhosh para más detalles.

    • Es completamente erróneo, porque es una violación de la restricción, y no por cualquier otra razón. En particular, esto es incorrecto: «int *my_int_ptr = 2 se define un número entero de puntero que apunta a la dirección 2».
    • gracias por aclarar.
    • Su frase «no por cualquier otra razón» es en sí misma errónea y engañosa. Si usted fijar el tipo de problema de compatibilidad, aún le quedan con el hecho de que el tutorial del autor es extremadamente tergiversar cómo puntero inicializaciones y asignaciones de trabajo.
  5. 14

    Una gran confusión acerca de C punteros viene de una muy mala elección que hizo originalmente con respecto a estilo de codificación, corroborado por una muy mala opción poco en la sintaxis del lenguaje.

    int *x = NULL; es correcta C, pero es muy engañoso, yo diría incluso absurda, y que ha dificultado la comprensión de la lengua para muchos un novato. Esto nos hace pensar que más tarde podríamos hacer *x = NULL; que es imposible, por supuesto. Se puede ver, el tipo de la variable no es int, y el nombre de la variable no es *x, ni la * en la declaración de jugar algún papel funcional en colaboración con la =. Es puramente declarativa. Así, lo que hace mucho más sentido es este:

    int* x = NULL; que también es correcta C, aunque no se adhiere a la original K&R el estilo de codificación. Se deja perfectamente claro que el tipo es int*, y la variable de puntero es x, por lo que se hace claramente evidente incluso para los no iniciados que el valor NULL se almacena en x, que es un puntero a int.

    Además, se hace más fácil para derivar una regla: cuando la estrella se aleja de el nombre de la variable, a continuación, es una declaración, mientras que la estrella se adjunta al nombre es puntero de eliminar.

    Por lo tanto, ahora se hace mucho más comprensible que el de más abajo podemos hacer x = NULL; o *x = 2; en otras palabras, se hace más fácil para un principiante para ver cómo variable = expression conduce a pointer-type variable = pointer-expression y dereferenced-pointer-variable = expression. (Para los iniciados, por la ‘expresión’ quiero decir ‘r-value’.)

    La desafortunada elección en la sintaxis del lenguaje es que cuando se declaran las variables locales se puede decir int i, *p; que declara un entero y un puntero a un entero, por lo que nos lleva a creer que la * es una parte útil del nombre. Pero no lo es, y esta sintaxis es sólo un peculiar caso especial, añadido por conveniencia, y en mi opinión debería haber existido nunca, porque invalida la regla que he propuesto más arriba. Que yo sepa, en ningún otro lugar en el idioma que se esta sintaxis significativo, pero incluso si es así, se apunta a una discrepancia en la forma en que los tipos de puntero se define en C. en todas partes, en una sola variable declaraciones, en las listas de parámetros, en los miembros de una estructura, etc. usted puede declarar su punteros como type* pointer-variable en lugar de type *pointer-variable; es perfectamente legal y tiene más sentido.

    • int *x = NULL; is correct C, but it is very misleading, I would even say nonsensical,… Tengo que estar de acuerdo para estar en desacuerdo. It makes one think….dejar de pensar, de leer un libro de lenguaje C, en primer lugar, no hay delito.
    • Añadir a que, según su opinión, int* somePtr= NULL, someotherPtr = NULL;…creo que de la diversión. 🙂
    • ^^ esto tendría mucho sentido para mí. Así que, supongo que es subjetivo.
    • Como una cuestión de opinión, creo que C debe ha sido diseñado de manera que int* somePtr, someotherPtr declara dos punteros, de hecho, yo solía escribir int* somePtr, pero que conduce al error que usted describe.
    • Dejé de usar la variable múltiple sintaxis de declaración a causa de esto. Declaro mi las variables una por una. Si yo realmente quiero en la misma línea, yo les separan con punto y coma en lugar de comas. «Si un lugar es malo, no ir a ese lugar.»
    • Bueno, si yo podría haber diseñado linux desde cero, yo habría usado create en lugar de creat. 🙂 El punto es que es como es y tenemos que moldear a nosotros mismos para adaptarse a eso. Todo se reduce a una elección personal, al final del día, de acuerdo.
    • ¿Cómo se puede explicar int* y[10]; ? Esto declara y de tipo int*[10].
    • Realmente no puedo explicarlo, creo que es una más de esas cosas raras acerca de C. Pero, al mismo tiempo, int *y[10] no hacer las cosas más claras.

  6. 6

    Me gustaría añadir algo ortogonal a los muchos y excelentes respuestas. En realidad, la inicialización en NULL está lejos de mala práctica y puede ser útil si ese puntero puede o no puede ser utilizado para almacenar un asignada dinámicamente bloque de memoria.

    int * p = NULL;
    ...
    if (...) {
        p = (int*) malloc(...);
        ...
    }
    ...
    free(p);

    Ya que según el ISO-IEC 9899 estándar free es un nop cuando el argumento es NULL, el código anterior (o algo más significativo a lo largo de la misma línea) es de fiar.

    • Es redundante para emitir el resultado de malloc en C, a menos que el código C también debe compilar C++.
    • Tienes razón, la void* se convierte como sea necesario. Pero tener el código que funciona con una C y un compilador de C++ puede tener beneficios.
    • C y C++ son lenguajes diferentes. Sólo hay errores de espera para usted si intenta compilar un archivo fuente escrito por uno usando un compilador diseñado para el otro. Es como tratar de escribir código C que se puede compilar utilizando Pascal herramientas.
    • Un uso común en el caso de código que debe compilar como C o C++ biblioteca de archivos de encabezado. Usted puede escribir dos versiones y el uso #ifdef __cplusplus para seleccionar el idioma, pero que añade los modos de falla y viola SECO. Es mucho más simple y más seguro en aquellos casos en los que escribir el código que funciona en todas partes. Concedido, una llamada a malloc() es poco probable que aparezca en un archivo de encabezado. Además, el reparto es benigno y algunas personas piensan que mejora la claridad.
    • Voy a tomar su palabra para eso: no es un caso de uso que he visto desde 1990, pero eso no quiere decir que no existen todavía. Para nuevos proyectos, recomiendo que los dos son tratados como totalmente incompatible idiomas tan distintos como el F# y APL. ¿Cómo garantiza que usted escoge la correcta biblioteca? C y C++ tienen diferentes convenciones de llamada y la vinculación de la incorrecta podría causar que todo el infierno para romper suelto, incluso si se podía llegar a construir. Suena como demasiado riesgo para muy poca recompensa para mí.
    • Un buen consejo. I (intentar) siempre inicializar mi puntero constantes a algo. En la moderna C, este suele ser su valor final y que pueden ser const punteros declarado en los medios de comunicación res, pero incluso cuando un puntero debe ser mutable (como el utilizado en un bucle o por realloc()), configuración a NULL capturas de los errores en los que se utiliza antes de que se establezca con su valor real. En la mayoría de los sistemas, de eliminar NULL provoca una violación de segmento en el punto de falla (aunque hay excepciones), mientras que un puntero sin inicializar contiene basura y escribir corrompe arbitrarias de memoria.
    • Además, es muy fácil ver en el depurador que un puntero contiene NULL, pero puede ser muy difícil decirle a un cubo de basura puntero de una válida. Por lo que es útil para asegurarse de que todos los punteros son siempre válidas o NULL, desde el momento de la declaración.
    • Buscando el primer ejemplo que viene a la mente, la versión de glibc <stdio.h>, de la línea 27 se #ifdef __cplusplus. Por el estándar de C++, todos los compiladores de C++ debe apoyar #include <stdio.h>, por ejemplo. Yo casi nunca se ven C bibliotecas que prohibir llamarlos de los programas de C++. Estoy de acuerdo en que es muy raro ver nada, pero el tipo de prototipos de función, extern las definiciones de variables y macros que suelen aparecen en los archivos de cabecera C escrito en ambos idiomas, aunque. Más probablemente, la gente que se enteró de C++ primero acaba de conseguir en el hábito.
    • Así, una especie de ¿por qué escribo ++i; en lugar de i++; en ambos idiomas menos que realmente se preocupan por el valor de retorno. En C++, con diferentes clases, que guarda el compilador a partir de la creación de un innecesario objeto temporal. Yo no perdonó a las neuronas a hacer de manera diferente en C.
    • Exactamente. En C o en C++ con la forma y los tipos de puntero, no importa. Pero, en C++ con más compleja clases y sobrecarga de operadores, se puede hacer una gran diferencia! Así que tengo la costumbre de hacerlo de manera que siempre funciona. Sospecho que es por eso que muchas personas echan void* valores de retorno de forma explícita.
    • Puedo ser pedante? (Ehm, como si…) El código de esta respuesta tiene un potencial de pérdida de memoria, porque dice p = malloc(... sin comprobar si p es todavía NULL. También, la pregunta era acerca de C, así que ¿por qué es este hilo de comentarios acerca de C++?
    • Puede ser pedante, por supuesto 🙂 Pero creo que se parecen perder el punto. He escrito un stub sólo para mostrar que mediante la creación de p a NULL usted puede incluso si usted toma una rama que termina por no tocar p. Si no se inicializa obtendría una violación de segmento. Davislor añadido un par de puntos más, por ejemplo, que un valor NULL es más fácil de detectar durante la depuración. Todo esto se aplica a c así. La única c++ punto específico es un detalle (no es el punto principal), es decir, el reparto.
    • El código no tiene ninguna fuga, simplemente porque no se especifica lo que es en los puntos suspensivos 😀 Pero tienes razón, dependiendo de lo que ponga en los puntos suspensivos que usted necesita para comprobar p antes de asignar el resultado de la malloc.

  7. 1

    Esto es correcto.

    int main()
    {
        char * x = NULL;
    
        if (x==NULL)
            printf("is NULL\n");
    
        return EXIT_SUCCESS;
    }

    Esta función es correcta para lo que hace. Se asigna la dirección del 0 al puntero char x. Es decir, la que apunta el puntero x en la dirección de memoria 0.

    Alternativa:

    int main()
    {
        char* x = 0;
    
        if ( !x )
            printf(" x points to NULL\n");
    
        return EXIT_SUCCESS;
    }

    Mi conjetura en cuanto a lo que quería es:

    int main()
    {
        char* x = NULL;
        x = alloc( sizeof( char ));
        *x = '2';
    
        if ( *x == '2' )
            printf(" x points to an address/location that contains a '2' \n");
    
        return EXIT_SUCCESS;
    }
    
    x is the street address of a house. *x examines the contents of that house.
    • «Se asigna la dirección del 0 al puntero char x». –> tal vez. C no especifica el valor de el puntero, sólo que char* x = 0; if (x == 0) será cierto. Los punteros no son necesariamente enteros.
    • No ‘punto del puntero x en la dirección de memoria 0’. Establece el valor del puntero a una sin especificar no válido valor que se puede prueba por comparación con 0 o NULL. La operación real de la implementación definido. No hay nada aquí que responde a la pregunta.
  8. -2

    Sólo recuerde:

    En C, lado izquierdo de valor siempre se evalúa en una ubicación de memoria, mientras que del lado derecho siempre se evalúa a un valor(un int o de la dirección o de la clase Foo).

    • Así que si tenemos int x; x = 2;, El x en x = 2 evalúa a una ubicación de memoria?
    • Sí, puedes poner 2 en donde x es, ¿cuál es el problema? msdn.microsoft.com/en-us/library/bkbs2cds.aspx
    • El problema es que x no se evalúa a una ubicación de memoria.
    • Entonces incomprendido a lo que me refiero.
    • Este es el pensamiento en un nivel equivocado acerca de lvalues. Por ejemplo, hay una buena probabilidad de que int foo() {int x; x = 2; return x;} se compila a algo como mov eax, 2. No se exactamente a cualquier dirección de memoria, como en el código de derecho?

Dejar respuesta

Please enter your comment!
Please enter your name here