为什么可以从函数返回“向量”？

Question

请考虑此代码。我已经多次看到这种类型的代码。 words 是一个局部向量。如何从函数中返回它？

我们能保证它不会死吗？

 std::vector<std::string> read_file(const std::string& path)
 {
    std::ifstream file("E:\\names.txt");

    if (!file.is_open())
    {
        std::cerr << "Unable to open file" << "\n";
        std::exit(-1);
    }

    std::vector<string> words;//this vector will be returned
    std::string token;

    while (std::getline(file, token, ','))
    {
        words.push_back(token);
    }

    return words;
}

Answer 1

C++11 前：

该函数不会返回局部变量，而是返回它的副本。但是，您的编译器可能会在没有进行实际复制操作的情况下执行优化。

更多详情请参阅this question & answer。

C++11：

函数将移动值。详情请见this answer。

Answer 2

我们能保证它不会死吗？

只要没有返回引用，这样做就完全没问题。 words 将被移动到接收结果的变量中。

局部变量将超出范围。在移动（或复制）之后。

Answer 3

我认为您指的是 C（和 C++）中不允许从函数返回数组（或至少不会按预期工作）的问题 - 这是因为数组返回将（如果您写成简单的形式）返回一个指向堆栈上实际数组的指针，然后在函数返回时立即将其删除。

但在这种情况下，它可以工作，因为std::vector 是一个类，并且类，如结构，可以（并且将）复制到调用者上下文中。 [实际上，大多数编译器将使用称为“返回值优化”的东西来优化这种特定类型的副本，专门引入以避免在从函数返回时复制大对象，但这是一种优化，从程序员的角度来看，它将表现得好像为对象调用了赋值构造函数]

只要你不返回一个指针或对函数返回的东西的引用，你就可以了。

Answer 4

为了更好地理解行为，您可以运行以下代码：

#include <iostream>

class MyClass
{
  public:
    MyClass() { std::cout << "run constructor MyClass::MyClass()" << std::endl; }
    ~MyClass() { std::cout << "run destructor MyClass::~MyClass()" << std::endl; }
    MyClass(const MyClass& x) { std::cout << "run copy constructor MyClass::MyClass(const MyClass&)" << std::endl; }
    MyClass& operator = (const MyClass& x) { std::cout << "run assignation MyClass::operator=(const MyClass&)" << std::endl; }
};

MyClass my_function()
{
  std::cout << "run my_function()" << std::endl;
  MyClass a;
  std::cout << "my_function is going to return a..." << std::endl;
  return a;
}

int main(int argc, char** argv)
{
  MyClass b = my_function();

  MyClass c;
  c = my_function();

  return 0;
}

输出如下：

run my_function()
run constructor MyClass::MyClass()
my_function is going to return a...
run constructor MyClass::MyClass()
run my_function()
run constructor MyClass::MyClass()
my_function is going to return a...
run assignation MyClass::operator=(const MyClass&)
run destructor MyClass::~MyClass()
run destructor MyClass::~MyClass()
run destructor MyClass::~MyClass()

请注意，此示例是在 C++03 上下文中提供的，它可以针对 C++ >= 11 进行改进

Answer 5

我不同意并且不推荐返回vector：

vector <double> vectorial(vector <double> a, vector <double> b)
{
    vector <double> c{ a[1] * b[2] - b[1] * a[2], -a[0] * b[2] + b[0] * a[2], a[0] * b[1] - b[0] * a[1] };
    return c;
}

这要快得多：

void vectorial(vector <double> a, vector <double> b, vector <double> &c)
{
    c[0] = a[1] * b[2] - b[1] * a[2]; c[1] = -a[0] * b[2] + b[0] * a[2]; c[2] = a[0] * b[1] - b[0] * a[1];
}

我在 Visual Studio 2017 上进行了测试，在发布模式下得到以下结果：

8.01 参考文献
5.09 MOPs 返回向量

在调试模式下，情况更糟：

0.053 MOPS 参考
返回向量 0.034 MOPs

Answer 6

这实际上是设计的失败。您不应该将返回值用于任何不是相对微不足道的东西的原始值。

理想的解决方案应该通过返回参数来实现，该参数决定引用/指针并正确使用“const\'y\'ness”作为描述符。

除此之外，您应该意识到 C 和 C++ 中数组上的标签实际上是一个指针，它的订阅实际上是一个偏移量或加法符号。

因此返回 foo[offset] 的标签或 ptr array_ptr === 数组标签实际上是在内存指针位置 foo + 类型返回类型的偏移量处返回元素。