¿Cómo puedo definir un literal de cadena en la línea de comandos de GCC?

En la línea de comando de GCC, quiero definir una cadena como -Dname=Mary. Luego, en el código fuente, quiero printf("%s", name); imprimir Mary.

¿Cómo podría hacerlo?

Dos opciones. Primero, escapa de las comillas para que el caparazón no las coma:

gcc -Dname=\"Mary\"

O, si realmente quieres -Dname=Mary, puedes encadenarlo, aunque es un poco raro.

#include <stdio.h>

#define STRINGIZE(x) #x
#define STRINGIZE_VALUE_OF(x) STRINGIZE(x)


int main(int argc, char *argv[])
{
    printf("%s", STRINGIZE_VALUE_OF(name));
}

Tenga en cuenta que STRINGIZE_VALUE_OF felizmente evaluará hasta la definición final de una macro.

Para evitar que el shell “coma” las comillas y otros caracteres, puede probar con comillas simples, como esta:

gcc -o test test.cpp -DNAME='"Mary"'

De esta manera, tiene control total sobre lo que se define (comillas, espacios, caracteres especiales y todo).

La forma más portátil que encontré hasta ahora fue usar \"Mary\". Funcionará no solo con GCC, sino con cualquier otro compilador de C. Por ejemplo, si intenta utilizar /Dname=""Mary"" con un compilador de Microsoft, se detendrá con un error, pero /Dname=\"Mary\" trabajará.

En Ubuntu estaba usando un alias que define CFLAGS, y CFLAGS incluía una macro que define una cadena, y luego uso CFLAGS en un Makefile. Tuve que escapar de los caracteres de comillas dobles y también de los caracteres \. Se veía algo como esto:

CFLAGS='" -DMYPATH=\\\"/home/root\\\" "'

Esta es mi solución para: -DUSB_PRODUCT=\""Arduino Leonardo\""

Lo usé en un archivo MAKE con:
GNU Make 3.81 (de GnuWin32)
y
avr-g++ (AVR_8_bit_GNU_Toolchain_3.5.0_1662) 4.9.2

El resultado en un archivo precompilado (opción -E para g++) es:
const u8 STRING_PRODUCT[] __attribute__((__progmem__)) = "Arduino Leonardo";

Aquí hay un ejemplo simple:

#include <stdio.h>
#define A B+20 
#define B 10
int main()
{
    #ifdef __DEBUG__
        printf("__DEBUG__ DEFINED\n");
        printf("%d\n",A);
    #else
        printf("__DEBUG__ not defined\n");
        printf("%d\n",B);
    #endif
    return 0;
}

Si compilo:

$gcc test.c

Producción:

__DEBUG__ not defined
10

Si compilo:

$gcc -D __DEBUG__ test.c

Producción:

__DEBUG__ defined
30

FYI: Aparentemente, incluso diferentes versiones de la misma cadena de herramientas en el mismo sistema pueden actuar de manera diferente en este sentido… (Como en, sería parecer esto sería un problema de paso de caparazón, pero aparentemente no se limita solo al caparazón).

Aquí tenemos xc32-gcc 4.8.3 vs. (avr-)gcc 4.7.2 (y varios otros) usando el mismo makefile y main.c, la única diferencia es 'make CC=xc32-gcc'etc.

CFLAGS += -D'THING="$(THINGDIR)/thing.h"' ha estado en uso en muchos versiones de gcc (y bash) durante varios años.

Para hacer esto compatible con xc32-gcc (y a la luz de otro comentario que afirma que \” es más portátil que ‘”), se tuvo que hacer lo siguiente:

CFLAGS += -DTHING=\"$(THINGDIR)/thing.h\"

ifeq "$(CC)" "xc32-gcc"
CFLAGS := $(subst \",\\\",$(CFLAGS))
endif

hacer cosas en realidad confuso al descubrir esto: aparentemente una -D sin comillas con // da como resultado un #define con un comentario al final… por ejemplo

THINGDIR=/thingDir/ -> #define /thingDir//thing.h -> #define /thingDir

(Gracias por la ayuda de la respuestas aquí, por cierto).