C++ 当返回类型为类时，什么'；返回值指针的名称是什么？

例如：

---

---

在汇编级别，编译时，函数

A:：func

实际上有两个参数：第一个是

this

指针，第二个是调用方创建的用于存储返回值的temp

A

对象的地址

例如，如果我们编写

a.func（）

，程序将在堆栈中创建一个temp

a

对象（我们称之为

t

），并将

a

的地址作为第一个参数传递，将

t

的地址作为第二个参数传递，最后调用函数

func

这里是我的问题：在

A:：func

的实现中，我们可以得到

A

的地址-它是这个

的指针；但是我们有办法得到
t
的地址吗？它叫什么名字

例如，如果我想在返回结果之前执行一些内存alloc/free操作，那么使用它将非常有用

下面是我想做的一个例子：

class A
{
    int * data;
    A func();
};

A A::func()
{
    // here "ret_p" is the pointer to the return value (let's pretend that it exists)  
    ret_p->data = new int[some length];  
    ...  
    return * ret_p;  
}

当然，我可以在
a:：func
中创建一个本地对象，然后返回它；但是程序会在我的本地对象和调用者创建的临时对象之间进行复制。由于调用方已经创建了一个临时对象，我希望直接使用它可以节省时间和空间。可能吗

这可能是C++的，但是我仍然希望…
 < P>代码< >代码> >代码> FUNC>代码>是.< /P>的一种形式。
根本不保证会发生，也没有C++级访问实现。
当你说“我想在返回结果之前做一些内存分配/释放”时，我认为你自己的头脑不清楚，你能举一个具体的例子吗？可能您所需要的一切都可以通过复制省略、移动运算符和RAII实现

根据你的例子，这里是你应该如何做的

class A
{
    std :: vector <int> data;
    A func();
};

A A::func()
{
    A ret;
    ret .data .assign (some_length, 123); // or whatever;
    return ret;
}

std:：vector
的移动构造函数将简单地复制指针。如果你想知道它是如何工作的，那么这里有一个国产的等价物

class A
{
    int * data;

    // Allocate
    A (size_t size) : data (new int [size]) {}

    // Free, only if we haven't moved.
    ~ A () {if (data) delete [] data;}

    // Move
    A (A && old) : data (old .data) {old .data = nullptr;}

    A (const A &) = delete; // or implement with a new allocation.
}

堆栈中没有这样的temp
a
对象参数（
t
）

如果调用
aa1=A.func（）
和
返回某物
内部，将调用
复制构造函数
，相当于此
a1（某物）。
a1
和
something
是不同的实例

如果你
a1；a1=a.func（）
和
返回某物内部，
a1=something；//（operator=）
将被调用。
a1
和
something
是不同的实例

如果调用
aa1=A.func（）和
返回A（p1）内部，这相当于
a1（p1），有一个实例
a1

如果调用
a.func（）而不指定var，并
返回某些内容内部，返回时不会发生任何事情

如果调用
a.func（）而不分配给var，并
返回a（p1）内部，将构造一个临时对象，然后立即销毁

如果你
a1；a1=a.func（）和
返回A（p1）内部，将构造一个临时对象，然后将调用操作符=调用
a1=temp对象，然后临时对象将被销毁

供你参考

毕竟，
aa1=A.func（）
或
aa1；a1=a.func（）
，
返回某物；//var
或
返回a（p1）；//调用构造函数将导致不同的行为，我认为您可以正确控制内存。
不，没有这样的事情。实现甚至不需要按照您描述的方式处理返回值。呃，这就是复制构造函数的用途。使用它。我在帖子中添加了一个例子。谢谢你的详细回答。我终于找到了最简单的优化方法：将对象作为引用返回
A&func（）
工作正常，调用方不再创建临时对象，现在由被调用方负责。优化后，我们得到了预期的正确副本省略。否。如果返回值，则返回引用时可能会遇到麻烦。它总是更安全，有时更高效。相信编译器，我完全理解你的建议，因为通常返回的引用将是被调用方的某个局部变量的引用，该变量位于堆栈中，如果调用其他函数，它将被销毁。这就是为什么调用方总是创建一个对象来保存结果。但在我的例子中，通过总是返回堆中创建的对象，我可以很好地控制一切——这节省了堆栈空间（以及复制时间）。在做出这样的声明之前，你需要分析你的代码。堆分配比堆栈分配要昂贵得多。当我检查反汇编代码时，不会发生这种情况。我应该提到，我正在使用Microsoft Visual Studio 2010。我很确定调用方在堆栈中为本地
对象留出了空间，并使用它来存储返回值-至少在“调试”模式下是这样。在“release”模式下，由于优化，该步骤有时会被跳过，但对于复杂的代码，临时对象仍然存在于堆栈中。你的其他描述是正确的。
A :: A (A && old)
: data (std :: move (old .data))
{
}

class A
{
    int * data;

    // Allocate
    A (size_t size) : data (new int [size]) {}

    // Free, only if we haven't moved.
    ~ A () {if (data) delete [] data;}

    // Move
    A (A && old) : data (old .data) {old .data = nullptr;}

    A (const A &) = delete; // or implement with a new allocation.
}