C++
Ablaufsteuerung

Bemerkungen

Fall

Führt eine Fallbezeichnung einer switch-Anweisung ein. Der Operand muss ein konstanter Ausdruck sein und mit der Schalterbedingung in type übereinstimmen. Wenn die switch-Anweisung ausgeführt wird, springt sie zu der Fallbezeichnung, wobei der Operand der Bedingung entspricht, falls vorhanden.

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

Schalter

Gemäß dem C ++ - Standard

Die switch Anweisung bewirkt, dass die Steuerung in Abhängigkeit von dem Wert einer Bedingung an eine von mehreren Anweisungen übergeben wird.

Der Schlüsselwort - switch wird von einem geklammerten Zustand und einem Block folgt, der enthalten kann case Etikett und ein optionales default Wenn der Schalter - Anweisung ausgeführt wird, wird die Steuerung entweder auf einen übertragen case Etikett mit einem Wert, der dem Zustand, falls vorhanden, oder an die passenden default - Etikett, falls vorhanden.

Die Bedingung muss ein Ausdruck oder eine Deklaration sein, die entweder einen Ganzzahl- oder Aufzählungstyp hat, oder ein Klassentyp mit einer Konvertierungsfunktion in Ganzzahl oder Aufzählungstyp.

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

Fang

Das catch Schlüsselwort führt einen Ausnahmehandler ein, d. H. Einen Block, in den das Steuerelement übertragen wird, wenn eine Ausnahme des kompatiblen Typs ausgelöst wird. Auf das catch Schlüsselwort folgt eine in Klammern stehende Ausnahmedeklaration , die in ihrer Form einer Funktionsparameterdeklaration ähnelt: Der Parametername kann weggelassen werden, und die Auslassungszeichen ... sind zulässig, was jedem Typ entspricht. Der Ausnahmehandler behandelt die Ausnahmebedingung nur, wenn ihre Deklaration mit dem Ausnahmetyp kompatibel ist. Weitere Informationen finden Sie unter Ausnahmen abfangen .

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

Führt in einer switch-Anweisung eine Beschriftung ein, zu der gesprungen wird, wenn der Wert der Bedingung nicht mit den Werten der Fallbezeichnungen übereinstimmt.

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

ob

Führt eine if-Anweisung ein. Dem Schlüsselwort if muss eine in Klammern stehende Bedingung folgen, die entweder ein Ausdruck oder eine Deklaration sein kann. Wenn die Bedingung wahr ist, wird die Unteranweisung nach der Bedingung ausgeführt.

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

sonst

Auf die erste Unteranweisung einer if-Anweisung kann das Schlüsselwort else folgen. Die Unteranweisung nach dem Schlüsselwort else wird ausgeführt, wenn die Bedingung falsch ist (dh wenn die erste Unteranweisung nicht ausgeführt wird).

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

gehe zu

Springt zu einer beschrifteten Anweisung, die sich in der aktuellen Funktion befinden muss.

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

Rückkehr

Gibt die Kontrolle von einer Funktion an ihren Aufrufer zurück.

Wenn return einen Operanden hat, wird der Operand in den Rückgabetyp der Funktion konvertiert und der konvertierte Wert wird an den Aufrufer zurückgegeben.

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

Wenn return keinen Operanden hat, muss die Funktion einen void Rückgabetyp haben. Als Sonderfall kann eine void -returning-Funktion auch einen Ausdruck zurückgeben, wenn der Typ den 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
}

Wenn main zurückkehrt, wird std::exit implizit mit dem Rückgabewert aufgerufen, und der Wert wird somit an die Ausführungsumgebung zurückgegeben. (Das Zurückkehren von main zerstört jedoch automatisch lokale Variablen, während std::exit direkt aufgerufen wird.)

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

werfen

1. Wenn throw in einem Ausdruck mit einem Operanden auftritt, ist seine Wirkung eine werfen Ausnahme , die eine Kopie des Operanden ist.

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

2. Wenn throw ohne einen Operanden in einem Ausdruck auftritt, ist seine Wirkung auf die aktuelle Ausnahme erneut auslösen . Wenn keine aktuelle Ausnahme std::terminate , wird std::terminate aufgerufen.

   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. Wenn der throw in einem Funktionsdeklarator auftritt, führt er eine dynamische Ausnahmespezifikation ein, die die Typen von Ausnahmen auflistet, die die Funktion weitergeben darf.

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

   Dynamische Ausnahmespezifikationen werden ab C ++ 11 nicht mehr unterstützt.

Beachten Sie, dass die ersten beiden oben genannten Verwendungsarten von throw Ausdrücke und keine Anweisungen darstellen. (Der Typ eines Wurfausdrucks ist void .) Dadurch können sie innerhalb von Ausdrücken verschachtelt werden, wie dies z.

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

Versuchen

Auf das Schlüsselwort try folgt ein Block oder eine Konstruktor-Initialisierungsliste und dann ein Block (siehe hier ). Auf den try-Block folgen ein oder mehrere Fangblöcke . Wenn sich eine Ausnahme aus dem try-Block verbreitet, hat jeder der entsprechenden catch-Blöcke nach dem try-Block die Möglichkeit, die Ausnahme zu behandeln, wenn die Typen übereinstimmen.

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
}    

Bedingte Strukturen: if, if..else

wenn und sonst:

es wurde verwendet, um zu überprüfen, ob der angegebene Ausdruck wahr oder falsch zurückgibt und als solcher wirkt:

if (condition) statement

Die Bedingung kann ein beliebiger gültiger C ++ - Ausdruck sein, der etwas zurückgibt, das beispielsweise mit der Wahrheit / Falschheit geprüft wird:

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

Die Bedingung kann beispielsweise alles sein, eine Funktion, eine Variable oder ein Vergleich

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, 

Wenn Sie nach mehreren Ausdrücken suchen möchten, haben Sie zwei Möglichkeiten:

mit binären Operatoren :

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 

mit if / ifelse / else :

für einen einfachen Schalter entweder wenn oder sonst

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

für mehrere Auswahlmöglichkeiten:

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
}

Es muss jedoch beachtet werden, dass Sie stattdessen ' switch ' verwenden sollten, wenn Ihr Code nach dem Wert dieser Variablen sucht

Jump-Anweisungen: Pause, Weiter, Los, Beenden.

Die Pause-Anweisung:

Mit break können wir eine Schleife verlassen, auch wenn die Bedingung für das Ende nicht erfüllt ist. Es kann verwendet werden, um eine Endlosschleife zu beenden oder sie vor ihrem natürlichen Ende zu beenden

Die Syntax lautet

break;

Beispiel : Wir verwenden häufig break in switch Fällen, dh wenn ein switch- switch einmal erfüllt ist, wird der Codeblock dieser Bedingung ausgeführt.

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

Wenn der Fall 1 erfüllt ist, wird in diesem Fall Block 1 ausgeführt. Was wir wirklich wollen, ist, dass nur der Block 1 verarbeitet wird. Wenn der Block 1 jedoch einmal verarbeitet wird, werden die Blöcke Block2, Block3 und Blockdefault ebenfalls verarbeitet, obwohl nur der Fall 1 erfüllt wurde Um dies zu vermeiden, verwenden wir break am Ende jedes Blocks wie:

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

Es wird also nur ein Satz bearbeitet und die Steuerung verlässt die Schalterschleife.

break kann auch in anderen bedingten und nicht bedingten Schleifen verwendet werden, z. B. if , while , for etc;

Beispiel:

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

Die weitere Anweisung:

Die continue-Anweisung bewirkt, dass das Programm den Rest der Schleife in der aktuellen Iteration überspringt, als wäre das Ende des Anweisungsblocks erreicht, wodurch es zur folgenden Iteration springt.

Die Syntax lautet

continue;

Beispiel betrachten Sie Folgendes:

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

was die Ausgabe erzeugt:

 @1
 @3
 @5
 @7
 @9

Wenn dieser Code immer dann erfüllt ist, wenn die Bedingung erfüllt ist, dass der Befehl " i%2==0 continue wird, wird der gesamte verbleibende Code übersprungen (@ und i), und die Inkrement- / Dekrementierungsanweisung der Schleife wird ausgeführt.

Die goto Anweisung:

Es ermöglicht einen absoluten Sprung zu einem anderen Punkt im Programm. Sie sollten diese Funktion sorgfältig verwenden, da bei der Ausführung keine Einschränkung der Verschachtelung auftritt. Der Zielpunkt wird durch ein Label identifiziert, das dann als Argument für die goto-Anweisung verwendet wird. Ein Label besteht aus einem gültigen Bezeichner gefolgt von einem Doppelpunkt (:)

Die Syntax lautet

goto label;
..
.
label: statement;

Hinweis: Von der Verwendung der goto-Anweisung wird dringend abgeraten, da es schwierig ist, den Steuerfluss eines Programms zu verfolgen, wodurch das Programm schwer verständlich und schwer zu ändern ist.

Beispiel:

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

Ausgabe :

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

Immer wenn die Bedingung num%2==0 erfüllt ist, sendet der goto die Ausführungssteuerung an den Anfang der do-while Schleife.

Die Exit-Funktion:

exit ist eine in cstdlib definierte cstdlib . Der Zweck des exit besteht darin, das laufende Programm mit einem bestimmten Exitcode zu beenden. Sein Prototyp ist:

void exit (int exit code);

cstdlib definiert die Standard-Exit-Codes EXIT_SUCCESS und EXIT_FAILURE .