Ce face nullptr
Un pointer care nu arată (încă) spre niciun obiect trebuie să aibă valoarea nullptr. Înainte de C++11 se folosea NULL sau 0, dar acestea sunt de fapt numere întregi și pot alege greșit între funcții supraîncărcate.
nullptr are propriul tip, std::nullptr_t, care se transformă în orice tip de pointer, dar nu în număr. Un pointer nul este false într-o condiție, deci if (p) înseamnă „dacă p arată spre ceva”.
Exemple
Exemplul 1: Verificarea unui pointer
#include <print>
#include <string>
void afiseaza(const std::string* nume) {
if (nume == nullptr) {
std::println("Nu avem un nume.");
return;
}
std::println("Nume: {}", *nume);
}
int main() {
std::string ana = "Ana";
afiseaza(&ana);
afiseaza(nullptr);
}
Rezultat
Nume: Ana
Nu avem un nume.
Exemplul 2: De ce nu 0: alegerea funcției supraîncărcate
0 este un int, deci alege prima funcție, deși intenția era „pointer gol”. nullptr alege corect varianta cu pointer.
#include <print>
void trimite(int cod) { std::println("trimite(int) cu {}", cod); }
void trimite(const char* text) { std::println("trimite(pointer), gol: {}", text == nullptr); }
int main() {
trimite(0);
trimite(nullptr);
}
Rezultat
trimite(int) cu 0
trimite(pointer), gol: true
Greșeli frecvente
- Citești valoarea printr-un pointer nul (
*pcândp == nullptr). Este comportament nedefinit; de obicei programul se oprește cu „Segmentation fault”. Verifică înainte. - După
delete p;lași pointerul cu adresa veche. Setează-l lanullptrsau, mai bine, foloseștestd::unique_ptr.
Comenzi înrudite
pointeri (*, &): Un pointer este o variabilă care ține adresa altei variabile; prin el poți citi și modifica valoarea de la acea adresă.new: Creează un obiect în memoria dinamică (heap) și returnează un pointer la el; obiectul trăiește până este distrus explicit cu delete.delete: Distruge un obiect creat cu new și eliberează memoria; scris ca = delete, interzice folosirea unei funcții.void: Înseamnă „niciun tip”: o funcție void nu returnează nimic, iar void* este un pointer către date de orice tip.std::unique_ptr: Pointer inteligent care deține singur un obiect și îl șterge automat când iese din domeniu.