Cheat sheet C++ per riferimenti rapidi (scarica PDF)

C++ è un linguaggio generico e un'estensione del linguaggio C. Essendo uno dei linguaggi di programmazione più richiesti sul mercato odierno, C++ è una scelta di studio popolare per aspiranti sviluppatori. I programmatori seguono corsi e sperimentano progetti C++ per migliorare le proprie conoscenze.

Ma hai mai desiderato un riferimento rapido C++ mentre lavori? E se potessi completare il lavoro in C++ in modo più efficiente? Questo cheat sheet C++ è un ottimo riferimento per aiutarti a lavorare più agevolmente.

Abbiamo curato un fantastico cheat sheet della sintassi C++ o un cheat sheet dei comandi C++ che ti aiuterà a migliorare o perfezionare le tue abilità.

Questo cheat sheet di programmazione C++ è anche una buona risorsa per la preparazione delle interviste. Pronto ad affrontare i progetti C++ nel modo più veloce? Iniziamo!

Scarica C++ Cheat Sheet PDF

Cheat Sheet C++

Sintassi 

Diamo il via al nostro foglio di riferimento C++ con la sintassi.

#include <iostream>
usingnamespacestd;

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

Durante la scrittura del codice in C++, assicurati sempre di terminare ogni riga con un punto e virgola per specificare la fine della riga. È necessario aggiungere anche la parentesi di chiusura per terminare la funzione principale; in caso contrario, riceverai errori durante la compilazione del codice.

• Riga 1: '#include ' specifica la libreria di file di intestazione , che ti aiuta a gestire oggetti di input e output come "cout". I file di intestazione vengono utilizzati per aggiungere funzionalità specifiche ai programmi C++.
• Riga 2: 'using namespace std' consente di utilizzare nomi per oggetti e variabili dalla libreria standard.
• Riga 3: Riga vuota. C++ ignora gli spazi presenti all'interno del codice.
• Riga 4: 'int main()', che è una funzione. Qualsiasi codice tra parentesi graffe {} verrà eseguito.
• Riga 5: cout è un oggetto utilizzato insieme all'operatore di inserimento (<<) per stampare il testo di output.
• Riga 6: return 0 viene utilizzato per terminare la funzione principale.

Commenti 

In C++, il compilatore ignora il testo seguito dai commenti. C++ supporta due diversi tipi di commenti:

//: specifica il commento a riga singola.

/* ….*/ :specifica il commento su più righe.

Tipi di dati 

I tipi di dati specificano il tipo della variabile di dati. Il compilatore alloca la memoria in base ai tipi di dati. Di seguito sono riportati i tipi di dati C++:

• Tipi di dati incorporati o primitivi: Tipi di dati predefiniti che possono essere utilizzati direttamente, inclusi Intero, Carattere, Booleano, Virgola mobile, Doppia virgola mobile, Senza valore o Vuoto e Carattere largo.
• Tipi di dati derivati: Derivato da tipi di dati primitivi:funzione, matrice, puntatore e riferimento.
• Tipi di dati definiti dall'utente: Definito dagli utenti:classe, struttura, unione, enumerazione e Typedef.

Variabili 

Le variabili memorizzano i valori dei dati. C++ supporta vari tipi di variabili, come int, double, string, char e float.

Ad esempio:

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

È possibile utilizzare alfabeti, numeri e il carattere di sottolineatura per un nome di variabile. Tuttavia, le variabili non possono iniziare con numeri o con il carattere di sottolineatura '_'. Invece, iniziano con lettere seguite da numeri o dal carattere di sottolineatura '_'. Inoltre, non è possibile utilizzare una parola chiave per il nome della variabile.

Ambito delle variabili

In C++, puoi dichiarare le tue variabili all'interno di tre parti del programma, noto anche come ambito delle variabili:

1. Variabili locali

Queste variabili sono dichiarate all'interno di una funzione o di un blocco di codice. Il loro ambito è limitato solo a quella funzione o blocco e non è possibile accedervi da nessun'altra istruzione al di fuori di quel blocco.

Ad esempio:

#include <iostream>
usingnamespacestd;

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

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

cout << c;

return0;
}

2. Variabili globali

Le variabili globali sono accessibili a qualsiasi funzione, metodo o blocco del programma. Di solito è definito al di fuori di tutte le funzioni. Il valore della variabile globale è lo stesso in tutto il programma.

Ad esempio:

#include <iostream>
usingnamespacestd;

// Global variable:
int g;

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

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

cout << g;

return0;
}

Modificatori del tipo di dati 

I modificatori del tipo di dati vengono utilizzati per modificare la lunghezza massima dei dati di un tipo di dati. La tabella seguente ti aiuterà a comprendere la dimensione e l'intervallo dei tipi di dati incorporati quando combinati con i modificatori. Ci sono quattro diversi tipi di modificatori disponibili in C++, ovvero firmato, senza segno, corto e lungo.

Valori letterali

I valori letterali in C++ sono dati che puoi usare per rappresentare i valori fissi. Puoi usarli direttamente all'interno del codice.

Ad esempio, 1, 2.5, “s”, ecc.

Ci sono diversi tipi di letterali disponibili in C++, come spiegato di seguito:

1. Intero letterale

Un intero letterale è numerico e non ha parti frazionarie o esponenziali.

Ad esempio: 

Decimale (base 10):0, -9, 22, ecc.

Ottale (base 8):021, 077, 033, ecc.

Esadecimale (base 16):0x7f, 0x2a, 0x521, ecc.

2. Letterali in virgola mobile

Questi sono letterali numerici che hanno una parte frazionaria o una parte esponente.

Ad esempio:(-2,0, 0,8589, -0,26E -5).

3. Carattere letterale

Si tratta di singoli caratteri racchiusi tra virgolette singole.

Ad esempio:'a', 'F', '2', ecc.

4. Sequenze di escape

Puoi usare le sequenze di escape in C++ per i caratteri non digitabili che hanno un significato speciale in C++.

Ad esempio:

5. Stringa letterale

Questa è una sequenza di caratteri racchiusa tra virgolette.

Ad esempio:

Costanti 

Per creare una variabile di cui non vuoi modificare i valori, puoi utilizzare la parola chiave “const”.

Ad esempio:

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

Funzioni matematiche

C++ fornisce diverse funzioni che consentono di eseguire attività matematiche. La tabella seguente evidenzia tutte le funzioni matematiche di base disponibili in C++:Math Functions

Input utente

C++ supporta "cout" e "cin" rispettivamente per visualizzare gli output e per ricevere input dagli utenti. Il cout usa l'operatore di iterazione (<<) e cin usa (>>).

Ad esempio:

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

Stringhe 

Una stringa è una raccolta o una sequenza di caratteri racchiusa tra virgolette.

Ad esempio:

string str= "Hello";

Per utilizzare la stringa all'interno del codice, devi includere la libreria di stringhe utilizzando questa riga di codice: 

#include <string>

C++ ti consentirà quindi di eseguire varie funzioni per manipolare le stringhe. La tabella seguente descrive i nomi delle funzioni e le relative descrizioni:

Operatori 

C++ supporta diversi tipi di operatori per aggiungere logica al codice ed eseguire operazioni sulle variabili e sui rispettivi valori. Ecco i tipi di operatori C++: 

1. Operatori aritmetici

Puoi eseguire operazioni matematiche comuni con gli operatori aritmetici.

2. Operatori di assegnazione

Puoi assegnare valori alle variabili con operatori di assegnazione.

3. Operatori di confronto

È possibile utilizzare questi operatori per confrontare due valori per restituire un valore vero o falso. Restituirà true se entrambi i valori corrispondono e false se non corrispondono.

4. Operatori logici

Questi operatori determinano la logica tra le variabili.

Dichiarazioni decisionali

Le istruzioni decisionali in C++ decidono il flusso di esecuzione del programma. Qui, i programmatori specificano più di una condizione. Se una condizione è vera, le istruzioni in quel blocco vengono eseguite. In caso contrario, vengono eseguite le istruzioni di altri blocchi.

C++ ha varie istruzioni decisionali:

• Dichiarazione If
• if..else istruzione
• Commuta istruzione
• Dichiarazione nidificata if
• Dichiarazione switch nidificata
• Operatore ternario

1. Se Dichiarazione

Questo è il tipo più elementare di dichiarazione decisionale. Indica al compilatore di eseguire il blocco di codice solo se la condizione è vera.

Sintassi:

if (expression)
{ //code}

Esempio: 

#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. Se..Altro Dichiarazione

Questa è un'estensione dell'istruzione "se". Indica al compilatore di eseguire il blocco "if" solo se la condizione specificata è vera. In caso contrario, esegue il blocco 'else'.

Sintassi:

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

Esempio: 

#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. Cambia dichiarazione

Quando devi eseguire condizioni rispetto a vari valori, puoi utilizzare le istruzioni switch.

Sintassi: 

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

default : //Optional
statement(s);
}

Esempio: 

#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. Dichiarazione If nidificata

Questa è un'istruzione "se" all'interno di un'altra istruzione "se". Puoi utilizzare questo tipo di istruzione quando devi basare una condizione specifica sul risultato di un'altra condizione.

Sintassi: 

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

Esempio: 

#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. Dichiarazione sugli switch annidati

Puoi includere un'istruzione switch all'interno di un'altra istruzione switch.

Sintassi: 

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': // ...
}

Esempio: 

#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. Operatore ternario

Esp1? Exp2:Exp3;

Innanzitutto, viene valutata l'espressione Exp1. Se è vero, allora Exp2 viene valutato e diventa il valore dell'intera espressione '?'. Se Exp1 è false, viene valutata Exp3 e il suo valore diventa il valore dell'espressione.

Cicli 

I loop vengono utilizzati per eseguire un particolare insieme di comandi per un determinato numero di tempo in base al risultato della condizione valutata. C++ include i seguenti cicli

• Durante il ciclo
• Ciclo del fare mentre
• Per ciclo
• Dichiarazione di rottura
• Continua dichiarazione

1. Mentre Loop

Il ciclo continuerà finché la condizione specificata non sarà vera.

while (condition)
{code}

2. Ciclo continuo

Quando la condizione diventa falsa, il ciclo do-while interrompe l'esecuzione. Tuttavia, l'unica differenza tra il ciclo while e quello do-while è che il ciclo do-while verifica la condizione dopo l'esecuzione del ciclo. Pertanto, il ciclo viene eseguito almeno una volta.

do
{
Code
}
while (condition)

3. Per Ciclo

È possibile utilizzare il ciclo for per eseguire più volte un blocco di codice. Questo ciclo esegue il blocco finché la condizione specificata in esso non è falsa.

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

4. Dichiarazione di rottura

Viene utilizzato per interrompere il flusso del codice in modo che il codice rimanente non venga eseguito. Questo ti porta fuori dal giro.

Ad esempio: 

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

5. Continua Dichiarazione

Questa affermazione interromperà il flusso e ti porterà alla valutazione della condizione. Successivamente, riavvia l'esecuzione del codice.

Ad esempio:

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

Array 

Gli array sono tipi di dati derivati ​​che memorizzano più elementi di dati di tipo simile in posizioni di memoria contigue.

Ad esempio:

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

1. Accesso ai valori dell'array

È necessario utilizzare il numero di indice per accedere agli elementi archiviati in un array.

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

2. Modifica degli elementi dell'array

È possibile modificare gli elementi archiviati in un array utilizzando il numero di indice.

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

Funzioni 

Una funzione è un gruppo di istruzioni per eseguire un compito specifico. La funzione comune in ogni programma C++ è la funzione main(). Puoi anche scomporre il tuo codice complesso in più piccole funzioni ed eseguirle separatamente.

Per questo, è necessario dichiarare, definire e chiamare quella funzione. C++ ha diverse funzioni integrate che puoi chiamare direttamente all'interno di qualsiasi programma.

Definizione di una funzione

Quella che segue è la sintassi per definire una funzione in C++:

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

Dove:

• tipo_ritorno specifica il tipo di valore restituito da quella funzione.
• nome_funzione specifica il nome della funzione e deve essere univoco.
• elenco parametri ti consente di passare più di un valore alla tua funzione, insieme ai relativi tipi di dati.
• corpo della funzione specifica l'insieme di istruzioni per eseguire un'attività.

Ad esempio:

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

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

return result;
}

Chiamare una funzione

Devi chiamare una funzione ovunque ti serva nel tuo programma.

Ad esempio:

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

Argomenti funzione

Puoi passare argomenti in tre modi:

• Chiamata per valore: Passa il valore effettivo di un argomento nel parametro formale della funzione. Non apporterà alcuna modifica al parametro all'interno della funzione e non ha effetto sull'argomento.
• Chiamata tramite puntatore: È possibile copiare un indirizzo di argomento nel parametro formale. Qui, l'indirizzo accede all'argomento effettivo utilizzato nella chiamata. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.
• Chiama per riferimento: È possibile copiare un riferimento ad un argomento nel parametro formale. Il riferimento accede all'argomento effettivo utilizzato nella chiamata. Ciò significa che le modifiche apportate al parametro influiscono sull'argomento.

Corsi di archiviazione 

Le classi di archiviazione definiscono la visibilità delle variabili e delle funzioni. C++ supporta varie classi di archiviazione, come auto, register, extern, static e mutable.

1. Classe di archiviazione automatica

Per impostazione predefinita, C++ usa questa classe di archiviazione per tutte le variabili.

Ad esempio:

{
int var;
autoint var1;
}

È possibile utilizzare solo "auto" all'interno delle funzioni per definire le variabili locali.

2. Registra la classe di archiviazione 

Questa classe di archiviazione definisce le variabili locali da memorizzare all'interno del registro anziché nella RAM. È utile quando si desidera accedere frequentemente alla variabile, ad esempio contatori. La dimensione della variabile avrà una dimensione massima uguale alla dimensione del registro.

Ad esempio:

{
registerint miles;
}

3. Classe di archiviazione statica

La classe di archiviazione statica dice al compilatore di mantenere le variabili locali in tutto il programma senza che sia necessario crearle e distruggerle quando entra ed esce dall'ambito. Definire una variabile come statica significa che manterrà i suoi valori tra le chiamate di funzione.

Le variabili globali sono statiche, il che significa che il loro ambito sarà limitato al file dichiarato. Se specifichi un membro dati di classe come statico, crea solo una copia di quel membro che tutti gli oggetti della sua classe condivideranno.

Ad esempio: 

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

Classe di archiviazione esterna

La classe di archiviazione esterna fornisce un riferimento di una variabile globale e la rende visibile a TUTTI i file di programma. Quando specifichi una variabile come 'extern', la variabile non può essere inizializzata perché punta il nome della variabile in una posizione di archiviazione che è stata precedentemente definita.

In caso di più file in cui si definisce una variabile o una funzione globale, da utilizzare anche in altri file, extern fornirà un riferimento in un altro file di variabile o funzione definita. Devi usare il modificatore extern quando devi condividere le stesse variabili globali o funzioni tra due o più file.

Ad esempio:

Programma 1

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

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

Programma 2

#include <iostream>

externint count;

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

Classe di archiviazione mutabile

È possibile utilizzare questa classe di archiviazione se si desidera che un membro dell'oggetto esegua l'override della funzione membro. Cioè, un membro mutabile che può essere modificato da una funzione membro const.

Struttura 

La struttura consente di definire gli elementi di dati dei tipi di dati non simili. Per utilizzare una struttura, è necessario definirla e accedere ai suoi membri della struttura.

Quella che segue è la sintassi per creare una struttura:

struct [structuretag] {
definizione del membro;
definizione del membro;
...
definizione del membro;
} [una o più variabili di struttura];

Ad esempio, vogliamo creare una struttura di libri composta da titolo, autore, soggetto e book_id, come segue:

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

È necessario utilizzare l'operatore di accesso ai membri (.) per accedere ai membri della struttura. Questo è un periodo tra il nome della variabile della struttura e il membro della struttura a cui desideriamo accedere.

Accesso ai membri della struttura

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

Riferimenti 

Quando si dichiara una variabile come riferimento, essa funge da alternativa a quella esistente. È necessario specificare la variabile di riferimento con "&", come mostrato di seguito:

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

Puntatore 

Un puntatore in C++ è una variabile che memorizza l'indirizzo di memoria di un'altra variabile. Analogamente alle variabili regolari, anche i puntatori hanno tipi di dati. Usiamo '*' per dichiarare i puntatori in C++.

Ad esempio:

string food = "Pizza"; // string variable

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

Classi e oggetti 

C++ è un linguaggio di programmazione orientato agli oggetti con classi e oggetti. La classe è un tipo di dati definito dall'utente che è possibile utilizzare per associare membri dati e funzioni membro. Puoi accedervi creando un'istanza di quella classe.

Creazione di una classe

Ecco come creare una classe in C++:

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

Creazione di un oggetto

Gli oggetti funzionano come un'istanza della classe, consentendo di accedere ai suoi membri, funzioni e variabili. È necessario utilizzare l'operatore punto (.), come mostrato di seguito:

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

Creazione di più oggetti

Ecco un esempio di come creare più oggetti della stessa classe:

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

Metodi di classe

I metodi sono come funzioni definite all'interno di una classe. C++ ha due tipi di metodi:inside class e outside class.

Metodo della classe interna

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

Metodo per classi esterne

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

Costruttori 

Un costruttore è un metodo chiamato automaticamente durante la creazione dell'oggetto. Ha lo stesso nome del nome della classe e nessun tipo di dati.

Ad esempio:

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

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

Specificatori di accesso 

Gli specificatori di accesso definiscono l'accesso dei membri della classe e delle variabili. C++ supporta tre tipi di identificatori di accesso:

• Pubblico: I membri della classe e le variabili sono accessibili dall'esterno della classe.

• Privato: I membri della classe e le variabili sono accessibili solo all'interno della classe e non all'esterno della classe.

• Protetto: I membri della classe e le variabili sono accessibili solo nelle loro sottoclassi.

Incapsulamento 

L'incapsulamento ti aiuta a nascondere i dati sensibili agli utenti. Qui, utilizziamo lo specificatore di accesso privato per dichiarare le variabili e i metodi. Se si desidera consentire ad altri di leggere o modificare tali variabili e metodi, è necessario utilizzare i metodi get e set pubblici.

Ad esempio:

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

Ereditarietà 

C++ supporta l'ereditarietà, consentendo di ereditare i membri e le variabili di una classe in un'altra. La classe ereditante è la classe figlia e l'altra è la classe genitore. Devi usare il simbolo (:) per ereditare:

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

Polimorfismo 

Il polimorfismo specifica le "molte forme". È la capacità di un singolo messaggio di essere visualizzato in più moduli e si verifica quando si hanno più classi figlie e una classe base.

Ad esempio:

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

Gestione dei file 

È possibile utilizzare una libreria fstream per gestire i file. La libreria fstream è composta da file di intestazione e .

#include

#include

di flusso: creare e scrivere nei file.

ifstream: leggere dal file specificato.

fstream: combinazione di sopra entrambi.

Creazione e scrittura

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

Lettura

// 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();

Eccezioni 

Durante la compilazione e l'esecuzione, potresti incorrere in errori. C++ consente di gestire e rilevare questi errori utilizzando la gestione delle eccezioni. Quella che segue è la sintassi per la gestione delle eccezioni che include un blocco try-catch:

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

Ad esempio:

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

Preprocessore

Di seguito sono riportati alcuni preprocessori integrati disponibili in C++ per varie funzionalità.

#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

Gestione dinamica della memoria

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

Matematica in virgola mobile

Devi includere la libreria "cmath" per eseguire attività su numeri a virgola mobile.

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

Conclusione 

Abbiamo raggiunto la fine del cheat sheet di riferimento C++. Congratulazioni!

In questo riferimento C++, abbiamo trattato quasi tutti gli aspetti C++ che qualsiasi principiante deve comprendere quando inizia la propria carriera o si prepara per un colloquio imminente. Questo cheat sheet C++ per principianti è un'eccellente risorsa che puoi consultare durante lo sviluppo di applicazioni o prima di presentarti per un colloquio.

Ci auguriamo che questo riferimento a C++ ti aiuti a capire tutto sul C++ in modo approfondito.

Interessato ad ampliare le tue conoscenze C++? Dai un'occhiata al nostro elenco dei migliori corsi C++.

Le persone stanno leggendo anche:

• Le migliori domande di intervista su C++
• Differenza tra C# e C++
• Miglior IDE C++
• I migliori libri C++
• I migliori corsi Java
• I migliori corsi HTML
• I migliori corsi di sviluppo Web
• I migliori corsi C