c++ - 问一个关于 eigen library with raw buffer 的问题

Question

最近我在使用 eigen 库，我发现了这个关于原始缓冲区操作的问题。

在下面的代码中，我创建了两个 9 个整数的原始缓冲区作为输入和输出。之后，我使用两个特征矩阵 in/out 通过放置新方法和特征映射来包装这两个缓冲区。然后我调用了一个简单的转置操作。然而，调用转置操作的不同方式将导致完全不同的原始缓冲区结果。如果我直接调用代码 1 中所示的 Eigen 转置函数，结果矩阵和相应的原始缓冲区的结果都是完全正确的。但是，当我将转置操作包装在一个返回特征矩阵的自定义函数中时，如代码 2 所示，问题就出现了。事实证明，只有结果矩阵是好的，但原始缓冲区似乎已损坏。有人知道这个问题吗？这是 Eigen 的错误吗？

代码1

#include <iostream>
#include <Eigen/Dense>
#include <Eigen/Dense>

using Eigen::MatrixXi;                                                          


int main() {                                                                    
  int *in;                                                                      
  in = new int[9];                                                              
  for (int i = 0; i < 9; i++)                                                   
    in[i] = i;                                                                  

  int *out;                                                                     
  out = new int[9];                                                             
  for (int i = 0; i < 9; i++)                                                   
    out[i] = 0;                                                                 

  MatrixXi m_in;                                                                
  m_in.resize(3, 3);                                                            
  new (&m_in) Eigen::Map<MatrixXi>(in, 3, 3);                                   

  MatrixXi m_out;                                                               
  m_out.resize(3, 3);                                                           
  new (&m_out) Eigen::Map<MatrixXi>(out, 3, 3);                                 

  m_out = m_in.transpose();                                                     
  std::cout << m_out << std::endl;                                              
  std::cout << "------------" << std::endl;                                     
  for (int i = 0; i < 9; i++)                                                   
    std::cout << out[i] << std::endl;                                           

  return 0;                                                                     
}

代码1的结果:

0 1 2
3 4 5
6 7 8
------------
0
3
6
1
4
7
2
5
8

代码2

#include <iostream>
#include <Eigen/Dense>
#include <Eigen/Dense>

using Eigen::MatrixXi;                                                          

MatrixXi MyTranspose(const MatrixXi &in) {                                      
  return in.transpose();                                                        
}                                                                               

int main() {                                                                    
  int *in;                                                                      
  in = new int[9];                                                              
  for (int i = 0; i < 9; i++)                                                   
    in[i] = i;                                                                  

  int *out;                                                                     
  out = new int[9];                                                             
  for (int i = 0; i < 9; i++)                                                   
    out[i] = 0;                                                                 

  MatrixXi m_in;                                                                
  m_in.resize(3, 3);                                                            
  new (&m_in) Eigen::Map<MatrixXi>(in, 3, 3);                                   

  MatrixXi m_out;                                                               
  m_out.resize(3, 3);                                                           
  new (&m_out) Eigen::Map<MatrixXi>(out, 3, 3);                                 

  m_out = MyTranspose(m_in);                                                     
  std::cout << m_out << std::endl;                                              
  std::cout << "------------" << std::endl;                                     
  for (int i = 0; i < 9; i++)                                                   
    std::cout << out[i] << std::endl;                                           

  return 0;                                                                     
}

代码2的结果:

0 1 2
3 4 5
6 7 8
------------
1028430744
32644
1028430744
32644
0
0
0
0
48

Answer 1

您正在用另一个不同类型的对象覆盖一个对象。 m_in正在被 Eigen::Map<MatrixXi>(in, 3, 3) 的内容覆盖因为它是 placement new 的目标。 m_in不是 in 的所有者缓冲区和假设它是的后续操作将破坏堆。

MatrixXi m_in;                                                                
m_in.resize(3, 3);                                                            
new (&m_in) Eigen::Map<MatrixXi>(in, 3, 3);   

将这 3 行(以及 m_out 的类似行)替换为:

Eigen::Map<MatrixXi> m_in(in, 3, 3);

这不会从堆中分配任何额外的内存，而是利用之前分配的 in[]和 out[] .

另一个问题是in[]和 out[]没有被删除。这无关紧要，因为程序无论如何都会退出，但不鼓励容易发生内存泄漏的编程风格。