C ++ हमें चर घोषित करते समय कोष्ठक में चर नाम को घेरने की अनुमति क्यों देता है?

Question 1

उदाहरण के लिए एक घोषणा जैसे:

int (x) = 0;

या यहां तक कि:

int (((x))) = 0;

मैं इस पर अड़ गया क्योंकि मेरे कोड में मैं एक के बाद एक के समान एक टुकड़ा है:

struct B
{
};

struct C
{
  C (B *) {}
  void f () {};
};

int main()
{
  B *y;
  C (y);
}

जाहिर है कि मैं Cउस वस्तु का निर्माण करना चाहता था, जो तब अपने विध्वंसक में उपयोगी हो। हालाँकि जैसा कि यह होता है कि संकलक प्रकार के साथ C (y);चर की घोषणा के रूप में व्यवहार करता है और इस प्रकार यह पुनर्परिभाषित के बारे में एक त्रुटि प्रिंट करता है । दिलचस्प बात यह है कि अगर मैं इसे कुछ इस तरह से या जैसे लिखूंगा जैसा कि इरादा है। सबसे अच्छा आधुनिक समाधान , कंस्ट्रक्टर कॉल में उपयोग करना है, निश्चित रूप से।yCyC (y).f ()C (static_cast<B*> (y)){}

तो जैसा कि मैंने उसके बाद पता लगाया है, वैरिएबल की घोषणा करना संभव है जैसे int (x) = 0;या यहां तक कि int (((x))) = 0;लेकिन मैंने कभी किसी को वास्तव में इस तरह की घोषणाओं का उपयोग करते हुए नहीं देखा है। तो मुझे दिलचस्पी है-ऐसी संभावना का उद्देश्य क्या है क्योंकि अब तक मैं देख रहा हूं कि यह केवल कुख्यात "सबसे डरावने पार्स" के समान मामला बनाता है और कुछ भी उपयोगी नहीं जोड़ता है?

Question 2

समूहन।

एक विशेष उदाहरण के रूप में, विचार करें कि आप फ़ंक्शन प्रकार के एक चर को घोषित कर सकते हैं जैसे कि

int f(int);

अब, आप ऐसी चीज़ के लिए सूचक की घोषणा कैसे करेंगे?

int *f(int);

नहीं, काम नहीं करता है! यह एक समारोह लौटने के रूप में व्याख्या की है int*। इसे सही तरीके से पार्स करने के लिए आपको कोष्ठक में जोड़ना होगा:

int (*f)(int);

सरणियों के साथ एक ही सौदा:

int *x[5];   // array of five int*
int (*x)[5]; // pointer to array of five int

Question 3

आमतौर पर इस तरह की घोषणाओं में कोष्ठक का उपयोग करने की अनुमति दी जाती है, क्योंकि वाक्य-विन्यास के दृष्टिकोण से घोषणा हमेशा इस तरह दिखाई देती है:

<front type> <specification>;

उदाहरण के लिए, निम्नलिखित घोषणा में:

int* p[2];

"सामने का प्रकार" है int(नहीं int*) और "विनिर्देश" है * p[2]।

नियम यह है कि आप "विनिर्देश" भाग में आवश्यकतानुसार किसी भी संख्या में कोष्ठक का उपयोग कर सकते हैं क्योंकि वे कभी-कभी अव्यवस्थित होने के लिए अपरिहार्य होते हैं। उदाहरण के लिए:

int* p[2]; // array of 2 pointers to int; same as int (*p[2]);
int (*p)[2]; // pointer to an array of 2 ints

किसी सरणी के लिए सूचक एक दुर्लभ मामला है, हालाँकि आपके पास कार्य करने के लिए सूचक के साथ समान स्थिति है:

int (*func(int)); // declares a function returning int*
int (*func)(int); // declares a pointer to function returning int

यह आपके प्रश्न का सीधा उत्तर है। यदि आपका प्रश्न कथन के बारे में है C(y), तो:

संपूर्ण अभिव्यक्ति के चारों ओर कोष्ठक लगाएं - (C(y))और आपको वही मिलेगा जो आप चाहते थे
यह कथन एक अस्थायी वस्तु बनाने के अलावा कुछ नहीं करता है, जो इस निर्देश के समाप्त होने के बाद रहना बंद कर देता है (मुझे आशा है कि यह वही है जो आप करना चाहते हैं)।