C++
Flödeskontroll

Anmärkningar

fall

Presenterar en etikett för en switch-uttalande. Operanden måste vara ett konstant uttryck och matcha omkopplarens tillstånd i typ. När switch-uttalandet körs kommer det att hoppa till etiketten med operand som är lika med villkoret, om någon.

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

växla

Enligt C ++ -standarden

switch gör att kontrollen överförs till en av flera påståenden beroende på värdet på ett villkor.

Nyckelordet switch följs av en parentes tillstånd och ett block, som kan innehålla case etiketter och en valfri default När omkopplaren satsen körs kommer kontrollen att överföras antingen till en case etikett med ett värde motsvarande de tillstånd, om någon eller till default om något.

Villkoret måste vara ett uttryck eller en deklaration, som har antingen heltal eller nummertyp, eller en klasstyp med en konverteringsfunktion till heltal eller nummertyp.

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

fånga

Den catch nyckelordet introducerar ett undantag handler, dvs ett block i vilket styrningen överföres när ett undantag av kompatibel typ kastas. Den catch nyckelordet följs av en parentes undantag deklaration, som är liknande i form till en funktionsparameter deklaration: parameternamnet kan uteslutas och ellips ... är tillåtet, som matchar något slag. Undantagshanteraren hanterar endast undantaget om dess deklaration är kompatibel med undantagstypen. För mer information, se fånga undantag .

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;
}

standard

I ett switch-uttalande introducerar du en etikett som hoppas till om villkorsvärdet inte är lika med något av falletiketternas värden.

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;
};

om

Presenterar ett if-uttalande. Nyckelordet if måste följas av ett parentesiserat villkor, som kan vara antingen ett uttryck eller en deklaration. Om villkoret är sanningsenligt, kommer ersättningen efter villkoret att köras.

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();
}

annan

Den första ersättningen av ett if-uttalande kan följas av sökordet else . Substatueringen efter det else nyckelordet kommer att köras när villkoret är falsey (det vill säga när det första substatementet inte körs).

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

gå till

Hoppar till ett märkt uttalande, som måste finnas i den aktuella funktionen.

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;
}

lämna tillbaka

Returnerar kontrollen från en funktion till den som ringer.

Om return har en operand, konverteras operand till funktionens returtyp och det konverterade värdet returneras till den som ringer.

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

Om return inte har en operand måste funktionen ha en void returtyp. Som ett speciellt fall kan en void returning-funktion också returnera ett uttryck om uttrycket har typ 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
}

När main avkastning, std::exit implicit anropas med returvärdet, och värdet är således tillbaka till exekveringsmiljö. (Att återvända från main förstör emellertid automatiska lokala variabler, medan du ringer std::exit direkt inte.)

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

kasta

1. När throw sker i ett uttryck med en operand är dess effekt att kasta ett undantag , vilket är en kopia av operanden.

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

2. När throw inträffar i ett uttryck utan operand är dess effekt att återkasta det nuvarande undantaget . Om det inte finns något nuvarande undantag kallas 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. När throw sker i en funktionsdeklarator introducerar den en dynamisk undantagsspecifikation, som visar vilka typer av undantag som funktionen får sprida.

   // 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();
   

   Dynamiska undantagsspecifikationer avskrivs från och med C ++ 11.

Observera att de två första användningarna av throw listas ovan utgör uttryck snarare än uttalanden. (Typen av ett kastuttryck är void .) Detta gör det möjligt att häcka dem inom uttryck, som så:

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

Prova

Nyckelordet try följs av ett block, eller genom en konstruktör initierare listan och sedan ett block (se här ). Tryckblocket följs av ett eller flera fångstblock . Om ett undantag sprids ut ur försöksblocket har varje motsvarande fångstblock efter försöksblocket möjlighet att hantera undantaget, om typerna matchar.

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
}    

Villkorliga strukturer: om, om..else

om och annat:

det brukade kontrollera om det givna uttrycket returnerar sant eller falskt och fungerar som sådant:

if (condition) statement

villkoret kan vara vilket som helst giltigt C ++ -uttryck som returnerar något som kontrolleras mot sanning / falskhet till exempel:

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

villkoret kan vara vad som helst, en funktion, en variabel eller en jämförelse till exempel

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, 

om vi vill leta efter flera uttryck kan vi göra det på två sätt:

använder binära operatörer :

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 

använder if / ifelse / annat :

för en enkel switch antingen om eller annat

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

för flera val:

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
}

men det måste noteras att du bör använda ' switch ' istället om din kod kontrollerar för samma variabelns värde

Hoppa uttalanden: break, fortsätt, goto, exit.

Pausinstruktionen:

Med paus kan vi lämna en slinga även om villkoret för dess slut inte är uppfyllt. Det kan användas för att avsluta en oändlig slinga eller för att tvinga den att sluta före dess naturliga slut

Syntaxen är

break;

Exempel : vi använder ofta break i switch , dvs när en fall i switch är uppfyllt kommer kodblocket för det villkoret att köras.

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

i detta fall om fall 1 är nöjd, körs block 1, vad vi verkligen vill är att bara blocket 1 ska bearbetas men istället när block1 har bearbetats återstående block, block2, block3 och blockdefault behandlas också trots att endast fall 1 var satified . För att undvika detta använder vi paus i slutet av varje block som:

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

så endast ett block bearbetas och kontrollen flyttas ut från omkopplingsslingan.

break kan också användas i andra villkorade och icke villkorade slingor som if , while , for etc;

exempel:

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

Fortsättinstruktionen:

Fortsättningsinstruktionen får programmet att hoppa över resten av slingan i den aktuella iterationen som om slutet på uttalningsblocket skulle ha nåtts, vilket får det att hoppa till följande iteration.

Syntaxen är

continue;

Exempel överväga följande:

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

som producerar utgången:

 @1
 @3
 @5
 @7
 @9

i den här koden närhelst villkoret i%2==0 är uppfyllt continue bearbetas, detta gör att kompilatorn hoppar över alla återstående koder (utskrift @ och i) och inkrement / minskning uttalande av loopen körs.

Goto-instruktionen:

Det gör att du kan hoppa till en annan punkt i programmet. Du bör använda den här funktionen noggrant eftersom dess körning ignorerar alla typer av häckningsbegränsningar. Destinationspunkten identifieras av en etikett, som sedan används som ett argument för goto-instruktionen. En etikett är gjord av en giltig identifierare följt av en kolon (:)

Syntaxen är

goto label;
..
.
label: statement;

Anmärkning: Användning av goto-uttalande är starkt avskräckt eftersom det gör det svårt att spåra kontrollflödet för ett program, vilket gör programmet svårt att förstå och svårt att modifiera.

Exempel:

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 );

utgång:

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

när villkoret num%2==0 är uppfyllt skickar goto exekveringskontrollen till början av do-while slingan.

Utgångsfunktionen:

exit är en funktion som definieras i cstdlib . Syftet med exit är att avsluta det löpande programmet med en specifik exitkod. Prototypen är:

void exit (int exit code);

cstdlib definierar standardutgångskoderna EXIT_SUCCESS och EXIT_FAILURE .