C++ 使用C+中的指针返回2D向量+；

全部

我使用2D向量将结果从函数返回到main。2D向量非常大，函数执行了10K+次，因此我必须使用指针返回它以加快速度

这是我的密码：

vector<vector<double>>* someFunction()
{
    vector<vector<double>> results;
    //do something...
    return &results;
}

vector*someFunction（）
{
矢量结果；
//做点什么。。。
回报与结果；
}

总的来说：

int main()
{
    // do something
    ////////// EDIT: vec is a pointer, I missed * at first place
    vector<vector<double>>* vec = someFunction();    // vec is empty!

    cout<<vec.size();        // size = 0

    return;
}

intmain（）
{
//做点什么
//////////编辑：vec是一个指针，我第一次错过了*
vector*vec=someFunction（）；//vec为空！
cout您正在返回一个指向局部变量的指针。退出函数作用域时，该变量将不再存在，留下一个悬空指针。这是未定义的行为

只需返回一个值：

vector<vector<double>> someFunction()
{
    vector<vector<double>> results;
    //do something...
    return results;
}

vector someFunction（）
{
矢量结果；
//做点什么。。。
返回结果；
}

如果您担心按值返回所涉及的昂贵拷贝，请记住，这些拷贝极有可能通过（RVO）被省略，具体称为返回值优化（NRVO）。即使没有发生这种情况（这是可选的，因此实现可以决定不这样做），在C++11中，移动语义会起作用。移动
std:：vector
非常便宜。
您将返回一个指向局部变量的指针。退出函数作用域时，该变量将不存在，留下一个悬空指针。这是未定义的行为

只需返回一个值：

vector<vector<double>> someFunction()
{
    vector<vector<double>> results;
    //do something...
    return results;
}

vector someFunction（）
{
矢量结果；
//做点什么。。。
返回结果；
}

如果您担心按值返回所涉及的昂贵拷贝，请记住，这些拷贝极有可能通过（RVO）被省略，具体称为返回值优化（NRVO）。即使没有发生这种情况（这是可选的，因此实现可以决定不这样做），在C++11中，移动语义会起作用。移动
std:：vector
非常便宜。
是否在此处不返回对局部变量的引用，因此超出范围？假设它在类中，则将其作为类的成员

或者，将引用作为参数传递到函数中

void someFunction(vector<vector<double>>& results)
{
    results.clear();

    //do something...
}    

void函数（向量和结果）
{
结果：清晰（）；
//做点什么。。。
}    
您是否在此处不返回对局部变量的引用，从而超出范围？假设它在类中，则将其作为类的成员

或者，将引用作为参数传递到函数中

void someFunction(vector<vector<double>>& results)
{
    results.clear();

    //do something...
}    

void函数（向量和结果）
{
结果：清晰（）；
//做点什么。。。
}    
返回指向向量的指针。删除方法中的*：

vector<vector<double>> someFunction()

vector someFunction（）

当然，返回向量，而不是指向它的指针
您返回指向向量的指针。删除方法中的*：

vector<vector<double>> someFunction()

vector someFunction（）

当然，返回向量，而不是指向它的指针。似乎已经有了一个流行的答案，但是有一种方法可以完全按照你的要求使用动态内存分配。我觉得这是值得指出的，因为，虽然它可能不是解决这个特定问题的最佳方法，但动态内存分配是一种非常有用的方法一般来说，这是一种非常有用的技术。其思想是“某些函数”应该创建一个指向动态分配的内存块的指针，该内存块将保存
向量
。以下是使用智能指针的工作代码，但如果c++11不是您的专长，您也可以使用传统的
new
和
delete
关键字进行分配：

#include <memory>
#include <vector>

using namespace std;

shared_ptr<vector<vector<double>>> someFunction() {
  vector<vector<double>> result;
  //Do stuff with result                                                                        
  shared_ptr<vector<vector<double>>> resultPtr =
    make_shared<vector<vector<double>>>(result);
  return resultPtr;
}

int main() {
  shared_ptr<vector<vector<double>>> ptr;
  ptr = someFunction();
  return 0;
}

#包括
#包括
使用名称空间std；
共享函数（）{
矢量结果；
//用结果做事
共享\u ptr resultPtr=
使_共享（结果）；
返回结果tr；
}
int main（）{
共享ptr；
ptr=someFunction（）；
返回0；
}

正如我所说，这可能不是最好的方法，但要知道，使用动态内存分配确实可以正确地返回指向本地对象的指针。
似乎已经有了一个流行的答案，但有一种方法可以完全按照您的要求使用动态内存分配。我觉得这是值得指出的，因为，虽然这可能不是解决这个特殊问题的最佳方法，但动态内存分配通常是一种非常有用的技术应该创建一个指向动态分配的内存块的指针，该内存块将保存
向量
。以下是使用智能指针的工作代码，但如果c++11不是您的专长，您也可以使用传统的
new
和
delete
关键字进行分配：

#include <memory>
#include <vector>

using namespace std;

shared_ptr<vector<vector<double>>> someFunction() {
  vector<vector<double>> result;
  //Do stuff with result                                                                        
  shared_ptr<vector<vector<double>>> resultPtr =
    make_shared<vector<vector<double>>>(result);
  return resultPtr;
}

int main() {
  shared_ptr<vector<vector<double>>> ptr;
  ptr = someFunction();
  return 0;
}

#包括
#包括
使用名称空间std；
共享函数（）{
矢量结果；
//用结果做事
共享\u ptr resultPtr=
使_共享（结果）；
返回结果tr；
}
int main（）{
共享ptr；
ptr=someFunction（）；
返回0；
}

正如我所说，这可能不是最好的方法，但要知道，使用动态内存分配确实可以正确地返回指向本地对象的指针。
1.它是否编译？2.RVO可能会删除副本，因此您可以通过value@Andrew是的，它可以编译，但是当执行它时，因为我需要将结果写入文件，它会触发一些断点。永远不要返回指向局部变量的指针！在C++11中，您可以使用移动语义！您可以向函数1添加引用参数。它是否编译？2.RVO可能会删除副本，因此您可以通过value@Andrew是的，它可以编译，但是当执行它时，因为我需要将结果写入文件，所以触发一些断点。永远不要返回指向局部变量的指针！在C++11中，可以使用移动语义！可以向函数添加引用参数