Dotaz: C Makro, složené závorky

[Jardík]

Mám strukturu a C makro

typedef struct
{
    int x;
    const char **pole;
} Struktura;

#define STRUKTURA(__jmeno__, __x__, __pole__) \
  Struktura __jmeno__ = { __x__, __pole__ };

A nedaří se mi docílit požadovaného výsledku. Zkouším to zavolat takto:

STRUKTURA(jmeno, 10, {"bla", "bla2", "bla3"})

Ale preprocesor na mě řve, že jsem makru předal 5 argumentů místo 3

Odpovědi

[l4m4]

> Ale preprocesor na mě řve, že jsem makru předal 5 argumentů místo 3

Nu však ano, předal, a to tyto:

jmeno

10

{"bla"

"bla2"

"bla3"}

Preprocesor nerozumí gramatice C, složené závorky pro něj nemají žádný význam, naopak ho lze využít ke zpracování různým způsobem nebalacovaných konstrukcí. Preprocesor rozumí C na úrovni tokenů, takže ho nespletou např. čárky uvnitř řetězce, ale to je vše.

[Jardík]

Hmm ... tak jsem to vyřešil, že jsem pole udělal const char* a budu tam strkat řetězec ve tvaru "bla\0bla\0bla\0", i když to není tak hezké jako předchozí zápis ...

[oroborus]

Napisat makro s "neznamym" poctom parametrov nie je problem,

 

makro:

#define STRUKTURA(jmeno, x, pole...) Struktura jmeno = { x , { pole } }

 

sa expanduje ako:

 Struktura jmeno = { 10 , { "bla", "bla1", "bla2" } };

 

problem je v tom, ze toto kompilator Cecka nezozere:

 
typedef struct
{
    int x;
     char *pole[];
} Struktura_1;

typedef struct
{
    int x;
     char **pole;
} Struktura_2;

typedef struct
{
    int x;
     const char *pole[];
} Struktura_3;

typedef struct
{
    int x;
     const char **pole;
} Struktura_4;

typedef struct
{
    int x;
     const char *pole[8];
} Struktura_5;

int main()
{
/*
    Struktura_1 jmeno = { 10, {"bla", "bla1", "bla2"} };    // nepojde skompilovat
    Struktura_2 jmeno = { 10, {"bla", "bla1", "bla2"} };    // nepojde skompilovat
    Struktura_3 jmeno = { 10, {"bla", "bla1", "bla2"} };    // NEpojde skompilovat
    Struktura_4 jmeno = { 10, {"bla", "bla1", "bla2"} };    // NEpojde skompilovat
*/
    Struktura_5 jmeno = { 10, {"bla", "bla1", "bla2"} };    // pojde skompilovat
}


[Jardík]

Je to špatný ... já totiž v tý struktuře měl to const char** vícekrát a to tím proměnným počtem argumentů nepořeším a stejně by to teda nevzal kompilátor ... zůstanu teda u toho řešení "s\0ošklivým\0řetězcem\0"

[l4m4]

Ve standardním C je třeba to dělat následovně:

typedef struct {
    int x;
    const char **array;
} Structure;

#define MAKE_STRUCTURE(name, x, array...) \
    const char *name##__array_data[] = array; \
    Structure name = { x, name##__array_data }

MAKE_STRUCTURE(joe, 3, {"foo", "bar", "baz"});

Je nevím, proč by to mělo být lepší než ten kód nenapsat rovnou (a pokud je ho hodně, tak generovat, nebo naopak příslušná data run-time načítat).

[l4m4]

Plácám nesmysly, to je samozřejmě gccismus. Ve standardním C se variadická makra zapisují pomocí __VA_ARGS__:

typedef struct {
    int x;
    const char **array;
} Structure;

#define MAKE_STRUCTURE(name, x, ...) \
    const char *name##__array_data[] = __VA_ARGS__; \
    Structure name = { x, name##__array_data }

MAKE_STRUCTURE(joe, 3, {"foo", "bar", "baz"});

[deda.jabko]

zkus to volat takto:

STRUKTURA(jmeno, 10, ((char * []){"bla", "bla2", "bla3"}));