İşaretçiyi değiştirmenin daha idiomatik bir yolu var mı?

Question

Aşağıdaki kodu düşünün:

#include <memory> 
#include <stdio.h> 
#include <stdexcept> 

class Foo { 
    public: 
     Foo(int n) { val =n; printf("Hi %d\n", val); }; 
     ~Foo() { printf("Bye %d\n", val); }; 
    private: 
     int val; 
}; 

int main() 
{ 
    std::shared_ptr<Foo> p = nullptr; // I don't know what I want yet 
    p = std::make_shared<Foo>(1); // OK, I've decided 

    // I've changed my mind, it needs to be something else 
    p = nullptr; 
    p = std::make_shared<Foo>(2); 

    return 0; 
} 

Onun çıkışı:

Hi 1 
Bye 1 
Hi 2 
Bye 2 

Bu yapmacık bir örnek. Foo oldukça ilgi çekicidir. Sadece ömrü ile ilgili bilgi yazdırır.

Kodun arkasındaki mantık şudur: p bildiriyorum, ancak başlangıçta ne gerektiğini bilmiyorum. Sonra ne olduğunu bildiğime karar veririm: 1. değeri almalıdır. Gerçek kodumda bu değer uzun sürebilir.

Bir süre sonra, bunun 1 olmamasına, 2 olması gerektiğine ben karar veririm. Daha önce ne olursa olsun, imha edilmeli ve başka bir şeyle değiştirilmelidir.

Şimdiye kadar, benim anlayışım yukarıdaki kodun bellek yönetimi açısından iyi ve istisnalar altında sağlam olmasıdır.

demenin daha deyimsel yolu var mı:

p = nullptr; 
p = std::make_shared<Foo>(2); 

elimden önce sahip tahrip edilmesi gerektiğini söylemek istiyorum çünkü ben sadece son satırı yazamazsınız.

Answer 1

Sadece imlecin atanması, önceki değere ihtiyacınız olmadığını bildirmek için yeterlidir. paylaşılan işaretçisi olduğundan ve başka sahiplerine sahip olabileceğinden, imha edilmesi gerekip gerekmediğini söylemezsiniz.

Benim görüşüme göre atama yeterlidir ancak shared_ptr::reset()'u kullanmayı tercih edebilirsiniz.

Answer 2

Eğer deyimsel (iyi!) Istemek için, en deyimsel olalım:

#include <memory> 
#include <stdexcept> 
#include <iostream> 

class Foo { 
public: 
    Foo(int n) 
    : val(n) 
    { 
     std::cout << "Hi " << val << "\n"; 
    }; 
    ~Foo() { 
     std::cout << "bye " << val << "\n"; 
    }; 
private: 
    int val; 
}; 

int main() 
{ 
    auto p = std::shared_ptr<Foo>(); // I don't know what I want yet 
    p = std::make_shared<Foo>(1); // OK, I've decided 

    // I've changed my mind, it needs to be something else 
    p = std::make_shared<Foo>(2); 

    return 0; 
} 

Answer 3

burada

p = std::make_shared<Foo>(2); 

Bu hat yapmam gereken başka bir şey yok imiş p önceki nesneyi yok eder Bu nesneye son başvuru. Daha sonra yeni paylaşım