C++
Debietregeling

Opmerkingen

geval

Introduceert een case-label van een schakeloptie. De operand moet een constante expressie zijn en overeenkomen met de schakelvoorwaarde in type. Wanneer de schakelopdracht wordt uitgevoerd, springt deze naar het hoofdlabel met operand gelijk aan de voorwaarde, indien aanwezig.

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

schakelaar

Volgens de C ++ standaard,

De switch zorgt ervoor dat de besturing wordt overgedragen naar een van de verschillende instructies, afhankelijk van de waarde van een voorwaarde.

Het sleutelwoord switch wordt gevolgd door een tussen haakjes staat en een blok, eventueel met case labels en een optionele default label. Wanneer de schakelaar instructie wordt uitgevoerd, zal de controle ofwel worden overgebracht naar een case label met een waarde als dat van de aandoening, indien aanwezig, of de default label, indien aanwezig.

De voorwaarde moet een uitdrukking of een declaratie zijn die een geheel getal of opsommingstype heeft, of een klassetype met een conversiefunctie naar een geheel getal of opsommingstype.

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

vangst

Het catch sleutelwoord introduceert een uitzonderingshandler, dat wil zeggen een blok waarin controle wordt overgedragen wanneer een uitzondering van het compatibele type wordt gegenereerd. De catch zoekwoord wordt gevolgd door een tussen haakjes uitzondering verklaring, die vergelijkbaar is in de vorm van een functie parameter verklaring: de naam van de parameter kan worden weggelaten, en de ellips ... is toegestaan, dat past bij elk type. De uitzonderingshandler verwerkt de uitzondering alleen als de verklaring compatibel is met het type uitzondering. Zie uitzonderingen vangen voor meer informatie.

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

standaard

Introduceert in een schakelinstructie een label waarnaar wordt gesprongen als de waarde van de voorwaarde niet gelijk is aan de waarden van de hoofdetiketten.

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

als

Introduceert een if-instructie. Het sleutelwoord if moet worden gevolgd door een haakjesvoorwaarde, die een uitdrukking of een verklaring kan zijn. Als de voorwaarde waarheidsgetrouw is, wordt het substatement na de voorwaarde uitgevoerd.

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

anders

Het eerste substatement van een if-instructie kan worden gevolgd door het trefwoord else . Het substatement achter het sleutelwoord else wordt uitgevoerd wanneer de voorwaarde falsey is (dat wil zeggen wanneer het eerste substatement niet wordt uitgevoerd).

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

ga naar

Springt naar een gelabelde instructie, die zich in de huidige functie moet bevinden.

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

terugkeer

Retourneert de controle van een functie naar de beller.

Als return een operand heeft, wordt de operand geconverteerd naar het retourtype van de functie en wordt de geconverteerde waarde teruggestuurd naar de beller.

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

Als return geen operand heeft, moet de functie het retourtype void hebben. In een speciaal geval kan een functie voor het retourneren van een void ook een uitdrukking retourneren als de uitdrukking het type 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
}

Wanneer main retourneert, wordt std::exit impliciet aangeroepen met de retourwaarde en wordt de waarde dus geretourneerd naar de uitvoeringsomgeving. (Terugkeren van main vernietigt echter automatische lokale variabelen, terwijl het aanroepen van std::exit niet.)

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

Gooi

1. Wanneer een throw voorkomt in een uitdrukking met een operand, heeft dit tot gevolg dat een uitzondering wordt gegenereerd , wat een kopie is van de operand.

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

2. Wanneer throw plaatsvindt in een expressie zonder operand, heeft dit tot gevolg dat de huidige uitzondering opnieuw wordt gegooid . Als er geen huidige uitzondering is, wordt std::terminate aangeroepen.

   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. Wanneer een throw voorkomt in een functie-declarator, introduceert deze een dynamische uitzonderingsspecificatie, waarin de soorten uitzonderingen worden vermeld die de functie mag doorgeven.

   // 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 uitzonderingsspecificaties zijn verouderd vanaf C ++ 11.

Merk op dat de eerste twee hierboven genoemde toepassingen van throw eerder uitdrukkingen zijn dan uitdrukkingen. (Het type van een worpexpressie is void .) Dit maakt het mogelijk om ze als volgt in expressies te nestelen:

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

proberen

Het sleutelwoord try wordt gevolgd door een blok, of door een constructeursinitialisatielijst en vervolgens een blok (zie hier ). Het try-blok wordt gevolgd door een of meer catch-blokken . Als een uitzondering zich buiten het try-blok voortplant, heeft elk van de overeenkomstige catch-blokken na het try-blok de mogelijkheid om de uitzondering af te handelen, als de typen overeenkomen.

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
}    

Voorwaardelijke structuren: if, if..else

indien en anders:

het gebruikte om te controleren of de gegeven uitdrukking waar of onwaar retourneert en als zodanig fungeert:

if (condition) statement

de voorwaarde kan elke geldige C ++ -uitdrukking zijn die iets retourneert dat bijvoorbeeld wordt gecontroleerd op waarheid / onwaarheid:

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

de voorwaarde kan alles zijn, een functie, een variabele of een vergelijking bijvoorbeeld

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, 

als we op meerdere expressies willen controleren, kunnen we dat op twee manieren doen:

met behulp van binaire 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 

if / ifelse / else gebruiken :

voor een eenvoudige schakelaar, of en anders

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

voor meerdere keuzes:

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
}

er moet echter worden opgemerkt dat u in plaats daarvan ' switch ' moet gebruiken als uw code naar de waarde van dezelfde variabele controleert

Spronginstructies: breken, doorgaan, naar de start gaan.

De pauze instructie:

Met pauze kunnen we een lus verlaten, zelfs als niet aan de voorwaarde voor het einde ervan is voldaan. Het kan worden gebruikt om een oneindige lus te beëindigen of om te stoppen voordat het natuurlijke einde is bereikt

De syntaxis is

break;

Voorbeeld : we gebruiken vaak break in switch cases, dat wil zeggen dat als een case-switch is voldaan, het codeblok van die voorwaarde wordt uitgevoerd.

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

in dit geval als aan geval 1 is voldaan, wordt blok 1 uitgevoerd, wat we echt willen dat alleen het blok1 wordt verwerkt, maar in plaats daarvan worden de resterende blokken, blok2, blok3 en blockdefault ook verwerkt, hoewel alleen geval 1 verzadigd was Om dit te voorkomen gebruiken we break aan het einde van elk blok zoals:

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

er wordt dus maar één blok verwerkt en de besturing komt uit de schakellus.

break kan ook worden gebruikt in andere voorwaardelijke en niet-voorwaardelijke lussen zoals if , while , for etc;

voorbeeld:

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

De doorgaan instructie:

De instructie continue zorgt ervoor dat het programma de rest van de lus in de huidige iteratie overslaat alsof het einde van het instructieblok zou zijn bereikt, waardoor het naar de volgende iteratie zou springen.

De syntaxis is

continue;

Beschouw bijvoorbeeld de volgende:

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

die de output produceert:

 @1
 @3
 @5
 @7
 @9

i deze code wanneer de voorwaarde i%2==0 wordt voldaan continue wordt verwerkt, dit zorgt ervoor dat de compiler om alle resterende code (printen @ en i) en increment overslaan / verlagen verklaring van de lus wordt uitgevoerd.

De goto-instructie:

Hiermee kunt u een absolute sprong maken naar een ander punt in het programma. U moet deze functie zorgvuldig gebruiken, omdat de uitvoering elk type nestbeperking negeert. Het bestemmingspunt wordt geïdentificeerd door een label, dat vervolgens wordt gebruikt als argument voor de goto-instructie. Een label bestaat uit een geldige identificatie gevolgd door een dubbele punt (:)

De syntaxis is

goto label;
..
.
label: statement;

Opmerking: het gebruik van de goto-instructie wordt sterk afgeraden omdat het moeilijk is om de besturingsstroom van een programma te achterhalen, waardoor het programma moeilijk te begrijpen en moeilijk te wijzigen is.

Voorbeeld:

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

output:

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

wanneer aan voorwaarde num%2==0 is voldaan, stuurt de goto de uitvoeringscontrole naar het begin van de do-while lus.

De exit functie:

exit is een functie gedefinieerd in cstdlib . Het doel van exit is om het lopende programma te beëindigen met een specifieke exitcode. Het prototype is:

void exit (int exit code);

cstdlib definieert de standaard EXIT_SUCCESS en EXIT_FAILURE .