C++ 返回共享的\u ptr

我有一个函数需要返回另一个类的新对象，所以我想我需要将它的返回对象保存在一个共享指针中。像这样

X类内

Y* func(param)
{
   return new Y(param);
}

我试着把它改成

std::shared_ptr<Y> func(param)
{
   std::shared_ptr<Y> y(new Y(param));
   return y;
}

std:：共享函数（参数）
{
std：：共享参数y（新y（参数））；
返回y；
}

---

我不想返回本地对象，那么我该怎么办？

返回一个堆分配的对象，这意味着要转移所有权。我建议您使用

std:：unique_ptr

作为返回类型

std::unique_ptr<Y> func(param)
{
   return std::unique_ptr<Y>(new Y(param));
}

---

返回一个堆分配的对象，这意味着您要转移所有权。我建议您使用

std:：unique_ptr

作为返回类型

std::unique_ptr<Y> func(param)
{
   return std::unique_ptr<Y>(new Y(param));
}

---

我建议您使用

std:：shared_ptr

作为返回类型，并使用

return std:：make_shared（）

来转移所有权。

以下是一个可能对您有所帮助的工作示例：

#include <memory>
#include <iostream>
#include <string>

class Y {
public:
    Y(const std::string& n)
    : name{n} {}

    std::string name;
};

std::shared_ptr<Y> func()
{
    return std::make_shared<Y>("new class");
}

int main()
{
    std::shared_ptr<Y> p_class = func();
    std::cout << p_class->name;
    // outputs: "new class"

    return 0;
}

#包括
#包括
#包括
Y类{
公众：
Y（常量标准：：字符串和n）
：name{n}{}
std：：字符串名；
};
std:：shared_ptr func（）
{
返回标准：：使_共享（“新类”）；
}
int main（）
{
std:：shared_ptr p_class=func（）；
std：：cout名称；
//输出：“新类”
返回0；
}

我建议您使用

std:：shared\u ptr

作为返回类型，并使用

return std:：make\u shared（）

来转移所有权。

以下是一个可能对您有所帮助的工作示例：

#include <memory>
#include <iostream>
#include <string>

class Y {
public:
    Y(const std::string& n)
    : name{n} {}

    std::string name;
};

std::shared_ptr<Y> func()
{
    return std::make_shared<Y>("new class");
}

int main()
{
    std::shared_ptr<Y> p_class = func();
    std::cout << p_class->name;
    // outputs: "new class"

    return 0;
}

#包括
#包括
#包括
Y类{
公众：
Y（常量标准：：字符串和n）
：name{n}{}
std：：字符串名；
};
std:：shared_ptr func（）
{
返回标准：：使_共享（“新类”）；
}
int main（）
{
std:：shared_ptr p_class=func（）；
std：：cout名称；
//输出：“新类”
返回0；
}

除了我的回答建议的

std:：unique\u ptr

，我想指出的是，从函数返回对象不需要在堆上创建对象。您只需按值返回新对象：

Y func(param)
{
   Y result(param);
   return result;
}

如果

Y

是可复制的，这将（并且一直）起作用。如果类不可复制，它将不起作用，如果它起作用，它可能涉及复制对象

虽然大多数编译器多年来确实消除了该副本，但如果您返回一个未命名的临时对象，现在标准

C++17

强制要求这样做。这意味着，即使您有一个不可复制和不可移动的对象，以下代码也将编译并返回一个新对象：

class Y {
  public:
  Y(int i): value(i) {}
  Y(Y const&) = delete;
  Y(Y&&) = delete;
  Y& operator=(Y const&) = delete;
  Y& operator=(Y&&) = delete;

  int value;
};

Y foo(int i) {
  return Y(i);
}

void bar {
  Y y = foo(42);
}

---

除了我的回答建议

std:：unique_ptr

，我还想指出，从函数返回对象不需要在堆上创建对象。您只需按值返回新对象：

Y func(param)
{
   Y result(param);
   return result;
}

如果

Y

是可复制的，这将（并且一直）起作用。如果类不可复制，它将不起作用，如果它起作用，它可能涉及复制对象

虽然大多数编译器多年来确实消除了该副本，但如果您返回一个未命名的临时对象，现在标准

C++17

强制要求这样做。这意味着，即使您有一个不可复制和不可移动的对象，以下代码也将编译并返回一个新对象：

class Y {
  public:
  Y(int i): value(i) {}
  Y(Y const&) = delete;
  Y(Y&&) = delete;
  Y& operator=(Y const&) = delete;
  Y& operator=(Y&&) = delete;

  int value;
};

Y foo(int i) {
  return Y(i);
}

void bar {
  Y y = foo(42);
}

---

返回的不是本地对象，而是副本。它也是std:：shared\u ptr。使用

std:：make_shared

。将

share_ptr

更改为

shared_ptr

后，它应该可以工作。在这两种情况下，您都不会返回本地对象，在这两种情况下，返回的值都会被复制。第一种方法是复制指针，第二种方法是复制对象。同样，也可能是不相关的，但您不应该将

std:：shared_ptr

和

std:：unique_ptr

视为指针，相反，大多数时候您应该从所有权的角度来看它们。事实上，您不会返回任何内容，因为这甚至不会编译<代码> STD:：SyrdYpPTFUNC（PARAM） >甚至不是有效的C++。但至少要考虑聪明的指针。这比很多人都要多。你不是在返回一个本地对象，而是在返回一个副本。它也是std:：shared\u ptr。使用

std:：make_shared

。将

share_ptr

更改为

shared_ptr

后，它应该可以工作。在这两种情况下，您都不会返回本地对象，在这两种情况下，返回的值都会被复制。第一种方法是复制指针，第二种方法是复制对象。同样，也可能是不相关的，但您不应该将

std:：shared_ptr

和

std:：unique_ptr

视为指针，相反，大多数时候您应该从所有权的角度来看它们。事实上，您不会返回任何内容，因为这甚至不会编译<代码> STD:：SyrdYpPTFUNC（PARAM） >甚至不是有效的C++。但至少要考虑聪明的指针。这比许多人做的还要多。