'ए (टीएमपीवीक्टर) कैसे है;' 'ए टीएमपीवीक्टर' के समान ही?

Question

This question इस कोड स्निपेट है:

A::A(const char *pc) { 
    A(string(pc)); 
} 

A::A(string s) { 
    vector<string> tmpVector; 
    tmpVector.push_back(s); 
    A(tmpVector); // <-- error 
} 

// Constructor 
A::A(vector<string> filePathVector) { 
} 

समस्या यह है कि vector<string> tmpVector; साथ A(tmpVector); संघर्ष:

error: conflicting declaration 'A tmpVector' 
error: 'tmpVector' has a previous declaration as 'std::vector<std::basic_string<char> > tmpVector' 

The answer का कहना है:

यह

ए (tmpVector);

इस

एक tmpVector जैसा ही है; // लेकिन वहाँ पहले से ही एक वस्तु tmpVector

कहा जाता है एक अतिरिक्त टिप्पणी के साथ है:

इस संदर्भ में,() ज़रूरत से ज़्यादा हैं।

मेरा प्रश्न है: ब्रांडेस अनिवार्य क्यों हैं? सी ++ 11 spec में वास्तव में क्या ऐसा करता है? मैंने पहले यह नहीं देखा है।

Answer 1

से §8 [dcl.decl] मानक की:

declarator: 
    ptr-declarator 
    noptr-declarator parameters-and-qualifiers trailing-return-type 
ptr-declarator: 
    noptr-declarator 
    ptr-operator ptr-declarator 
noptr-declarator: 
    declarator-id attribute-specifier-seq_opt 
    noptr-declarator parameters-and-qualifiers 
    noptr-declarator [ constant-expression_opt] attribute-specifier-seq_opt 
    (ptr-declarator) 

(व्याकरण का शेष छोड़े गए):

Declarators वाक्य रचना की है।

विशेष रूप से, ध्यान दें कि

1. एक ptr-declarator एक declarator है।
2. फॉर्म का कुछ (ptr-declarator)noptr-declarator है जो बदले में ptr-declarator है।

दूसरे शब्दों में, आपके पास जितने चाहें ब्रांड्स के कई जोड़े हो सकते हैं और यह अभी भी एक घोषणाकर्ता है। के साथ एक अभिव्यक्ति बयान:

अभिव्यक्ति-बयान और घोषणाओं को शामिल व्याकरण में एक अस्पष्टता है: अब इस T(x); तरह के मामलों में एक अस्पष्टता, जिसके द्वारा §6.8 [stmt.ambig] मानक का हल हो गई है का कारण बनता है एक समारोह शैली स्पष्ट प्रकार रूपांतरण (5.2.3) ने अपने सबसे बाईं ओर उपसूचक रूप एक घोषणा जहां पहले declarator एक साथ (शुरू होता है से पृथक हो सकता है। उन मामलों में बयान एक घोषणा है।

उदाहरण के साथ उस पैराग्राफ सीधे कवर के साथ यह मामला है:

class T { 
// ... 
public: 
    T(); 
    T(int); 
    T(int, int); 
}; 

T(a);  // declaration 
T(*b)();  // declaration 
T(c)=7;  // declaration 
T(d),e,f=3; // declaration 
extern int h; 
T(g)(h,2); // declaration