指向矢量元素的void指针

void pointer to vector elements

本文关键字：void 指针 元素      更新时间：2023-10-16

我想要一个指向向量的void指针。

void *para;
vector<double> x(2);
x[0] = 0;
x[1] = 1;
para = &x;

我现在可以这样使用向量了。

vector<double> k = *(static_cast<vector<double>*>(para));
cout << k[0] << "n";

现在我想通过指针访问向量的元素。我该怎么做？但现在我想直接通过空指针para获得向量x的元素，而不使用新的向量k

double k = ??? // here should be the element of x via para

提前谢谢。

现在我想通过指针访问向量的元素。

这有两个步骤：将指针重新解释为向量，然后访问元素。

我该怎么做？但现在我想直接通过空指针para获得向量x的元素，而不使用新的向量k。

void *para;
vector<double> x(2);
para = &x;
// step 1: reinterpret the pointer as a vector
auto *voidToVector = reinterpret_cast< vector<double>* >(para);
// step 2: access elements
double k = (*voidToVector)[0];

也就是说，请不要将数据作为void*存储在您的应用程序中。每次你这样做，你都可以假设一个开发人员稍后可能会看到它，并在里面死去（那个开发人员甚至可能是你）。

编辑：

对于函数中的计算，我需要访问向量的元素，向量>>accel；有更好的方法吗？？？？

考虑一下：

class FourDimensionalVector
{
public:
    FourDimensionalVector(std::size_t x, std::size_t y, std::size_t z, std::size_t a)
    : d1{x}, d2{y}, d3{z}, d4{a}
    , data{ d1 * d2 * d3 * d4 }
    {
    }
    // ALL access to the vector elements can/should be done through this
    double& operator()(std::size_t x, std::size_t y, std::size_t z, std::size_t a)
    {
        assert(d1 > x); // same for the other dimensions
        return data[x * d1 + y * d2 + z * d3 + a];
    }
    // implement other interface elements here (iteration access, reading the size,
    // resetting the values, etc.
private:
    std::size_t d1, d2, d3, d4;
    std::vector<double> data; // store flattened data
};

这样，您只需将对数据的引用作为参数传递，并根据需要对其进行编辑。我不确定索引逻辑是否正常（代码也不完整），但想法是一样的。

客户代码：

void YourFunction(FourDimensionalVector& fdv)
{
    fdv[2, 3, 4, 0] = fdv[2, 3, 4, 0] + 0.38;
}

该解决方案类型强大、高效且干净（完全避免了铸造和空洞*）。

[Jojia编辑]：但是你的解决方案和这个有什么区别

vector<vector<vector<vector<double>>>> Xaccel;
void initialize(&Xaccel); //This function initializes values for all elements of Xaccel
void myfunction(&Xaccel){
double x = Xaccel[0][0][0][0];
}

我看不出你的解决方案有什么不同。但是：我认为将这些大对象传递给函数myfunction可能是个问题。这是正确的吗？

[edit-by-utnapistim]：从语义的角度来看，它们是相同的：都向函数发送相同的数据，并分配相同的内存（我的解决方案也存储维度，但不管怎样）。

从维护/可重用性/可测试性/模块化的角度来看，它们是完全不同的：我的解决方案抽象了这样一个事实，即你的四维矩阵是一个向量（向量的向量…）。

这将允许您使用4d矩阵接口（您可以实现该接口以满足客户端代码的需求）而不是矢量来编写客户端代码，并允许您根据矩阵定义操作。

例如，vector<vector<vector<double>>>代码可用于创建稀疏/不对称矩阵（外部向量中的第一行比第二行长三倍，依此类推）。矩阵类将通过切断对向量的访问来防止这种情况。

如果您选择保留vector<vector...>解决方案，请至少键入以下内容：

typedef vector<vector<vector<double>>> FourDMatrix;
FourDMatrix Xaccel;
void initialize(FourDMatrix& Xaccel);
void myfunction(FourDMatrix& Xaccel);

在这一行中，您创建了一个副本：

vector<double> k = *(static_cast<vector<double>*>(para));

因此，解决方案之一是使用参考：

vector<double> &k = *(static_cast<vector<double>*>(para));
k[0] = 123;

或指针

vector<double> *pk = static_cast<vector<double>*>(para);
(*pk)[0] = 123; // but usage is more explicit, so reference would be better

我假设你们知道你们在做什么，你们真的需要通过一个void *传递向量。其中一个原因可能是将指向向量的指针作为cookie传递给预期void *的C API。请注意，在c++中使用void *的可能性很低，为了类型安全，应该使用boost::any或boost::variant。

相关文章：