बयानों में चर के दायरे

Question

मेरे पास एक कक्षा है जिसमें कोई डिफ़ॉल्ट कन्स्ट्रक्टर या असाइनमेंट ऑपरेटर नहीं है, इसलिए इसे किसी अन्य फ़ंक्शन के परिणाम के आधार पर एक if/else कथन के भीतर घोषित और प्रारंभ किया जाता है। लेकिन फिर यह कहता है कि यह बाद में दायरे से बाहर है, भले ही सशर्त के दोनों मार्ग एक उदाहरण बनायेंगे।

निम्नलिखित उदाहरण पर विचार (int के साथ किया बस बिंदु को वर्णन):

#include <iostream> 

int main() 
{ 
    if(1) { 
    int i = 5; 
    } else { 
    int i = 0; 
    } 

    std::cout << i << std::endl; 
    return 0; 
} 

चर सशर्त के अंत में क्षेत्र से बाहर एक सशर्त ही बार में घोषित करते हैं? ऐसी परिस्थिति को संभालने का सही तरीका क्या है जहां कोई डिफ़ॉल्ट कन्स्ट्रक्टर नहीं है लेकिन कन्स्ट्रक्टर के लिए तर्क कुछ सशर्त पर निर्भर करते हैं?

संपादित

दिए गए उत्तर के प्रकाश में, स्थिति इतनी शायद दृष्टिकोण परिवर्तन होगा और अधिक जटिल है। एक सार आधार वर्ग ए और दो वर्गों बी और सी कि ए से निकाले जाते हैं नहीं है कैसे होगा कुछ इस तरह:

if(condition) { 
    B obj(args); 
} else { 
    C obj(args); 
} 

परिवर्तन दृष्टिकोण? चूंकि ए सार है, मैं केवल A* obj घोषित नहीं कर सका और उचित प्रकार new के साथ बना सकता हूं।

Answer 1

"सशर्त के अंत में एक सशर्त गोद में बाहर जाने वाले चर?"

हाँ - एक स्थानीय चर का दायरा केवल enclosing कोष्ठक के भीतर गिर जाता है:

{ 
    int x; //scope begins 

    //... 
}//scope ends 
//x is not available here 

आपके मामले में, आप class A है कहना।

आप संकेत के साथ काम कर रहे हैं, तो नहीं:

A a(condition ? 1 : 2); 

या आप एक अलग निर्माता प्रोटोटाइप उपयोग कर रहे हैं:

A a = condition ? A(1) : A(2,3); 

आप ढेर पर उदाहरण बना रहे हैं:

A* instance = NULL; 
if (condition = true) 
{ 
    instance = new A(1); 
} 
else 
{ 
    instance = new A(2); 
} 

या आप त्रिगुट ऑपरेटर इस्तेमाल कर सकते हैं:

//if condition is true, call A(1), otherwise A(2) 
A* instance = new A(condition ? 1 : 2); 

संपादित करें:

हाँ आप:

A* x = NULL; //pointer to abstract class - it works 
if (condition) 
    x = new B(); 
else 
    x = new C(); 

संपादित करें:

ऐसा लगता है क्या आप देख रहे हैं कारखाने पैटर्न है (यह देखने के लिए ऊपर):

class A; //abstract 
class B : public A; 
class C : public A; 

class AFactory 
{ 
public: 
    A* create(int x) 
    { 
     if (x == 0) 
      return new B; 
     if (x == 1) 
      return new C; 
     return NULL; 
    } 
}; 

Answer 2

चर करें के अंत में सशर्त से बाहर एक सशर्त बाहर घोषित किया गया सशर्त?

हां।

स्थिति है जहाँ कोई डिफ़ॉल्ट निर्माता लेकिन निर्माता के लिए बहस होती है संभाल करने के लिए सही तरीका क्या है कुछ सशर्त, पर निर्भर करते हैं?

एक ऐसा फ़ंक्शन लिखें जो एक मान देता है, जिससे आप प्रतिलिपि बनाते हैं।

T foo() 
{ 
    if(condition) 
     return T(x); 
    return T(y); 
} 

void bar() 
{ 
    T i(foo()); 
} 

संपादित करें:

के बाद से एक सार है, मैं तो बस एक * obj की घोषणा नहीं कर सकता है और नए के साथ उचित प्रकार पैदा करते हैं।

आपका क्या मतलब है? यह वास्तव में गतिशील टाइपिंग कैसे काम करता है। सिवाय इसके कि मैं कच्चे सूचक का उपयोग नहीं करता, मैं एक अद्वितीय_पीटीआर का उपयोग करता हूं।

std::unique_ptr<A> obj; 
if(condition) { 
    obj = std::unique_ptr<A>(new B(args)); 
} else { 
    obj = std::unique_ptr<A>(new C(args)); 
} 

Answer 3

हाँ, यह क्षेत्र से बाहर हो सकता है अगर एक सशर्त, पाश आदि में घोषित होगा सशर्त के आधार पर चर परिवर्तन के प्रकार?

Answer 4

आपका विकल्प संकेत होगा:

MyObject *obj; 
if(cond1) 
{ 
    obj = new MyObject(1, 2, 3); 
} 
else 
{ 
    obj = new MyObject(4, 5); 
} 

इसे अवश्य हटा दें जब आप इसे के साथ किया जाता है, या एक स्मार्ट सूचक का उपयोग करें।