¿Por qué la mayoría de los programadores de C de nombre a variables como este:

int *myVariable;

lugar de como esta:

int* myVariable;

Ambos son válidos. A mí me parece que el asterisco es una parte de la clase, no de una parte del nombre de la variable. ¿Alguien puede explicar esta lógica?

  • posibles duplicados de las declaraciones de Puntero en C++: la colocación de la asterisco
  • El segundo estilo se parece más intuitivo en general, pero el primero es el camino a seguir para evitar relacionadas con el tipo de errores en el código. Si usted está realmente conectado a este último estilo, siempre se puede ir con typedefs, pero que añade una complejidad innecesaria, en mi humilde opinión.
InformationsquelleAutor WBlasko | 2008-12-29

13 Comentarios

  1. 233

    Son EXACTAMENTE equivalentes.
    Sin embargo, en

    int *myVariable, myVariable2;

    Parece obvio que mivariable tiene el tipo int*, mientras que myVariable2 tiene el tipo int.
    En

    int* myVariable, myVariable2;

    puede parecer obvio que ambos son de tipo int*, pero que no es correcto como myVariable2 tiene el tipo int.

    Por lo tanto, el primer estilo de programación es más intuitivo.

    • tal vez, pero yo no mezclar y combinar tipos en una declaración.
    • De acuerdo. Incluso después de leer todos los argumentos aquí, me estoy pegando con int* someVar para proyectos personales. Tiene más sentido.
    • Sólo tiene más sentido hasta que aprenda C de la declaración de la sintaxis basada en «declaraciones siguen a utilizar». Las declaraciones se utiliza la misma sintaxis que el uso del mismo tipo de las variables de hacer. Cuando se declara un array de enteros, no se ve como: int[10] x. Esto es simplemente no C de la sintaxis. La gramática explícita analiza como: int (*x), y no como (int *) x, por lo que colocar el asterisco de la izquierda es simplemente engañosa y se basan en un malentendido de C sintaxis de declaración.
    • Corrección: por lo tanto, nunca se debe declarar más de una variable en una sola línea. En general, usted no debe motivar a un cierto estilo de codificación basada en algunas otras no relacionadas, malo y peligroso estilo de codificación.
    • Esta es la razón por la que se adhieren a una variable por declaración de puntero. No hay absolutamente ninguna confusión si no int* myVariable; int myVariable2; lugar.
    • «puede parecer obvio que ambos son de tipo int*» No es tan obvio, este es un ingenuo argumento. Considere la posibilidad de int *const a, b;. ¿De dónde viene el * «enlazar»? El tipo de a es int *const, así que ¿cómo puede usted decir que el * pertenece a la variable cuando se parte de el tipo de la misma?
    • es la manera de que el compilador, debe», El compilador grupos que como int * const a , b ; punto en el que es obvio lo que está pasando.
    • Estoy totalmente de acuerdo con esta respuesta. Sólo tenía que echada en mi centavo y medio. Mi estilo preferido de la declaración de variables es mantener las variables del mismo tipo definido de manera conjunta. Yo por lo general tienen una línea de char *buffer = 0, *swap = 0, *outbuff = 0; no sé, parece ordenado y organizado en forma eficiente la minimización de la función de la altura, ya que los compiladores de tomar el símbolo inmediatamente después del asterisco para ser el puntero, para mí siempre ha sentido poner el asterisco antes del nombre de la variable.

  2. 114

    Si se mira de otra manera, *myVariable es de tipo int, que tiene algún sentido.

    • Esta es mi explicación favorita, y funciona bien, porque explica C de la declaración de las peculiaridades en general, incluso la desagradable y antipático puntero a la función de la sintaxis.
    • Es limpio, ya que se puede imaginar no hay ninguna real de los tipos de puntero. Sólo hay variables que, cuando debidamente referenciado o eliminan las referencias, le da uno de los tipos primitivos.
    • En realidad, ‘*mivariable’ puede ser de tipo NULL. Para empeorar las cosas, que podría ser un azar de la memoria ubicación de la memoria.
    • qonf: NULL no es un tipo. myVariable puede ser NULO, en cuyo caso *myVariable provoca un fallo de segmentación, pero no hay ningún tipo NULL.
    • Este punto puede ser engañoso, en este contexto: int x = 5; int *pointer = &x;, porque sugiere que establezca la int *pointer a algún valor, no el pointer sí mismo.
    • La misma lógica puede también ser utilizado para las matrices: «int x[10]» significa que «x[n] es un entero» en lugar de «int a[10] x» o «*int x», lo que significa que «x es una matriz/un puntero a enteros». Hacerlo de esta manera para las cosas tales como «int x, *y, z[10]», lo que significa que x, *y, z[n] son enteros.
    • int *const x. «*const es de tipo int». Umm…
    • Sí, ANSI C añade la palabra clave const, que se rompió a las «declaraciones de espejo de usar» un poco.

  3. 40

    Porque el * en la línea que une más estrechamente a la variable que el tipo:

    int* varA, varB; //This is misleading

    Como @Lundin señala a continuación, const añade aún más sutilezas que pensar. Que de todo se puede eludir esta declarando una variable por línea, que nunca es ambigua:

    int* varA;
    int varB;

    El equilibrio entre el código y concisa código es difícil de huelga — de una docena de líneas redundantes de int a; no es bueno tampoco. Aún así, me defecto a una declaración por línea y la preocupación acerca de la combinación de código más adelante.

    • Así, la engañosa primer ejemplo está en mis ojos un error de diseño. Si pudiera, me iba a quitar esa forma de declaración de C completamente, y por lo tanto son de tipo int*.
    • «el * une más estrechamente a la variable de tipo» Este es un ingenuo argumento. Considere la posibilidad de int *const a, b;. ¿De dónde viene el * «enlazar»? El tipo de a es int* const, así que ¿cómo puede usted decir que el * pertenece a la variable cuando se parte de el tipo de la misma?
    • Específica a la pregunta, o cubriendo todos los casos: elija uno. Voy a hacer una nota, pero este es otro buen argumento para mi última sugerencia: una declaración por línea reduce las oportunidades para desordenar esto.
  4. 31

    Algo que nadie ha mencionado aquí por el momento es que el asterisco es en realidad el «eliminar operador» en C.

    *a = 10;

    La línea anterior no significa que quiera asignar 10 a a, significa que quiero asignar 10 a cualquier ubicación de la memoria a puntos. Y nunca he visto a nadie de la escritura

    * a = 10;

    tiene usted? Así que el eliminar operador es bastante escriben siempre sin dejar un espacio. Esta es, probablemente, para distinguirla de una multiplicación roto a través de múltiples líneas:

    x = a * b * c * d
      * e * f * g;

    Aquí *e sería engañoso, ¿no?

    Ahora bien, ¿qué significa la siguiente línea en realidad significa:

    int *a;

    La mayoría de la gente diría:

    Significa que a es un puntero a una int valor.

    Esto es técnicamente correcto, la mayoría de la gente le gusta ver/leer esa manera, y esa es la forma moderna de la C que las normas que lo definen (tenga en cuenta que el lenguaje C sí mismo es anterior a todos los estándares ANSI e ISO). Pero no es la única forma de mirarlo. También puede leer esta línea como sigue:

    El valor sin referencia de a es de tipo int.

    Así en el hecho de que el asterisco en esta declaración puede ser visto también como una de eliminar el operador, lo que también explica su colocación. Y que a es un puntero no es realmente declarado en absoluto, que está implícito en el hecho de que la única cosa que realmente puede desreferenciar un puntero.

    El estándar de C sólo define dos significados para el * operador:

    • operador de direccionamiento indirecto
    • operador de multiplicación

    Y direccionamiento indirecto es solo un decir, no existe ningún significado extra para declarar un puntero, no es sólo direccionamiento indirecto, que es lo que la operación de eliminación de referencias que hace, se realiza un acceso indirecto, por lo que también dentro de una instrucción como int *a; esto es una indirecta acceso (* medios de acceso indirecto) y por lo tanto la segunda afirmación anterior está mucho más cerca de la norma que el primero es.

    • Gracias por me ahorro de escribir otra respuesta aquí. Por CIERTO, yo suelo leer el int a, *b, (*c)(); como algo parecido a «declarar los siguientes objetos como int: el objeto a, el objeto apuntado por b, y el objeto devuelto de la función señalada por c«.
    • El * en int *a; no es un operador, y no se trata de eliminar a (que no está definido aún)
    • Por favor el nombre de la página y el número de línea de cualquier ISO de C estándar donde este estándar dice que el asterisco puede ser algo más que la multiplicación o la indirección. Sólo muestra «declaración de puntero» por ejemplo, en ninguna parte se define un tercer significado para asterisk (y no define ningún sentido, que no sería un operador). Oh, yo en ningún reclamo está «definido», que hizo que hasta. O como Jonathan Leffler hat puso en el estándar de C, * es siempre «gramática», no forma parte de la declaración de los especificadores de la lista (por lo que no es parte de una declaración, por lo que debe ser un operador)
    • ver C11 6.7.6.1/1, el significado de * en declarators se especifica. Es una parte de la sintaxis para declarar un puntero (por ejemplo, int * a; declara a tipo «puntero a int«)
    • El uso de * como un operador está definido por C11 6.5.3. El código int *a; no coincide con la especificación de gramática para un unario-expresión, por lo tanto, la * símbolo no es un operador de allí. De hecho, int *a; es una declaración. Declaraciones y expresiones son diferentes. Las declaraciones están cubiertos por 6.7, expresiones están cubiertos por 6.5.
    • 6.7.6.1 sólo se muestra la declaración, por ejemplo, exactamente como he dicho, no da significa para * (que sólo da un significado a la expresión total, no a la * dentro de la expresión!). Se dice que «int a;» declara un puntero, que lo hace, nunca dijo lo contrario, pero sin un significado que se da a *, la lectura como *el valor sin referencia de a es un int es todavía totalmente válido, ya que tiene el mismo significado fáctico. Nada, en realidad no hay nada escrito en 6.7.6.1 contradice esa afirmación.
    • No hay una «expresión total». int *a; es una declaración, no una expresión. a no se eliminan las referencias por int *a;. a aún no existe todavía en el punto de la * está siendo procesada. ¿Crees que int *a = NULL; es un error porque elimina referencias a un puntero nulo?

  5. 17

    Voy a salir en una extremidad aquí y decir que hay una respuesta clara a esta pregunta, tanto para las declaraciones de variables y de los parámetros y tipos de retorno, que es que el asterisco debe ir junto al nombre de: int *myVariable;. Para apreciar por qué, mira cómo declarar otros tipos de símbolo en C:

    int my_function(int arg); para una función;

    float my_array[3] de una matriz.

    El patrón general, que se conoce como declaración de la siguiente manera el uso de, es que el tipo de símbolo se divide en la parte antes de que el nombre, y las partes alrededor de el nombre, y estas piezas de todo el nombre de imitar la sintaxis que se usa para obtener un valor del tipo de la izquierda:

    int a_return_value = my_function(729);

    float an_element = my_array[2];

    y: int copy_of_value = *myVariable;.

    C++ lanza una llave en las obras con referencias, porque la sintaxis en el punto donde se utilizan referencias es idéntica a la de los tipos de valor, por lo que se podría argumentar que C++ tiene un enfoque diferente de C. Por otro lado, C++ mantiene el mismo comportamiento de C en el caso de los punteros, por lo que las referencias están realmente como el impar hacia fuera en este sentido.

  6. 11

    Que es sólo una cuestión de preferencia.

    Al leer el código, distinguiendo entre variables y punteros es más fácil en el segundo caso, pero puede llevar a confusión cuando se está poniendo ambas variables y punteros de un tipo común en una sola línea (que es a menudo desalentados por las directrices del proyecto, ya que disminuye la legibilidad).

    Prefiero declarar punteros con su correspondiente signo al lado del nombre del tipo, por ejemplo,

    int* pMyPointer;
    • La pregunta es acerca de C, donde no hay referencias.
    • Gracias por decírmelo, aunque la pregunta no es acerca de punteros o referencias, pero sobre formateo de código, básicamente.
  7. 7

    En K&R, se coloca el puntero del operador junto al nombre de la variable en lugar del tipo. Personalmente, considero que el libro sea la máxima autoridad C/de la biblia. También viene de un Objetivo-C de fondo, sigo el *nombre de la convención.

  8. 7

    Una gran gurú dijo una vez: «Leer es el camino del compilador, usted debe.»

    http://www.drdobbs.com/conversationsa-midsummer-nights-madness/184403835

    Concedido este fue el tema de la const colocación, pero la misma regla se aplica aquí.

    El compilador lee como:

    int (*a);

    no como:

    (int*) a;

    Si te metes en el hábito de poner la estrella junto a la variable, para hacer una de sus declaraciones más fácil de leer. También evita hacer daño a la vista, tales como:

    int* a[10];

    — Edit —

    Para explicar exactamente a qué me refiero cuando digo que se analiza como int (*a), que significa que * se une más fuertemente a a que int, en gran medida la forma que en la expresión 4 + 3 * 7 3 se une más fuertemente a 7 que 4 debido a la mayor preferencia de *.

    Con disculpas por el arte ascii, una sinopsis de la A. S. T. para el análisis de int *a se ve aproximadamente así:

          Declaration
          /         \
         /           \
    Declaration-      Init-
    Secifiers       Declarator-
        |             List
        |               |
        |              ...
      "int"             |
                    Declarator
                    /       \
                   /        ...
               Pointer        \
                  |        Identifier
                  |            |
                 "*"           |
                              "a"

    Como se muestra claramente, * se une más fuertemente a a desde su ancestro común es Declarator, mientras que usted necesita para ir todo el camino hasta el árbol para Declaration para encontrar un antepasado común que implica la int.

    • No, el compilador definitivamente lee el tipo de (int*) a.
    • Este es el gran malentendido de que la mayoría de los modernos los programadores de C++ tienen. El análisis de una declaración de variable es algo como esto. Paso 1. Leer el primer token, que se convierte en el «tipo de base» de la declaración. int en este caso. Paso 2. Leer una declaración, incluyendo cualquier tipo de decoración. *a en este caso. Paso 3 Lea el siguiente carácter. Si por comas, de consumir y volver al paso 2. Si el punto y coma parar. Si nada más tirar un error de sintaxis. …
    • Si el analizador se lea de la manera como se sugiere, entonces nos gustaría ser capaz de escribir int* a, b; y conseguir un par de punteros. El punto que estoy haciendo es que el * se une a la variable y se analiza con él, no con el tipo para formar el «tipo de base» de la declaración. Eso también es parte de la razón por la que typedefs se introdujo para permitir que typedef int *iptr; iptr a, b; crear un par de punteros. Mediante el uso de un typedef que puede enlazar la * a la int.
    • No, el compilador más probable es que se lea como el formal de la sintaxis indica (ver mi respuesta para citas). Que es: la sentencia declarativa-especificador de independiente y el init-declaradores-lista separada, en donde este último se divide en elementos de puntero/direct-declarador de pares. A continuación, la hora de determinar el tipo real de la variable, la sentencia declarativa-especificador y el puntero junto forma el tipo.
    • Sí, el compilador lee como la sintaxis contaned en la norma dicta. Que se pueden encontrar como BNF en varios lugares en la web. O como se muestra arriba en el arte ascii he añadido. El punto que estoy tratando de hacer es que Declarator (parte de la Init-Declarator-List) consume tanto el * y el nombre de la variable. Es la base sobre la que he estado lo que se analiza como int (*a)
    • … Sin duda, el compilador «combina» el tipo base de la Declaration-Specifier con el «decoraciones» en la Declarator para llegar a la final para cada tipo de variable. Sin embargo no se «mueven» las decoraciones para la Declaración de especificador de lo contrario int a[10], b; produciría completamente ridículo de los resultados, Se analiza int *a, b[10]; como int *a , b[10] ;. No hay otra manera de describir lo que hace sentido.
    • Sí, bueno, la parte importante aquí no es realmente la sintaxis o el fin de que el compilador de análisis, pero que el tipo de int*a es el final de leer por el compilador como: «a tiene el tipo int*«. Que fue lo que me refiero con mi comentario original.

  9. 3

    Porque tiene más sentido cuando se tiene declaraciones como:

    int *a, *b;
    • Esto es, literalmente, un ejemplo de una petición de principio. No, no tiene más sentido de esa manera. «int* a ,b» podría hacer que ambos punteros.
    • Tienes la cola que menea al perro allí. Seguro K&R puede ha especificado que int* a, b; hecho b un puntero a int. Pero ellos no. Y con buena razón. Bajo la propuesta de su sistema ¿cuál es el tipo de b en la siguiente declaración: int* a[10], b;?
  10. 2

    Para declarar múltiples punteros en una línea, yo prefiero int* a, * b; que de forma más intuitiva declara «un» como un puntero a un entero, y no se mezcla de estilos cuando, asimismo, declarar la «b». Como alguien dijo, yo no declarar dos diferentes tipos en la misma declaración de todos modos.

  11. 2

    Personas que prefieren int* x; están tratando de forzar su código en un mundo de ficción donde el tipo está en la izquierda y el identificador (nombre) está a la derecha.

    Digo «ficticio» porque:

    En C y C++, en el caso general, que declaró el identificador está rodeado por el tipo de información.

    Que puede sonar loco, pero usted sabe que es verdad. Aquí están algunos ejemplos:

    • int main(int argc, char *argv[]) significa «main es una función que toma un int y una matriz de punteros a char y devuelve un int.» En otras palabras, la mayoría de los del tipo de información que está a la derecha. Algunas personas piensan que las declaraciones de función no cuentan porque son de alguna manera «especial». OK, vamos a intentar una variable.

    • void (*fn)(int) significa fn es un puntero a una función que toma un int y no devuelve nada.

    • int a[10] declara ‘a’ como una matriz de 10 ints.

    • pixel bitmap[height][width].

    • Claramente, he palmitas ejemplos que tienen una gran cantidad de información de tipo en la derecha para hacer mi punto. Hay un montón de declaraciones donde la mayoría-si no todos-de que el tipo está en la izquierda, como struct { int x; int y; } center.

    Esta sintaxis de declaración surgió de K&R del deseo de las declaraciones de reflejar el uso. La lectura de simples declaraciones es intuitivo, y la lectura más compleja puede ser dominado por el aprendizaje de la derecha-izquierda-derecha de la regla (a veces llamada la espiral de la norma o sólo a la derecha-a la izquierda de la regla).

    C es bastante sencilla que muchos programadores de C abrazo de este estilo y de la escritura simples declaraciones como int *p.

    En C++, la sintaxis tiene un poco más complejo (con las clases, las referencias, las plantillas, la enumeración de las clases), y, como una reacción a esa complejidad, vamos a ver más esfuerzo en separar el tipo del identificador en muchas declaraciones. En otras palabras, usted puede ver más de int* p-declaraciones de estilo si usted echa un vistazo a una gran franja de código C++.

    En cualquiera de los dos idiomas, que puede siempre tiene el tipo en el lado izquierdo de variable declaraciones (1) nunca declarar múltiples variables en la misma instrucción, y (2) hacer uso de typedefs (o alias declaraciones, que, irónicamente, poner el alias de identificadores a la izquierda de tipos). Por ejemplo:

    typedef int array_of_10_ints[10];
    array_of_10_ints a;
    • Pequeña pregunta, ¿por qué no puede void (*fn)(int) significa «fn es una función que acepta un int y devuelve (void *) ?
    • Porque los paréntesis en (*fn) mantener el puntero asociado con fn más que el tipo de retorno.
    • Lo consiguió. Creo que es lo suficientemente importante como para ser añadido en su respuesta, voy a sugerir una edición muy pronto.
    • Creo que satura la respuesta sin agregar mucho valor. Esto es simplemente la sintaxis de la lengua. La mayoría de la gente preguntando acerca de por qué la sintaxis es de esta manera que, probablemente, ya saben las reglas. Cualquier otra persona a quien confundido en este punto se puede ver la aclaración en estos comentarios.
  12. 1

    Ya he contestado a una pregunta similar en el CP, y, porque nadie ha mencionado que, también aquí tengo que señalar que C es un lenguaje de formato libre, sea cual sea el estilo que usted elija su bien, mientras que el analizador puede hacer una distinción de cada token.
    Esta peculiaridad de C a un tipo muy especial de concurso llamado C ofuscación concurso.

  13. 0

    Muchos de los argumentos en este tema son claras subjetivo y el argumento acerca de «la estrella se une a el nombre de la variable» es ingenuo. Aquí hay un par de argumentos que no son solo opiniones:


    El olvidado tipo de puntero calificadores

    Formalmente, la «estrella» ni pertenece al tipo ni el nombre de la variable, es parte de su propia gramaticales elemento denominado puntero. Formal de la sintaxis de C (ISO 9899:2018) es:

    (6.7) declaración:

    declaración de los especificadores de init-declaradores-lista deopción ;

    Donde declaración de los especificadores de contiene el tipo (y almacenamiento), y el init-declaradores-lista de contiene el puntero y el nombre de la variable. Lo que vemos si diseccionar esta sentencia declarativa de la lista de sintaxis más:

    (6.7.6) sentencia declarativa:

    punteroopción directo-declarador de



    (6.7.6) puntero:

    * tipo de calificador de lista deopción

    * tipo de calificador de lista deopción puntero

    Donde una sentencia declarativa es el conjunto de la declaración, directa-declarador es el identificador (nombre de variable), y un puntero es la estrella seguido por un tipo opcional calificador de lista de pertenecer a el puntero en sí.

    Lo que hace que los diferentes estilos de los argumentos sobre «la estrella pertenece a la variable» incoherente, es que se han olvidado de estos tipo de puntero calificadores. int* const x, int *const x o int*const x?

    Considerar int *const a, b;, ¿cuáles son los tipos de a y b? No es tan obvia que «la estrella pertenece a la variable» más. Más bien, uno podría empezar a meditar en donde el const pertenece.

    Que sin duda puede hacer un argumento sólido de que la estrella pertenece al tipo de puntero calificador, pero no mucho más que eso.

    El tipo de calificador de lista para el puntero puede causar problemas para las personas que utilizan el int *a estilo. Aquellos que usan punteros dentro de un typedef (que no deberíamos, muy mala práctica!) y pensar que «la estrella pertenece a el nombre de la variable» tienden a escribir esta muy sutil error:

        /*** bad code, don't do this ***/
        typedef int *bad_idea_t; 
        ...
        void func (const bad_idea_t *foo);

    Esto compila correctamente. Ahora usted puede pensar que el código está hecho const correcta. No es así! Este código es accidentalmente un fingido const corrección.

    El tipo de foo es en realidad int*const* – el exterior de la mayoría de puntero fue de sólo lectura, no la punta de los datos. Así que dentro de esta función podemos hacer **foo = n; y va a cambiar el valor de la variable en el llamador.

    Esto es debido a que en la expresión const bad_idea_t *foo, el * no pertenece a el nombre de la variable aquí! En pseudo-código, este parámetro declaración es para ser leído como const (bad_idea_t *) foo y no como (const bad_idea_t) *foo. La estrella pertenece a la escondida tipo de puntero, en este caso, el tipo es un puntero y un const calificados puntero está escrito como *const.

    Pero la raíz del problema en el ejemplo de arriba es la práctica de ocultar detrás de los punteros de un typedef y no la * estilo.


    Respecto a la declaración de varias variables en una sola línea

    Declarar varias variables en una sola línea es ampliamente reconocida como una mala práctica1). CERT-C, lo resume muy bien como:

    DCL04-C. no declarar más de una variable por declaración de

    Sólo leer el inglés, entonces el sentido común está de acuerdo en que un declaración debe ser uno declaración.

    Y no importa si las variables son punteros o no. Declarar cada variable en una sola línea hace que el código sea más claro en casi todos los casos.

    Por lo que el argumento acerca de que el programador se confundan sobre int* a, b es malo. La raíz del problema es el uso de múltiples declarators, no la colocación de la *. Independientemente del estilo, usted debería escribir esto en su lugar:

        int* a; //or int *a
        int b;

    Otro sonido, pero subjetiva argumento sería que, dado int* a el tipo de a es sin duda int* y así la estrella pertenece con el tipo de clasificación.

    Pero básicamente mi conclusión es que muchos de los argumentos publicados aquí son sólo subjetivas e ingenuo. Realmente no se puede hacer un argumento válido para cualquiera de los estilos – es realmente una cuestión subjetiva de preferencia personal.


    1) CERT-C DCL04-C.

    • En lugar de sorprendentemente, si has leído el artículo que me enlaza, hay una breve sección sobre el tema de typedef int *bad_idea_t; void func(const bad_idea_t bar); Como el gran profeta Dan Saks enseña «Si usted coloque siempre la const a la derecha tanto como usted puede, sin cambiar el significado semántico» esta completamente deja de ser un problema. También hace que su const declaraciones más consistente para leer. «Todo a la derecha de la palabra const es la que es constante, todo a la izquierda es su tipo.» Esto se aplicará a todos consts en una declaración. Intente con int const * * const x;

Dejar respuesta

Please enter your comment!
Please enter your name here