C++ 从对象向量中获取成员向量

我有以下设置

class obj {
  public:
  int a();
  int b();
  int c();
  int d();
};

std::vector<obj> obj_vector;
//Fill obj_vector

类obj{
公众：
int a（）；
int b（）；
int c（）；
int d（）；
};
std：：向量obj_向量；
//填充对象向量

我想访问这些方法（这是一个需要int向量的接口）

void func（向量a、向量b、向量c、向量d）；

我最初认为扩展向量是最好的方法，但已经被警告不要这样做

我已经实现了

get_a_vec(vector<obj>);

get_a_vec（向量）；

等等，但这有点笨拙。有什么好的选择吗

---

提前谢谢

我的理解是，您需要一个函数，该函数从给定的

向量中的
obj
s中提取
a
的值，并将其放入另一个
向量中，如果这是真的，那么我建议使用
friend
函数

在类
obj
中声明友元函数允许此函数访问该类的
private
数据成员

class obj {
    friend vector<int> get_a_vec(const vector<obj>&);
    friend vector<int> get_b_vec(const vector<obj>&);
    friend vector<int> get_c_vec(const vector<obj>&);
    friend vector<int> get_d_vec(const vector<obj>&);     
    int a;
    int b;
    int c;
    int d;
};

vector<int> get_a_vec(const vector<obj>& vec)
{
    vector<int> result(vec.size());
    for (unsigned i = 0;i<vec.size();i++)
        result->at(i) = vec[i].a;
    return result;
}

类obj{
友元向量get_a_vec（const vector&）；
友元向量get_b_vec（const vector&）；
友元向量get_c_vec（const vector&）；
友元向量get_d_vec（const vector&）；
INTA；
int b；
INTC；
int d；
};
向量获取向量（常量向量和向量）
{
向量结果（vec.size（））；
对于（无符号i=0；iat（i）=vec[i].a；
返回结果；
}
我的理解是，您需要一个函数，从给定的
向量
中的
obj
s中提取
a
的值，并将其放入另一个
向量
，如果这是真的，那么我建议使用
friend
函数

在类
obj
中声明友元函数允许此函数访问该类的
private
数据成员

class obj {
    friend vector<int> get_a_vec(const vector<obj>&);
    friend vector<int> get_b_vec(const vector<obj>&);
    friend vector<int> get_c_vec(const vector<obj>&);
    friend vector<int> get_d_vec(const vector<obj>&);     
    int a;
    int b;
    int c;
    int d;
};

vector<int> get_a_vec(const vector<obj>& vec)
{
    vector<int> result(vec.size());
    for (unsigned i = 0;i<vec.size();i++)
        result->at(i) = vec[i].a;
    return result;
}

类obj{
友元向量get_a_vec（const vector&）；
友元向量get_b_vec（const vector&）；
友元向量get_c_vec（const vector&）；
友元向量get_d_vec（const vector&）；
INTA；
int b；
INTC；
int d；
};
向量获取向量（常量向量和向量）
{
向量结果（vec.size（））；
对于（无符号i=0；iat（i）=vec[i].a；
返回结果；
}
您可以编写一个通用函数，从对象序列中提取任何类成员：

template <typename InIt, typename OutIt, typename Class, typename Member>
void extract(InIt start, InIt end, OutIt out, Member Class::*member) {
    for (; start != end; ++start, ++out) {
        *out = (*start).*member;
    }
}

// Example
int main()
{
    std::vector<obj> objs {{1,2,3,4},{5,6,7,8}};
    std::vector<int> ints;

    extract(objs.begin(), objs.end(), back_inserter(ints), &obj::a);

    std::copy(ints.begin(), ints.end(), 
              std::ostream_iterator<int>(std::cout, "\n"));
}

模板
无效提取（初始开始、初始结束、输出、成员类：：*成员）{
对于（；开始！=结束；++开始，++输出）{
*out=（*开始）。*成员；
}
}
//范例
int main（）
{
std：：向量objs{{1,2,3,4}，{5,6,7,8}；
std：：向量整数；
提取（objs.begin（），objs.end（），back_inserter（ints），&obj:：a）；
std:：copy（ints.begin（），ints.end（），
std:：ostream_迭代器（std:：cout，“\n”）；
}
您可以编写一个通用函数，从对象序列中提取任何类成员：

template <typename InIt, typename OutIt, typename Class, typename Member>
void extract(InIt start, InIt end, OutIt out, Member Class::*member) {
    for (; start != end; ++start, ++out) {
        *out = (*start).*member;
    }
}

// Example
int main()
{
    std::vector<obj> objs {{1,2,3,4},{5,6,7,8}};
    std::vector<int> ints;

    extract(objs.begin(), objs.end(), back_inserter(ints), &obj::a);

    std::copy(ints.begin(), ints.end(), 
              std::ostream_iterator<int>(std::cout, "\n"));
}

模板
无效提取（初始开始、初始结束、输出、成员类：：*成员）{
对于（；开始！=结束；++开始，++输出）{
*out=（*开始）。*成员；
}
}
//范例
int main（）
{
std：：向量objs{{1,2,3,4}，{5,6,7,8}；
std：：向量整数；
提取（objs.begin（），objs.end（），back_inserter（ints），&obj:：a）；
std:：copy（ints.begin（），ints.end（），
std:：ostream_迭代器（std:：cout，“\n”）；
}
编写一个函数，从单个对象检索所需的成员

然后将该函数传递给
std:：transform

例如，如果您有
int get_a_成员（obj&）
函数，只需调用

std::vector<int> avec;
std::transform(obj_vector.begin(), obj_vector.end(), get_a_member);

std:：vector avec；
std:：transform（obj_vector.begin（），obj_vector.end（），get_a_成员）；

如果您想要更复杂或可重用的函数，请将其改为函子。然后您可以在其构造函数中向其传递参数（例如告诉它返回哪个成员）。
编写一个函数，从单个对象检索所需的成员

然后将该函数传递给
std:：transform

例如，如果您有
int get_a_成员（obj&）
函数，只需调用

std::vector<int> avec;
std::transform(obj_vector.begin(), obj_vector.end(), get_a_member);

std:：vector avec；
std:：transform（obj_vector.begin（），obj_vector.end（），get_a_成员）；

如果您想要一个更复杂或可重用的函数，请将其改为函子。然后您可以在其构造函数中向其传递参数（例如告诉它返回哪个成员）.
向量不是很大，所以性能不是什么大问题，以防这会影响最佳解决方案。你是说你的消费者期望一个包含四个元素的
向量
，还是一个
向量
？对不起，消费者需要一个obj.a向量、一个obj.b向量、一个obj.c向量和一个obj.d向量。这更清楚吗？哦，你的意思是你想把一个元组向量“压缩”成一个向量元组！@invisiblerhino:你在放入
（）
在每一个之后。向量不是很大，所以性能不是什么大问题，以防这会影响最佳解决方案。你是说你的消费者期望一个包含四个元素的
向量，还是一个
向量
？对不起，消费者需要一个obj.a向量、一个obj.b向量、一个obj.c向量和一个obj.d向量。清楚吗r？哦，你的意思是你想把一个元组向量“压缩”成一个向量元组！@invisiblerhino:当你放入
（）
每次之后。或者你可以编写一个函子，并用
std:：transform将其应用到向量上。我想他会抱怨拥有
a
作为
private
成员，即使这样做有效吗？什么是字段？解决方案看起来不错，这是我的想法。@TAMER先生：他们肯定会为此公开o工作。从问题中不清楚它们是否是专用的，或者示例代码是否缺少
public
说明符。@invisiblerhino:
字段
是一个拼写错误。现在已修复。或者您可以编写一个函子