C++ 返回 MyClass* 与 MyClass

Question

我正在创建一个模板类，我需要一个返回该类的对象并分配它的方法。我有一种方法，它接受 2 个对象、创建一个新对象并返回它，以及赋值运算符的重载以正确复制成员。

我尝试过两种方法(两种方法都是静态的)。

方法 1:可行，但这不是不好的做法吗？

template <class T>
MyClass<T>* MyClass<T>::MyFunction(const MyClass& a, const MyClass& b)
{
    MyClass<T> *newObject= new MyClass<T>(a.member, b.member2);

    //...do stuff to the object

    return newObject;
}

方法2:行不通，但这不是更好的思路吗？

template <class T>
MyClass<T> MyClass<T>::MyFunction(const MyClass& a, const MyClass& b)
{
    MyClass<T> newObject(a.member, b.member2);

    //...do stuff to the object

    return newObject;
}

我对方法 1 的担心是我在堆中创建了一个新对象并且从未销毁它。我将其所有成员分配给 MyClass 的另一个实例，但是如果我第二次执行该操作，第一个实例会发生什么情况？我在堆栈上创建的第一个"new"对象是否就在那里？

方法 2 的问题是，在调用赋值操作重载之前，对象超出了范围。我研究了复制构造函数和移动构造函数。不幸的是，我没有看到在这种情况下被召唤的人(可能这里严重缺乏经验)。

为了完成，这里是相关代码的其余部分。

template <class T>
void MyClass<T>::operator = (const MyClass& b)
{
    if (this == &b) { return; }

    DeleteData();
    //just calls the same member removal operation as the destructor
    //to clear everything out to receive new data

    //...simple member copying stuff
}

template<class T>
inline void MyClass<T>::DeleteData()
{
    //call delete on members which need to be deleted manually
}

template <class T>
MyClass<T>::~MyClass()
{
    DeleteData();
}

template <class T>
MyClass<T>::MyClass(const T member, const T member2)
{
    //member initialization operations
}

使用示例:

MyClass<T> myObj1(member1, member 2);

MyClass<T> myObj2(member1, member 2);

MyClass<T> myObj3 = *(MyClass<T>::MyFunction(myObj1, myObj2));

TL;DR 问题:

当在函数内部使用new返回class*而不是class时，创建的对象在不再有任何对象时会被销毁引用文献？

如果不是，返回在方法中创建的对象的最佳实践是什么？

如果是这样，这种方法是不是一种不好的做法？

如果之前已经回答过这个问题，我深表歉意，我对 C++ 还很陌生，我之前的研究没有给我带来满意的答案，可能是因为我不知道我不知道什么。

已实现的解决方案: (我还添加了一个复制构造函数。没有它，这个解决方案仍然适用于问题的范围，但是有一些超出这个问题范围的项目被修复了。希望将来有人会发现这个信息有用)

//this is a static function of MyClass
template <class T>
std::unique_ptr<MyClass<T>> MyClass<T>::MyFunction(const MyClass& a, const MyClass& b)
{
    std::unique_ptr<MyClass<T>> newObj = std::make_unique<MyClass<T>>(a.member, b.member2);

    //...Be the factory...

    return newObj ;
}

int main()
{
    MyClass<T> myObj1(member1, member 2);

    MyClass<T> myObj2(member1, member 2);

    MyClass<T> myObj3 = *(MyClass<T>::MyFunction(myObj1, myObj2));
}

Answer 1

When using new inside a function to return a class* instead of a class is the created object destroyed when it no longer has any references?

事实并非如此。传递给 new 的任何内容都必须显式删除，或者传递给拥有其所有权的容器(例如 unique_ptr)。

If so, is this method a bad practice?

这取决于情况，但通常情况下，是的，一般不鼓励返回和处理原始指针，因为它很容易出现内存泄漏。您上面的代码确实泄漏了(正如您所描述的)。

If not, what is the best practice to return an object that is created in a method?

这要看情况。如果您不介意复制，或者您的对象已定义移动语义，则可以像方法 2 中那样返回一个具体对象，并希望编译器执行 return value optimization .

如果您介意复制，请考虑returning a smart pointer某种形式:

template <class T>
std::unique_ptr<MyClass<T>> MyClass<T>::MyFunction(const MyClass& a, const MyClass& b)
{
  auto newObject = std::unique_ptr<MyClass<T> {new MyClass<T>(a.member, b.member2)};
  //...do stuff to the object
  return newObject;
}