C/C++ advierte o prohíbe la concatenación de cadenas literales

Question 1

¿Hay alguna manera de advertir o prohibir concatenaciones de cadenas literales como:

const char *a = "foo" " bar";

Pasé horas buscando un error en una gran matriz estática que tenía

const char * a[] = {"foo" "bar"};

en lugar de

const char * a[] = {"foo", "bar"};

Question 2

Clang tiene una advertencia -Concatenación de cadenas de caracteres que está diseñado explícitamente para detectar tales errores:

warning: suspicious concatenation of string literals in an array initialization; did you mean to separate the elements with a comma? [-Wstring-concatenation]
char const *a[]  = { "ok", "foo" "bar", "ok"};
                                 ^
                                ,

Esto no funcionará exactamente para el ejemplo de juguete que mostró porque necesita tener varios inicializadores y solo perder comas en un par de lugares, es decir:

// no warning
char const *b[]  = {"foo" "bar"};
// no warning
char const *c[]  = {"ok", "foo" "bar"};
// no warning
char const *d[]  = {"foo" "bar", "ok"};

Pero cuando tiene una gran cantidad de inicializadores en una matriz y solo comete un error tipográfico en un par de lugares, esto parece ideal.

Aquí está un manifestación.

GCC no parece tener una advertencia equivalente, pero hay una pedido para que se agregue.

Tenga en cuenta que esto solo funciona para la inicialización de matrices. tu ejemplo de

const char *x = "foo" " bar";

no será detectado por esta advertencia (o cualquier otra que yo sepa).

También tenga en cuenta que habilitar esta advertencia puede generar muchos falsos positivos, pero puede usarlo con moderación cuando intente detectar errores.

Question 3

No precisamente. La concatenación de cadenas literales es una parte indispensable de la gramática C/C++ y tiene muchos casos de uso. Por lo tanto, se necesita algún tipo de esfuerzo y eso puede frustrar el objetivo de detectar un error garrafal.

Sin embargo, la concatenación de cadenas funciona de manera muy estricta en dos literales de cadena que aparecen uno tras otro con solo un espacio en blanco en el medio, por lo que romper el espacio en blanco provocará un error. Por ejemplo, en este caso podrías haber escrito:

const *char[] = {("foo") ("bar")};  // Error

lo que causaría un error mientras que la declaración prevista no lo haría:

const *char[] = {("foo"), ("bar")};  // OK

Entonces, en resumen, no puede tener alguna forma de decirle explícitamente al compilador que dos literales de cadena pueden concatenarse y fallar en todos los demás casos, por lo que tendrá que decirle al compilador explícitamente cuando un literal de cadena puede estar concatenado. no ser concatenado.

Question 4

Cualquiera de las macros a continuación hace que sea imposible concatenar accidentalmente dos cadenas.

PPC (preprocesador C) las macros son increíbles en general. También es legal tener una coma final al final de una lista de elementos.

Puedes hacer algo como esto:

#define STRINGCOMMA(a) a,

const char *x[] = {
    STRINGCOMMA("foo")
    STRINGCOMMA("bar")
};

O incluso:

#define QUOTESTRINGCOMMA(a) #a,

const char *x[] = {
    QUOTESTRINGCOMMA(foo)
    QUOTESTRINGCOMMA(bar)};

La coma se agrega por usted, y sería ilegal que usted mismo lo hiciera accidentalmente.

Si está interesado, también es posible llevar este concepto más allá para permitir la creación de listas paralelas con los mismos argumentos, pero con un procesamiento diferente:

Macro X

#define VARLIST \
  DO(foo) \
  DO(bar)

#define DO(a) #a,
  const char *x[] = {
VARLIST
};
#undef DO

Esto sería útil si desea crear una lista de enumeraciones y una lista de cadenas, a partir de la misma lista de nombres.

Question 5

Pasé horas encontrando un error en una gran matriz estática…

Bueno, puedes hacer esto:

char const * a [] = 
    { "foo"
    , "bar"
    , "baz"
    , "asdf"
    , "ghjk"
    };

¿Ha sido útil esta solución?