C++：return std::vector<> 成员，通过引用指向一个临时对象

Question

我有两个功能。

function1 调用 function2，它 returns 对对象的引用，然后我用它来调用 public 函数。

function1(function2).returned_object.mymethod();

这是一种相当笨拙的做事方式，但它确实有效。

现在我有一个问题，我需要调用一个方法，然后调用另一个方法，所以我需要一个临时对象。

ClassName temp_obj = function1(function2);

temp_obj.method1();
temp_obj.method2();

我的问题是，我如何声明一个临时对象来存储 returns 引用的对象。我猜我需要一个指针。

另一个问题是，temp_obj 包含在一个向量中，我担心那里有冲突和内存泄漏。如果我使用指针，那么我是否也必须使用析构函数？

相关代码如下：

bool Machine::perform_function(std::vector<Job>& jobs) {
    bool add = true;

    if (can_fail) {
        add = coin_toss();

    }

    for (int i = 0; i < my_jobs.size(); i++) {

        if (add) {
            find_job(my_jobs[i], jobs).toggle(name, item_name, true);

        }
        if (!add) {
            find_job(my_jobs[i], jobs).toggle(name, item_name, false);

        }
    }

    return add;
}


Job& Machine::find_job(std::string jobname, std::vector<Job>& jobs) {

    for (int i = 0; i < jobs.size(); i++) {

        if (jobs[i].is_job(jobname)) {
            return jobs[i];

        }
    }
}

Answer 1

把结果存起来作为参考就好了：

ClassName & temp_obj = function1(function2);
temp_obj.method1();
temp_obj.method2();

您的其他问题：

The other problem is, temp_obj is contained in a vector, and I'm concerned about conflicts there and memory leakage.

可以returnjobs[i]作为参考。向量 return 上的 operator[] 本身就是一个引用。只要您不以更改该引用指向的方式修改向量，并且您没有存储对已销毁对象的引用，您就可以使用它。

当您的临时引用超出范围时，什么也不会发生。仅供参考。

Answer 2

您需要一个临时变量，但该临时变量可能是一个引用，因此不会进行任何复制，您可以安全地使用它。

但更好的是，您可以使用 <algorithm> 函数来完成您需要的工作，而无需重新发明轮子：

std::string name = ...;
auto it = std::find_if(begin(jobs), end(jobs), [&name] (const Job& job) { return job.is_job(name); });

if (it != jobs.end())
{
  it->method1();
  it->method2();
}

Answer 3

你的问题不清楚。但是如果你想创建一个指向函数或成员函数的指针，这里有关于此类变量的常见问题解答。

https://isocpp.org/wiki/faq/pointers-to-members#fnptr-vs-memfnptr-types

Answer 4

假设 function1() 是 returns 一个参考（你的问题对此不清楚），只需使用参考

 ClassName &temp_obj = function1(function2);

 temp_obj.method1();
 temp_obj.method2();

如果function1() returns一个const引用，那么temp也需要const.

这样做的局限性在于，一旦创建，就无法重新设置引用（用来引用不同的对象）。例如，在 ;

 ClassName &temp_obj = function1(function2);    // initialisation

 temp_obj = function1(some_other_function);     // reassignment
 temp_obj.method1();
 temp_obj.method2();

重新分配不会重新设置 temp，即使 function1() returns 第二次调用的引用不同。相反，被引用的对象将被赋值（假设它有一个有效的赋值运算符）。如果你想要一个可以随时间引用不同对象的变量，你需要一个指针。

 ClassName *temp_obj = &function1(function2);    // assumes function1() returns a reference

 temp_obj = &function1(some_other_function);      //  reassigns the pointer

 temp_obj->method1();
 temp_obj->method2();

C++：return std::vector<> 成员，通过引用指向一个临时对象

C++: return a std::vector<> member, by reference, to a temporary object

c++

memory-management

pass-by-reference

stdvector

temporary-objects