C 避免使用三重指针

C++ Avoiding Triple Pointers

本文关键字：三重 指针      更新时间：2023-10-16

我正在尝试创建一个x指针的数组，将尺寸的矩阵引用y的y y16。是否有任何方法可以在C 中实现这一目标，而无需使用三倍POINTERS？

编辑：为问题添加一些上下文。

屏幕上有许多几何形状，每个几何形状都具有变色为1x16阵列的转换。每个快照代表每个组件数量的转换。因此，矩阵维度为num_snapshots的num_components为16，其中后两个维度在运行时已知。最后，我们有许多几何形状，并采用了运动。

我正在创建一个可以使用三重指针参数的函数，尽管我无法在我的情况下使用三重指针。我还能通过哪些其他方法传递这些数据（可能是通过多个参数）？最糟糕的情况是，我考虑过将整个3D矩阵变平到一个阵列，尽管这似乎是一件马虎的事情。有更好的建议吗？

我现在拥有的：

function(..., double ***snapshot_transforms, ...)

我想完成的工作：

function (..., <1+ non-triple pointer parameters>, ...)

以下不是我要创建的功能，该功能采用三重指针，而是显示数据的全部内容。

static double ***snapshot_transforms_function (int num_snapshots, int num_geometries)
{
    double component_transform[16];
    double ***snapshot_transforms = new double**[num_snapshots];
    for (int i = 0; i < num_snapshots; i++)
    {
        snapshot_transforms[i] = new double*[num_geometries];
        for (int j = 0; j < num_geometries; j++)
        {
            snapshot_transforms[i][j] = new double[16];
            // 4x4 transform put into a 1x16 array with dummy values for each component for each snapshot
            for (int k = 0; k < 16; k++)
                snapshot_transforms[i][j][k] = k;
        }
    }
    return snapshot_transforms;
}

edit2：我不能创建新类，也不能使用诸如std之类的c 功能，因为标题文件中的曝光函数原型已放入包装器中（这不知道如何知道如何解释三重指针）以翻译为其他语言。

edit3：在注释中每个人的输入之后，我认为使用扁平阵列进行的阵列可能是最好的解决方案。我希望可以使用简单的数据类型（包括单个指针）整齐地跨多个数据片来划分这个三重指针，并将这些复杂数据分开。尽管我认为在这里有警告的情况下，我认为没有一种很好的方法。感谢大家的帮助=）

使用 std::vector容易容易，更好，更少的错误。毕竟，您正在使用C ，而不是C。我用vector s代替了所有C风格的阵列指针。Typedef doublecube使得您不必一遍又一遍地键入vector<vector<vector<double>>>。除此之外，代码基本上保持与您所拥有的相同。

如果您实际上不需要虚拟值，我将完全删除该最内向的k循环。reserve将为您保留实际数据所需的内存空间。

#include <vector>
using std::vector; // so we can just call it "vector"
typedef vector<vector<vector<double>>> doublecube;
static doublecube snapshot_transforms_function (int num_snapshots, int num_geometries)
{    
    // I deleted component_transform. It was never used
    doublecube snapshot_transforms;
    snapshot_transforms.reserve(num_snapshots);
    for (int i = 0; i < num_snapshots; i++)
    {
        snapshot_transforms.at(i).reserve(num_geometries);
        for (int j = 0; j < num_geometries; j++)
        {
            snapshot_transforms.at(i).at(j).reserve(16);
            // 4x4 transform put into a 1x16 array with dummy values for each component for each snapshot
            for (int k = 0; k < 16; k++)
                snapshot_transforms.at(i).at(j).at(k) = k;
        }
    }
    return snapshot_transforms;
}

添加一点对象 - 取向通常会使代码更易于管理 - 例如，以下是一些代码，这些代码创建了100 Matrix对象的数组，每个矩阵数量有不同。（如果愿意，您也可以改变每个Matrix的列数，但我在16岁时离开了）：

#include <vector>
#include <memory>  // for shared_ptr (not strictly necessary, but used in main() to avoid unnecessarily copying of Matrix objects)
/** Represents a (numRows x numCols) 2D matrix of doubles */
class Matrix
{
public:
   // constructor
   Matrix(int numRows = 0, int numCols = 0)
      : _numRows(numRows)
      , _numCols(numCols)
   {
      _values.resize(_numRows*_numCols);
      std::fill(_values.begin(), _values.end(), 0.0f);
   }
   // copy constructor
   Matrix(const Matrix & rhs)
      : _numRows(rhs._numRows)
      , _numCols(rhs._numCols)
   {
      _values.resize(_numRows*_numCols);
      std::fill(_values.begin(), _values.end(), 0.0f);
   }
   /** Returns the value at (row/col) */
   double get(int row, int col) const {return _values[(row*_numCols)+col];}
   /** Sets the value at (row/col) to the specified value */
   double set(int row, int col, double val) {return _values[(row*_numCols)+col] = val;}
   /** Assignment operator */
   Matrix & operator = (const Matrix & rhs)
   {
      _numRows = rhs._numRows;
      _numCols = rhs._numCols;
      _values  = rhs._values;
      return *this;
   }
private:
   int _numRows;
   int _numCols;
   std::vector<double> _values;
};
int main(int, char **)
{
   const int numCols = 16;
   std::vector< std::shared_ptr<Matrix> > matrixList;
   for (int i=0; i<100; i++) matrixList.push_back(std::make_shared<Matrix>(i, numCols));
   return 0;
}
相关文章：