C++
प्रवाह नियंत्रण

टिप्पणियों

मामला

एक स्विच स्टेटमेंट के केस लेबल का परिचय देता है। ऑपरेंड एक स्थिर अभिव्यक्ति होना चाहिए और प्रकार में स्विच की स्थिति से मेल खाना चाहिए। जब स्विच स्टेटमेंट निष्पादित किया जाता है, तो यह स्थिति के बराबर ऑपरेंड के साथ केस लेबल पर कूद जाएगा, यदि कोई हो।

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

स्विच

C ++ मानक के अनुसार,

switch स्टेटमेंट से किसी स्थिति के मूल्य के आधार पर कई बयानों में से एक को नियंत्रित किया जा सकता है।

कीवर्ड switch के बाद एक कोष्ठक स्थिति और एक ब्लॉक होता है, जिसमें case लेबल और एक वैकल्पिक default लेबल हो सकता है। जब स्विच स्टेटमेंट निष्पादित किया जाता है, तो नियंत्रण या तो case लेबल पर case मान से मेल खाते हुए, यदि कोई हो, या default लेबल, यदि कोई हो, को स्थानांतरित कर दिया जाएगा।

स्थिति एक अभिव्यक्ति या एक घोषणा होनी चाहिए, जिसमें पूर्णांक या गणना प्रकार या पूर्णांक या गणन प्रकार के रूपांतरण फ़ंक्शन के साथ एक वर्ग प्रकार है।

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

पकड़

catch कीवर्ड एक अपवाद हैंडलर का परिचय देता है, अर्थात, एक ब्लॉक जिसमें नियंत्रण को स्थानांतरित किया जाएगा जब संगत प्रकार का अपवाद फेंक दिया जाता है। catch कीवर्ड का एक कोष्ठक अपवाद घोषणा के बाद होता है , जो फ़ंक्शन पैरामीटर घोषणा के रूप में समान है: पैरामीटर नाम छोड़ा जा सकता है, और दीर्घवृत्त ... की अनुमति है, जो किसी भी प्रकार से मेल खाता है। अपवाद हैंडलर केवल उस अपवाद को हैंडल करेगा यदि उसकी घोषणा अपवाद के प्रकार के साथ संगत है। अधिक विवरण के लिए, अपवादों को पकड़ना देखें।

try {
    std::vector<int> v(N);
    // do something
} catch (const std::bad_alloc&) {
    std::cout << "failed to allocate memory for vector!" << std::endl;
} catch (const std::runtime_error& e) {
    std::cout << "runtime error: " << e.what() << std::endl;
} catch (...) {
    std::cout << "unexpected exception!" << std::endl;
    throw;
}

चूक

एक स्विच स्टेटमेंट में, एक लेबल का परिचय देता है जो कि स्थिति के मान के किसी भी लेबल के मान के बराबर नहीं होने पर कूद जाएगा।

char c = getchar();
bool confirmed;
switch (c) {
  case 'y':
    confirmed = true;
    break;
  case 'n':
    confirmed = false;
    break;
  default:
    std::cout << "invalid response!\n";
    abort();
}

class Base {
    // ...
    // we want to be able to delete derived classes through Base*,
    // but have the usual behaviour for Base's destructor.
    virtual ~Base() = default;
};

अगर

एक if statement का परिचय देता है। कीवर्ड if किसी कोष्ठक स्थिति के अनुसार होना चाहिए, जो कि एक अभिव्यक्ति या एक घोषणा हो सकती है। यदि स्थिति सत्य है, तो स्थिति के बाद सबस्टेशन निष्पादित किया जाएगा।

int x;
std::cout << "Please enter a positive number." << std::endl;
std::cin >> x;
if (x <= 0) {
    std::cout << "You didn't enter a positive number!" << std::endl;
    abort();
}

अन्य

यदि किसी कथन के पहले सबस्टेशन का अनुसरण कीवर्ड द्वारा किया जा सकता else । else कीवर्ड के बाद सबस्टेशन को निष्पादित किया जाएगा जब स्थिति गलत हो (अर्थात, जब पहला सबस्टेशन निष्पादित नहीं होता है)।

int x;
std::cin >> x;
if (x%2 == 0) {
    std::cout << "The number is even\n";
} else {
    std::cout << "The number is odd\n";
}

के लिए जाओ

एक लेबल स्टेटमेंट पर कूदता है, जिसे वर्तमान फ़ंक्शन में स्थित होना चाहिए।

bool f(int arg) {
    bool result = false;
    hWidget widget = get_widget(arg);
    if (!g()) {
        // we can't continue, but must do cleanup still
        goto end;
    }
    // ...
    result = true;
  end:
    release_widget(widget);
    return result;
}

वापसी

किसी फ़ंक्शन से इसके कॉलर पर नियंत्रण लौटाता है।

यदि return में एक ऑपरेंड है, तो ऑपरेंड फ़ंक्शन के रिटर्न प्रकार में परिवर्तित हो जाता है, और परिवर्तित मान कॉलर को वापस कर दिया जाता है।

int f() {
    return 42;
}
int x = f(); // x is 42
int g() {
    return 3.14;
}
int y = g(); // y is 3

यदि return में एक ऑपरेंड नहीं है, तो फ़ंक्शन में void रिटर्न प्रकार होना चाहिए। एक विशेष मामले के रूप में, एक void फ़ंक्शन भी एक अभिव्यक्ति वापस कर सकता है यदि अभिव्यक्ति में टाइप void ।

void f(int x) {
    if (x < 0) return;
    std::cout << sqrt(x);
}
int g() { return 42; }
void h() {
    return f(); // calls f, then returns
    return g(); // ill-formed
}

जब main रिटर्न, std::exit अर्थ है वापसी मूल्य के साथ कहा जाता है, और इस प्रकार मूल्य निष्पादन वातावरण में वापस आ जाता है। (हालांकि, main से लौटते समय स्वचालित स्थानीय चर नष्ट हो जाते हैं, जबकि std::exit कॉल से std::exit सीधे नहीं होता है।)

int main(int argc, char** argv) {
    if (argc < 2) {
        std::cout << "Missing argument\n";
        return EXIT_FAILURE; // equivalent to: exit(EXIT_FAILURE);
    }
}

फेंकना

1. जब throw एक ऑपरेंड के साथ एक अभिव्यक्ति में होता है, तो इसका प्रभाव एक अपवाद को फेंकना है , जो ऑपरेंड की एक प्रति है।

   void print_asterisks(int count) {
       if (count < 0) {
           throw std::invalid_argument("count cannot be negative!");
       }
       while (count--) { putchar('*'); }
   }
   

2. जब throw एक ऑपरेंड के बिना एक अभिव्यक्ति में होता है, तो इसका प्रभाव वर्तमान अपवाद को फिर से उखाड़ना है । यदि कोई वर्तमान अपवाद नहीं है, तो std::terminate को कहा जाता है।

   try {
       // something risky
   } catch (const std::bad_alloc&) {
       std::cerr << "out of memory" << std::endl;
   } catch (...) {
       std::cerr << "unexpected exception" << std::endl;
       // hope the caller knows how to handle this exception
       throw;
   }
   

3. जब throw एक फ़ंक्शन घोषणाकर्ता में होता है, तो यह एक गतिशील अपवाद विनिर्देश का परिचय देता है, जो उन अपवादों के प्रकारों को सूचीबद्ध करता है जिन्हें फ़ंक्शन को प्रचारित करने की अनुमति है।

   // this function might propagate a std::runtime_error,
   // but not, say, a std::logic_error
   void risky() throw(std::runtime_error);
   // this function can't propagate any exceptions
   void safe() throw();
   

   डायनेमिक अपवाद विनिर्देश C ++ 11 के रूप में हटाए गए हैं।

ध्यान दें कि के पहले दो का उपयोग करता है throw सूचीबद्ध ऊपर बयान के बजाय भाव का गठन। (थ्रो एक्सप्रेशन का प्रकार void ।) इससे उन्हें भावों के भीतर घोंसला बनाना संभव होता है, जैसे:

unsigned int predecessor(unsigned int x) {
    return (x > 0) ? (x - 1) : (throw std::invalid_argument("0 has no predecessor"));
}

प्रयत्न

कीवर्ड की try एक ब्लॉक, या एक कंस्ट्रक्टर इनिशियलाइज़र सूची और उसके बाद एक ब्लॉक ( यहाँ देखें) द्वारा की जाती है। कोशिश ब्लॉक एक या एक से अधिक पकड़ ब्लॉक के बाद है । यदि कोई अपवाद ट्राई ब्लॉक से बाहर निकलता है, तो कोशिश ब्लॉक के बाद संगत कैच ब्लॉक्स में से प्रत्येक के पास अपवाद को संभालने का अवसर होता है, यदि प्रकार मेल खाते हैं।

std::vector<int> v(N);     // if an exception is thrown here,
                           // it will not be caught by the following catch block
try {
    std::vector<int> v(N); // if an exception is thrown here,
                           // it will be caught by the following catch block
    // do something with v
} catch (const std::bad_alloc&) {
    // handle bad_alloc exceptions from the try block
}    

सशर्त संरचनाएं: यदि, यदि

यदि और

यह जाँच करता था कि क्या दी गई अभिव्यक्ति सही है या गलत है और इस तरह से कार्य करती है:

if (condition) statement

स्थिति किसी भी मान्य C ++ अभिव्यक्ति हो सकती है जो कुछ ऐसा लौटाती है जिसे उदाहरण के लिए सत्य / असत्य के खिलाफ जांचा जाए:

if (true) { /* code here */ }  // evaluate that true is true and execute the code in the brackets
if (false) { /* code here */ } // always skip the code since false is always false

स्थिति कुछ भी हो सकती है, एक फ़ंक्शन, एक चर या उदाहरण के लिए एक तुलना

if(istrue()) { } // evaluate the function, if it returns true, the if will execute the code
if(isTrue(var)) { } //evalute the return of the function after passing the argument var
if(a == b) { } // this will evaluate the return of the experssion (a==b) which will be true if equal and false if unequal
if(a) { } //if a is a boolean type, it will evaluate for its value, if it's an integer, any non zero value will be true, 

अगर हम एक से अधिक अभिव्यक्तियों की जाँच करना चाहते हैं, तो हम इसे दो तरीकों से कर सकते हैं:

बाइनरी ऑपरेटरों का उपयोग करना :

if (a && b) { } // will be true only if both a and b are true (binary operators are outside the scope here
if (a || b ) { } //true if a or b is true 

का उपयोग कर अगर / ifelse / और :

एक सरल स्विच के लिए या तो या तो

if (a== "test") {
    //will execute if a is a string "test" 
} else {
    // only if the first failed, will execute 
}

कई विकल्पों के लिए:

if (a=='a') { 
// if a is a char valued 'a'  
} else if (a=='b') {
// if a is a char valued 'b' 
} else if (a=='c') {
// if a is a char valued 'c'
} else { 
//if a is none of the above
}

हालाँकि यह ध्यान दिया जाना चाहिए कि यदि आपके कोड समान चर के मान की जाँच करते हैं तो आपको ' स्विच ' का उपयोग करना चाहिए

जम्प स्टेटमेंट्स: ब्रेक, कंटीन्यू, गोटो, एग्जिट।

ब्रेक निर्देश:

ब्रेक का उपयोग करके हम एक लूप छोड़ सकते हैं, भले ही इसके अंत के लिए शर्त पूरी न हो। इसका उपयोग एक अनंत लूप को समाप्त करने के लिए किया जा सकता है, या इसके प्राकृतिक अंत से पहले इसे समाप्त करने के लिए मजबूर किया जा सकता है

वाक्य-विन्यास है

break;

उदाहरण : हम अक्सर switch मामलों में break का switch हैं, यानी एक बार जब मैं स्विच संतुष्ट हो जाता है तो उस स्थिति के कोड ब्लॉक को निष्पादित किया जाता है।

switch(conditon){
case 1: block1;
case 2: block2;
case 3: block3;
default: blockdefault;
} 

इस स्थिति में यदि केस 1 संतुष्ट है तो ब्लॉक 1 को निष्पादित किया जाता है, जो हम वास्तव में चाहते हैं, केवल ब्लॉक 1 को संसाधित किया जाना है, लेकिन इसके बजाय ब्लॉक 1 संसाधित होने पर शेष ब्लॉक, ब्लॉक 2, ब्लॉक 3 और ब्लॉकडफॉल्ट भी संसाधित किए जाते हैं, भले ही केवल मामला 1 संतृप्त हो। इससे बचें, हम प्रत्येक ब्लॉक के अंत में ब्रेक का उपयोग करते हैं जैसे:

switch(condition){
case 1: block1;
        break;
case 2: block2;
        break;
case 3: block3;
        break;
default: blockdefault;
        break;
}

इसलिए केवल एक ब्लॉक को संसाधित किया जाता है और नियंत्रण स्विच लूप से बाहर निकल जाता है।

ब्रेक भी अन्य सशर्त और गैर सशर्त छोरों में इस्तेमाल किया जा सकता है जैसे if , while , for आदि;

उदाहरण:

if(condition1){
   ....
   if(condition2){
    .......
    break;
    }
 ...
}

निर्देश जारी रखें:

जारी निर्देश कार्यक्रम को वर्तमान पुनरावृत्ति में शेष लूप को छोड़ देने का कारण बनता है जैसे कि स्टेटमेंट ब्लॉक का अंत तक पहुंच गया होगा, जिससे यह निम्न पुनरावृत्ति पर कूद जाएगा।

वाक्य-विन्यास है

continue;

उदाहरण निम्नलिखित पर विचार करें:

for(int i=0;i<10;i++){
if(i%2==0)
continue;
cout<<"\n @"<<i;
}

जो उत्पादन का उत्पादन करता है:

 @1
 @3
 @5
 @7
 @9

मैं इस कोड जब भी हालत i%2==0 संतुष्ट हो जाता है continue / पाश की घटती बयान निष्पादित हो जाता है संसाधित किया जाता है, इस का कारण बनता है संकलक सभी शेष कोड (मुद्रण @ और i) और वेतन वृद्धि को छोड़ने के लिए।

गोटो निर्देश:

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

वाक्य-विन्यास है

goto label;
..
.
label: statement;

नोट: गोटो स्टेटमेंट का उपयोग अत्यधिक हतोत्साहित करता है क्योंकि किसी प्रोग्राम के नियंत्रण प्रवाह को ट्रेस करना कठिन हो जाता है, जिससे प्रोग्राम को समझना और संशोधित करना कठिन हो जाता है।

उदाहरण :

int num = 1;
STEP:
do{
 
    if( num%2==0 )
    {
        num = num + 1;
        goto STEP;
     }

   cout << "value of num : " << num << endl;
   num = num + 1;
 }while( num < 10 );

आउटपुट:

value of num : 1
value of num : 3
value of num : 5
value of num : 7
value of num : 9

जब भी स्थिति num%2==0 संतुष्ट होती है, तो गोटो do-while लूप की शुरुआत में निष्पादन नियंत्रण भेजता है।

निकास समारोह:

exit cstdlib में परिभाषित फंक्शन है। exit का उद्देश्य एक विशिष्ट निकास कोड के साथ चल रहे कार्यक्रम को समाप्त करना है। इसका प्रोटोटाइप है:

void exit (int exit code);

cstdlib मानक निकास कोड EXIT_SUCCESS और EXIT_FAILURE को परिभाषित करता है।