C++ bietet einen Standardsatz von Operatoren für ausgewählte Bedingungen und Schleifen.
Die Schlüsselwörter im Zusammenhang mit Bedingungskonstrukten für Codeverzweigungen sind:
- wenn
- anders
- Schalter
- Fall
- Unterbrechung
- Ursprünglich
Die Schlüsselwörter für Schleifenkonstrukte sind:
- tun
- während
- Unterbrechung
- fortsetzen
- zum
Bedingungsanweisungen
if-Anweisung
Die Bedingungskonstruktion mit dem if -Operator wird wie folgt gebildet:
int x = 56;
bool check_x()
{
if (x > 0)
return true;
return false;
}
In diesem Fall steht die Bedingung in Klammern hinter der if-Anweisung. In dieser Konstruktion wird der Code return true; ausgeführt, wenn x größer als 0 ist. Die nächste Zeile return false; bezieht sich nicht mehr auf den Code, der ausgeführt wird, wenn die Bedingung erfüllt ist. In Bedingungskonstrukten wird, wenn diese Bedingung erfüllt ist, nur eine Codezeile ausgeführt, wenn der Code nicht in geschweiften Klammern eingerahmt ist, d. h. wenn der Hauptteil des Codes, der unter der Bedingung ausgeführt wird, nicht gebildet wird. Betrachten Sie zwei Codeoptionen:
Erste Wahl:
int x = 56;
bool check_x()
{
if (x > 0)
x = 0;
return true;
return false;
}
In diesem Code wird immer return true; ausgeführt, da nur die Zeile x = 0; zu dem unter der Bedingung ausgeführten Code gehört
Zweite Option:
int x = 56;
bool check_x()
{
if (x > 0)
{
x = 0;
return true;
}
return false;
}
In diesem Code wird return true; nur ausgeführt, wenn die Bedingung x > 0 wahr ist.
Betreiber sonst
Die else -Anweisung wird in Verbindung mit der if -Anweisung verwendet, um eine Folge von Bedingungen zu bilden.
int x = 56;
bool check_x()
{
if (x > 0)
{
x = 0;
return true;
}
else if (x < 0)
{
x = 0;
return false;
}
else
{
return false;
}
}
Die else-Anweisung kann sowohl zum Hinzufügen einer neuen Bedingung verwendet werden, wenn die vorherige Bedingung nicht erfüllt wurde – das Konstrukt else if. – als auch als abschließender Code in der Folge von Bedingungen, wenn die vorherigen Bedingungen nicht erfüllt wurden. Es ist auch möglich, keine geschweiften Klammern für den Codekörper zu verwenden, wenn der Code in eine Zeile passt.
Anweisungen switch, case, break, default
Das Konstrukt switch case wird verwendet, um einen Codezweig auszuwählen, dessen Bedingung eine ganzzahlige Auswahl verwendet. Das bedeutet, dass der switch case für einfache ganzzahlige Werte, Aufzählungen und die Auswahl per Zeichencode verwendet werden kann.
int x = 100;
bool check_x()
{
switch (x)
{
case 0:
return true;
case 50:
x = 0:
break;
case 100:
return false;
default:
return false;
}
Im obigen Code wird die Variable x auf Gleichheit mit den Zahlen 0, 50, 100 geprüft. Der Operator default wählt den Code aus, der ausgeführt wird, wenn keine der Bedingungen zutrifft. Beachten Sie auch, dass im Codeblock mit case 50: eine break -Anweisung hinzugefügt wird, diese Anweisung verlässt die Bedingung, während die return-Anweisung die Funktion verlässt. Wenn Sie keine break-Anweisung hinzufügen, wird die Codeausführung in case 100: block: . fortgesetzt. Dank dieser Funktion der switch case -Konstruktion ist es möglich, Bedingungen zu kombinieren, für die Sie dies benötigen denselben Code ausführen. Zum Beispiel:
int x = 100;
bool check_x()
{
switch (x)
{
case 0:
case 50:
case 100:
return true;
default:
return false;
}
}
Daher gibt die Funktion für x gleich 0, 50, 100 wahr zurück, während die Funktion für alle anderen Werte falsch zurückgibt.
Außerdem kann der Code zum Auswählen eines Falls in dieser Konstruktion in Codeblöcke verpackt werden, wodurch Sie den Bereich einschränken und Variablendeklarationen mit denselben Namen verwenden können.
int x = 100;
int check_x()
{
switch (x)
{
case 0:
{
int y = 1;
return y;
}
case 50:
{
int y = 2;
return y;
}
case 100:
{
int y = 3;
return y;
}
default:
return x;
}
}
Durch die Einschränkung des Gültigkeitsbereichs erhalten wir also die Möglichkeit, Variablen mit demselben Namen in Fallbedingungen zu verwenden. Aber vergessen Sie nicht, dass die Variable y außerhalb des Gültigkeitsbereichs, der durch geschweifte Klammern begrenzt ist, in diesem Fall nicht existiert.
Schleifenanweisungen
While-Anweisung
Die while-Anweisung wiederholt den Code in ihrem Rumpf, bis die Bedingung erfüllt ist. Zum Beispiel:
int i = 0;
while (i < 10)
{
i = i + 1;
}
In diesem Code ist i gleich 10, nachdem die Schleife ausgeführt wurde.
Aussage machen
Die do-Anweisung wird in Verbindung mit der while-Anweisung verwendet und ermöglicht, dass der Schleifenkörper mindestens einmal ausgeführt wird, bevor die Schleifenbedingung überprüft wird. Zum Beispiel:
int i = 15;
do
{
i = i - 5;
std::cout << i << std::endl;
}
while (i > 0 && i < 13);
In diesem Code stimmt die Variable I zunächst nicht mit der Bedingung überein und in der üblichen While-Schleife wurde der Code des Schleifenkörpers nicht ausgeführt, aber da hier die do-while-Schleife verwendet wird, erfolgt die Prüfung nach dem Schleifenkörper hingerichtet. Als Ergebnis sieht die Ausgabe von std::cout wie folgt aus:
10 5 0
Warum gibt es eine 0 in der Ausgabe, fragen Sie sich vielleicht? Schließlich passt es nicht zum Zustand. Auch hier, weil die Überprüfung nach der Ausführung des Codes im Schleifenkörper durchgeführt wird. Das heißt, der Hauptteil des Zyklus wurde ausgeführt, und dann wurde die Überprüfung bereits durchgeführt, wodurch der Zyklus seine Arbeit beendet.
break-Anweisung
Wie beim switch case-Konstrukt kann diese Anweisung in Schleifen verwendet werden. Dies ist notwendig, um die Schleife zu verlassen, bevor die Schleifenbedingung erfüllt ist. Zum Beispiel:
int i = 15;
while (i < 50)
{
if (i < 0)
{
break;
}
i = i - 5;
}
In diesem künstlichen Beispiel würde eine Endlosschleife dadurch entstehen, dass die Variable i abnimmt statt zunimmt, und gemäß der Schleifenbedingung nur dann verlassen wird, wenn i größer als 50 ist. Aber dank der break-Anweisung und Der Test auf einen negativen Wert der Variablen i Die Programmausführung verlässt diese Schleife, sobald i kleiner als 0 wird.
Continue-Anweisung
Mit dieser Anweisung können Sie die Iteration der Schleife unterbrechen und eine neue Iteration der Schleife starten, bevor Sie den gesamten Code im Hauptteil der Schleife ausführen. Zum Beispiel:
int i = 0;
while (i < 5)
{
if (i == 3)
{
i = i + 1;
continue;
}
std::cout << i << std::endl;
i = i + 1;
}
Wenn wir diesen Code ausführen, erhalten wir die folgende Ausgabe:
0 1 2 4
Das heißt, die Ausgabe der Zahl 3 wird übersprungen.
Die for-Anweisung
Schleifen mit der for-Anweisung ermöglichen es Ihnen, die Initialisierung von Variablen, die Bedingung und die Änderung dieser Variablen zu kombinieren.
Das heißt, die folgende While-Schleife
int i = 0;
while (i < 10)
{
Entspricht der folgenden for-Schleife:
for (int i = 0; i < 10; i++)
{
// ToDo Something
}
Der Vorteil dieser for-Schleife ist, dass die Variable I im lokalen Gültigkeitsbereich der for-Schleife liegt.
for -Schleifen können mit mehreren Variablen desselben Typs initialisiert werden. Zum Beispiel:
for (int i = 0, *p = &i; i < 9; i += 2) {
std::cout << i << ':' << *p << ' ';
}
Eine Bedingung kann auch eine Deklaration oder Initialisierung einer Variablen sein. Zum Beispiel:
char cstr[] = "Hello";
for (int n = 0; char c = cstr[n]; ++n) {
std::cout << c;
}
Aufgrund des C++11-Standards kann der auto -Operator als Variablentyp verwendet werden, wodurch Sie den Typ einer Variablen von einem Initialisierer ableiten können:
std::vector<int> v = {3, 1, 4, 1, 5, 9};
for (auto iter = v.begin(); iter != v.end(); ++iter) {
std::cout << *iter << ' ';
}
Ein interessanter Punkt ist auch, dass der Initialisierer-, Bedingungs- und Änderungsblock ein Ausdruck sein kann:
int n = 0;
for (std::cout << "Loop start\n";
std::cout << "Loop test\n";
std::cout << "Iteration " << ++n << '\n')
{
if(n > 1)
break;
}
Beginnend mit dem C++11-Standard können for -Schleifen Container durchlaufen, die Iteration unterstützen. Zum Beispiel der Vektorcontainer aus der Standardbibliothek:
std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (const int& i : v)
std::cout << i << ' ';
In diesem Code sieht die Schleifenstruktur wie folgt aus:
for (извлекаемый из контейнера при каждой итерации объект : контейнер)
{
// Тело цикла
}
Bereichsbasierte for-Schleifen unterstützen auch die auto-Anweisung. Zum Beispiel:
std::vector<int> v = {0, 1, 2, 3, 4, 5};
for (auto& i : v)
std::cout << i << ' ';
