Condivisione della tecnologia

한어Русский языкEnglishFrançaisIndonesianSanskrit日本語DeutschPortuguêsΕλληνικάespañolItalianoSuomalainenLatina

Spiegazione dei puntatori intelligenti

Smart Pointer è uno strumento in C++ utilizzato per gestire automaticamente la memoria allocata dinamicamente.

È una classe che incapsula le funzioni dei puntatori grezzi e può gestire automaticamente l'allocazione e il rilascio delle risorse, aiutando così i programmatori a evitare errori comuni di gestione della memoria, come perdite di memoria, puntatori pendenti e altri problemi.

I puntatori intelligenti funzionano tramite il meccanismo Resource Acquisition Is Inizializzazione (RAII), il che significa che i puntatori intelligenti acquisiscono risorse quando vengono costruiti e rilasciano risorse quando vengono distrutte. Ciò garantisce che le risorse vengano rilasciate correttamente anche in circostanze anomale.

 

Problemi risolti da puntatori intelligenti

(1) Perdita di memoria: la memoria viene rilasciata manualmente, ma può essere rilasciata automaticamente utilizzando i puntatori intelligenti.

(2) Propagazione e rilascio di puntatori di proprietà condivisa, come problemi di distruzione quando più thread utilizzano lo stesso oggetto.

 

Diversi tipi di puntatori intelligenti

La libreria standard C++ fornisce diversi tipi di puntatori intelligenti, tra cui:

1. std::unique_ptr：

   • modello di proprietà esclusiva, ovvero aunique_ptrUn'istanza ha la proprietà esclusiva dell'oggetto a cui punta.
   • Quandounique_ptrQuando esce dall'ambito o viene reimpostato in modo esplicito, chiama automaticamente il distruttore e rilascia l'oggetto gestito.
   • La copia non è supportata, ma è possibile lo spostamento.

2. std::shared_ptr：

   • Modello di proprietà condivisa, che consente molteplicishared_ptrLe istanze condividono la proprietà dello stesso oggetto.
   • Utilizza il conteggio dei riferimenti per tenere traccia dei riferimenti allo stesso oggettoshared_ptrquantità.
   • quando l'ultimoshared_ptrQuando un'istanza esce dall'ambito o viene reimpostata, il conteggio dei riferimenti viene ridotto a zero, viene chiamato il distruttore dell'oggetto e l'oggetto viene rilasciato.

3. std::weak_ptr：

   • utilizzato per risolvereshared_ptrproblema di riferimento circolare.
   • Senza incrementare il conteggio dei riferimenti, è possibile osservarlo tramiteshared_ptroggetti gestiti, ma non partecipa alla gestione del suo ciclo di vita.
   • Quando non c'èshared_ptrQuando un'istanza punta a un oggetto,weak_ptrPuò rilevare che l'oggetto è stato distrutto.

La progettazione e l'uso dei puntatori intelligenti semplifica notevolmente la gestione della memoria in C++ e migliora la robustezza e la sicurezza del programma. Nella moderna programmazione C++, è altamente consigliabile utilizzare puntatori intelligenti anziché puntatori grezzi per migliorare la qualità e la manutenibilità del codice.

 

Esempio di puntatore intelligente

I puntatori intelligenti vengono utilizzati in C++ come mezzo per gestire automaticamente la memoria allocata dinamicamente per prevenire perdite di memoria e altri problemi correlati alla gestione delle risorse.

std::unique_ptrEsempio

std::unique_ptrè un puntatore intelligente con proprietà esclusiva, che garantisce che ce ne sia solo unostd::unique_ptr Un'istanza ha il controllo su una determinata risorsa.Quandostd::unique_ptrQuando esce dall'ambito o viene reimpostato, le risorse di sua proprietà verranno automaticamente rilasciate.

#include <memory>
 
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor called.n"; }
    ~MyClass() { std::cout << "MyClass destructor called.n"; }
    void doSomething() { std::cout << "Doing something...n"; }
};
 
int main() {
    // 创建一个unique_ptr来管理MyClass的实例
    std::unique_ptr<MyClass> uptr(new MyClass());
 
    // 调用doSomething方法
    uptr->doSomething();
 
    // unique_ptr会在离开作用域时自动调用MyClass的析构函数
    return 0;
}

std::shared_ptrEsempio

std::shared_ptrè un puntatore intelligente a proprietà condivisa che consente piùstd::shared_ptrLe istanze condividono la proprietà della stessa risorsa.std::shared_ptrUtilizzare un conteggio dei riferimenti per tenere traccia del numero di puntatori intelligenti che puntano alla stessa risorsa. Quando il conteggio dei riferimenti raggiunge 0, la risorsa viene rilasciata.

#include <memory>
 
class MyClass {
public:
    MyClass() { std::cout << "MyClass constructor called.n"; }
    ~MyClass() { std::cout << "MyClass destructor called.n"; }
    void doSomething() { std::cout << "Doing something...n"; }
};
 
int main() {
    // 创建一个shared_ptr来管理MyClass的实例
    std::shared_ptr<MyClass> sptr(new MyClass());
    
    // 创建第二个shared_ptr，共享同一个MyClass实例
    std::shared_ptr<MyClass> sptr2 = sptr;
 
    // 调用doSomething方法
    sptr->doSomething();
 
    // 当所有shared_ptr实例都超出作用域时，MyClass的析构函数才会被调用
    return 0;
}

 

Precauzioni

In usostd::shared_ptr Quando si esegue questa operazione, fare attenzione a evitare situazioni di riferimento circolare, che faranno sì che il conteggio dei riferimenti non scenda mai a 0, con conseguenti perdite di risorse.Nel caso di riferimenti circolari, è possibile utilizzarestd::weak_ptrper interrompere il ciclo,std::weak_ptrNon incrementa il conteggio dei riferimenti, mantiene solo il filestd::shared_ptrGestire i riferimenti deboli alle risorse.

Questi esempi mostrano come utilizzare i puntatori intelligenti per gestire la memoria allocata dinamicamente per garantire che le risorse vengano rilasciate correttamente al momento opportuno, evitando errori comuni che possono verificarsi durante la gestione manuale della memoria.

 

Altri esempi

https://www.cnblogs.com/dio-della-morte/p/17962676

Italiano: Italiano: https://zhuanlan.zhihu.com/p/678722914