C++ Cheat Sheet für Schnellreferenzen (PDF herunterladen)

 C Programming >> C-Programmierung >  >> Tags >> PDF
C++ Cheat Sheet für Schnellreferenzen (PDF herunterladen)

C++ ist eine Mehrzwecksprache und C-Spracherweiterung. Als eine der gefragtesten Programmiersprachen auf dem heutigen Markt ist C++ eine beliebte Studienwahl für aufstrebende Entwickler. Programmierer nehmen an Kursen teil und experimentieren mit C++-Projekten, um ihre Kenntnisse zu verbessern.

Aber sehnen Sie sich während der Arbeit jemals nach einer C++-Schnellreferenz? Was wäre, wenn Sie die C++-Arbeit effizienter erledigen könnten? Dieser C++-Spickzettel ist eine großartige Referenz, die Ihnen hilft, reibungsloser zu arbeiten.

Wir haben einen erstaunlichen C++-Syntax-Spickzettel oder C++-Befehls-Spickzettel kuratiert, der Ihnen helfen wird, Ihre Fähigkeiten zu verbessern oder zu verbessern.

Dieser C++-Programmier-Spickzettel ist auch eine gute Ressource für die Vorbereitung auf Vorstellungsgespräche. Sind Sie bereit, C++-Projekte schnell anzugehen? Fangen wir an!

C++-Spickzettel als PDF herunterladen

 

C++-Spickzettel

Syntax 

Beginnen wir mit unserem C++-Referenzblatt mit Syntax.

#include <iostream>
usingnamespacestd;

intmain() {
cout << "Hello World!";
return0;
}

Stellen Sie beim Schreiben von Code in C++ immer sicher, dass Sie jede Zeile mit einem Semikolon beenden, um das Ende der Zeile anzugeben. Sie müssen auch die schließende Klammer hinzufügen, um die main-Funktion zu beenden; Andernfalls erhalten Sie beim Kompilieren des Codes Fehler.

  • Zeile 1: ‚#include ‘ gibt die Header-Dateibibliothek an , das Ihnen beim Umgang mit Eingabe- und Ausgabeobjekten wie „cout“ hilft. Header-Dateien werden verwendet, um C++-Programmen spezifische Funktionen hinzuzufügen.
  • Zeile 2: „using namespace std“ ermöglicht es Ihnen, Namen für Objekte und Variablen aus der Standardbibliothek zu verwenden.
  • Zeile 3: Leerzeile. C++ ignoriert die im Code vorhandenen Leerzeichen.
  • Zeile 4: ‚int main()‘, das ist eine Funktion. Jeder Code innerhalb der geschweiften Klammern {} wird ausgeführt.
  • Zeile 5: cout ist ein Objekt, das zusammen mit dem Einfügeoperator (<<) verwendet wird, um den Ausgabetext zu drucken.
  • Zeile 6: return 0 wird verwendet, um die Hauptfunktion zu beenden.

Kommentare 

In C++ ignoriert der Compiler den Text gefolgt von den Kommentaren. C++ unterstützt zwei verschiedene Arten von Kommentaren:

//: gibt den einzeiligen Kommentar an.

/* ….*/ :gibt den mehrzeiligen Kommentar an.

Datentypen 

Datentypen geben den Typ der Datenvariablen an. Der Compiler weist den Speicher basierend auf den Datentypen zu. Im Folgenden sind die C++-Datentypen aufgeführt:

  • Integrierte oder primitive Datentypen: Vordefinierte Datentypen, die direkt verwendet werden können, einschließlich Integer, Character, Boolean, Floating Point, Double Floating Point, Valueless or Void und Wide Character.
  • Abgeleitete Datentypen: Abgeleitet von primitiven Datentypen:Funktion, Array, Zeiger und Referenz.
  • Benutzerdefinierte Datentypen: Definiert von Benutzern:Klasse, Struktur, Union, Enumeration und Typedef.

Variablen 

Variablen speichern die Datenwerte. C++ unterstützt verschiedene Arten von Variablen, wie z. B. int, double, string, char und float.

Zum Beispiel:

int num = 12; // Integer
string name = "Unity Buddy"; // String(text)
char ch = 'U'; //character
float fl = 5.99; // Floating point number

Sie können Buchstaben, Zahlen und den Unterstrich für einen Variablennamen verwenden. Variablen dürfen jedoch nicht mit Zahlen oder dem Unterstrich „_“ beginnen. Stattdessen beginnen sie mit Buchstaben, gefolgt von Zahlen oder dem Unterstrich „_“. Außerdem können Sie kein Schlüsselwort für den Variablennamen verwenden.

Variablenbereich

In C++ können Sie Ihre Variablen in drei Teilen des Programms deklarieren, die auch als Geltungsbereich der Variablen bezeichnet werden:

1. Lokale Variablen

Diese Variablen werden innerhalb einer Funktion oder eines Codeblocks deklariert. Ihr Geltungsbereich ist nur auf diese Funktion oder diesen Block beschränkt und kann von keiner anderen Anweisung außerhalb dieses Blocks aufgerufen werden.

Zum Beispiel:

#include <iostream>
usingnamespacestd;

intmain () {
// Local variable:
int a, b;
int c;

// initialization
a = 10;
b = 20;
c = a + b;

cout << c;

return0;
}

2. Globale Variablen

Globale Variablen sind für jede Funktion, Methode oder jeden Block des Programms zugänglich. Normalerweise wird es außerhalb aller Funktionen definiert. Der Wert der globalen Variablen ist im gesamten Programm gleich.

Zum Beispiel:

#include <iostream>
usingnamespacestd;

// Global variable:
int g;

intmain () {
// Local variable:
int a, b;

// initialization
a = 10;
b = 20;
g = a + b;

cout << g;

return0;
}

Datentypmodifikatoren 

Datentypmodifikatoren werden verwendet, um die maximale Datenlänge eines Datentyps zu ändern. Die folgende Tabelle hilft Ihnen, die Größe und den Bereich der integrierten Datentypen in Kombination mit Modifikatoren zu verstehen. In C++ sind vier verschiedene Arten von Modifikatoren verfügbar, nämlich signiert, unsigniert, kurz und lang.

Datentyp

Größe (in Byte)

Reichweite

kurzes int

2

-32.768 bis 32.767

unsigned short int

2

0 bis 65.535

unsigned int

4

0 bis 4.294.967.295

int

4

-2.147.483.648 bis 2.147.483.647

lange int

4

-2.147.483.648 bis 2.147.483.647

unsigned long int

4

0 bis 4.294.967.295

lang lang int

8

-(2^63) bis (2^63)-1

unsigned long long int

8

0 bis 18.446.744.073.709.551.615

signiertes Zeichen

1

-128 bis 127

unsigned char

1

0 bis 255

schweben

4

doppelt

8

langes Doppel

12

wchar_t

2 oder 4

1 breites Zeichen

Literale

Literale in C++ sind Daten, die Sie verwenden können, um die festen Werte darzustellen. Sie können sie direkt im Code verwenden.

Zum Beispiel 1, 2,5, „s“ usw.

In C++ sind verschiedene Arten von Literalen verfügbar, wie unten erläutert:

1. Integer-Literal

Ein Integer-Literal ist numerisch und hat keinen Bruch- oder Exponentialteil.

Beispiel: 

Dezimal (Basis 10):0, -9, 22 usw.

Oktal (Basis 8):021, 077, 033 usw.

Hexadezimal (Basis 16):0x7f, 0x2a, 0x521 usw.

2. Fließkommaliterale

Dies sind numerische Literale, die entweder einen Bruchteil oder einen Exponententeil haben.

Zum Beispiel:(-2,0, 0,8589, -0,26E -5).

3. Zeichenliteral

Dies sind einzelne Zeichen, die in ein einfaches Anführungszeichen eingeschlossen sind.

Zum Beispiel:„a“, „F“, „2“ usw.

4. Escape-Sequenzen

Sie können Escape-Sequenzen in C++ für nicht typisierbare Zeichen verwenden, die in C++ eine besondere Bedeutung haben.

Zum Beispiel:

Escape-Sequenzen

Charaktere

\b

Rücktaste

\f

Formular-Feed

\n

Zeilenumbruch

\r

Zurück

\t

Horizontaler Tabulator

\v

Vertikaler Tabulator

\\

Backslash

\'

Einfaches Anführungszeichen

\"

Doppeltes Anführungszeichen

\?

Fragezeichen

\0

Nullzeichen

5. Zeichenfolgenliteral

Dies ist eine Zeichenfolge, die in doppelte Anführungszeichen eingeschlossen ist.

Zum Beispiel:

"gut"

String-Konstante

""

Null-String-Konstante

" "

Zeichenfolgenkonstante von sechs Leerzeichen

"x"

String-Konstante mit einem einzelnen Zeichen

"Die Erde ist rund\n"

gibt String mit Zeilenumbruch

aus

Konstanten 

Um eine Variable zu erstellen, deren Werte Sie nicht ändern möchten, können Sie das Schlüsselwort „const“ verwenden.

Zum Beispiel:

constint LIGHT_SPEED = 2997928;
LIGHT_SPEED = 2500// cannot change the value

Mathematische Funktionen

C++ bietet mehrere Funktionen, mit denen Sie mathematische Aufgaben ausführen können. Die folgende Tabelle hebt alle grundlegenden mathematischen Funktionen hervor, die in C++ verfügbar sind:Math Functions

Funktion

Beschreibung

abs(x)

Gibt den absoluten Wert von x

zurück

acos(x)

Gibt den Arkuskosinus von x

zurück

asin(x)

Gibt den Arkussinus von x

zurück

atan(x)

Gibt den Arkustangens von x

zurück

cbrt(x)

Gibt die Kubikwurzel von x

zurück

Decke(x)

Gibt den Wert von x aufgerundet auf die nächste ganze Zahl zurück

cos(x)

Gibt den Kosinus von x

zurück

cosh(x)

Gibt den hyperbolischen Kosinus von x

zurück

exp(x)

Gibt den Wert von Ex

zurück

expm1(x)

Gibt ex -1

zurück

fabs(x)

Gibt den Absolutwert eines Floating x zurück

fdim(x, y)

Gibt die positive Differenz zwischen x und y

zurück

Etage(x)

Gibt den Wert von x zurück, abgerundet auf die nächste ganze Zahl

hypot(x, y)

Gibt sqrt(x2 +y2) ohne zwischenzeitlichen Überlauf oder Unterlauf zurück

fma(x, y, z)

Gibt x*y+z ohne Genauigkeitsverlust zurück

fmax(x, y)

Gibt den höchsten Wert eines fließenden x und y

zurück

fmin(x, y)

Gibt den niedrigsten Wert eines fließenden x und y

zurück

fmod(x, y)

Gibt den Gleitkommarest von x/y

zurück

pow(x,y)

Gibt den Wert von x hoch y zurück

Sünde(x)

Gibt den Sinus von x zurück (x im Bogenmaß)

sinh(x)

Gibt den hyperbolischen Sinus eines Double-Werts zurück

tan(x)

Gibt den Tangens eines Winkels zurück

tanh(x)

Gibt den hyperbolischen Tangens eines Double-Werts zurück

Benutzereingaben

C++ unterstützt „cout“ und „cin“, um Ausgaben anzuzeigen bzw. Eingaben von Benutzern entgegenzunehmen. cout verwendet den Iterationsoperator (<<) und cin verwendet (>>).

Zum Beispiel:

int x; // declaring a variable
cout << "Type a number: "; // Type any number and hit enter
cin >> x; // Get user input from the keyboard
cout << "Your number is: " << x; // Display the value

Strings 

Eine Zeichenfolge ist eine Sammlung oder Folge von Zeichen, die in doppelte Anführungszeichen eingeschlossen sind.

Zum Beispiel:

string str= "Hello";

Um eine Zeichenfolge in Ihrem Code zu verwenden, müssen Sie die Zeichenfolgenbibliothek mithilfe dieser Codezeile einschließen: 

#include <string>

Mit C++ können Sie dann verschiedene Funktionen ausführen, um Zeichenfolgen zu manipulieren. Die folgende Tabelle beschreibt die Funktionsnamen und ihre Beschreibungen:

Funktion

Beschreibung

int vergleich(const string&str)

Zwei String-Objekte vergleichen

int Länge()

Ermittelt die Länge des Strings

void swap(string&str)

Vertauscht die Werte zweier String-Objekte

string substr(int pos, int n)

Erstellt ein neues String-Objekt mit n Zeichen

int-Größe()

Gibt die Länge des Strings in Bytes zurück

void resize(int n)

Ändert die Länge des Strings auf bis zu n Zeichen

string&replace(int pos, int len, string&str)

Ersetzt den Teil des Strings, der an der Zeichenposition pos beginnt und sich über len Zeichen erstreckt

string&append(const string&str)

Fügt ein neues Zeichen am Ende eines anderen String-Objekts hinzu

char&at(int pos)

Greift auf ein einzelnes Zeichen an der angegebenen Position pos

zu

int find(string&str, int pos, int n)

Findet eine im Parameter angegebene Zeichenfolge

int find_first_of(string&str, int pos, int n)

Finde das erste Vorkommen der angegebenen Sequenz

int find_first_not_of(string&str, int pos, int n )

Sucht die Zeichenfolge für das erste Zeichen, das mit keinem der in der Zeichenfolge angegebenen Zeichen übereinstimmt

int find_last_of(string&str, int pos, int n)

Sucht nach der Zeichenfolge für das letzte Zeichen einer angegebenen Sequenz

int find_last_not_of(string&str, int pos)

Sucht nach dem letzten Zeichen, das nicht mit der angegebenen Zeichenfolge übereinstimmt

string&einfügen()

Fügt ein neues Zeichen vor dem durch die Position pos

angegebenen Zeichen ein

int max_size()

Findet die maximale Länge des Strings

void push_back(char ch)

Fügt am Ende der Zeichenfolge ein neues Zeichen ch hinzu

void pop_back()

Entfernt das letzte Zeichen der Zeichenfolge

Zeichenfolge&zuweisen()

Weist der Zeichenfolge einen neuen Wert zu

int copy(string&str)

Kopiert den Inhalt von string in einen anderen

void clear()

Entfernt alle Elemente aus der Zeichenfolge

const_reverse_iterator crbegin()

Zeigt auf das letzte Zeichen der Zeichenkette

const_char* data()

Kopiert die Zeichen von string in ein Array

bool leer()

Überprüft, ob der String leer ist oder nicht

string&erase()

Entfernt die Zeichen wie angegeben

char&front()

Gibt eine Referenz des ersten Zeichens

zurück

Zeichenfolge&Operator+=()

Hängt ein neues Zeichen am Ende der Zeichenfolge an

string&operator=()

Weist der Zeichenfolge einen neuen Wert zu

Zeichenoperator[](pos)

Ruft ein Zeichen an der angegebenen Position pos

ab

int rfind()

Sucht nach dem letzten Vorkommen der Zeichenfolge

iteratorende()

Bezieht sich auf das letzte Zeichen der Zeichenkette

reverse_iterator rend()

Zeigt auf das erste Zeichen des Strings

voidshrink_to_fit()

Reduziert die Kapazität und gleicht sie der Größe des Strings an

char* c_str()

Gibt einen Zeiger auf ein Array zurück, das eine nullterminierte Folge von Zeichen enthält

void reserve(inr len)

Fordert eine Kapazitätsänderung an

allocator_type get_allocator();

Gibt das zugewiesene Objekt zurück, das der Zeichenfolge zugeordnet ist

Operatoren 

C++ unterstützt verschiedene Arten von Operatoren, um Ihrem Code Logik hinzuzufügen und Operationen mit Variablen und ihren jeweiligen Werten auszuführen. Hier sind die C++-Operatortypen: 

1. Arithmetische Operatoren

Mit arithmetischen Operatoren können Sie gängige mathematische Operationen durchführen.

Operator

Name

Beispiel

+

Zusatz

x + y

-

Subtraktion

x - y

*

Multiplikation

x * y

/

Abteilung

x / j

%

Modul

x % y

++

Erhöhen

++x

--

Verringern

--x

2. Zuweisungsoperatoren

Mit Zuweisungsoperatoren können Sie Variablen Werte zuweisen.

Operator

Beispiel

Beschreibung 

Gleich wie

=

x =5

Um der Variablen einen Wert zuzuweisen.

x =5

+=

x +=3

Es wird den Wert 3 zum Wert von x addieren.

x =x + 3

-=

x -=3

Es subtrahiert den Wert 3 vom Wert von x.

x =x - 3

*=

x *=3

Es wird den Wert 3 mit dem Wert von x multiplizieren.

x =x * 3

/=

x /=3

Es teilt den Wert von x durch 3.

x =x / 3

%=

x %=3

Es wird die Erinnerung zurückgeben, den Wert x durch 3 zu teilen.

x =x % 3

&=

x &=3

x =x &3

|=

x |=3

x =x | 3

^=

x ^=3

x =x ^ 3

>>=

x>>=3

x =x>> 3

<<=

x <<=3

x =x <<3

3. Vergleichsoperatoren

Sie können diese Operatoren verwenden, um zwei Werte zu vergleichen, um einen wahren oder falschen Wert zurückzugeben. Es wird wahr zurückgegeben, wenn beide Werte übereinstimmen, und falsch, wenn sie nicht übereinstimmen.

Operator

Name

Beispiel

==

Gleich

x ==y

!=

Ungleich

x !=y

>

Größer als

x> y

<

Weniger als

x

>=

Größer als oder gleich

x>=y

<=

Kleiner als oder gleich

x <=y

4. Logische Operatoren

Diese Operatoren bestimmen die Logik zwischen Variablen.

Operator

Name

Beschreibung

Beispiel

&&

Logisch und

Gibt wahr zurück, wenn beide Aussagen wahr sind

x <5 &&x <10

||

Logisch oder

Gibt wahr zurück, wenn eine der Aussagen wahr ist

x <5 || x <4

!

Logisch nicht

Kehrt das Ergebnis um, gibt false zurück, wenn das Ergebnis wahr ist

!(x <5 &&x <10)

Entscheidungserklärungen

Entscheidungsanweisungen in C++ entscheiden über den Ablauf der Programmausführung. Hier spezifizieren Programmierer mehr als eine Bedingung. Wenn eine Bedingung zutrifft, werden die Anweisungen in diesem Block ausgeführt. Andernfalls werden stattdessen die Anweisungen aus anderen Blöcken ausgeführt.

C++ hat verschiedene Entscheidungsanweisungen:

  • If-Anweisung
  • if..else-Anweisung
  • Switch-Anweisung
  • Verschachtelte if-Anweisung
  • Verschachtelte switch-Anweisung
  • Ternärer Operator

1. If-Anweisung

Dies ist die grundlegendste Art der Entscheidungsfindung. Es weist den Compiler an, den Codeblock nur auszuführen, wenn die Bedingung wahr ist.

Syntax:

if (expression)
{ //code}

Beispiel: 

#include <iostream>
usingnamespacestd;

intmain () {
int b = 10;
if( b < 20 ) {
cout << "b is less than 20;" << endl;
}
cout << "value of a is : " << b << endl;

return0;
}

2. If..Else-Anweisung

Dies ist eine Erweiterung der 'if'-Anweisung. Es weist den Compiler an, den „if“-Block nur dann auszuführen, wenn die angegebene Bedingung wahr ist. Andernfalls wird der „else“-Block ausgeführt.

Syntax:

if (expression)
{//code}
else
{//code}

Beispiel: 

#include <iostream>
usingnamespacestd;

intmain () {
int b = 10;
if( b < 20 ) {
cout << "b is less than 20;" << endl;
}
cout << "value of a is : " << b << endl;

return0;
}

3. Switch-Anweisung

Wenn Sie Bedingungen für verschiedene Werte ausführen müssen, können Sie switch-Anweisungen verwenden.

Syntax: 

switch(expression) {
case constant-expression :
statement(s);
break; //optional
case constant-expression :
statement(s);
break; //optional

default : //Optional
statement(s);
}

Beispiel: 

#include <iostream>
usingnamespacestd;

intmain () {
// local variable declaration:
char grade = 'D';

switch(grade) {
case'A' :
cout << "Outstanding!" << endl;
break;
case'B' :
case'C' :
cout << "Well done" << endl;
break;
case'D' :
cout << "Pass" << endl;
break;
case'F' :
cout << "Try again" << endl;
break;
default :
cout << "Invalid grade" << endl;
}
cout << "Your grade is " << grade << endl;

return0;
}

4. Verschachtelte If-Anweisung

Dies ist eine „if“-Anweisung innerhalb einer anderen „if“-Anweisung. Sie können diese Art von Anweisung verwenden, wenn Sie eine bestimmte Bedingung auf das Ergebnis einer anderen Bedingung stützen müssen.

Syntax: 

if( boolean_expression 1) {
// Executes when the boolean expression 1 is true
if(boolean_expression 2) {
// Executes when the boolean expression 2 is true
}
}

Beispiel: 

#include <iostream>
usingnamespacestd;

intmain () {
// local variable declaration:
int x = 100;
int y = 200;

if( x == 100 ) {
if( y == 200 ) {

cout << "Value of x is 100 and y is 200" << endl;
}
}
cout << "Exact value of x is : " << x << endl;
cout << "Exact value of y is : " << y << endl;

return0;
}

5. Verschachtelte Switch-Anweisung

Sie können eine switch-Anweisung in eine andere switch-Anweisung einfügen.

Syntax: 

switch(ch1) {
case'A':
cout << "This A is part of outer switch";
switch(ch2) {
case'A':
cout << "This A is part of inner switch";
break;
case'B': // ...
}
break;
case'B': // ...
}

Beispiel: 

#include <iostream>
usingnamespacestd;

intmain () {
int x = 100;
int y = 200;

switch(x) {
case100:
cout << "This is part of outer switch" << endl;
switch(y) {
case200:
cout << "This is part of inner switch" << endl;
}
}
cout << "Exact value of x is : " << x << endl;
cout << "Exact value of y is : " << y << endl;

return0;
}

6. Ternärer Operator

Exp1 ? Exp2 :Exp3;

Zuerst wird der Ausdruck Exp1 ausgewertet. Wenn es wahr ist, wird Exp2 ausgewertet und wird zum Wert des gesamten „?“-Ausdrucks. Wenn Exp1 falsch ist, wird Exp3 ausgewertet und sein Wert wird zum Wert des Ausdrucks.

Schleifen 

Schleifen werden verwendet, um basierend auf dem Ergebnis der ausgewerteten Bedingung einen bestimmten Satz von Befehlen für eine bestimmte Anzahl von Zeiten auszuführen. C++ enthält die folgenden Schleifen

  • While-Schleife
  • Do-while-Schleife
  • For-Schleife
  • Break-Anweisung
  • Anweisung fortsetzen

1. While-Schleife

Die Schleife wird fortgesetzt, bis die angegebene Bedingung wahr ist.

while (condition)
{code}

2. Do-While-Schleife

Wenn die Bedingung falsch wird, stoppt die Ausführung der do-while-Schleife. Der einzige Unterschied zwischen der While- und der Do-While-Schleife besteht jedoch darin, dass die Do-While-Schleife die Bedingung nach testet Ausführen der Schleife. Daher wird die Schleife mindestens einmal ausgeführt.

do
{
Code
}
while (condition)

3. For-Schleife

Sie können die for-Schleife verwenden, um einen Codeblock mehrmals auszuführen. Diese Schleife führt den Block aus, bis die darin angegebene Bedingung falsch ist.

for (int a=0; i< count; i++)
{
Code
}

4. Break-Anweisung

Dies wird verwendet, um den Fluss des Codes zu unterbrechen, damit der verbleibende Code nicht ausgeführt wird. Das bringt Sie aus der Schleife.

Beispiel: 

for (int i = 0; i < 10; i++) {
if (i == 4) {
break;
}
cout << i << "\n";
}

5. Anweisung fortsetzen

Diese Anweisung unterbricht den Fluss und führt Sie zur Bewertung der Bedingung. Später startet es die Codeausführung erneut.

Zum Beispiel:

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

Arrays 

Arrays sind abgeleitete Datentypen, die mehrere Datenelemente ähnlichen Typs an zusammenhängenden Speicherorten speichern.

Zum Beispiel:

string vehicles [4]; //declaring array to store up to 4 variables.
string vehicles[4]= {"car", "scooter", "cycle", "bike"}; //initializing the array

1. Zugriff auf Array-Werte

Sie müssen die Indexnummer verwenden, um auf die in einem Array gespeicherten Elemente zuzugreifen.

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
cout << vehicles [0];

2. Ändern von Array-Elementen

Sie können die in einem Array gespeicherten Elemente über die Indexnummer ändern.

string vehicles[4]= {"car", "scooter", "cycle", "bike"};
vehicles [0]= " "airplane";
cout << vehicles[0];

Funktionen 

Eine Funktion ist eine Gruppe von Anweisungen zur Ausführung einer bestimmten Aufgabe. Die gemeinsame Funktion in jedem C++-Programm ist die main()-Funktion. Sie können Ihren komplexen Code sogar in mehrere kleine Funktionen zerlegen und diese separat ausführen.

Dazu müssen Sie diese Funktion deklarieren, definieren und aufrufen. C++ hat mehrere eingebaute Funktionen, die Sie direkt in jedem Programm aufrufen können.

Definieren einer Funktion

Das Folgende ist die Syntax zum Definieren einer Funktion in C++:

return_type function_name( parameter list ) {
body of the function
}

Wo:

  • return_type gibt den Werttyp an, der von dieser Funktion zurückgegeben wird.
  • Funktionsname gibt den Namen der Funktion an und muss eindeutig sein.
  • Parameterliste ermöglicht es Ihnen, mehr als einen Wert zusammen mit ihren Datentypen an Ihre Funktion zu übergeben.
  • Hauptteil der Funktion gibt den Satz von Anweisungen an, um eine Aufgabe zu erfüllen.

Zum Beispiel:

intmax(int num1, int num2) { // declaring the function max
int result;

if (num1 > num2)
result = num1;
else
result = num2;

return result;
}

Aufrufen einer Funktion

Sie müssen eine Funktion überall dort aufrufen, wo Sie sie in Ihrem Programm benötigen.

Zum Beispiel:

#include <iostream>
usingnamespacestd;

// function declaration
intmax(int num1, int num2);

intmain () {
int a = 100;
int b = 200;
int ret;

ret = max(a, b);
cout << "Max value is : " << ret << endl;

return0;
}

Funktionsargumente

Sie können Argumente auf drei Arten übergeben:

  • Call-by-Value: Übergibt den tatsächlichen Wert eines Arguments an den formalen Parameter der Funktion. Es ändert keine Parameter innerhalb der Funktion und wirkt sich nicht auf das Argument aus.
  • Call by pointer: Sie können eine Argumentadresse in den Formalparameter kopieren. Hier greift die Adresse auf das eigentliche beim Aufruf verwendete Argument zu. Das bedeutet, dass sich Änderungen am Parameter auf das Argument auswirken.
  • Aufruf per Referenz: Sie können eine Argumentreferenz in den Formalparameter kopieren. Die Referenz greift auf das tatsächliche Argument zu, das im Aufruf verwendet wird. Das bedeutet, dass sich Änderungen am Parameter auf das Argument auswirken.

Speicherklassen 

Speicherklassen definieren die Sichtbarkeit der Variablen und Funktionen. C++ unterstützt verschiedene Speicherklassen wie auto, register, extern, static und mutable.

1. Automatische Speicherklasse

Standardmäßig verwendet C++ diese Speicherklasse für alle Variablen.

Zum Beispiel:

{
int var;
autoint var1;
}

Sie können das „auto“ nur innerhalb von Funktionen zum Definieren der lokalen Variablen verwenden.

2. Speicherklasse registrieren 

Diese Speicherklasse definiert die lokalen Variablen, die im Register statt im RAM gespeichert werden sollen. Dies ist nützlich, wenn Sie häufig auf die Variable zugreifen möchten, z. B. Zähler. Die Größe der Variablen hat eine maximale Größe gleich der Registergröße.

Zum Beispiel:

{
registerint miles;
}

3. Statische Speicherklasse

Die statische Speicherklasse weist den Compiler an, lokale Variablen im gesamten Programm beizubehalten, ohne sie erstellen und zerstören zu müssen, wenn sie in den Gültigkeitsbereich eintreten oder ihn verlassen. Eine Variable als statisch zu definieren bedeutet, dass sie ihre Werte zwischen Funktionsaufrufen beibehält.

Globale Variablen sind statisch, was bedeutet, dass ihr Geltungsbereich auf ihre deklarierte Datei beschränkt ist. Wenn Sie ein Klassendatenelement als statisch angeben, wird nur eine Kopie dieses Elements erstellt, die alle Objekte seiner Klasse gemeinsam nutzen.

Beispiel: 

#include <iostream>

// Function declaration
voidfunc1(void);

staticint count = 10; /* Global variable */

main() {
while(count--) {
func();
}

return0;
}

// Function definition
voidfunc1( void ) {
staticint i = 5; // local static variable
i++;
std::cout << "i is " << i ;
std::cout << " and count is " << count << std::endl;
}

Externe Speicherklasse

Die externe Speicherklasse stellt eine Referenz auf eine globale Variable bereit und macht sie für ALLE Programmdateien sichtbar. Wenn Sie eine Variable als „extern“ angeben, kann die Variable nicht initialisiert werden, da sie den Variablennamen auf einen zuvor definierten Speicherort verweist.

Bei mehreren Dateien, in denen Sie eine globale Variable oder Funktion definieren, die auch in anderen Dateien verwendet werden soll, stellt extern eine Referenz in einer anderen Datei mit definierter Variable oder Funktion bereit. Sie müssen den extern-Modifizierer verwenden, wenn Sie dieselben globalen Variablen oder Funktionen zwischen zwei oder mehr Dateien teilen müssen.

Zum Beispiel:

Programm 1

#include <iostream>
int count ;
externvoidwrite_extern();

main() {
count = 5;
write_extern();
}

Programm 2

#include <iostream>

externint count;

voidwrite_extern(void) {
std::cout << "Count is " << count << std::endl;
}

Änderbare Speicherklasse

Sie können diese Speicherklasse verwenden, wenn Sie möchten, dass ein Objektmember die Memberfunktion überschreibt. Das heißt, ein änderbares Element, das durch eine konstante Elementfunktion geändert werden kann.

Struktur 

Mit der Struktur können Sie die Datenelemente der nicht ähnlichen Datentypen definieren. Um eine Struktur zu verwenden, müssen Sie sie definieren und auf ihre Strukturmitglieder zugreifen.

Das Folgende ist die Syntax zum Erstellen einer Struktur:

struct [Strukturtag] {
Elementdefinition;
Elementdefinition;
...
Elementdefinition;
} [eine oder mehrere Strukturvariablen];

Beispielsweise möchten wir eine Struktur von Büchern erstellen, die aus Titel, Autor, Thema und book_id wie folgt besteht:

structBooks {
char title[50];
char author[50];
char subject[100];
int book_id;
} book;

Sie müssen den Elementzugriffsoperator (.) verwenden, um auf Strukturelemente zuzugreifen. Dies ist ein Punkt zwischen dem Namen der Strukturvariablen und dem Strukturelement, auf das wir zugreifen möchten.

Zugriff auf Strukturmitglieder

#include <iostream>
#include <cstring>

usingnamespacestd;

structBooks {
char title[50];
char author[50];
char subject[100];
int book_id;
};

intmain() {
structBooksBook1; // Declare Book1 of type Book
structBooksBook2; // Declare Book2 of type Book

// book 1 specification
strcpy( Book1.title, "Learn C++ Programming");
strcpy( Book1.author, "Chand Miyan");
strcpy( Book1.subject, "C++ Programming");
Book1.book_id = 6495407;

// book 2 specification
strcpy( Book2.title, "Telecom Billing");
strcpy( Book2.author, "Yakit Singha");
strcpy( Book2.subject, "Telecom");
Book2.book_id = 6495700;

// Print Book1 info
cout << "Book 1 title : " << Book1.title <<endl;
cout << "Book 1 author : " << Book1.author <<endl;
cout << "Book 1 subject : " << Book1.subject <<endl;
cout << "Book 1 id : " << Book1.book_id <<endl;

// Print Book2 info
cout << "Book 2 title : " << Book2.title <<endl;
cout << "Book 2 author : " << Book2.author <<endl;
cout << "Book 2 subject : " << Book2.subject <<endl;
cout << "Book 2 id : " << Book2.book_id <<endl;

return0;
}

Referenzen 

Wenn Sie eine Variable als Referenz deklarieren, fungiert sie als Alternative zur vorhandenen. Sie müssen die Referenzvariable mit „&“ angeben, wie unten gezeigt:

string food = "Pizza";
string &meal = food; // reference to food

Zeiger 

Ein Zeiger in C++ ist eine Variable, die die Speicheradresse einer anderen Variablen speichert. Ähnlich wie reguläre Variablen haben auch Zeiger Datentypen. Wir verwenden „*“, um Zeiger in C++ zu deklarieren.

Zum Beispiel:

string food = "Pizza"; // string variable

cout << food; // Outputs the value of food (Pizza)
cout << &food; // Outputs the memory address of food (0x6dfed4)

Klassen und Objekte 

C++ ist eine objektorientierte Programmiersprache mit Klassen und Objekten. Klasse ist ein benutzerdefinierter Datentyp, den Sie verwenden können, um Datenmember und Memberfunktionen miteinander zu verbinden. Sie können auf sie zugreifen, indem Sie eine Instanz dieser Klasse erstellen.

Erstellen einer Klasse

So erstellen Sie eine Klasse in C++:

classMyClass { // The class
public: // Access specifier- accessible to everyone
int myNum; // Attribute (int variable)
string myString; // Attribute (string variable)
};

Erstellen eines Objekts

Objekte funktionieren als Instanz der Klasse und ermöglichen Ihnen den Zugriff auf ihre Mitglieder, Funktionen und Variablen. Sie müssen den Punktoperator (.) wie unten gezeigt verwenden:

classMyClass {
public:
int myNum;
string myString;
};

intmain() {
MyClass myObj; // Creating an object of MyClass

myObj.myNum = 15;
myObj.myString = "Some text";

// Print attribute values
cout << myObj.myNum << "\n";
cout << myObj.myString;
return0;
}

Mehrere Objekte erstellen

Hier ist ein Beispiel dafür, wie Sie mehrere Objekte derselben Klasse erstellen:

classCar {
public:
string brand;
};

intmain() {
// Create an object of Car
Car carObj1;
carObj1.brand = "BMW";

// Create another object of Car
Car carObj2;
carObj2.brand = "Ford";
// Print attribute values
cout << carObj1.brand "\n";
cout << carObj2.brand "\n";
return0;
}

Klassenmethoden

Methoden sind wie Funktionen, die innerhalb einer Klasse definiert sind. C++ hat zwei Arten von Methoden:innerhalb der Klasse und außerhalb der Klasse.

Inside-Class-Methode

classMyClass {
public:
voidmyMethod() { // Method/function inside the class
cout << "Hello World!";
}
};

intmain() {
MyClass myObj; // Create an object of MyClass
myObj.myMethod(); // Call the method
return0;
}

Methode außerhalb der Klasse

classMyClass {
public:
voidmyMethod(); // Method declaration
};

// Method/function definition outside the class
void MyClass::myMethod() {
cout << "Hello World!";
}

intmain() {
MyClass myObj; // object creation
myObj.myMethod(); // Call the method
return0;
}

Konstruktoren 

Ein Konstruktor ist eine Methode, die automatisch bei der Objekterstellung aufgerufen wird. Es hat denselben Namen wie der Klassenname und keinen Datentyp.

Zum Beispiel:

classFir_Class {
public:
Fir_Class() { // Constructor
cout << "Hello World!";
}
};

intmain() {
Fir_Class myObj; // call the constructor
return0;
}

Zugriffsspezifizierer 

Zugriffsbezeichner definieren den Zugriff der Klassenmitglieder und Variablen. C++ unterstützt drei Arten von Zugriffsbezeichnern:

  • Öffentlich: Auf Klassenmitglieder und Variablen kann von außerhalb der Klasse zugegriffen werden.
  • Privat: Auf Klassenmitglieder und Variablen kann nur innerhalb der Klasse und nicht außerhalb der Klasse zugegriffen werden.
  • Geschützt: Auf Klassenmitglieder und Variablen kann nur in ihren Unterklassen zugegriffen werden.

Kapselung 

Die Kapselung hilft Ihnen, sensible Daten vor den Benutzern zu verbergen. Hier verwenden wir den privaten Zugriffsspezifizierer zum Deklarieren der Variablen und Methoden. Wenn Sie anderen erlauben möchten, diese Variablen und Methoden zu lesen oder zu ändern, müssen Sie die öffentlichen Get- und Set-Methoden verwenden.

Zum Beispiel:

#include <iostream>
usingnamespacestd;

classEmployee {
private:
int name;

public:
// Setter
voidsetName(int n) {
name= s;
}
// Getter
intgetName() {
return name;
}
};

intmain() {
Employee myObj;
myObj.setName("Bob");
cout << myObj.getName();
return0;
}

Vererbung 

C++ unterstützt die Vererbung, sodass Sie die Mitglieder und Variablen einer Klasse an eine andere vererben können. Die erbende Klasse ist die untergeordnete Klasse und die andere die übergeordnete Klasse. You must use (:) symbol to inherit:

// Parent class
classVehicle {
public:
string brand = "Ford";
voidsound() {
cout << "honk \n" ;
}
};

// Child class
classCar: public Vehicle {
public:
string model = "Mustang";
};

intmain() {
Car myCar;
myCar.sound();
cout << myCar.brand + " " + myCar.model;
return0;
}

Polymorphism 

Polymorphism specifies the “many forms.” It is the ability of a single message to be displayed in multiple forms and takes place when you have multiple child classes and one base class.

Zum Beispiel:

// Parent class
classAnimal {
public:
voidsound() {
cout << "The animal makes a sound \n" ;
}
};

// Child class
classPig : public Animal {
public:
voidsound() {
cout << "The pig says: wee wee \n" ;
}
};

// Derived class
classDog : public Animal {
public:
voidsound() {
cout << "The dog says: bow wow \n" ;
}
};
intmain() {
Animal ani;
Pig myPig;
Dog myDog;

ani.sound();
myPig.sound();
myDog.sound();
return0;
}

File Handling 

You can use an fstream library to handle files. The fstream library consists of and header file.

#include

#include

ofstream: create and write to the files.

ifstream: read from the specified file.

fstream: combination of above both.

Creating and Writing

#include <iostream>
#include <fstream>
usingnamespacestd;

intmain() {
// Create and open a text file
ofstream MyFile("filename.txt");

// Write to the file
MyFile << "content";

// Close the file
MyFile.close();
}

Reading

// text string to output the text file
string myText;

// Read from the text file
ifstream MyReadFile("filename.txt");

// for reading the file line by line
while (getline (MyReadFile, myText)) {
// Output the text from the file
cout << myText;
}

// Close the file
MyReadFile.close();

Exceptions 

While compiling and running, you might run into errors. C++ allows you to handle and catch these errors using exception handling. The following is the syntax for exception handling that includes a try-catch block:

try {
// Block of code to try
throw exception; // Throw an exception when a problem arise
}
catch () {
// Block of code to handle errors
}

Zum Beispiel:

try {
int age = 10;
if (age >= 20) {
cout << "you are old enough.";
} else {
throw505;
}
}
catch (int num) {
cout << "Access denied \n";
cout << "Error number: " << num;
}

Preprocessor

The following are some in-built preprocessors available in C++ for various functionalities.

#include <stdio.h> // Insert standard header file

#include "myfile.h" // Insert file in current directory

#define X some text // Replace X with some text

#define F(a,b) a+b // Replace F(1,2) with 1+2

#define X \

 some text // Multiline definition

#undef X // Remove definition

#if defined(X) // Conditional compilation (#ifdef X)

#else // Optional (#ifndef X or #if !defined(X))

#endif // Required after #if, #ifdef

Dynamic Memory Management

#include <memory> // Include memory (std namespace)
shared_ptr<int> x; // Empty shared_ptr to a integer on heap. Uses reference counting for cleaning up objects.
x = make_shared<int>(12); // Allocate value 12 on heap
shared_ptr<int> y = x; // Copy shared_ptr, implicit changes reference count to 2.
cout << *y; // Dereference y to print '12'
if (y.get() == x.get()) { // Raw pointers (here x == y)
cout << "Same";
}
y.reset(); // Eliminate one owner of object
if (y.get() != x.get()) {
cout << "Different";
}
if (y == nullptr) { // Can compare against nullptr (here returns true)
cout << "Empty";
}
y = make_shared<int>(15); // Assign new value
cout << *y; // Dereference x to print '15'
cout << *x; // Dereference x to print '12'
weak_ptr<int> w; // Create empty weak pointer
w = y; // w has weak reference to y.
if (shared_ptr<int> s = w.lock()) { // Has to be copied into a shared_ptr before usage
cout << *s;
}
unique_ptr<int> z; // Create empty unique pointers
unique_ptr<int> q;
z = make_unique<int>(16); // Allocate int (16) on heap. Only one reference allowed.
q = move(z); // Move reference from z to q.
if (z == nullptr){
cout << "Z null";
}
cout << *q;
shared_ptr<B> r;
r = dynamic_pointer_cast<B>(t); // Converts t to a shared_ptr<B>

Floating Point Math

You must include the “cmath” library to perform tasks on floating-point numbers.

#include <cmath> // Include cmath (std namespace)

sin(x); cos(x); tan(x); // you can perform Trig functions, x (double) is in radians

asin(x); acos(x); atan(x); // Inverses

atan2(y, x); // atan(y/x)

sinh(x); cosh(x); tanh(x); // Hyperbolic sin, cos, tan functions

exp(x); log(x); log10(x); // e to the x, log base e, log base 10

pow(x, y); sqrt(x); // x to the y, square root

ceil(x); floor(x); // Round up or down (as a double)

fabs(x); fmod(x, y); // Absolute value, x mod y

iostream.h and iostream

#include <iostream> // Include iostream (std namespace)

cin >> x >> y; // Read words x and y (any type) from standard input

cout << "x=" << 3 << endl; // Write line to stdout

cerr << x << y << flush; // Write to stderr and flush

c = cin.get(); // c = getchar();

cin.get(c); // Read char

cin.getline(s, n, '\n'); // Read line into char s[n] to '\n' (default)

if (cin) // Good state (not EOF)?

// To read/write any type T:

istream& operator>>(istream& i, T& x) {i >> ...; x=...; return i;}

ostream& operator<<(ostream& o, const T& x) {return o << ...;}

Conclusion 

We’ve reached the end of the C++ reference cheat sheet. Congrats!

In this C++ reference, we have covered almost every C++ aspect that any beginner needs to understand when starting their career or preparing for an upcoming interview. This C++ cheat sheet for beginners is an excellent resource that you can go through while developing applications or before appearing for an interview.

We hope this C++ reference will help you understand everything about C++ in-depth.

Interested in expanding your C++ knowledge? Check out our list of the best C++ courses.

People are also reading:

  • Best C++ Interview Questions
  • Difference between C# vs C++
  • Best C++ IDE
  • Best C++ Books
  • Best Java Courses
  • Best HTML Courses
  • Best Web Development Courses
  • Best C Courses