Expresii și declarații în programarea C ++ - dummies

Partea C ++ pentru Dummies Cheat Sheet

Pentru a efectua un calcul în programul C ++ aveți nevoie de o expresie. O expresie este o afirmație care are atât valoare, cât și tip. În programul C ++, o declarație este o declarație care definește o variabilă sau este un "rezervor de reținere" pentru un fel de valoare ca un număr sau un caracter.

Expresii

Expresiile iau una din următoarele forme:

objName // pentru o expresie a operatorului obiect simplu // pentru operatorii unari expr1 operator expr2 // pentru operatorii binari expr1? expr2: expr3 // pentru operatorul ternary funcName ([list de argumente]); // pentru apeluri de funcții

Expresii literare

Un literal este o formă de expresie constantă. Diferitele tipuri de literali sunt definite în tabelul următor.

Exemplu	Introduceți
1	int
1L	lung int
1LL	0
dublu	1. 099
float	'1'
caracterele	" > u8 "Acesta este un șir UTF-16 cu un caracter UTF-16: u2018"
char8_t *	u "
U este un șir UTF-32 cu un caracter UTF-32:	U00002018 "
char32_t *	true, false
bool	0b101
standard)	Declarații
Declarațiile folosesc atât tipuri intrinseci, cât și definite de utilizator. Tipurile intrinseci sunt	[] char [] wchar_t [] [] int float [long] dublu bool
Declarațiile au una din următoarele forme:	[] [const] var [= expression]; // variabilă [] [const] tip array [dimensiune] [= {list}]; // array [const] tipul de obiect [(lista de argumente)]; // obiect obiect [const] [= {list de argumente}]; // tip alternativ [const] * [const] ptr [= expresie pointer]; // tip pointer & refName = obiect; // tipul de referință fnName ([list de argumente]); // funcția

Cuvântul auto poate fi folosit dacă C ++ poate determina tipul de variabilă în sine:

auto var = 1L; // tipul de var este lung int

Cuvântul cheie declype extrage tipul unei expresii. Acest tip poate fi utilizat atunci când se utilizează un nume de tip. De exemplu, exemplul următor utilizează decltype pentru a declara oa doua variabilă cu același tip ca o variabilă existentă:

decltype (var1) var2; // tipul de var2 este identic cu var1

Definitia unei functii are urmatorul format:

// functie simpla [] tip fnName (lista de argumente) {…} // functie membra definita in afara clasei [inline] Clasa:: func (lista argumentelor) [const] {…} // constructorul / destructorii pot fi, de asemenea, definiți în afara clasei Clasa:: Class } // constructorii / destructorul pot fi șterși sau defaútați // în locul definiției Clasă:: Clasă ([list de argumente]) =; Clasă:: ~ Class () =;

Un operator supraîncărcat arată ca o definiție a funcției.Cei mai mulți operatori suprasarcini pot fi scrise ca membri sau ca simple funcții. Când este scris ca o funcție membră, * acesta este primul argument asumat operatorului:

MyClass & operator + (const MyClass & m1, const MyClass & m2); // simplu MyClass & MyClass:: operatorul + (const MyClass & m2); // membru;

Utilizatorii pot de asemenea să definească propriile tipuri folosind clasele sau structurile de cuvinte cheie:

ClassName [: [virtual] [public] BaseClass] {: // constructor ClassName ([arg list] // destructor [virtual] ~ ClassName () <{…} | [=; > // membrii de date publice tip dateMemberName [= initialValue]; // funcții ale membrilor publici () [] [] [] … // // const tip membru al funcției memberFunctionName ([arg list]] const [{…}] // funcții membre virtuale memberFunctionName ([) [{…}}; // funcții pure ale membrilor virtuali tip virtual memberFunctionName ([arg list]] = 0; // funcția care trebuie să suprascrie un tip de funcție de clasă de bază memberFunctionName ([arg list]) suprascrie; // o funcție care nu poate fi suprascrisă într-un tip de subclasă memberFunctionName ([arg list]) final;};

În plus, un constructor cu un singur argument poate fi marcat în mod explicit ca nu va fi utilizat într-o conversie implicită de la un tip la altul. Marcarea unui constructor implicit înseamnă "folosirea definiției implicite a constructorului C ++". Semnalizarea unui constructor ca ștergere elimină definiția implicită a constructorului C ++.

C ++ acceptă două tipuri de tipuri enumerate. Următorul tip de enumerare vechi nu creează un tip nou:

enum STATE {DC, // primește 0 ALABAMA, // primește 1 ALASKA, // primește 2 ARKANSAS, // primește 3 // … și așa mai departe}; int n = ALASKA; // ALASKA este de tip int

În mod implicit, o intrare individuală este de tip int, dar aceasta poate fi modificată în standardul C ++ 2011:

enum ALPHABET: char {A = 'a', // devine ' B, // primește 'b' C, // primește 'c' // … și așa mai departe}; char c = A; // A este de tip char

C ++ 2011 permite unui al doilea format care creează un tip nou:

// următoarea enumerare definește un nou tip STATE enum class STATE {DC, // primește 0 ALABAMA, // primește 1 ALASKA, // primește 2 ARKANSAS, // primește 3 … si asa mai departe}; STATE s = STAT:: ALASKA; / / acum STATE este un tip nou // foloseste urmatorul alt tip de clasa enum ALPHABET: char {A = 'a', // devine 'a' B, // devine 'b' C, // devine 'c ' //… si asa mai departe}; ALPHABET c = ALFABET:: A; // A este de tip ALPHABET

Declarațiile de șabloane au un format puțin diferit:

// tipul T este furnizat de programator la tipul de șablon funcțional Nume_funcțional ([arg list]] clasă șablon ClasăName {{…}};