Question

我有一个结构：

struct myStruct {

    // there are other members as well
    float U, V, W;
}
std::vector <myStruct> myVec;
myVec.resize(num);

我想只将myVec []。U传递给所有myVec用于函数。

Answer 1

将一对迭代器传递给函数：

struct pick_U : std::unary_function<myStruct&, float&> {
    float &operator()(myStruct &ms) const { return ms.U; }
};

your_function(
    boost::make_transform_iterator(myVec.begin(), pick_U()),
    boost::make_transform_iterator(myVec.end(), pick_U()),
    ... other args ...
};

然后your_function可以迭代浮点数。

Answer 2

由于浮点数组需要连续存储，并且向量myVec不会连续存储U，因此需要复制：

std::vector<float> uv;
uv.reserve(myVec.size());

for (auto const & s : myVec) { uv.push_back(s.U); }

// now use uv.data() if your callee needs a float*

在较旧的编译器上，您必须说：

for (std::vector<myStruct>::const_iterator it = myVec.begin(), end = myVec.end(); it != end; ++it)
    uv.push_back(it->U);

您可能还必须说&uv[0]而不是uv.data()来获取指向数组的原始指针。

Answer 3

两个选项：

第一个选项：重新设计，而不是

struct myStruct 
{

    // there are other members as well
    float U, V, W;
}

std::vector <myStruct> myVec;

你有

struct myStructs {

    // there are other members as well
    std::vector<float> Us, Vs, Ws;
}

myStructs allOfMyStructs;

然后你可以简单地传递Us向量。（这也称为面向数据的编程）

第二个选项：将所有U元素复制到一个向量中。

std::vector<float> Us;
for (auto iter = myVec.begin(); iter != myVec.end(); iter++)
   Us.push_back(iter->U);

然后你只需传递Us矢量。

Answer 4

根据您的代码示例和您的解释来判断，您需要这样的内容：

#include <iostream>
#include <vector>
using namespace std;

struct myStruct {
    float u;
};

void foo(float& f) {
    f = 44.1;
}

int main() {
    vector<myStruct> myVec(5, myStruct());
    for (auto& i : myVec) {
        foo(i.u);
    }
    for (const auto& i : myVec) {
        cout << i.u << endl;
    }
}

// g++ -Wall -Wextra test.cc -o test -O3 -s -std=c++0x

例如。

如同你所知，如何将myVec [n] .U传递给函数。

但是，看看你的评论和其他帖子，我不确定。

只将std :: vector的struct成员传递给函数（C ++）

4 个答案: