Question

我想要一个指向矢量的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";

现在我想通过指针访问向量的元素。我怎样才能做到这一点？但是现在我想直接通过void指针para得到向量x的元素，而不使用新的向量k。像这样：

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

提前感谢。

Answer 1

在此行中，您可以创建一个副本：

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 *传递矢量。其中一个原因可能是将指向vector的指针作为Cookie传递给期望void *的C API。请注意，在c ++本身中使用void *的理由很少，您应该使用boost::any或boost::variant来确保类型安全。

Answer 2

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

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

我该怎么做？但是现在我想直接通过void指针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*。每次你这样做，你都可以假设一个开发人员可能会在以后看到它并在内部死掉（而开发人员甚至可能是你）。

编辑：

对于函数中的计算，我需要访问向量的元素，向量＆gt;＆gt;＆gt;加速度;还有更好的方法????

考虑一下：

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可能是个问题。这是对的吗？

[utnapistim编辑] ：从语义的角度来看，它们是相同的：都将相同的数据发送到函数并分配相同的内存（我的解决方案也存储维度，但无论如何）。

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

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

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

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

typedef vector<vector<vector<double>>> FourDMatrix;

FourDMatrix Xaccel;

void initialize(FourDMatrix& Xaccel);
void myfunction(FourDMatrix& Xaccel);

void指向矢量元素的指针

2 个答案: