Tal vez yo no soy de este planeta, pero me parece que el siguiente debe ser un error de sintaxis:

int a[] = {1,2,}; //extra comma in the end

Pero no lo es. Me sorprendió cuando este código compilado en Visual Studio, pero he aprendido a no confiar en MSVC compilador tan lejos como C++ reglas, por lo que he comprobado el standard y es permitido por la norma así. Usted puede ver 8.5.1 por las reglas de la gramática si no me creen.

int a[] = {1,2,}; Extraño coma permitido. Alguna razón en particular?

¿Por qué es esto permitido? Esto puede ser un estúpido inútil pregunta, pero quiero que entiendas por qué estoy pidiendo. Si se tratara de un sub-caso general de una regla gramatical, entiendo yo – que decidió no hacer la gramática en general más difícil sólo para no permitir redundante coma al final de una lista de inicializador. Pero no, el adicional por comas es explícitamente permitido. Por ejemplo, no está permitido tener un redundantes coma al final de una función llamada lista de argumentos (cuando la función toma ...), que es normal.

Así que, de nuevo, ¿hay alguna razón en particular redundante coma es explícitamente permitido?

  • Tenga en cuenta también que VIM sintaxis de la sangría parece empujar este estilo, me ha parecido que la sangría puede ser un problema si no el uso que coma extra.
  • Cada uno parece estar aceptando ‘la facilidad de agregar nueva línea’ – pero son las personas que se definen especificaciones de lenguaje que realmente molesta acerca de tales cosas? Si de verdad tienen que entender entonces por qué no ignorar una falta ; cuando es claro que la siguiente token es en realidad una instrucción siguiente.
  • Sí, los diseñadores de lenguajes considerar tales cosas. Permite colocar el punto y coma tendría un mayor impacto y sería muy ambiguo en muchas partes de la lengua (recuerde, el espacio en blanco no es semántico en C). Una coma adicional es que este caso no es ambiguo. Un extra de punto y coma casi nunca es ambigua, y así también está permitido. En el caso de que sea ambigua (después de un for() por ejemplo), agregando que lanza una advertencia del compilador.
  • La inversión de tu pregunta, y usted termina con: «¿por Qué debería ser explícitamente no permitido?» ¿Tiene una respuesta para eso?
  • pero un punto y coma después de un for() no es «ambigua» en absoluto.
  • Es ambigua para un lector humano, y es a menudo un error. Es por eso que lanza una advertencia. Del mismo modo if (x = 1) no es ambiguo en la gramática, pero es muy ambigua para los seres humanos, y por lo tanto lanza una advertencia.
  • Cómo es ambiguo? Es bien definido lo que for (a; b; c); medios. No hay ninguna ambigüedad aquí, ni por el compilador ni para el programador. Que es a menudo un error y fácil no es pertinente.
  • Su if ejemplo no es ambiguo, ya sea. No creo que «ambigua» significa lo que usted piensa que significa!
  • Tienes razón en que es inequívoco, pero el 87% del tiempo, además no es lo que el programador quiere.
  • He disparado a mí mismo en el pie un par de veces con este problema en javascript; es decir (por supuesto) no le gusta y barfs cuando encuentra uno, pero los demás navegadores aceptan.
  • De hecho. Pero «ambiguo» no es el término correcto.
  • Mientras estamos de acuerdo en que es algo útil para el compilador para que nos proteja de, mientras que un punto y coma final en una declaración de matrices no es algo útil para el compilador para protegernos de los.
  • Me parece que esta característica indispensable, y plantea que mi ire a ningún extremo, cuando trato con los idiomas que prohíben el punto y coma final (SQL, estoy mirando a ti)
  • Lo más sorprendente en este tema, es cómo tales nimiedades evocar tales desproporcionados de interés y el voto de frenesí.
  • Sin duda muy útil y a menudo visto en la enumeración
  • Varias preguntas relacionadas con: stackoverflow.com/questions/2311864/… , stackoverflow.com/questions/6372650/trailing-commas-and-c , stackoverflow.com/questions/792753/… , stackoverflow.com/questions/2361265/why-is-this-c-snippet-legal . El último podría ser argumentado que se trata de un duplicado, aunque está pidiendo C# en lugar de C++.
  • en.wikipedia.org/wiki/Parkinson%27s_law_of_triviality
  • Me gustaría que fuera permitidos para los parámetros de la plantilla, también!
  • ¿Qué pasa cuando uso el Yoda de la coma? un int[] = {,1,2}; stackoverflow.com/questions/10483635

19 Comentarios

  1. 427

    Hace que sea más fácil para generar código fuente, y también para escribir el código que puede ampliarse fácilmente en una fecha posterior. Considerar lo que se requiere para agregar una entrada extra para:

    int a[] = {
       1,
       2,
       3
    };

    … tienes que agregar la coma a la línea existente y añadir una nueva línea. Compare eso con el caso donde los tres ya tiene una coma después de éste, en donde usted sólo tiene que añadir una línea. Del mismo modo, si desea quitar una línea que usted puede hacerlo sin tener que preocuparse acerca de si es la última línea o no, y usted puede cambiar el orden de las líneas sin necesidad de tocar el violín alrededor con comas. Básicamente, significa que hay una uniformidad en la manera de tratar las líneas.

    Ahora piense acerca de la generación de código. Algo como (pseudo-código):

    output("int a[] = {");
    for (int i = 0; i < items.length; i++) {
        output("%s, ", items[i]);
    }
    output("};");

    No hay necesidad de preocuparse acerca de si el elemento actual que está escrito es el primero o el último. Mucho más simple.

    • Esto es especialmente si se utiliza macros para agregar elementos a las matrices. El uso de macros no tienen la inteligencia para distinguir cuando no agregar una coma, o más bien la adición de esta lógica hace macros inherentemente más complejo.
    • También, cuando se utiliza un VCS, las «diferencias» entre las dos versiones es más limpio ya que sólo hay una línea que cambia cuando un elemento se ha añadido o quitado.
    • Si la justificación es hacer que la generación de código más simple, entonces, ¿por qué no adoptar el paréntesis no el estilo de algunos funcional de las lenguas? y por qué no deducir todos los tipos? y quite el punto y coma? y así sucesivamente. Creo que la verdadera razón era muy subjetivo y lamentable criterios de la lengua de los diseñadores.
    • ¿Por qué «lamentable»? ¿Cuál es el inconveniente? Sólo porque algunos se han tomado en consideración para la generación de código (y fácil manipulación) para una pequeña parte de la lengua no significa que tiene que ser la principal motivación detrás de todas las decisiones en el idioma. La inferencia de tipos, la eliminación de puntos y comas, etc. gran implicaciones para las lenguas. Usted está estableciendo una falsa dicotomía aquí, de la OMI.
    • Lamentable, porque es incompatible con otras normas, tales como comas entre los argumentos del método, por lo que el código de generación de chicos no obtener «ayuda» que hay? Mi referencia a la inferencia de tipos, la eliminación de puntos y comas, etc. fueron a poner un ejemplo exagerado de una gran ayuda para la generación de código. En otras palabras, en mi humilde opinión, o el lenguaje es plenamente coherente o es totalmente de generación de código orientado.
    • Que es donde el pragmatismo victorias sobre el dogmatismo: ¿por qué tienen que ser completo una cosa o completo el otro, cuando es más útil a ser una mezcla de ambos? ¿Cómo se consigue realmente en el camino, ser capaz de añadir una coma al final? Es esta una inconsistencia que ha impedido que en algún sentido? Si no, por favor pesar de que irrelevante falta de elegancia en contra de la práctica de beneficios de permitir una coma al final.
    • su apoyada en un número de otros idiomas además de c++ como bien sé que php y c# de apoyo a este así que no es un c++ sólo cosa
    • Una vez me topé con este problema cuando escribí un script de generación de código C que describe un Modelo 3D y estaba feliz de que yo no tenía que manejar la última entrada por separado.
    • La generación de código – podemos decir que el hecho de un 10% o menos veces; el resto del tiempo que implica la escribir en el código. Estadísticamente significativas o no, aquellos feroces codificadores de que la explosión fuera de 100s de caracteres por minuto, no puede permitirse el lujo de tipo 2 más (o 20 más para el caso) de los personajes? No me estoy quejando, pero esta justificación parece extraño. Creo que eso hace la vida más fácil en algún otro lado, MS, tal vez?
    • No es cuestión de escribir la tasa es una cuestión de simplicidad, al copiar, eliminar o reordenar los elementos. Esto hizo que mi vida sea más fácil, tan sólo ayer. Sin ningún inconveniente, ¿por qué no hacer la vida más fácil? Como para tratar de señalar con el dedo a MS, tengo la fuerte sospecha de que esto ha sido en C desde antes de que Microsoft aún existía… Que decir de esta justificación parece extraño, pero yo apuesto a que no beneficia a cientos de miles de desarrolladores a través de cientos de empresas de todos los días. No es que una mejor explicación de en busca de algo que beneficia a los programadores de compiladores?
    • Totalmente con usted, mi pensamiento es, ¿por qué no hacer la vida más fácil en otros lugares? Como nota extra y un poco irónicamente, otro MS producto totalmente desprecia el punto y coma final. 🙂
    • Yo sospechoso no iba a ser tan útil en otros lugares – porque la mayoría de los otros lugares no uso homogéneo de la lista de elementos. Por ejemplo, para las llamadas de método, la reordenación de los parámetros es algo que generalmente se toma mucho más la atención debido al tipo de sistema. La posición de hace un semántica diferencia, no sólo un orden de aparición diferencia. (Este no es la cantidad de agua para los argumentos con nombre, por supuesto). Se siente como que esto fue un simple «vamos a poner en este caso, por razones pragmáticas, pero mantener el mismo lenguaje más simple en otros lugares» de la decisión.
    • Bueno, me refería a otras cosas, como ser capaz de decir: public property int Index; (para auto-propiedades implementadas principalmente) que es mucho más fácil escribir (menos de caracteres, todos en la misma fila), más legible que feo public int Index { get; set; }; y supongo que poco más fácil para la generación de código así.
    • La introducción de nuevas palabras clave después de la liberación es un negocio difícil. Es posible que esto no causa ningún problema (al igual que otros contextual de palabras clave), pero no estoy del todo seguro… y ¿cómo haría un público «getter» privado «setter» de esa manera? Yo no quiero tener dos diferentes sintaxis para ello… (Personalmente deseo campo, como los eventos fueron declaradas como public event EventHandler Foo { agregar; quitar; }; para hacerlas más claras, pero ahí vamos…)
    • «otro MS producto totalmente desprecia el punto y coma final» … creo Mrchief realmente estaba hablando de objeto y literales de matriz en IE6, IE7, IE8 y también si mal no recuerdo.
    • Esto fue en K&R C.
    • He publicado un respuesta en esta lógica, tal como se expresa en «Profundidad C secretos»
    • Me pregunto si alguno de los idiomas de uso de elemento intiator o declaración-iniciador de los personajes? Si, por ejemplo, un idioma requiere que cada elemento de una lista, incluyendo el primero, ser precedido por un signo de dos puntos, a continuación, agregar elementos a una lista, en cualquier lugar, ya sea al principio o al final, no plantearía problema, y en los casos en que un artículo o declaración que sea necesario para abarcar varias líneas, la falta de un elemento iniciador de caracteres en la línea siguiente podría ser más visible que la falta de un elemento terminador o elemento-separador al final de la línea anterior.
    • Esto me recuerda a la de Oxford Comma debate. En cualquier caso, especialmente para la matriz de definiciones, creo que permitir que la coma es mucho mejor: cada línea tiene una bien definida índice independiente de la sintaxis. Esta es la codificación, no en inglés!
    • anotado C++ manual de referencia dice que esto vino de C y la C99 justificación que cito en mi respuesta dice proporciona flexibilidad para agregar o eliminar miembros de una lista de inicializador, y simplifica la máquina de generación de este tipo de listas.
    • En el clavo!

  2. 126

    Es útil si haces algo como esto:

    int a[] = {
      1,
      2,
      3, //You can delete this line and it's still valid
    };
    • Me sorprende que C++ tiene esto y muchos otros idiomas no (he.e Javascript)
    • JavaScript soporta esta sintaxis: var a = [1, 2,];, por lo que la mayoría de las otras lenguas que conozco… ActionScript, Python, PHP.
    • Eso va a causar un error de análisis en IE JavaScript, así que ten cuidado!
    • No para mí en IE9. Pero hace algo extraño… se crea un elemento null. Voy a tener cuidado.
    • Lo sentimos, usted está en lo correcto – no es un error de análisis en IE, pero será insertar un elemento adicional establecido para undefined.
    • C# también permite a esto, en algunos casos.
    • Fujiwara: Mathematica tiene el mismo problema.
    • Bueno, técnicamente no. Antes de ES5, el idioma no era compatible con punto y coma final. Sin embargo, el vacío elemento de la matriz se undefined. Por lo tanto, en JavaScript, se puede escribir [, 2]. Sí, es completamente inútil, pero funciona.
    • Más frustrante, JSON no es compatible con esta sintaxis.

  3. 38

    Facilidad de uso para el desarrollador, yo creo.

    int a[] = {
                1,
                2,
                2,
                2,
                2,
                2, /*line I could comment out easily without having to remove the previous comma*/
              }

    Además, si por cualquier razón usted tenía una herramienta que el código generado para usted; la herramienta no tiene que preocuparse acerca de si es el último elemento en la inicializar o no.

  4. 32

    Siempre he asumido que hace que sea más fácil para añadir elementos extra:

    int a[] = {
                5,
                6,
              };

    simplemente se convierte en:

    int a[] = { 
                5,
                6,
                7,
              };

    en una fecha posterior.

    • No creo que hacer la edición de un poco más rápido es una buena razón para jugar la sintaxis. En mi humilde opinión este es sólo otro extraño C++ característica.
    • Bueno, es heredado de C. Es muy posible que sólo se trata de un descuido en el idioma original de la especificación, que pasa a tener un efecto útil.
    • Ok, no sabía que proviene de C. acabo de comprobar que está permitido en Java, también. Se siente un poco raro, aunque, en mi intuición de la coma es el separador no es un terminator. Además, es posible omitir la última coma. Por lo tanto, es un terminator, un separador, o ambos? Pero bueno, esta característica está disponible y es bueno saber.
    • el código fuente es para los seres humanos, no máquinas. Pequeñas cosas como esta nos guarde de hacer simple transposición de los errores son una bendición, no un descuido. Para referencia, también funciona de esta manera en PHP y ECMAScript (y por lo tanto, JavaScript y ActionScript), aunque no es válido en la notación de objetos JavaScript (JSON) (por ejemplo, [1,2,3,] está bien, pero {a:1, b:2, c:3,} no es).
    • Yo diría que en lugar de echar a perder la sintaxis, esto mejora la sintaxis. No puedo contar el número de veces que he estado me alegro de que usted puede hacer esto.
    • También es permitido en la última C# especificación
    • Cuanto más lo pienso, más estoy convencido de que la sintaxis de un lenguaje de programación debe ser lo más sencilla y coherente como sea posible y con el menor número posible de excepciones: esto hace que sea más fácil aprender el idioma (menos reglas a tener en cuenta). La ventaja de ahorrar uno o dos pulsaciones de teclas al añadir / quitar un elemento de una lista (que, por cierto, no me hacer que a menudo comparado con el total de la cantidad de tiempo que paso de codificación) parece bastante trivial para mí en comparación con tener claramente definida la sintaxis.
    • Y esto es coherente: «foo = 1,» dondequiera que en la matriz de entrada.
    • He publicado un respuesta teniendo en cuenta esto, como se encuentra en el libro «de Profundidad C secretos»

  5. 21

    Todo lo que todo el mundo está diciendo acerca de la facilidad de agregar/quitar/generación de líneas es correcta, pero el verdadero lugar de la sintaxis brilla es cuando la fusión de los archivos de origen juntos. Imagina que tienes esta matriz:

    int ints[] = {
        3,
        9
    };

    Y se supone que he comprobado este código en un repositorio.

    A continuación, su compañero de ediciones, añadiendo al final:

    int ints[] = {
        3,
        9,
        12
    };

    Y editar de forma simultánea, añadiendo al principio:

    int ints[] = {
        1,
        3,
        9
    };

    Semánticamente estos tipos de operaciones (adición al principio, añadiendo al final) debe ser totalmente combinación de seguros y su control de versiones de software (esperemos git) debe ser capaz de automerge. Lamentablemente, este no es el caso porque su versión no tiene coma después de la 9 y la de sus compañeros no. Mientras que, si la versión original había detrás de la 9, habrían automerged.

    Así, mi regla de oro es: usar el punto y coma final si la lista abarca varias líneas, no lo utilice si la lista está en una sola línea.

  6. 15

    Coma final creo que es permitido por razones de compatibilidad con versiones anteriores. Hay un montón de código existente, principalmente auto-generado, lo que pone un punto y coma final. Esto hace que sea más fácil escribir un bucle sin condición especial al final.
    por ejemplo,

    for_each(my_inits.begin(), my_inits.end(),
    [](const std::string& value) { std::cout << value << ",\n"; });

    No hay realmente ninguna ventaja para el programador.

    P. S. a Pesar de que es más fácil para generar automáticamente el código de esta manera, yo en realidad siempre tuvo cuidado de no poner el punto y coma final, los esfuerzos son mínimos, la legibilidad se ha mejorado, y eso es más importante. Escribir el código una vez, leer muchas veces.

    • No estoy de acuerdo por completo; [en mi opinión] ha encontrado su camino en muchas lenguas creada mucho después de la C, precisamente porque es ventajoso para el programador sea capaz de cambiar todo el contenido de la matriz, un comentario fuera de las líneas queramos o no, y así sucesivamente, sin tener que preocuparse acerca de tonto transposición inducida por errores de sintaxis. No estamos ya enfatizar lo suficiente?
    • por la misma lógica, ¿por qué no al final (nada) de estar permitido, ¿int a = b + c +; o if(a && b &&); será más fácil de copiar y pegar nada en el final y más fácil la escritura de los generadores de código. Este problema es tanto trivial, y subjetiva, en estos casos siempre es bueno hacer lo que es mejor para el lector de códigos.
    • Bushuyev: ¡Exactamente! A menudo me han expresiones largas, con + o &&, con el operador en el final de la línea y, por supuesto, tengo que pasar un poco de tiempo extra cuando quiero quitar el último de los operandos de la expresión. Creo que este coma sintaxis es realmente extraño!
    • No estoy de acuerdo en aquellos. Mientras permitiendo que comas finales en las matrices y el como es un bug de la eliminación de la característica y hace su vida más fácil como programador, me gustaría que por el puro aras de la legibilidad tomar medidas para retirar de la cola Y (&&) declaraciones, pros y los otros operadores de sentencias condicionales. Es simplemente feo, de la OMI.
    • Con respecto a la && operador, a veces hago las oraciones condicionales como if (true \n && b1 \n && b2) para que yo pueda agregar y quitar líneas como sea necesario.
  7. 12

    Una de las razones por las que esto está permitido por lo que yo sé es que debe ser simple para generar automáticamente código; usted no necesita ninguna manipulación especial para el último elemento.

  8. 11

    Hace que los generadores de código que escupen matrices o enumeraciones más fácil.

    Imaginar:

    std::cout << "enum Items {\n";
    for(Items::iterator i(items.begin()), j(items.end); i != j; ++i)
        std::cout << *i << ",\n";
    std::cout << "};\n";

    I. e., no hay necesidad de hacer un manejo especial de el primer o último elemento a evitar escupir el punto y coma final.

    Si el generador de código está escrito en Python, por ejemplo, es fácil evitar escupir el punto y coma final mediante el uso de str.join() función:

    print("enum Items {")
    print(",\n".join(items))
    print("}")
  9. 9

    Veo un caso de uso que no fue mencionado en otras respuestas,
    nuestro favorito Macros:

    int a [] = {
    #ifdef A
        1, //this can be last if B and C is undefined
    #endif
    #ifdef B
        2,
    #endif
    #ifdef C
        3,
    #endif
    };

    La adición de macros para manejar última , sería un gran dolor. Con este pequeño cambio en la sintaxis de esto es simple de administrar. Y esto es más importante que la máquina genera código porque es generalmente mucho más fácil que hacerlo en Turing completo langue de muy limitada preprocesor.

  10. 8

    Me sorprende después de todo este tiempo nadie ha citado el Anotado C++ Manual De Referencia(BRAZO), dice lo siguiente acerca de [dcl.init] con el énfasis es mío:

    Claramente hay demasiadas anotaciones para inicializaciones, pero cada uno parece servir a un estilo particular de uso del bien. La ={initializer_list,opt} notación fue heredado de C y sirve también para la inicialización de estructuras de datos y matrices. […]

    aunque la gramática ha evolucionado desde BRAZO fue escrito el origen de los restos.

    y podemos ir a la C99 justificación para ver por qué esto era permitido en C y dice:

    K&R permite una coma final en un archivo de inicialización en el final de una
    inicializador de la lista. El Estándar ha conservado esta sintaxis, ya que
    proporciona flexibilidad para agregar o eliminar miembros de un inicializador
    lista, y simplifica la máquina de generación de este tipo de listas.

  11. 7

    El único idioma donde es – en la práctica* – no se permite es Javascript, y causa una cantidad innumerable de problemas. Por ejemplo, si usted copy & paste de una línea desde el centro de la matriz, pegar a la final, y se olvidó de quitar la coma luego de su sitio web será totalmente rota por su IE visitantes.

    *En teoría es permitido, pero Internet Explorer no cumple con el estándar y la trata como un error

    • JavaScript «matrices» (que son sólo objetos con una mágica propiedad de longitud) son más inusual de todos modos: var x = [,,,] es legal (excepto en IE < 9, pero en las especificaciones dice que es legal)
    • De acuerdo a la especificación ECMAScript, es perfectamente válido; en teoría debería funcionar en cualquier navegador que implementa JavaScript de acuerdo con el mencionado pliego, en particular la parte de la especificación de encontrar aquí.
    • Por desgracia JavaScript es todo acerca de hacer apps para el público. Así que no, no es perfectamente válido cuando ~50% de los usuarios tienen problemas con el uso de tu aplicación. Y sí, si yo pudiera, me gustaría prohibición IE < 9 — demasiado horas gastar en sólo hacer código de trabajo allí…
    • sí, he dicho en mi respuesta =)
    • microsoft inventa sus propias especificaciones y los comandos que otros cumplir, al menos, que la mentalidad está cambiando (gracias a dios)
    • Bonini: El problema que describes pueden ser resueltos mediante la ejecución de un comprobador de sintaxis en el código antes de su envío.

  12. 7

    Es más fácil para las máquinas, es decir, el análisis y la generación de código.
    También es más fácil para los seres humanos, es decir, la modificación, comentar y visual-la elegancia a través de consistencia.

    Suponiendo que C, ¿vas a escribir el siguiente?

    #include <stdio.h>
    #include <stdlib.h>
    
    int main(void)
    {
        puts("Line 1");
        puts("Line 2");
        puts("Line 3");
    
        return EXIT_SUCCESS
    }

    No. No sólo porque la declaración final es un error, sino también porque es inconsistente. Así que ¿por qué hacer lo mismo con las colecciones? Incluso en idiomas que le permiten omitir el último punto y coma y comas, de la comunidad, en general, no gusta. El Perl de la comunidad, por ejemplo, no parece como omitir el punto y coma, bar one-liners. Se aplican de que comas demasiado.

    No omitir comas en multiline colecciones por la misma razón que no ommit de punto y coma para multilínea bloques de código. Quiero decir, no se incluso si el idioma se lo permitió, derecho? A la derecha?

    • Hay lenguas (por ejemplo, Pascal), que permiten que. I. e. usted tiene que elegir entre ; como un terminator (C) o como un separador (Pascal). Mismo por ‘,’. Sería aceptar que para mi si ‘,’ es un terminator, pero entonces {1, 2, 3} debe ser un error de sintaxis.
  13. 6

    La razón es trivial: la facilidad de agregar/quitar líneas.

    Imaginar el siguiente código:

    int a[] = {
       1,
       2,
       //3, //- not needed any more
    };

    Ahora, usted puede fácilmente agregar o quitar elementos de la lista sin tener que agregar/quitar el punto y coma final a veces.

    En contraste con otras respuestas, yo realmente no creo que la facilidad de generación de la lista es una razón válida: después de todo, es trivial para el código de caso especial de la última (o primera) línea. Los generadores código se escriben una vez y se utiliza muchas veces.

  14. 6

    Que permite a cada línea a seguir de la misma forma. En primer lugar, esto hace que sea más fácil añadir nuevas filas y tener un sistema de control de versiones de la pista el cambio de manera significativa y también permite analizar el código más fácilmente. No puedo pensar en una razón técnica.

  15. 5

    Esto está permitido para proteger de errores causados por el movimiento de los elementos alrededor de una larga lista.

    Por ejemplo, supongamos que tenemos un código como este.

    #include <iostream>
    #include <string>
    #include <cstddef>
    #define ARRAY_SIZE(array) (sizeof(array) / sizeof *(array))
    int main() {
        std::string messages[] = {
            "Stack Overflow",
            "Super User",
            "Server Fault"
        };
        size_t i;
        for (i = 0; i < ARRAY_SIZE(messages); i++) {
            std::cout << messages[i] << std::endl;
        }
    }

    Y es genial, como muestra la trilogía original de la Pila de sitios de Exchange.

    Stack Overflow
    Super User
    Server Fault

    Pero hay un problema con él. Se puede ver, el pie de página en este sitio web muestra Fallas de Servidor antes de Super Usuario. Mejor arreglar eso antes de que alguien lo note.

    #include <iostream>
    #include <string>
    #include <cstddef>
    #define ARRAY_SIZE(array) (sizeof(array) / sizeof *(array))
    int main() {
        std::string messages[] = {
            "Stack Overflow",
            "Server Fault"
            "Super User",
        };
        size_t i;
        for (i = 0; i < ARRAY_SIZE(messages); i++) {
            std::cout << messages[i] << std::endl;
        }
    }

    Después de todo, líneas de movimiento de todo no podía ser tan difícil, ¿podría ser?

    Stack Overflow
    Server FaultSuper User

    Yo sé, no hay un sitio web llamado «Servidor de FaultSuper de Usuario», pero nuestro compilador afirma que existe. Ahora, el problema es que C tiene una concatenación de cadenas característica, que permite escribir dos cadenas entre comillas dobles y concatenar usando nada (problema similar puede ocurrir también con los números enteros, como - signo tiene varios significados).

    Ahora lo que si la matriz original tenía un inútil coma al final? Así, las líneas se mueven, pero tal error no hubiera ocurrido. Es fácil pasar por alto algo tan pequeño como una coma. Si te acuerdas de poner una coma después de cada elemento de la matriz, tal error no puede suceder. Usted no quiero perder cuatro horas de depuración de algo, hasta que se encuentra la coma es la causa de sus problemas.

  16. 4

    Como muchas cosas, el punto y coma final en una matriz de inicializador es una de las cosas de C++ heredado de C (y tendrán que soportar para siempre). Una vista totalmente diferentes de los que aquí se menciona en el libro «de Profundidad C secretos».

    Allí después de un ejemplo con más de una «coma paradojas» :

    char *available_resources[] = {
    "color monitor"           ,
    "big disk"                ,
    "Cray"                      /* whoa! no comma! */
    "on-line drawing routines",
    "mouse"                   ,
    "keyboard"                ,
    "power cables"            , /* and what's this extra comma? */
    };

    leemos :

    …que coma final después de la final de inicializador no es un error tipográfico, pero un bache en la sintaxis que se realiza desde los aborígenes C. Su presencia o ausencia es permitido, pero ha ninguna importancia. La justificación se reivindica en el ANSI C justificación es que hace que la generación automatizada de C más fácil. La demanda sería más creíble si las comas finales estaban permitidos en cada lista separada por comas, como en la enumeración de las declaraciones, o de variable múltiple declarators en una sola declaración. Ellos no lo son.

    … esto me hace más sentido

    • La prohibición en contra de la coma en el enum caso es algo muy interesante, ya que es el caso en el que la falta la coma supondría la menor ambigüedad. Dado struct foo arr[] = {{1,2,3,4,5}, {3,4,5,6,7}, }; hay dos sensible significados de la lengua podría asignar: crear una matriz de dos elementos, o crear un tres-elemento de la matriz en la que el último elemento tiene valores predeterminados. Si C había adoptado la posterior interpretación, pude ver que prohíbe enum foo {moe, larry, curly, }; en el principio de que sólo debe haber una manera de escribir la instrucción (sin la coma), pero…
    • …dado que C está dispuesto a ignorar la coma en los casos en que razonablemente pudo haber sido (pero no) le asigna un importante significado (lo que sería un fuerte argumento en favor de prohibir ahí) es curioso que no está dispuesto en un caso en el que la coma no podía tener un significado [incluso si uno interpreta enum foo {moe,,larry,curly,}; como saltarse un número entre moe y larry, no generalmente no importa si el punto y coma final fue de procesar. El único caso en que podría cuestión sería si el último elemento fue el máximo valor para su tipo declarado, y que…
    • …podría ser manejado por simplemente decir que el desbordamiento que se produce después de la última asignado un valor de enumeración debe ser ignorado.
    • Hay lenguajes, como C#, donde a priori el diseño de investigación, va tan lejos como la consideración de funciones del IDE y de integración cuando devoloping el idioma. C no era (y no podría haber sido) uno de estos idiomas.
    • Incluso con lenguajes de programación como C#, el cambio de los objetivos del diseño se han producido algunos bastante grave inconsistencia en el diseño. Por ejemplo, el lenguaje se abstuvo de apoyar cualquier forma de retorno de tipo sobrecarga de métodos normales y los operadores (aunque el marco subyacente podría apoyarla porque fue visto como contrario a la meta de tener una simple compilación de idioma, pero lambda evaluación incluye el tipo de reglas de inferencia cuya resolución es de tipo NP-completo. Añadir nuevo método/sobrecarga de operadores reglas podría romper el código existente (aunque creo que las buenas reglas podría minimizar el peligro)…
    • …pero no veo esos problemas en la C final coma reglas. En mi humilde opinión, uno de los principales factores en la decisión de qué permitir/prohibir debería ser si la gente que en general sabía que un idioma, pero no una característica particular es probable que incorrectamente supongo que en función de su significado. Por esa norma, int foo[] = {1,2,}; es mucho más peligroso que enum {LARRY, CURLY, };, y es poco probable que el significado de cualquier código existente (incluido el código permite a través de compilador de extensiones) iba a cambiar mening caso de que éste se hizo legítimo.
    • Todas sus observaciones a hacer realmente un punto fuerte

  17. 2

    Además de la generación de código y la edición de la facilidad, si desea implementar un programa de análisis, este tipo de gramática es más simple y fácil de implementar. C# sigue esta regla en algunos de los lugares que hay una lista separada por comas de los elementos, los elementos similares en una enum definición.

  18. 1

    Hace que la generación de código más fácil ya que sólo tendrá que añadir una línea y no necesita tratar de añadir la última entrada como si se trata de un caso especial. Esto es especialmente cierto cuando el uso de macros para generar código. Hay un empuje para tratar de eliminar la necesidad de macros a partir del lenguaje, pero el lenguaje hizo evolucionar de la mano con las macros disponibles. La coma adicional permite que las macros como la siguiente para ser definidos y utilizados:

    #define LIST_BEGIN int a[] = {
    #define LIST_ENTRY(x) x,
    #define LIST_END };

    Uso:

    LIST_BEGIN
       LIST_ENTRY(1)
       LIST_ENTRY(2)
    LIST_END

    Que es un ejemplo muy simplificado, pero a menudo utilizan este patrón de macros para definir cosas como el envío, el mensaje, el evento o la traducción de mapas y tablas. Si una coma no se le permitió al final, tendríamos un especial:

    #define LIST_LAST_ENTRY(x) x

    y que sería muy difícil de usar.

  19. -4

    Si utiliza una matriz sin longitud especificada,VC++6.0 puede identificar automáticamente su longitud,por lo que si el uso de «int a[]={1,2,};»la longitud de a es 3,pero el último no ha sido inicializado,puede utilizar «cout<

    • Es esto un error de VC6 que no es compatible con el estándar?

Dejar respuesta

Please enter your comment!
Please enter your name here