Question

所以我有两个容器

set<Person>
vector<Person*>

是否有任何方法可以修改以下转换lambda代码，以便可以使用任何容器？

transform(container.begin(), container.end(), back_inserter(data),
          [](const Person* p) { return PairResults(p->getTime(), p->getName()); }
);

现在我只能让它在矢量上工作。

感谢。

＆GT;＆GT; Solution Code Here

非常感谢安德鲁对这个问题的帮助！

Answer 1

你可以使用函数重载的小技巧来完成它：定义两个产生Person指针的函数，如下所示：

const Person* make_ptr(const Person* p) { return p; }
const Person* make_ptr(const Person& p) { return &p; }

下一个问题是统一lambda元素的类型：遗憾的是，说[](auto p) {...}并让编译器为你挑选Person或Person*是不合法的。使用模板解决了这个问题：

template<typename T, typename R>
void xform(vector<T>& from, vector<R>& to) {
    transform(from.begin(), from.end(), back_inserter(to),
        [&](T &p) { return PairResults(make_ptr(p)->getTime(), make_ptr(p)->getName()); }
    );
}

现在一切正常 - 您可以使用xform或Person的容器来呼叫Person*，并获得正确的结果。

Demo on ideone.

Answer 2

您可以使用代理对象接受指向Person的指针或引用Person，并为它们指定两个指针语义：

实例：http://ideone.com/Wk2VMx

#include <algorithm>
#include <iostream>
#include <vector>
#include <set>
#include <string>

struct Person {
    int age;
    std::string name;
};

class PersonProxy {
    public:
        PersonProxy(Person& p)
        : person(&p) {}
        PersonProxy(Person* p)
        : person(p) {}

        Person& operator*() { return *person; }
        Person* operator->() { return person; }

    private:
        Person* person;
};

int main()
{
    std::vector<Person> p1;
    p1.push_back(Person{42, "Bob"});

    Person bill{30, "Bill"};
    std::set<Person*> p2;
    p2.insert(&bill);

    std::vector<int> data;

    auto the_lambda = [](PersonProxy pp) {return pp->age;};

    std::transform(p1.begin(), p1.end(), std::back_inserter(data), the_lambda);
    std::transform(p2.begin(), p2.end(), std::back_inserter(data), the_lambda);

    for (int age : data)
    {
        std::cout << age << "\n";
    }

}

另一种方法是使用函子而不是lambda，并定义operator()(Person&)和operator()(Person*)，但上面的方法是提供一个类型，你可以用它来编写lambda，来自Person和Person*的隐式转化可用。

Answer 3

可能以下内容可行

   template <class T> struct MakePair {
      PairResults operator () (const T & p) {
         return PairResults(p.getTime(), p.getName());
      }
   };

   template <class T> struct MakePair<T*> {
      PairResults operator () (const T * p) {
         return PairResults(p->getTime(), p->getName());
      }
   };

   typedef decltype (* (container.begin ())) container_element_type;

   transform(container.begin(), container.end(), back_inserter(data),
          [] (const container_element_type & p) {
              return MakePair<container_element_type> {} (p);
          }
   );

在我看来，很难实现你所需要的这一事实表明你的代码中缺少一些抽象。

例如，谁负责在向量中处理堆分配的对象？

考虑将容器的实现细节隐藏在具有明确定义接口的PersonContainer后面。

C ++使用相同的代码循环遍历对象和指针

＆GT;＆GT; Solution Code Here

3 个答案: