如何在函数内部创建对象并将其返回给main（）而不使用析构函数在c ++中将其删除？

Question

我有这个课：

class foo{

public:
    foo();
    foo(const int& var);
    foo(const foo& var);
    ~foo();

    foo retSumOf(const foo& var1, const foo& var2);

private:
    int a;
    char* x;

};

这个功能：

foo foo::retSumOf(const foo& var1, const foo& var2){

    //Make somehow a foo object,
    //lets name it 'result'

    result.a = var1.a + var2.a;

    return (result);
}

我主要要这样做：

main(){

    foo a, b;
    foo* c;

    a.a = 1;
    b.a = 2;

    c = retSumOf(a, b);

    cout << "sum =" << c->a;

}

无需调用（重载）副本构造函数！

在C ++中，有没有一种方法可以通过函数动态创建对象并返回其地址？ 如果没有构造函数在调用retSumOf（）结束时将其删除？

Answer 1

为什么？

是的，您可以像杰里米所说的那样返回一个（智能）指针，但是为什么要这么做呢？ 为什么不正确地实现复制和移动功能呢？ 您已经有一个构造函数； 按照五个规则，无论如何，您都应该实现其他四个功能，或者取消它们。

Answer 2

修改功能，如下所示：

foo* foo::retSumOf(const foo& var1, const foo& var2){

    //Make somehow a foo object,
    //lets name it 'result'
    foo* result = new foo();

    result->a = var1.a + var2.a;

    return (result);
}

Answer 3

首先有两种方法：

您可以将返回值用作参数：

void foo::computeSumOf(foo & result, const foo& var1, const foo& var2) ...

另一种方法是利用RVO优化

foo foo::retSumOf(const foo& var1, const foo& var2)
{
    return foo(var1.a + var2.a);
}
//...
foo x = someFoo.retuSomOf(a,b);

第三（如果可以使用c ++ 11），可以使用write move构造函数和赋值来避免复制构造函数。 通过这样做，您可以优化不必要的成员副本，并将内存从一个实例“移动”到另一个实例。 您可以在此处找到更多信息。

class foo{
public:
    foo(foo && rValue) { ... };
    foo& operator = (foo && rValue) { ... };
    ...
};
foo foo::retSumOf(const foo& var1, const foo& var2){
    foo result;
    //same code
    return result;
}

最后，您可以使用shared_ptr或其他智能指针（例如intrusive_ptr ）

std::shared_ptr<foo> foo::retSumOf(const foo& var1, const foo& var2){
    std::shared_ptr<foo> result = new foo;
    result->a = ...
    return result;
}

Answer 4

您可以将其声明为静态的：

static myClass objName;

或使用新的（首选）：

myClass* objName = new myClass;    
return objName

如果使用第二种方法，则需要修改函数以返回指针而不是对象。

Answer 5

您可以从函数返回值作为对foo的引用，并将其保存在const foo& 。 const-reference将foo实例的寿命延长到变量的寿命。

foo& foo::retSumOf(const foo& var1, const foo& var2)
...
const foo& c = retSumOf(a, b);

编辑

原来这不起作用： http : //ideone.com/WM3bIe

Answer 6

做这个

class foo
{
    ...
    friend foo retSumOf(const foo& var1, const foo& var2);
    ...
};

foo retSumOf(const foo& var1, const foo& var2);
{
    foo result;
    result.a = var1.a + var2.a;

    return (result);
}

并启用编译器优化 。 由于函数中只有一个return语句，并且result是局部的，因此编译器将在堆栈中代替返回值创建它，从而避免了复制。

不用担心。 （是的，无需调用“移动”）。

如果您想要一种更“实用”的方法，请给foo一个定义成员值并按需使用的构造函数：

class foo
{
  // you existing code andd ...

  foo(int i, const char* s) :a(i), x(s) 
  {}
};

这样你就可以

foo retSumOf(const foo& var1, const foo& var2)
{  return foo(var1.a + var1.b, nullptr); }

甚至有意义，您可以将retSumOf命名retSumOf operator+并让c = a+b ；

无论如何，请避免将c用作裸指针：永远不清楚谁必须删除接收到的对象。 它只需要是一个值。

永远不要使用char *作为成员：不清楚赋值或复制后是谁拥有数据。 使用std::string代替。

Answer 7

不知道我的答案是否正确，但是它似乎一直对我有效：

#include <iostream>

class Foo
{
    public:
        Foo() {std::cout<<"HEY!";}
        ~Foo() {}
};


Foo&& GetFoo()
{
    return std::move(Foo());
}


int main()
{
    GetFoo();
    return 0;
}

我通常只是移动在函数中创建的对象。.以便尽可能避免使用指针。.否则，我将使用Smart指针，但是上面是我通常所做的。