क्या सी मैक्रो को बाएं मूल्य के रूप में बुलाए जाने के लिए कोई चाल है?

Question

उदाहरण के लिए

,

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

मैं मौजूदा मैक्रो इंटरफ़ेस बदले बिना इस तरह मैक्रो कॉल न करे करना चाहते हैं।

LEFT(n) = ... 

कोई विचार?

Answer 1

इस प्रयास करें:

#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

मुझे नहीं लगता कि इसे रोकने का कोई तरीका है। मैक्रोज़ का उपयोग करने का शायद सबसे अच्छा तरीका नहीं होगा।

Answer 4

शायद const है, हालांकि यह एक स्पष्ट प्रकार की आवश्यकता है:

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

... हालांकि आप typeof संकलक एक्सटेंशन है यदि:

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

Answer 5

मैं इनलाइन समारोह के साथ जाना चाहते हैं, लेकिन यदि आप एक मैक्रो चाहते हैं:

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

Answer 6

आप टर्नरी ऑपरेटर का उपयोग कर सकते हैं मैक्रो का परिणाम सीई एक rvalue होने के लिए है, लेकिन त्रुटि संदेश उपयोगकर्ताओं के लिए भ्रामक हो सकता है:

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 
} 

प्रवंचना वहाँ है कि विशिष्ट ऑपरेटर के शब्दों में है। केवल ऑपरेटर युक्त अभिव्यक्ति का प्रकार अभिव्यक्ति की दो शाखाओं का एक सामान्य प्रकार (या एक प्रकार से परिवर्तनीय) है, भले ही उनमें से केवल एक का मूल्यांकन किया जाए। अब, जब संकलक true ? x.left : (node*)0 का मूल्यांकन करता है तो यह x.left अभिव्यक्ति को हल करता है लेकिन x.left और (node*)0 के सामान्य प्रकार के साथ। उनमें से दोनों मूल रूप से एक ही प्रकार के हैं, केवल विवरण के साथ (node*)0 एक लालसा के बजाए एक रैवल्यू है।

Answer 7

मैं सिर्फ एक स्पष्ट डाली

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

के लिए जाना चाहते हैं इस तरह के एक डाली का परिणाम हमेशा एक rvalue है।

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

Answer 8

आप उस तरह "एक्सेसर" मैक्रो नहीं लिखते आप करते हैं: इसके अलावा में आप बदलना क्या संकेत दिए गए एक const जोड़ने के लिए इंगित कर रहे हैं के रूप में पहले से ही एक और जवाब में दिया गया था अनुमति देने के लिए नहीं चाहते हैं

typedef struct 
{ 
    ... 
} X; 

X x; 

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

फिर आप किसी अन्य चर की तरह बाएं मैक्रो तक पहुंचते हैं। यह कोड को और अधिक पठनीय बनाता है जबकि एक ही समय में पूरी तरह से असुरक्षित, बदसूरत दिखने वाला, त्रुटि प्रवण, अपरिभाषित-व्यवहार बैले फ़ंक्शन-जैसी मैक्रोज़ से जुड़ा होता है।

Answer 9

सी ++ के लिए, मैं एकल + का प्रयोग करेंगे:

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

एक सामान्य मैक्रो मामले के लिए, यह +0 है कि यह भी void* और समारोह संकेत के लिए काम करता जोड़ने से अधिक लाभ दिया है।सी के लिए, आप अल्पविराम ऑपरेटर

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