C++ Variablen und Typen

Einführung

In diesem Lab lernst du die Variablen und Datentypen in C++. Du wirst lernen, wie Variablen definiert werden und wie verschiedene Arten von Variablen verwendet werden.

Inhaltsvorschau

Computerprogramme verarbeiten Daten. Eine Variable wird verwendet, um ein Datenstück für die Verarbeitung zu speichern. Sie wird Variable genannt, weil Sie den gespeicherten Wert ändern können.

• Variablen
• Bezeichner
• Variablendeklaration
• Konstanten
• Ausdrücke
• Zuweisung
• Grundtypen
• Literale für Grundtypen und Zeichenkette

Variablen

Eine Variable ist ein benannter Speicherort, der einen Wert eines bestimmten Datentyps speichert. Mit anderen Worten hat eine Variable einen Namen, einen Typ und speichert einen Wert.

• Eine Variable hat einen Namen (oder Bezeichner), z.B. radius, area, age, height. Der Name ist erforderlich, um jede Variable eindeutig zu identifizieren, um einem Variablen einen Wert zuzuweisen und den gespeicherten Wert abzurufen.
• Eine Variable hat einen Typ wie int oder double.
• Eine Variable kann einen Wert des bestimmten Typs speichern. Eine Variable ist mit einem Typ assoziiert und kann nur Werte des bestimmten Typs speichern.
• Der Typ bestimmt die Größe und die Layout der Daten, den Wertebereich und die Menge der anwendbaren Operationen.

Im folgenden Diagramm sind zwei Typen von Variablen dargestellt: int und double. Eine int-Variable speichert eine Ganzzahl (ganze Zahl). Eine double-Variable speichert eine Gleitkommazahl.

Bezeichner

Ein Bezeichner ist erforderlich, um eine Variable (oder jedes andere Entität wie eine Funktion oder eine Klasse) zu benennen. C++ stellt die folgenden Regeln für Bezeichner auf:

• Ein Bezeichner ist eine Folge von Zeichen, die Groß- und Kleinschreibung (a-z, A-Z), Ziffern (0-9) und Unterstrich (_) umfassen.
• Leerzeichen (Leerzeichen, Tabulator, Zeilenumbruch) und andere Sonderzeichen (wie +, -, *, /, '@' usw.) sind nicht erlaubt.
• Ein Bezeichner muss mit einem Buchstaben oder einem Unterstrich beginnen. Er kann nicht mit einer Ziffer beginnen. Bezeichner, die mit einem Unterstrich beginnen, werden normalerweise für den Systemgebrauch reserviert.
• Ein Bezeichner kann kein reservierter Schlüsselwort oder ein reserviertes Literal sein (z.B. int, double, if, else, for).
• Bezeichner sind groß- und kleinschreibungssensitiv. Ein rose ist KEIN Rose und KEIN ROSE.

Variablennamenskonvention

Ein Variablennamen ist ein Substantiv oder eine Substantivphrase, die aus mehreren Wörtern besteht. Das erste Wort ist klein geschrieben, während die verbleibenden Wörter mit einem großen Anfangsbuchstaben geschrieben werden, ohne Leerzeichen zwischen den Wörtern. Beispielsweise thefontSize, roomNumber, xMax und thisIsAVeryLongVariableName, was als Camel-Case bekannt ist.

Empfehlungen

1. Es ist wichtig, einen Namen zu wählen, der selbstbeschreibend ist und genau die Bedeutung der Variable widerspiegelt, z.B. numberOfStudents oder numStudents.
2. Verwenden Sie keine bedeutungslosen Namen wie a, b, c, d, i, j, k, i1, j99. Vermeiden Sie Namen mit einem einzelnen Buchstaben, es sei denn, es handelt sich um übliche Namen wie x, y, z für Koordinaten, i für Index.
3. Es ist völlig in Ordnung, lange Namen von etwa 30 Zeichen zu verwenden, um sicherzustellen, dass der Name seine Bedeutung genau widerspiegelt.
4. Verwenden Sie Singular- und Pluralsubstantive vorsichtig, um zwischen singularen und pluralen Variablen zu unterscheiden. Verwenden Sie beispielsweise die Variable row, um auf eine einzelne Zeilennummer zu verweisen, und rows, um auf mehrere Zeilen zu verweisen.

Variable Deklaration

Bevor Sie eine Variable verwenden, müssen Sie zunächst ihren Namen und Typ in einer der folgenden Syntaxen deklarieren:

Beispiel

int mark1;           // Deklarieren Sie eine int-Variable namens mark1
mark1 = 76;          // Verwenden Sie mark1
int mark2;           // Deklarieren Sie die int-Variable mark2
mark2 = mark1 + 10;  // Verwenden Sie mark2 und mark1
double average;      // Deklarieren Sie die double-Variable average
average = (mark1 + mark2) / 2.0;   // Verwenden Sie average, mark1 und mark2
int mark1;           // Fehler: Deklarieren Sie zweimal
mark2 = "Hello";     // Fehler: Weisen Sie einen Wert eines anderen Typs zu
int number;             // Deklariert, aber nicht initialisiert
cout << number << endl; // Vor der Initialisierung verwendet, keine Warnung/Fehler, aber unerwartetes Ergebnis.

Beachten Sie, dass:

• In C++ müssen Sie den Namen einer Variable deklarieren, bevor Sie sie verwenden können.
• C++ ist eine "stark typisierte" Sprache. Eine Variable hat einen Typ. Nachdem der Typ einer Variable deklariert wurde, kann sie nur einen Wert dieses bestimmten Typs speichern.
• Jede Variable kann nur einmal deklariert werden.
• In C++ können Sie eine Variable überall innerhalb des Programms deklarieren, solange sie vor der Verwendung deklariert wird.
• Der Typ einer Variable kann innerhalb des Programms nicht geändert werden.
• Eine Variable, die gerade deklariert wurde, aber nicht initialisiert wurde, enthält Müll. C/C++ gibt keine Warnung/Fehler aus, wenn Sie eine Variable verwenden, bevor Sie sie initialisieren - was zu unerwarteten Ergebnissen führen kann.

Konstanten (const)

Konstanten sind nicht veränderbare Variablen, die mit dem Schlüsselwort const deklariert werden. Ihre Werte können während der Programmausführung nicht geändert werden. Außerdem muss const bei der Deklaration initialisiert werden. Beispielsweise:

const double PI = 3.1415926;  // Muss initialisiert werden

Konstantennamenskonvention: Verwenden Sie Großbuchstaben, verbunden mit Unterstrichen. Beispielsweise MIN_VALUE.

Ausdrücke

Ein Ausdruck ist eine Kombination von Operatoren (wie '+', '-', '*', '/') und Operandern (Variablen oder Literalwerte), die ausgewertet werden kann, um einen einzelnen Wert eines bestimmten Typs zu ergeben. Beispielsweise:

1 + 2 * 3           // liefert int 7

int sum, number;
sum + number        // ausgewertet zu einem int-Wert

double principal, interestRate;
principal * (1 + interestRate)  // ausgewertet zu einem double-Wert

Zuweisung (=)

Eine Zuweisungsanweisung:

1. weist einen Literalwert (der rechten Seite) einer Variablen (der linken Seite) zu; oder
2. wertet einen Ausdruck (der rechten Seite) aus und weist den resultierenden Wert einer Variablen (der linken Seite) zu.

Die rechte Seite muss ein Wert sein; und die linke Seite muss eine Variable (oder eine Speicheradresse) sein.

Die Syntax für die Zuweisungsanweisung lautet:

Die Zuweisungsanweisung sollte so interpretiert werden: Der Ausdruck auf der rechten Seite (RHS) wird zuerst ausgewertet, um einen resultierenden Wert (der rvalue oder right-value genannt wird) zu erzeugen. Der rvalue wird dann der Variablen auf der linken Seite (LHS) zugewiesen (oder lvalue, was ein Speicherort ist, der einen rvalue aufnehmen kann).

Grundtypen

Die folgende Tabelle zeigt die typischen Größen, das Minimum und das Maximum für die primitiven Typen. Beachten Sie erneut, dass die Größen von Implementierung zu Implementierung variieren können.

Der sizeof-Operator

C/C++ stellt einen einstelligen sizeof-Operator zur Verfügung, um die Größe des Operanden (in Bytes) zu erhalten. Das folgende Programm verwendet den sizeof-Operator, um die Größe der grundlegenden Typen auszugeben (speichern Sie den folgenden Code in test.cpp in /home/labex/Code).

/*
 * Drucke die Größe der grundlegenden Typen.
 */
#include <iostream>
using namespace std;

int main() {
   cout << "sizeof(char) ist " << sizeof(char) << " Bytes " << endl;
   cout << "sizeof(short) ist " << sizeof(short) << " Bytes " << endl;
   cout << "sizeof(int) ist " << sizeof(int) << " Bytes " << endl;
   cout << "sizeof(long) ist " << sizeof(long) << " Bytes " << endl;
   cout << "sizeof(long long) ist " << sizeof(long long) << " Bytes " << endl;
   cout << "sizeof(float) ist " << sizeof(float) << " Bytes " << endl;
   cout << "sizeof(double) ist " << sizeof(double) << " Bytes " << endl;
   cout << "sizeof(long double) ist " << sizeof(long double) << " Bytes " << endl;
   cout << "sizeof(bool) ist " << sizeof(bool) << " Bytes " << endl;
   return 0;
}

Ausgabe:

sizeof(char) ist 1 Bytes
sizeof(short) ist 2 Bytes
sizeof(int) ist 4 Bytes
sizeof(long) ist 4 Bytes
sizeof(long long) ist 8 Bytes
sizeof(float) ist 4 Bytes
sizeof(double) ist 8 Bytes
sizeof(long double) ist 12 Bytes
sizeof(bool) ist 1 Bytes

Die typedef-Anweisung

Das häufige Tippen von unsigned int kann lästig werden. Die typedef-Anweisung kann verwendet werden, um einen neuen Namen für einen bestehenden Typ zu erstellen. Beispielsweise können Sie einen neuen Typ namens "uint" für "unsigned int" wie folgt erstellen. Die typedef-Anweisung sollte direkt nach #include platziert werden. Verwenden Sie typedef mit Vorsicht, da es das Programm schwerer zu lesen und zu verstehen macht.

typedef unsigned int uint;

Viele C/C++-Compiler definieren einen Typ namens size_t, der eine typedef von unsigned int ist.

typedef unsigned int size_t;

Literale für Grundtypen und Zeichenketten

Ganzzahl-Literale

Eine ganze Zahl wie 123 und -456 wird standardmäßig als int behandelt. Beispielsweise:

int number = -123;
int sum = 4567;

Neben den standardmäßigen Dezimalzahlen können Sie für einen Wert im Hexadezimalformat einen Präfix '0x' und für einen binären Wert (in einigen Compilern) das Präfix '0b' verwenden. Beispielsweise:

int number1 = 1234;       // Dezimal
int number2 = 01234;      // Oktal 1234, Dezimal 2322
int number3 = 0x1abc;     // Hexadezimal 1ABC, Dezimal 15274
int number4 = 0b10001001; // Binär (kann in einigen Compilern nicht funktionieren)

Ein long-Literal wird durch ein Suffix 'L' oder 'l' identifiziert (meiden Sie Kleinbuchstaben, da diese mit der Zahl Eins verwechselt werden können). Ein long long int wird durch ein Suffix 'LL' identifiziert. Sie können auch das Suffix 'U' für unsigned int, 'UL' für unsigned long und 'ULL' für unsigned long long int verwenden. Beispielsweise:

long number = 12345678L;     // Suffix 'L' für long
long sum = 123;              // int 123 wird automatisch in long 123L umgewandelt
long long bigNumber = 987654321LL;  // Suffix 'LL' für long long int erforderlich

Für short-Literale ist kein Suffix erforderlich. Sie können jedoch nur ganzzahlige Werte im zugelassenen Bereich verwenden. Beispielsweise:

short midSizeNumber = -12345;

Gleitkomma-Literale

Eine Zahl mit einem Dezimalpunkt wie 55.66 und -33.44 wird standardmäßig als double behandelt. Sie können sie auch in wissenschaftlicher Notation ausdrücken, z.B. 1.2e3, -5.5E-6, wobei e oder E den Exponenten in der Potenz von 10 bezeichnet. Sie können dem Bruchteil oder dem Exponenten ein Plus- (+) oder Minuszeichen (-) voranstellen. Der Exponent muss eine ganze Zahl sein.

Für float-Literale müssen Sie ein Suffix von 'f' oder 'F' verwenden, z.B. -1.2345F. Beispielsweise:

float average = 55.66;      // Fehler! Die rechte Seite ist ein double. Suffix 'f' für float erforderlich.
float average = 55.66f;

Verwenden Sie für long double das Suffix 'L' (oder 'l').

bool-Literale

Es gibt nur zwei bool-Literale, nämlich true und false. Beispielsweise:

bool done = true;
bool gameOver = false;
int i;
if (i == 9) {   // liefert entweder true oder false
  ......
}

Zeichen-Literale

Ein druckbares char-Literal wird durch Einschließen des Zeichens in eine einzelne Anführungszeichenfolge geschrieben, z.B. 'z', '$' und '9'. In C++ werden Zeichen mit dem 8-Bit ASCII-Code dargestellt und können in arithmetischen Operationen als 8-Bit vorzeichenbehaftete Ganzzahlen behandelt werden. Mit anderen Worten, char und 8-Bit vorzeichenbehaftete Ganzzahl sind austauschbar. Sie können auch eine ganze Zahl im Bereich [-128, 127] einer char-Variablen zuweisen; und [0, 255] einer unsigned char. Beispielsweise:

char letter = 'a';             // Identisch mit 97
char anotherLetter = 98;       // Identisch mit dem Buchstaben 'b'
cout << letter << endl;        // 'a' wird ausgegeben
cout << anotherLetter << endl; // 'b' wird ausgegeben statt der Zahl
anotherLetter += 2;            // 100 oder 'd'
cout << anotherLetter << endl; // 'd' wird ausgegeben
cout << (int)anotherLetter << endl;  // 100 wird ausgegeben

Zeichenkette-Literale

Ein String-Literal besteht aus null oder mehr Zeichen, die von einer doppelten Anführungszeichenfolge umgeben sind, z.B. "Hello, world!", "The sum is ", "". Beispielsweise:

String directionMsg = "Turn Right";
String greetingMsg = "Hello";
String statusMsg = "";             // leere Zeichenkette

Beispiel (Literale)

/* Testing Primitive Types */
#include <iostream>
using namespace std;

int main() {
   char gender ='m';             // char wird in einfachen Anführungszeichen eingeschlossen
   bool isMarried = true;         // true(nicht null) oder false(0)
   unsigned short numChildren = 8; // [0, 255]
   short yearOfBirth = 1945;      // [-32767, 32768]
   unsigned int salary = 88000;   // [0, 4294967295]
   double weight = 88.88;       // Mit Bruchteil
   float gpa = 3.88f;           // Suffix 'f' für float erforderlich

   // "cout <<" kann verwendet werden, um den Wert eines beliebigen Typs auszugeben
   cout << "Gender is " << gender << endl;
   cout << "Is married is " << isMarried << endl;
   cout << "Number of children is " << numChildren << endl;
   cout << "Year of birth is " << yearOfBirth << endl;
   cout << "Salary is " << salary << endl;
   cout << "Weight is " << weight << endl;
   cout << "GPA is " << gpa << endl;
   return 0;
}

Ausgabe:

Gender is m
Is married is 1    // true
Number of children is 8
Year of birth is 1945
Salary is 88000
Weight is 88.88
GPA is 3.88

Zusammenfassung

In diesem Abschnitt haben wir mehrere Grundtypen vorgestellt. Sie sollten wissen, wie eine Variable dargestellt und darauf operiert werden kann. Denken Sie daran, wie groß jeder Typ im Speicher ist und welchen Wertebereich jeder Typ hat.