C++ 从另一个唯一ptr的原始ptr创建唯一ptr_C++_Unique Ptr

C++ 从另一个唯一ptr的原始ptr创建唯一ptr

c++

C++ 从另一个唯一ptr的原始ptr创建唯一ptr,c++,unique-ptr,C++,Unique Ptr,使用另一个唯一指针的原始指针创建唯一指针时会发生什么？在下面的示例中，调用createsecondclass时会发生什么？我以为创建第二个对象时第一个对象会放弃所有权，但调用get时第一个对象不会放弃所有权 class SecondClass { SecondClass(Object* obj) : second_obj_(obj) {} ..... private: std::unique_ptr<Obj> second_obj_;

使用另一个唯一指针的原始指针创建唯一指针时会发生什么？在下面的示例中，调用createsecondclass时会发生什么？我以为创建第二个对象时第一个对象会放弃所有权，但调用get时第一个对象不会放弃所有权

class SecondClass {
     SecondClass(Object* obj) : second_obj_(obj) {}
     .....
     private:
          std::unique_ptr<Obj> second_obj_;
}

class FirstClass {
     FirstClass() {
          std::unique_ptr<Obj> first_obj_ = std::make_unique<Obj>();
      }
      std::unique_ptr<SecondClass> CreateSecondClass() {
           std::make_unique<Obj>(first_obj_.get());      
       }
     .....
     private:
          std::unique_ptr<Obj> first_obj_;
          SecondClass second_class;
}

class第二类{
第二类（Object*obj）：第二类（Object*obj）{}
.....
私人：
std：：唯一的第二个对象；
}
头等舱{
头等舱{
std:：unique_ptr first_obj_uj=std:：make_unique（）；
}
std:：unique_ptr CreateSecondClass（）{
std:：make_unique（first_obj_uj.get（））；
}
.....
私人：
std：：唯一性\u ptr first\u obj\u；
二等二等；
}

使用另一个唯一指针的原始指针创建唯一指针时会发生什么

坏事可能会发生

您最终得到2个

unique_ptr

对象，它们都认为自己是原始指针的独占所有者，因此这两个对象都将尝试管理并最终释放所拥有的内存。为了避免这种情况，您必须将所有权从一个

unique\u ptr

传递给另一个

unique\u ptr

s，或者至少为其中一个

unique\u ptr

s提供一个不会释放内存的自定义

deleter

（在这种情况下，您不应该首先使用2个

unique\u ptr

对象）

在下面的示例中，调用createsecondclass时会发生什么

第一个对象

和

第二个对象

最后都会在内存中保留指向相同

对象

的指针，并且它们都会尝试

删除它
我以为第一个对象
在创建第二个对象
时会放弃所有权
否，因为unique\u ptr:：get（）
只返回原始指针的副本，所以它不会释放指针的所有权。如果需要，请使用unique\u ptr:：release（）
：
class SecondClass {
public:
    SecondClass(Object* obj) : second_obj_(obj) {}
    ...
private:
    std::unique_ptr<Object> second_obj_;
};

class FirstClass {
public:
    FirstClass() : first_obj_(std::make_unique<Object>()) {}

    std::unique_ptr<SecondClass> CreateSecondClass() {
        return std::make_unique<SecondClass>(first_obj_.release());
    }
    ...
private:
    std::unique_ptr<Object> first_obj_;
};

如果确实希望FirstClass
和SecondClass
共享同一个指针，请使用std:：shared\u ptr
而不是std:：unique\u ptr
：
class SecondClass {
public:
    SecondClass(std::shared_ptr<Object> obj) : second_obj_(obj) {}
    ...
private:
    std::shared_ptr<Object> second_obj_;
};

class FirstClass {
public:
    FirstClass() : first_obj_(std::make_shared<Object>()) {}

    std::unique_ptr<SecondClass> CreateSecondClass() {
        return std::make_unique<SecondClass>(first_obj_);
    }
    ...
private:
    std::shared_ptr<Object> first_obj_;
};

class第二类{
公众：
第二类（std:：shared_ptr obj）：第二类（obj）{}
...
私人：
std：：共享的第二个对象；
};
头等舱{
公众：
FirstClass（）：第一个对象（std:：make_shared（））{}
std:：unique_ptr CreateSecondClass（）{
return std:：make_unique（第一个对象）；
}
...
私人：
std：：共享优先对象；
};

使用另一个唯一指针的原始指针创建唯一指针时会发生什么
坏事可能会发生
您最终得到2个unique_ptr
对象，它们都认为自己是原始指针的独占所有者，因此这两个对象都将尝试管理并最终释放所拥有的内存。为了避免这种情况，您必须将所有权从一个unique\u ptr
传递给另一个unique\u ptr
s，或者至少为其中一个unique\u ptr
s提供一个不会释放内存的自定义deleter
（在这种情况下，您不应该首先使用2个unique\u ptr
对象）
在下面的示例中，调用createsecondclass时会发生什么
第一个对象
和第二个对象
最后都会在内存中保留指向相同对象
的指针，并且它们都会尝试删除它
我以为第一个对象
在创建第二个对象
时会放弃所有权
否，因为unique\u ptr:：get（）
只返回原始指针的副本，所以它不会释放指针的所有权。如果需要，请使用unique\u ptr:：release（）
：
class SecondClass {
public:
    SecondClass(Object* obj) : second_obj_(obj) {}
    ...
private:
    std::unique_ptr<Object> second_obj_;
};

class FirstClass {
public:
    FirstClass() : first_obj_(std::make_unique<Object>()) {}

    std::unique_ptr<SecondClass> CreateSecondClass() {
        return std::make_unique<SecondClass>(first_obj_.release());
    }
    ...
private:
    std::unique_ptr<Object> first_obj_;
};

如果确实希望FirstClass
和SecondClass
共享同一个指针，请使用std:：shared\u ptr
而不是std:：unique\u ptr
：
class SecondClass {
public:
    SecondClass(std::shared_ptr<Object> obj) : second_obj_(obj) {}
    ...
private:
    std::shared_ptr<Object> second_obj_;
};

class FirstClass {
public:
    FirstClass() : first_obj_(std::make_shared<Object>()) {}

    std::unique_ptr<SecondClass> CreateSecondClass() {
        return std::make_unique<SecondClass>(first_obj_);
    }
    ...
private:
    std::shared_ptr<Object> first_obj_;
};

class第二类{
公众：
第二类（std:：shared_ptr obj）：第二类（obj）{}
...
私人：
std：：共享的第二个对象；
};
头等舱{
公众：
FirstClass（）：第一个对象（std:：make_shared（））{}
std:：unique_ptr CreateSecondClass（）{
return std:：make_unique（第一个对象）；
}
...
私人：
std：：共享优先对象；
};
如果您想放弃所有权，应该使用
std:：unique\u ptr
无法知道您将如何处理用get（）
提取的指针，尤其是无法知道您决定将其交给另一个std:：unique\u ptr

如果两个std:：shared_ptr
s将存储相同的指针，您将获得对象的双重delete
，这是未定义的行为

但是，如果要将所有权从一个std:：unique_ptr
传递到另一个，则可能应该使用移动语义：
class Obj {};

struct SecondClass {
    SecondClass(std::unique_ptr<Obj>&& obj) : second_obj_(std::move(obj)) {}
private:
    std::unique_ptr<Obj> second_obj_;
};

struct FirstClass {
    FirstClass() {
        first_obj_ = std::make_unique<Obj>();
    }

    std::unique_ptr<SecondClass> CreateSecondClass() {
        return std::make_unique<SecondClass>(std::move(first_obj_));  
        //note that first_obj_ points to nullptr now. Only SecondClass owns the Obj.
    }
private:
    std::unique_ptr<Obj> first_obj_;
};

类Obj{}；
结构二级{
第二类（std:：unique_ptr&&obj）：第二类（std:：move（obj））{
私人：
std：：唯一的第二个对象；
};
结构一级{
头等舱{
第一个对象=std:：使对象唯一（）；
}
std:：unique_ptr CreateSecondClass（）{
返回std:：make_unique（std:：move（first_obj））；
//请注意，第一个对象现在指向nullptr。只有第二个类拥有该对象。
}
私人：
std：：唯一性\u ptr first\u obj\u；
};
如果您想放弃所有权，应该使用
std:：unique\u ptr
无法知道您将如何处理用get（）
提取的指针，尤其是无法知道您决定将其交给另一个std:：unique\u ptr

如果两个std:：shared_ptr
s将存储相同的指针，您将获得对象的双重delete
，这是未定义的行为

但是，如果您想将所有权从一个std:：unique_ptr
传递给另一个，则y