将几十个非成员函数转换为方法？

Question

Let's say we have some class Foo and we have many non-member functions that mutate vectors of class Foo ; ie:

void remove_duplicate_foos(std::vector<Foo>* foos_io) {
  std::vector<Foo>& foos = &foos_io;
  // removing duplicates
}

Let's say we have dozens of functions like this that manipulate Foo vectors. So we roll up a class called FooStore that contains a vetor of Foo and has methods to manipulate that Foo vector.

class FooStore {
  public:
  void remove_duplicates() {
    ::remove_duplicates(&foos);
  }
  private:
  std::vector<Foo> foos;
}

Now, is there any handy way to do pretty much this dozens of times? Is it a bad idea to this? Should the function remain non-member only?

Answer 1

I can see the benefit of doing this, as you don't want to expose foos to the outside... Also, you don't want to specify the "text" twice by copying/pasting, potentially making a mistake in the forward call.

This more or less solves it using macros:

#include <vector>

class Foo{};

void x1(std::vector<Foo>*){}
void x2(std::vector<Foo>*){}
void x3(std::vector<Foo>*){}

class FooStore
{
  public:
#define FOO_STORE_FWD(name)\
    void name()\
    {\
      ::name(&foos);\
    }

    FOO_STORE_FWD(x1)
    FOO_STORE_FWD(x2)
    FOO_STORE_FWD(x3)

#undef FOO_STORE_FWD

  private:
  std::vector<Foo> foos;
};


void testFooStore()
{
  FooStore f;
  f.x1();
  f.x2();
  f.x3();
}

Furthermore, I can see the benefit of making a function a friend, but then that function has to "know" about you. In this case it knows about your member, not of you...

---

In c++ 11, it can be modified as follows:

#define FOO_STORE_FWD(name)\
    auto name() -> decltype(::name(&foos)){ return ::name(&foos); }

this should handle forwarding to functions multiple return types