C++ Cheat Sheet
Ultimo aggiornamento
Hello World e struttura del programma
L'esecuzione parte da main, che restituisce un int.
| Elemento | Codice |
|---|---|
| Includere un header | #include <iostream> |
| Punto di ingresso | int main() { ... } |
| Stampare una riga | std::cout << "Hello, World!" << std::endl; |
| Leggere l'input | std::cin >> x; |
| Usare il namespace std | using namespace std; |
| Restituire successo | return 0; |
| Commenti | // line e /* block */ |
Tipi di dati
| Tipo | Descrizione |
|---|---|
int | Intero (di solito 32 bit) |
long / long long | Interi più ampi |
float / double | Numeri in virgola mobile |
char | Singolo byte / carattere |
bool | true o false |
std::string | Testo dinamico da <string> |
auto | Il compilatore deduce il tipo |
std::size_t | Tipo senza segno per dimensioni e indici |
Variabili e riferimenti
I riferimenti sono alias; i puntatori contengono indirizzi.
| Operazione | Sintassi |
|---|---|
| Dichiarare e inizializzare | int x = 5; |
| Inizializzazione con graffe | int x{5}; |
| Costante | const double PI = 3.14159; |
| Costante a tempo di compilazione | constexpr int N = 10; |
| Riferimento (alias) | int &r = x; |
| Puntatore | int *p = &x; |
| Dereferenziare un puntatore | *p = 10; |
| Inferenza del tipo | auto y = 3.14; |
Controllo del flusso
| Istruzione | Sintassi |
|---|---|
| If / else | if (x > 0) { ... } else { ... } |
| Switch | switch (n) { case 1: ...; break; default: ...; } |
| Ciclo while | while (i < n) { ... } |
| Ciclo do-while | do { ... } while (i < n); |
| Ciclo for | for (int i = 0; i < n; i++) { ... } |
| For basato su range | for (auto x : vec) { ... } |
| For su range per riferimento | for (auto &x : vec) { ... } |
| Break / continue | break; esce da un ciclo, continue; passa all'iterazione successiva |
Funzioni
| Operazione | Sintassi |
|---|---|
| Definire una funzione | int add(int a, int b) { return a + b; } |
| Nessun valore di ritorno | void greet() { ... } |
| Argomenti predefiniti | int pow(int b, int e = 2) { ... } |
| Passaggio per riferimento | void inc(int &x) { x++; } |
| Riferimento const (nessuna copia) | void print(const std::string &s) { ... } |
| Overloading | int max(int a, int b); e double max(double a, double b); |
| Lambda | auto f = [](int x) { return x * 2; }; |
| Lambda con cattura | auto g = [n](int x) { return x + n; }; |
Classi e OOP
| Operazione | Sintassi |
|---|---|
| Definire una classe | class Dog { ... }; |
| Specificatori di accesso | public:, private:, protected: |
| Variabile membro | std::string name; |
| Constructor | Dog(std::string n) : name(n) {} |
| Destructor | ~Dog() { ... } |
| Funzione membro | void bark() { ... } |
| Creare un oggetto | Dog d("Rex"); |
| Ereditarietà | class Puppy : public Dog { ... }; |
| Funzione virtuale | virtual void speak(); |
Container STL
I container più comuni della libreria standard.
| Container | Uso ed esempio |
|---|---|
std::vector<int> | Array dinamico: v.push_back(1); v.size(); |
std::string | Testo: s += "!"; s.length(); |
std::array<int, 3> | Array a dimensione fissa con info sui limiti |
std::map<K, V> | Chiave-valore ordinato: m["a"] = 1; |
std::unordered_map<K, V> | Hash map (ricerca più veloce, nessun ordine) |
std::set<T> | Valori unici ordinati: s.insert(5); |
std::pair<A, B> | Due valori: make_pair(1, "x") |
std::queue / std::stack | Adattatori coda FIFO / pila LIFO |
Algoritmi e iteratori STL
Da <algorithm>; quasi tutti accettano un intervallo di iteratori begin/end.
| Operazione | Sintassi |
|---|---|
| Iteratori begin / end | v.begin(), v.end() |
| Ordinare | std::sort(v.begin(), v.end()); |
| Ordinare in modo decrescente | std::sort(v.begin(), v.end(), std::greater<int>()); |
| Trovare un valore | auto it = std::find(v.begin(), v.end(), 5); |
| Contare le corrispondenze | std::count(v.begin(), v.end(), 5); |
| Elemento minimo / massimo | std::max_element(v.begin(), v.end()); |
| Sommare un intervallo | std::accumulate(v.begin(), v.end(), 0); |
| Trasformare ogni elemento | std::transform(v.begin(), v.end(), v.begin(), fn); |
Smart pointer e C++ moderno
Preferisci gli smart pointer a new/delete grezzi per una pulizia automatica.
| Funzionalità | Sintassi |
|---|---|
| Proprietà unica | auto p = std::make_unique<Dog>("Rex"); |
| Proprietà condivisa | auto p = std::make_shared<Dog>("Rex"); |
| Riferimento non proprietario | std::weak_ptr<Dog> w = p; |
| Semantica di spostamento | auto v2 = std::move(v1); |
| Nullptr | int *p = nullptr; |
| Structured binding | auto [key, val] = *it; |
| Valore opzionale | std::optional<int> maybe; |
| Template | template <typename T> T add(T a, T b) { return a + b; } |
La sintassi, i container STL e le funzionalità moderne di C++ che usi di più, in una sola pagina. Questa cheat sheet di C++ è un riferimento rapido per scrivere in C++: tipi di dati, riferimenti, classi, i container della libreria standard come vector e unordered_map e gli smart pointer che sostituiscono new/delete grezzi.
Tutto quello che trovi qui è C++ standard (C++11 e successivi) e si compila con g++ o clang++. Copia quello che ti serve oppure prova qualsiasi frammento dal vivo nel playground C++, senza installare nessun compilatore. Stai imparando il linguaggio? Il corso interattivo gratuito di C++ di Coddy copre puntatori, STL e classi passo dopo passo.
Domande frequenti sulla cheat sheet di C++
Questa cheat sheet di C++ è gratuita?
Sì. Questa cheat sheet di C++ è completamente gratuita e non richiede registrazione. Salvala nei preferiti e torna quando devi controllare la sintassi, un container STL o uno smart pointer.
Qual è la differenza tra puntatore e riferimento in C++?
Un puntatore è una variabile che contiene un indirizzo; può essere nullo, può essere riassegnato per puntare altrove e lo dereferenzi con
*p. Un riferimento (int &r = x) è un alias di una variabile esistente: va collegato al momento della dichiarazione, non può mai essere nullo né ricollegato e si usa come la variabile stessa. Usa i riferimenti per parametri passati per riferimento più puliti e i puntatori quando ti serve un'indirezione opzionale o riassegnabile.Meglio new/delete o gli smart pointer?
Meglio gli smart pointer.
std::unique_ptr e std::shared_ptr (tramite make_unique/make_shared) liberano la memoria automaticamente quando escono dallo scope, evitando i memory leak e le doppie deallocazioni tipiche della gestione manuale con new/delete. Usa new/delete grezzi solo nel codice di basso livello che ha un motivo preciso per farlo.Posso esercitarmi con il C++ online?
Sì. Apri il playground C++ per compilare ed eseguire nel browser qualsiasi frammento di questa cheat sheet, senza installare un compilatore. Quando vuoi un percorso strutturato, il corso interattivo gratuito di C++ di Coddy ti porta passo dopo passo da variabili e cicli fino a classi e STL.
Questa cheat sheet va bene per chi inizia?
Sì. È organizzata dai mattoni più comuni (tipi, controllo del flusso, funzioni) fino a quelli avanzati (STL e smart pointer), così puoi usare le prime sezioni fin dal primo giorno e arrivare al resto con il tempo.
Risorse correlate
Altre cheat sheet
