home Herstellungstechnologie Produktionsanlagen
Industrielle Fertigung
Industrielles Internet der Dinge | Industrielle Materialien | Gerätewartung und Reparatur | Industrielle Programmierung |
home  MfgRobots >> Industrielle Fertigung >  >> Industrial programming >> C Sprache

C++-Variablen und -Typen:int, double, char, string, bool

Variablen in C++

Eine C++-Variable stellt uns eine benannte Speicherkapazität zur Verfügung. Es ermöglicht dem Programmierer, Daten nach Bedarf zu manipulieren. Jede Variable hat in C++ einen Typ. Der Variablentyp hilft bei der Bestimmung der Größe und des Layouts der Speicherzuordnung der Variablen, des Wertebereichs, der in diesem Speicher gespeichert werden kann, und der Reihe von Operationen, die darauf angewendet werden können.

In diesem C++-Tutorial lernen Sie:

Grundlegende Typen von Variablen in C++

Hier sind die grundlegenden Typen von C++-Variablen:

Int:

Eine Ganzzahl ist ein numerisches Literal (das Zahlen zugeordnet ist) ohne Bruch- oder Exponentialanteil. Beispiel. 120, -90 usw.

Doppelt:

Es ist ein Gleitkommawert mit doppelter Genauigkeit. Beispiel:11.22, 2.345

Zeichen:

Ein Zeichenliteral wird erstellt, indem ein einzelnes Zeichen in einfache Anführungszeichen gesetzt wird. Zum Beispiel:„a“, „m“, „F“, „P“, „}“ usw.

Float:

Ein Gleitkommaliteral ist ein numerisches Literal, das entweder eine Bruchform oder eine Exponentenform hat. Zum Beispiel:1,3, 2,6

String-Literale:

Ein Zeichenfolgenliteral ist eine Folge von Zeichen, die in doppelte Anführungszeichen eingeschlossen sind. Zum Beispiel:„Wie geht es dir?“

Bool:

Es hält den booleschen Wert wahr oder falsch.

Regeln zum Deklarieren von Variablen in C++

Hier sind einige allgemeine Regeln für die Benennung einer Variablen:

C++-Variablendatentypen

C++ definiert eine ganze Menge primitiver Typen

Die Leere type hat keine zugeordneten Werte und kann nur in wenigen Fällen verwendet werden. Es wird am häufigsten als Rückgabetyp von Funktionen verwendet, die keinen Wert zurückgeben.

Die arithmetischen Typen umfassen Zeichen, Ganzzahlen, boolesche Werte und Gleitkommazahlen. Arithmetischer Typ, wenn weiter in 2 Kategorien unterteilt

  1. Gleitkommatypen . Float (oder Gleitkommatyp) repräsentiert Dezimalzahlen. Der IEEE-Standard legt eine Mindestanzahl signifikanter Stellen fest. Die meisten Compiler bieten normalerweise mehr Genauigkeit als das angegebene Minimum. Typischerweise werden Floats in 32 Bit, Doubles in 64 Bits und Long Doubles in 96 oder 128 Bits dargestellt.
  2. Ganzzahlige Typen (einschließlich Zeichen, Ganzzahlen und boolesche Typen). Der Boolesche Wert type hat nur zwei Arten von Werten:True oder False. Es gibt mehrere char 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 ganzzahligen Typen kann signiert oder unsigniert sein.

Vorzeichentyp :Sie repräsentieren negative oder positive Zahlen (einschließlich Null). Bei einem vorzeichenbehafteten Typ muss der Bereich gleichmäßig zwischen +ve- und -ve-Werten aufgeteilt werden. Somit enthält ein 8-Bit-Zeichen mit Vorzeichen 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. Die Namenslänge ist nicht begrenzt.

Bezeichner müssen

sein

// definiert vier verschiedene int-Variablen

int guru99, gurU99, GuRu99, GURU99;

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

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

C++-Variablendeklaration und -definition

Eine Deklaration einer Variablen macht dem Programm einen Namen in dem Bereich bekannt, in dem sie definiert ist. Beispiel:

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

int a,b;
a=b=1000;
List initialization
int a(5);
int b{5};

Const Qualifier in C++

Angenommen, es gibt eine Variable buffsize, die die Anzahl der Eingaben angibt, die vom Benutzer genommen werden sollen. Hier wollen wir den Wert von buffsize nicht im gesamten Programm ändern. Wir wollen eine Variable definieren, von der wir wissen, dass sie sich nicht ändern sollte.

Verwenden Sie in diesem Fall das Schlüsselwort const

const int bufSize = 512;    // input buffer size

Dies definiert bufSize als eine Konstante. Jeder Versuch, bufSize zuzuweisen oder zu ändern, gibt einen Fehler aus.

Hier können wir den Wert eines konstanten Objekts nicht ändern, nachdem wir es erstellt haben, 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

Variablenumfang in C++

Ein Geltungsbereich ist ein Bereich eines Programms, in dem eine Variable eine Bedeutung hat. Meistens kann derselbe Name verwendet werden, um auf verschiedene Entitäten innerhalb verschiedener Geltungsbereiche zu verweisen. Variablen sind ab dem Punkt sichtbar, an dem sie deklariert werden, bis zum Ende des Bereichs, in dem ihre Deklaration erscheint.

#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 3 Namen, nämlich main, sum und val. Es verwendet den Namespace-Namen std zusammen mit zwei anderen Namen aus diesem Namespace – cout und endl.

Verschachtelter Bereich

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

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

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

-Anweisung ist diejenige, die den wiederverwendeten Namen verwendet, der im globalen Gültigkeitsbereich definiert ist. Diese Anweisung gibt

aus

42 0

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

0 0

Ausgabe #3 überschreibt die standardmäßigen Bereichsregeln mithilfe des Bereichsoperators. Der globale Geltungsbereich hat keinen Namen. Wenn also der Bereichsoperator (::) eine leere linke Seite hat. Es interpretiert es als eine Anforderung, den Namen auf der rechten Seite des globalen Gültigkeitsbereichs abzurufen. Daher verwendet der Ausdruck die globalen wiederverwendeten und Ausgaben

42 0

Variablentypkonvertierung

Eine Variable eines Typs kann in einen anderen umgewandelt werden. Dies wird als „Typkonvertierung“ bezeichnet. Sehen wir uns die Regeln zum Konvertieren verschiedener C++-Variablentypen an:

Die Zuweisung von Nicht-Bool zu einer Bool-Variablen ergibt False, wenn der Wert 0 ist, andernfalls True.

bool b = 42;            // b is true

Die Zuweisung einer bool zu einem der anderen arithmetischen Typen ergibt 1, wenn die bool wahr ist, und 0, wenn die bool falsch ist.

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

Die Zuweisung eines Gleitkommawerts zu einer Variablen vom Typ int ergibt den abgeschnittenen Wert. Der gespeicherte Wert ist der Teil vor dem Komma.

int i = 3.14;               // i has value 3

Die Zuweisung eines int-Werts zu einer Variablen vom Typ Float führt dazu, dass der Bruchteil Null wird. Die Genauigkeit geht normalerweise verloren, wenn die Ganzzahl mehr Bits hat, als die Floating-Variable 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-Char-Typ 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. Daher gibt die Zuweisung von –1 an ein 8-Bit-Zeichen ohne Vorzeichen diesem Objekt nach obiger Logik den Wert 255.

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

Wenn wir versuchen, einem Objekt mit Vorzeichen einen Wert außerhalb des zulässigen Bereichs zuzuweisen, ist das Ergebnis unvorhersehbar. Es ist undefiniert. Das Programm scheint nach außen hin zu funktionieren, oder es kann 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, dann ist die Bedingung falsch; alle anderen Werte (nicht Null) ergeben true. Wenn wir einen Bool in einem arithmetischen Ausdruck verwenden, wird sein Wert nach dem gleichen Konzept immer entweder in 0 oder 1 konvertiert. Daher ist die Verwendung eines Bool in einem arithmetischen Ausdruck normalerweise mit ziemlicher Sicherheit falsch.

Achtung:Mischen Sie nicht signierte und unsignierte Typen

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

Beispielsweise in einem arithmetischen Ausdruck wie 

x* y

Wenn x -1 und y 1 ist und sowohl x als auch y ganzzahlig sind, dann ist der Wert wie erwartet -1.

Wenn x ganzzahlig und y vorzeichenlos sind, dann hängt der Wert dieses Ausdrucks davon ab, wie viele Bits eine Ganzzahl auf dem Compiler hat. Auf unserem Rechner ergibt dieser Ausdruck 4294967295.

Variablen registrieren

Auf Registervariablen kann im Vergleich zu Speichervariablen schneller zugegriffen werden. Daher können Variablen, die häufig in einem C++-Programm verwendet werden, mit register in Register geschrieben werden Stichwort. Das Schlüsselwort register weist den Compiler an, die angegebene Variable in einem Register zu speichern. Es ist die Wahl des Compilers, ob er es in ein Register schreibt oder nicht. Im Allgemeinen führen Compiler selbst verschiedene Optimierungen durch, darunter das Einfügen einiger Variablen in das Register. Die Anzahl der Registervariablen in einem C++-Programm ist unbegrenzt. Aber der Compiler darf die Variable nicht in einem Register speichern. Dies liegt daran, dass der Registerspeicher sehr begrenzt ist und am häufigsten vom Betriebssystem verwendet wird.

Zu definieren:

register int i;

Kommentare

Kommentare sind die Teile des Codes, die vom Compiler ignoriert werden. Es erlaubt dem Programmierer, Notizen in den relevanten Bereichen des Quellcodes/Programms zu machen. Kommentare kommen entweder in Blockform oder in einzelnen Zeilen. Die Programmkommentare sind erläuternde Aussagen. Es kann in den C++-Code eingebunden werden, was jedem hilft, seinen Quellcode zu lesen. Alle Programmiersprachen erlauben irgendeine Form von Kommentaren. C++ unterstützt sowohl einzeilige als auch mehrzeilige Kommentare.

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

Escape-Sequenzen

Einige Zeichen, wie z. B. Rücktaste und Steuerzeichen, haben kein sichtbares Bild. Solche Zeichen werden als nicht druckbare Zeichen bezeichnet. Andere Zeichen (einfache und doppelte Anführungszeichen, Fragezeichen und umgekehrter Schrägstrich) haben in den 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 Programmiersprache C++ definiert mehrere Escape-Sequenzen:

Was macht es? Charakter

Zeilenumbruch

\n

Vertikaler Tabulator

\v

Backslash

\\

Wagenrücklauf

\r

Horizontaler Tabulator

\t

Rücktaste

\b

Fragezeichen

\?

Seitenvorschub

\f

Alarm (Glocke)

\a

Doppeltes Anführungszeichen

\”

Einfaches Anführungszeichen

\’

Wir verwenden eine Escape-Sequenz, als wäre es 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 oder zwei oder drei Oktalziffern. Die verallgemeinerte Escape-Sequenz repräsentiert den numerischen Wert des Zeichens. 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, da 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


C Sprache

  • C Sprache
  • VHDL
  • Verilog
  • MATLAB
  • Python
  • Java
    1. C#-Variablen und (primitive) Datentypen
    2. C++-Variablen, Literale und Konstanten
    3. C++-Datentypen
    4. C-Variablen, Konstanten und Literale
    5. C-Datentypen
    6. Arten von benutzerdefinierten Funktionen in der C-Programmierung
    7. C Lagerklasse
    8. Operatoren in C++ mit Beispiel:Was ist, Typen und Programme
    9. Java - Variablentypen
    10. C - Variablen