¿Hay algún truco para prohibir que se llame macro C como valor a la izquierda?

Question

Por ejemplo,

struct node { 
    struct node *left, *right; 
}; 
#define LEFT(X) (X->left) 
#define RIGHT(X) (X->right) 

quisiera prohibir llamada a la macro como esto sin cambiar la interfaz macro existente.

LEFT(n) = ... 

¿Alguna idea?

Answer 1

Prueba esto:

#define LEFT(X) ((X)->left+0) 
#define RIGHT(X) ((X)->right+0) 

Answer 2

#undef LEFT 
#undef RIGHT 

//template<class T> 
inline const node * const LEFT(const node * X) { 
    return X->left; 
} 

Answer 3

no creo que hay alguna forma de evitar eso. Probablemente la mejor manera sería no usar macros.

Answer 4

Tal const, aunque requiere un tipo explícito:

#define LEFT(X) ((const struct node *) (X->left)) 

... aunque si usted tiene la extensión typeof compilador:

#define LEFT(X) ((const typeof(X->left)) (X->left)) 

Answer 5

me gustaría ir con la función en línea, pero si quiere una macro:

#define LEFT(X) (1 ? (X)->left : 0) 

Answer 6

Puede usar el operador ternario para ce el resultado de la macro a ser un valor de lado derecho, pero el mensaje de error puede ser confuso para los usuarios:

struct node { 
    node *left, *right; 
}; 
#define LEFT(x) (true ? (x).left : (node*)0) 
int main() { 
    node n; 
    // LEFT(n); // error 
    node *l = LEFT(n); // OK 
} 

El truco no está en la semántica de ese operador específico. El tipo de expresión que contiene solo el operador es un tipo común (o un tipo convertible desde) de las dos ramas de la expresión, incluso si solo una de ellas se evalúa alguna vez. Ahora, cuando el compilador evalúa true ? x.left : (node*)0, resuelve la expresión x.left pero con el tipo común de x.left y (node*)0. Ambos son básicamente del mismo tipo, con el único detalle de que (node*)0 es un valor r, en lugar de un valor l.

Answer 7

me gustaría ir a por una conversión explícita

#define LEFT(X) ((struct node*)(X->left)) 
#define RIGHT(X) ((struct node*)(X->right)) 

el resultado de un reparto tan es siempre un valor de lado derecho. Si además usted no desea permitir a cambiar lo que los punteros apuntan a añadir un const como ya se ha dado en otra respuesta:

#define LEFT(X) ((struct node const*)(X->left)) 
#define RIGHT(X) ((struct node const*)(X->right)) 

Answer 8

Usted no escribe macros "descriptor de acceso" por el estilo, lo hace

typedef struct 
{ 
    ... 
} X; 

X x; 

#define LEFT (x.y.z.left) 

A continuación, accede a la macro IZQUIERDA como cualquier otra variable. Esto hace que el código sea más legible y, al mismo tiempo, deshabilita de forma efectiva todo el ballet inseguro, de aspecto feo, propenso a errores, comportamiento indefinido asociado con macros funcionales.

Answer 9

para C++, me gustaría utilizar unario +:

#define LEFT(X) (+((X)->left)) 
#define RIGHT(X) (+((X)->right)) 

Para un caso de macro general, esto tiene la ventaja sobre la adición de +0 que también trabaja para void* y función punteros.Para C, puede usar el operador de coma

#define LEFT(X) (0, ((X)->left)) 
#define RIGHT(X) (0, ((X)->right))