从向量返回底层数组

Question

阵列是否会被释放,如果是,那么解决方法是什么？

double * GetArrayFromVector( std::map<std::string, double> m, char ** names, int count )
{ 
    if(!names) return 0;

    std::vector<double> vec(m.size());
    for (int i=0; i<count; ++i)
    { 
       if(!names[i]) return 0;
       std::map<std::string, double>::iterator iter=m.find(name[i]);
       if(iter!=m.end())
          vec.push_back(iter->second);
       else
         return 0;   
    }

    return &vec[0]; 
}

非常感谢

Answer 1

是的 - 一旦你从函数返回它就会被释放,因为它vec是在堆栈上声明的.在std::vector析构函数需要释放内存的照顾.因为你正在返回一个解除分配的数组的地址,你将开始搞乱释放内存,这是一个很大的禁忌.充其量,你会立即崩溃.在最糟糕的情况下,你会默默地成功解决一个巨大的安全漏洞.

有两种方法可以解决这个问题:(1)返回整个向量by-value,它生成整个向量的副本,或者(2)通过引用参数返回向量.

解决方案1:

std::vector<double> GetArrayFromVector(...)
{
    ...
    return vec;  // make copy of entire vec, probably not a good idea
}

解决方案2:

void GetArrayFromVector(..., std::vector<double> & vec)
{
    // compute result, store it in vec
}

Answer 2

将你的功能分成两部分.让你的函数只做一个动作:
1.从地图填充矢量.
2.从vector创建数组.
不要忘记通过const引用传递map.

主要注意事项:GetArrayFromVector的调用者负责内存释放.

void FillVector( const std::map<std::string, double>& m, 
                  std::vector< double >& v, 
                  char ** names, 
                  int count )
 {
       .......
 }

 double* createArray( const std::vector< double >& v )
 {
     double* result = new double [v.size()];

     memcpy( result, &v.front(), v.size() * sizeof( double ) );

     return result; 
 }  

 // and finally your function

 double* GetArrayFromVector( const std::map<std::string, double>& m,  
                             char ** names, 
                             int count )
 {
      std::vector< double > v;
      FillVector( m, v, names, count );

      return CreateArray( v );
 }