C++ Variablen und Typen: Int, Char, Float, Double, String & Bool

C++ Variable Datentypen

C++ definiert eine ganze Reihe primitiver Typen

Die ungültig Dem Typ sind keine Werte zugeordnet und er kann nur in wenigen Fällen verwendet werden. Dies ist am häufigsten der Rückgabetyp von Funktionen, die keinen Wert zurückgeben.

Die arithmetische Typen Dazu gehören Zeichen, Ganzzahlen, Boolesche Werte und Gleitkommazahlen. Arithmetiktypen werden weiter in zwei Kategorien unterteilt

1. Gleitkommatypen. Der Float-Typ (oder Floating-Typ) stellt Dezimalzahlen dar. Der IEEE-Standard gibt eine Mindestanzahl signifikanter Ziffern an. Die meisten Compiler bieten normalerweise mehr Genauigkeit als das angegebene Minimum. Floats werden normalerweise mit 32 Bit, Doubles mit 64 Bit und Long Doubles mit 96 oder 128 Bit dargestellt.
2. Integrale Typen (einschließlich Zeichen, Ganzzahlen und boolesche Typen). Der Boolean Typ hat nur zwei Arten von Werten: Wahr oder Falsch. Es gibt einige verkohlen Arten, von denen die meisten existieren, um die Internationalisierung zu unterstützen. Der einfachste Zeichentyp ist char. Ein Zeichen hat die gleiche Größe wie ein einzelnes Maschinenbyte, also ein einzelnes Byte.

Die Integrale Typen kann signiert oder unsigniert sein.

Signierter Typ: Sie stellen negative oder positive Zahlen dar (einschließlich Null). Bei einem vorzeichenbehafteten Typ muss der Bereich gleichmäßig zwischen positiven und negativen Werten aufgeteilt sein. Ein vorzeichenbehaftetes 8-Bit-Zeichen enthält daher Werte von –127 bis 127.

Vorzeichenloser Typ: In einem vorzeichenlosen Typ sind alle Werte >= 0. Ein 8-Bit-Zeichen ohne Vorzeichen kann 0 bis 255 (beide einschließlich) enthalten.

Variablenname oder Bezeichner

Bezeichner können aus einigen Buchstaben, Ziffern und dem Unterstrich oder einer Kombination davon bestehen. Es gibt keine Begrenzung der Namenslänge.

Bezeichner müssen

• Beginnen Sie entweder mit einem Buchstaben oder einem Unterstrich („_“).
• Dabei wird die Groß-/Kleinschreibung beachtet. Groß- und Kleinbuchstaben sind unterschiedlich:

// definiert vier verschiedene int-Variablen

int guru99, gurU99, GuRu99, GURU99;

Die C++ Die Sprache hat einige Namen für ihre Verwendung reserviert.

Es gibt viele akzeptierte Konventionen für die Benennung von Variablen verschiedene Programmiersprachen. Das Befolgen dieser Konventionen kann die Lesbarkeit des Programms verbessern.

• Ein Bezeichner sollte zumindest einen Hinweis auf seine Bedeutung geben.
• Variablennamen werden normalerweise in Kleinbuchstaben geschrieben – guru99, nicht Guru99 oder GURU99.
• Die von uns definierten Klassen beginnen normalerweise mit einem Großbuchstaben.
• Bezeichner, die mehrere Wörter enthalten, sollten jedes Wort visuell unterscheiden. Beispiel: guru99_website, nicht guru99website.

C++ Variablendeklaration und -definition

Durch die Deklaration einer Variablen wird dem Programm in dem Bereich, in dem sie definiert ist, ein Name bekannt gegeben. Beispiel:

int a=5;
int b;
char c='A'; 

int a,b;
a=b=1000;

List initialization
int a(5);
int b{5};

Konstanter Qualifizierer in C++

Angenommen, es gibt eine Variable buffsize, die die Anzahl der Eingaben angibt, die vom Benutzer entgegengenommen werden sollen. Hier möchten wir den Wert von buffsize nicht im gesamten Programm ändern. Wir möchten eine Variable definieren, deren Wert sich unserer Meinung nach nicht ändern sollte.

Verwenden Sie in diesem Fall das Schlüsselwort const

const int bufSize = 512;    // input buffer size

Dies definiert bufSize als Konstante. Jeder Versuch, bufSize zuzuweisen oder zu ändern, führt zu einem Fehler.

Hier können wir den Wert eines const-Objekts nach dessen Erstellung nicht mehr ändern, es muss zwingend deklariert und initialisiert werden. Andernfalls gibt der Compiler einen Fehler aus.

const int i = get_size();  // ok: initialized at run time
const int j = 42;          // ok: initialized at compile time
const int k;               // error: k is uninitialized const
int i = 42;
const int ci = i;    	   // ok: the value in i is copied into ci 

Gültigkeitsbereich der Variablen in C++

Ein Bereich ist ein Bereich eines Programms, in dem eine Variable eine Bedeutung hat. Meistens kann derselbe Name verwendet werden, um auf verschiedene Entitäten in unterschiedlichen Bereichen zu verweisen. Variablen sind vom Punkt ihrer Deklaration bis zum Ende des Gültigkeitsbereichs, in dem ihre Deklaration erscheint, sichtbar.

#include <iostream>	
int main()	
{	
    int sum = 0;	
    // sum values from 1 through 10 inclusive	
    for (int val = 1; val <= 10; ++val)	
        sum += val;  // equivalent to sum = sum + val	
    cout << "Sum of 1 to 10 inclusive is "<< sum <<endl;	
    return 0;	
}	 

Dieses Programm definiert drei Namen: viz, main, sum und val. Es verwendet den Namespace-Namen std sowie zwei weitere Namen aus diesem Namespace – cout und endl.

• Der Funktionsname „main“ wird außerhalb der geschweiften Klammern definiert. Der Funktionsname main hat – wie die meisten anderen außerhalb einer Funktion definierten Namen – einen globalen Gültigkeitsbereich. Das bedeutet, dass nach der Deklaration Namen vorhanden sind globalen Präsenz sind im gesamten Programm zugänglich.
• Die Variable sum wird im Rahmen des Blocks definiert, der den Hauptteil der Hauptfunktion darstellt. Der Zugriff kann vom Deklarationspunkt aus und im gesamten Hauptteil der Hauptfunktion erfolgen. Allerdings nicht außerhalb davon. Dies bedeutet, dass die Variable Summe hat Blockbereich.
• Die Variable val wird im Rahmen der „for-Anweisung“ definiert. Es kann problemlos in dieser Anweisung verwendet werden, jedoch nicht an anderer Stelle in der Hauptfunktion. Es hat lokaler Geltungsbereich.

Verschachtelter Bereich

Der Bereich kann andere Bereiche enthalten. Der enthaltene (oder verschachtelte) Bereich wird als innerer Bereich bezeichnet. Der enthaltende Bereich ist der äußere Bereich.

#include <iostream>	
using namespace std;	
// Program for illustration purposes only: It is bad style for a function	
// to use a global variable and also define a local variable with the same name	
int reused = 42;  // reused has global scope	
int main()	
{	
    int unique = 0; // unique has block scope	
    // output #1: uses global reused; prints 42 0	
    cout << reused << " " << unique << endl;	
    int reused = 0; // new, local object named reused hides global reused	
    // output #2: uses local reused; prints 0 0	
    cout << reused << " " << unique << endl;	
    // output #3: explicitly requests the global reused; prints 42 0	
    cout << ::reused << " " << unique << endl;	
    return 0;	
}	 

Ausgang #1 erscheint vor der lokalen Definition von wiederverwendet. Somit diese Ausgabe

Die Anweisung ist diejenige, die den im globalen Bereich definierten Namen wiederverwendet. Diese Anweisung wird ausgegeben

42 0

Ausgang #2 tritt nach der lokalen Definition von wiederverwendet auf. Es ist jetzt im Geltungsbereich. Daher verwendet diese zweite Ausgabeanweisung einfach das lokale Objekt mit dem Namen „reused“ anstelle des globalen Objekts und gibt aus

0 0

Ausgang #3 überschreibt die Standardbereichsregeln mithilfe von Bereichsoperator. Der globale Bereich hat keinen Namen. Wenn also der Bereichsoperator(::) eine leere linke Seite hat, interpretiert er dies als Anforderung, den Namen auf der rechten Seite des globalen Bereichs abzurufen. Daher verwendet der Ausdruck den globalen wiederverwendeten Wert und gibt aus

42 0

Konvertierung von Variablentypen

Eine Variable eines Typs kann in einen anderen konvertiert werden. Dies wird als „Typkonvertierung“ bezeichnet. Sehen wir uns die Regeln für die Konvertierung verschiedener C++ Variablentypen:

Die Zuweisung eines Nicht-Bool-Werts zu einer Bool-Variable ergibt „false“, wenn der Wert 0 ist, und andernfalls „true“.

bool b = 42;            // b is true

Die Zuweisung eines Bool-Werts zu einem der anderen arithmetischen Typen ergibt 1, wenn der Bool-Wert wahr ist, und 0, wenn der Bool-Wert falsch ist.

bool b = true;
int i = b;              // i has value 1

Wenn Sie einer Variablen vom Typ int einen Gleitkommawert zuweisen, wird der Wert abgeschnitten. Der gespeicherte Wert ist der Teil vor dem Dezimalpunkt.

int i = 3.14;               // i has value 3

Das Zuweisen eines int-Werts zu einer Variablen vom Typ Float führt dazu, dass der Bruchteil Null wird. Genauigkeit geht normalerweise verloren, wenn die Ganzzahl mehr Bits hat, als die Gleitkommavariable aufnehmen kann.

Int i=3;
double pi = i;          // pi has value 3.0

Wenn wir versuchen, einer Variablen vom Typ ohne Vorzeichen einen Wert außerhalb des zulässigen Bereichs zuzuweisen, ist das Ergebnis der Rest des Werts %(modulo)

Beispielsweise kann ein 8-Bit-Zeichentyp ohne Vorzeichen Werte von 0 bis einschließlich 255 enthalten. Die Zuweisung eines Werts außerhalb dieses Bereichs führt dazu, dass der Compiler den Rest dieses Werts Modulo 256 zuweist. Nach der obigen Logik ergibt die Zuweisung von –1 an ein vorzeichenloses 8-Bit-Zeichen diesem Objekt daher den Wert 255.

unsigned char c = -1;   // assuming 8-bit chars, c has value 255

Wenn wir versuchen, einem Objekt mit vorzeichenbehaftetem Typ einen außerhalb des zulässigen Bereichs liegenden Wert zuzuweisen, ist das Ergebnis unvorhersehbar. Es ist undefiniert. Das Programm scheint äußerlich zu funktionieren, es könnte abstürzen oder fehlerhafte Werte erzeugen.

signed char c2 = 256;   // assuming 8-bit chars, the value of c2 is undefined

Der Compiler wendet denselben Konvertierungstyp an, wenn wir einen Wert eines Typs verwenden, wo ein Wert eines anderen Typs erwartet wird.

int i = 42;
if (i) // condition will evaluate as true
i = 0; 

Wenn dieser Wert = 0 ist, ist die Bedingung falsch; Alle anderen Werte (ungleich Null) ergeben „true“. Wenn wir einen Bool-Wert in einem arithmetischen Ausdruck verwenden, wird nach dem gleichen Konzept sein Wert immer entweder in 0 oder 1 konvertiert. Daher ist die Verwendung eines Bool-Werts in einem arithmetischen Ausdruck normalerweise mit ziemlicher Sicherheit falsch.

Achtung: Mischen Sie nicht signierte und nicht signierte Typen

Ausdrücke, die vorzeichenbehaftete und vorzeichenlose Ausdrücke mischen, können zu überraschenden und falschen Ergebnissen führen, wenn der vorzeichenbehaftete Wert negativ ist. Wie oben erläutert, werden vorzeichenbehaftete Werte automatisch in vorzeichenlose umgewandelt.

Zum Beispiel in einem arithmetischen Ausdruck wie

x* y

Wenn x -1 und y 1 ist und sowohl x als auch y int sind, ist der Wert erwartungsgemäß -1.

Wenn x int ist und y ohne Vorzeichen ist, hängt der Wert dieses Ausdrucks davon ab, wie viele Bits eine Ganzzahl auf dem Compiler hat. Auf unserer Maschine ergibt dieser Ausdruck 4294967295.

Variablen registrieren

Auf Registervariablen kann im Vergleich zu Speichervariablen schneller zugegriffen werden. Variablen, die häufig in einem C++ Das Programm kann in Registern abgelegt werden mit Registrieren Schlüsselwort. Das Schlüsselwort register weist den Compiler an, die angegebene Variable in einem Register zu speichern. Es ist die Entscheidung des Compilers, ob er sie in ein Register schreibt oder nicht. Im Allgemeinen führen Compiler selbst verschiedene Optimierungen durch, bei denen einige der Variablen in das Register geschrieben werden. Es gibt keine Begrenzung für die Anzahl der Registervariablen in einem C++ Programm. Der Compiler kann die Variable jedoch nicht in einem Register speichern. Dies liegt daran, dass der Registerspeicher sehr begrenzt ist und in der Regel vom Betriebssystem verwendet wird.

Definieren:

register int i;

Kommentare

Kommentare sind die Teile des Codes, die vom Compiler ignoriert werden. Sie ermöglichen dem Programmierer, in den relevanten Bereichen des Quellcodes/Programms Notizen zu machen. Kommentare kommen entweder in Blockform oder in einzelnen Zeilen. Die Programmkommentare sind erklärende Aussagen. Sie können in die C++ Code, der jedem hilft, der den Quellcode liest. Alle Programmiersprachen erlauben irgendeine Form von Kommentaren. C++ unterstützt sowohl einzeilige als auch mehrzeilige Kommentare.

• Einzeilige Kommentare sind diejenigen, die mit // beginnen und bis zum Ende der Zeile fortgesetzt werden. Wenn das letzte Zeichen in einer Kommentarzeile ein \ ist, wird der Kommentar in der nächsten Zeile fortgesetzt.
• Mehrzeilige Kommentare sind diejenigen, die mit /* beginnen und mit */ enden.

/* This is a comment */
/* C++ comments can  also 
* span multiple lines 
*/

Escape-Sequenzen

Einige Zeichen, wie z. B. Backspace und Steuerzeichen, haben kein sichtbares Bild. Solche Zeichen werden als nicht druckbare Zeichen bezeichnet. Andere Zeichen (einfache und doppelte Anführungszeichen, Fragezeichen und Backslash) haben in vielen Programmiersprachen eine besondere Bedeutung.

Unsere Programme können keines dieser Zeichen direkt verwenden. Stattdessen können wir eine Escape-Sequenz verwenden, um ein solches Zeichen darzustellen. Eine Escape-Sequenz beginnt mit einem Backslash.

Die C++ Programmiersprache definiert mehrere Escape-Sequenzen:

Was bedeutet es?	Charakter
Neue Zeile	\n
Vertikale Registerkarte	\v
Backslash	\\
Wagenrücklauf	\r
Horizontale Registerkarte	\t
Rücktaste	\b
Fragezeichen	\?
Formularvorschub	\f
Alarm (Glocke)	\a
Double Angebot!	\ "
Einzelzitat	\ '

Wir verwenden eine Escape-Sequenz, als wäre sie ein einzelnes Zeichen:

cout << '\n';        // prints a newline
cout << "\tguru99!\n";   // prints a tab followed by "guru99!" and a newline 

Wir können auch verallgemeinerte Escape-Sequenzen \x schreiben, gefolgt von einer oder mehreren hexadezimalen Ziffern. Oder wir verwenden ein \, gefolgt von einer, zwei oder drei Oktalziffern. Die verallgemeinerte Escape-Sequenz stellt den numerischen Wert des Zeichens dar. Einige Beispiele (unter der Annahme des Zeichensatzes Latin-1):

\7 (bell)    \12 (newline)      \40 (blank)
\0 (null)    \115 ('M')         \x4d ('M') 

Wir können vordefinierte Escape-Sequenzen verwenden, wie wir jedes andere Zeichen verwenden.

cout << "Hi \x4dO\115!\n";  // prints Hi MOM! followed by a newline
cout << '\115' << '\n';     // prints M followed by a newline 

Zusammenfassung

• A C++ Variable bietet uns eine benannte Speicherfähigkeit.
• C++ Variablentypen: int, double, verkohlen, Float, String, Bool usw.
• Der enthaltene (oder verschachtelte) Bereich wird als innerer Bereich bezeichnet, und der enthaltende Bereich ist der äußere Bereich.
• Eine Variable eines Typs kann in einen anderen umgewandelt werden. Dies wird als „Typkonvertierung“ bezeichnet.
• Auf Registervariablen kann im Vergleich zu Speichervariablen schneller zugegriffen werden.
• Kommentare sind die Teile des Codes, die vom Compiler ignoriert werden.
• Für einige Zeichen, beispielsweise Rücktaste und Steuerzeichen, ist kein Bild sichtbar.