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;
}

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

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;
}