Question

我有一个带矢量输入的函数。为简化起见，我们使用这个print_in_order函数：

#include <iostream>
#include <vector>

template <typename vectorlike>
void print_in_order(std::vector<int> const & order,
                    vectorlike const & printme) {
    for (int i : order)
        std::cout << printme[i] << std::endl;
}

int main() {
    std::vector<int> printme = {100, 200, 300};
    std::vector<int> order = {2,0,1};
    print_in_order(order, printme);
}

现在我有一个vector<Elem>，并希望为向量中的每个Elem打印一个整数成员Elem.a。我可以通过创建一个新的vector<int>（为所有Elems复制a）并将其传递给print函数来做到这一点 - 但是，我觉得必须有一种方法来传递一个“虚拟”向量，当使用operator[]时，仅返回成员a。请注意，我不想更改print_in_order函数来访问该成员，它应该保持一般。

这是否可能，也许是lambda表达式？完整代码如下。

#include <iostream>
#include <vector>

struct Elem {
    int a,b;
    Elem(int a, int b) : a(a),b(b) {}
};

template <typename vectorlike>
void print_in_order(std::vector<int> const & order,
                    vectorlike const & printme) {
    for (int i : order)
        std::cout << printme[i] << std::endl;
}

int main() {
    std::vector<Elem> printme = {Elem(1,100), Elem(2,200), Elem(3,300)};
    std::vector<int> order = {2,0,1};

    // how to do this?
    virtual_vector X(printme) // behaves like a std::vector<Elem.a>
    print_in_order(order, X);
}

Answer 1

直接做你想做的事情真的不可能。相反，您可能希望从standard algorithm library中获取提示，例如std::for_each，其中您使用 extra 参数，该参数是您为每个元素调用的类函数对象。然后你可以轻松传递一个只打印想要的元素的lambda函数。

也许像

template<typename vectorlike, typename functionlike>
void print_in_order(std::vector<int> const & order,
                vectorlike const & printme,
                functionlike func) {
    for (int i : order)
        func(printme[i]);
}

然后将其称为

print_in_order(order, printme, [](Elem const& elem) {
    std::cout << elem.a;
});

由于C ++有函数重载，你仍然可以保留普通向量的旧print_in_order函数。

Answer 2

您可以选择两种数据结构

struct Employee
{
  std::string name;
  double salary;
  long payrollid;
};

std::vector<Employee> employees;

或者

struct Employees
{
   std::vector<std::string> names;
   std::vector<double> salaries;
   std::vector<long> payrollids;
};

C ++的设计使用第一个选项作为默认选项。 Javascript等其他语言倾向于鼓励第二种选择。

如果你想找到平均工资，选项2更方便。如果您想按工资对员工进行排序，则选项1更容易使用。

但是你可以使用lamdas在两者之间进行部分互换。 lambda是一个微不足道的小函数，它接受一个Employee并为他返回一个薪水 - 所以有效地提供了一个平面向量的双重我们可以采取的意思 - 或采取一个索引和一个员工，并返回一个员工，做一点点琐碎的数据重新格式化。

Answer 3

使用成员指针，您可以实现一种代理类型，允许您通过其中一个成员（请参阅pointer to data member）或其中一个获取者替换每个对象来查看对象容器（请参阅{{3} }）。第一个解决方案仅解决数据成员，第二个解决方案同时解决这两个问题。

容器必须知道要使用哪个容器以及要映射的成员，这将在构造时提供。成员指针的类型取决于该成员的类型，因此必须将其视为附加模板参数。

template<class Container, class MemberPtr>
class virtual_vector
{
public:
    virtual_vector(const Container & p_container, MemberPtr p_member_ptr) :
        m_container(&p_container),
        m_member(p_member_ptr) 
    {}

private:
    const Container * m_container;
    MemberPtr m_member;
};

接下来，实现operator[]运算符，因为您提到了它是您想要访问元素的方式。取消引用成员指针的语法起初可能会令人惊讶。

template<class Container, class MemberPtr>
class virtual_vector
{
public:
    virtual_vector(const Container & p_container, MemberPtr p_member_ptr) :
        m_container(&p_container),
        m_member(p_member_ptr) 
    {}

    // Dispatch to the right get method
    auto operator[](const size_t p_index) const 
    {
        return (*m_container)[p_index].*m_member;
    }

private:
    const Container * m_container;
    MemberPtr m_member;
};

要使用此实现，您可以编写如下内容：

int main() {
    std::vector<Elem> printme = { Elem(1,100), Elem(2,200), Elem(3,300) };
    std::vector<int> order = { 2,0,1 };

    virtual_vector<decltype(printme), decltype(&Elem::a)> X(printme, &Elem::a);
    print_in_order(order, X);
}

这有点麻烦，因为没有发生模板参数推断。因此，我们添加一个自由函数来推导出模板参数。

template<class Container, class MemberPtr>
virtual_vector<Container, MemberPtr>
make_virtual_vector(const Container & p_container, MemberPtr p_member_ptr) 
{
    return{ p_container, p_member_ptr };
}

用法变为：

int main() {
    std::vector<Elem> printme = { Elem(1,100), Elem(2,200), Elem(3,300) };
    std::vector<int> order = { 2,0,1 };

    auto X = make_virtual_vector(printme, &Elem::a);
    print_in_order(order, X);
}

如果你想支持成员函数，它会有点复杂。首先，取消引用数据成员指针的语法与调用函数成员指针略有不同。您必须实现operator[]的两个版本，并根据成员指针类型启用正确的版本。幸运的是，标准提供了pointer to member function和std::enable_if（都在std::is_member_function_pointer标题中），这使我们可以做到这一点。成员函数指针要求您指定要传递给函数的参数（在本例中为非）以及表达式周围的一组额外括号，这些括号将计算要调用的函数（参数列表之前的所有内容）。

template<class Container, class MemberPtr>
class virtual_vector
{
public:
    virtual_vector(const Container & p_container, MemberPtr p_member_ptr) :
        m_container(&p_container),
        m_member(p_member_ptr) 
    {}

    // For mapping to a method
    template<class T = MemberPtr>
    auto operator[](std::enable_if_t<std::is_member_function_pointer<T>::value == true, const size_t> p_index) const
    {
        return ((*m_container)[p_index].*m_member)();
    }

    // For mapping to a member
    template<class T = MemberPtr>
    auto operator[](std::enable_if_t<std::is_member_function_pointer<T>::value == false, const size_t> p_index) const
    {
        return (*m_container)[p_index].*m_member;
    }

private:
    const Container * m_container;
    MemberPtr m_member;
};

为了测试这一点，为了说明目的，我在Elem课程中添加了一个getter。

struct Elem {
    int a, b;
    int foo() const { return a; }
    Elem(int a, int b) : a(a), b(b) {}
};

以下是它的使用方法：

int main() {
    std::vector<Elem> printme = { Elem(1,100), Elem(2,200), Elem(3,300) };
    std::vector<int> order = { 2,0,1 };

    {   // print member
        auto X = make_virtual_vector(printme, &Elem::a);
        print_in_order(order, X);
    }
    {   // print method
        auto X = make_virtual_vector(printme, &Elem::foo);
        print_in_order(order, X);
    }
}

Answer 4

template<class F>
struct index_fake_t{
  F f;
  decltype(auto) operator[](std::size_t i)const{
    return f(i);
  }
};
template<class F>
index_fake_t<F> index_fake( F f ){
  return{std::move(f)};
} 
template<class F>
auto reindexer(F f){
  return [f=std::move(f)](auto&& v)mutable{
    return index_fake([f=std::move(f),&v](auto i)->decltype(auto){
      return v[f(i)];
    });
  };
}
template<class F>
auto indexer_mapper(F f){
  return [f=std::move(f)](auto&& v)mutable{
    return index_fake([f=std::move(f),&v](auto i)->decltype(auto){
      return f(v[i]);
    });
  };
}

现在，按顺序打印可以改写为：

template <typename vectorlike>
void print(vectorlike const & printme) {
  for (auto&& x:printme)
    std::cout << x << std::endl;
}
template <typename vectorlike>
void print_in_order(std::vector<int> const& reorder, vectorlike const & printme) {
  print(reindexer([&](auto i){return reorder[i];})(printme));
}

并将.a打印为：

print_in_order( reorder, indexer_mapper([](auto&&x){return x.a;})(printme) );

可能存在一些错别字。

实际上将struct的向量转换为struct成员的向量

4 个答案: