2

我有两种方法f(vector<int>& x, ....) and g(DBConn& x, ....) ，其中 (....) 参数都是相同的。

这两种方法中的代码完全相同，除了一个语句，我们根据 x 的类型执行不同的操作：

in f(): we do x.push_back(i)
in g(): we do x.DeleteRow(i)

将公共代码提取到一个方法中但同时拥有两个不同语句的最简单方法是什么？

我正在考虑使用一个模板化的仿函数来重载运算符 () (int a) 但这似乎有点过分了。

4

6 回答 6

6 
common_function(....)
{
}

f(vector<int>x,... )
{
    x.push_back(i);
    common_f(...);
}
g(DBConn& x, ....)
{
    x.DeleteRow(i);
    common_f(...);
}
于 2010-06-02T13:51:41.993 回答
4

您可以编写一个具有两个实现的简单适配器，每个实现调用不同类的所需方法。

class MyInterface {
public:
  virtual doIt(int i) = 0;
}

class VectorImp : public MyInterface {
public:
  vector<int>& v;
  VectorImp(vector<int>& theVector) : v(theVector) {}
  doIt(int i) { x.push_back(i); }
}

class DbImp : public MyInterface {
public:
  DBConn& c;
  VectorImp(DBConn& conn) : c(conn) {}
  doIt(int i) { c.DeleteRow(i); }
}
于 2010-06-02T13:52:06.920 回答
1

还有一个想法：

template<class T>
void f(T &t, void (T::*p)(int), ...)
{
  ...
  (t.*p)(i);
}

void g()
{
  DBConn x;
  vector<int> y;
  f(x, &DBConn::DeleteRow, ...);
  f(y, &vector<int>::push_back, ...);
}
于 2010-06-02T14:16:10.173 回答
1 
template<class T>
struct Adapter;

template<>
struct Adapter<vector<int> >
{
  static void execute(vector<int> &x, int i)
  {
    x.push_back(i);
  }
};

template<>
struct Adapter<DBConn>
{
  static void execute(DBConn &x, int i)
  {
    v.DeleteRow(i);
  }
};

template<class T>
void f(T &t, ...)
{
  ...
  Adapter<T>::execute(t, i);
  ...
}

或者：

template<class T>
struct adapter_traits;

template<>
struct adapter_traits<vector<int> >
{
  typedef void (vector<int>::*PMF)(int);
  static const PMF pmf = &vector<int>::push_back;
}

template<>
struct adapter_traits<DBConn>
{
  typedef void (DBConn::*PMF)(int);
  static const PMF pmf = &DBConn::DeleteRow;
}

template<class T>
void f(T &t, ...)
{
  ...
  (t.*adapter_traits<T>::pmf)(i);
  ...
}

注意：我可能有一些语法错误，但你明白了。

于 2010-06-02T14:11:31.017 回答
1

函子的经典案例：

#include <vector>
#include <DBConn.h>

// T:    The type of the object that is to be manipulated.
// A:    The type of the object that will do the manipulating
//       This may be a functor object or a function pointer.
//
// As this is a template function the template parameters will
// be deduced by the compiler at compile time.
template<typename T,typename A>
void action(T& obj,A const& action/*,....*/)
{
    // Do Stuff
    action(obj,5);
    // Do more Stuff
}

// Functor object
struct MyVectorAction
{
    // Just defines the operator()
    // Make sure it is a const method.
    // This does the unique bit of code. The parameters should be what you pass into action
    void operator()(std::vector<int>& data,int val) const   {data.push_back(val);}
};
void f(std::vector<int>& x)
{
    action(x,MyVectorAction()/*.... Params ....*/);
}


struct MyDBConnAction
{   void operator()(DBConn& data,int val) const   {data.DeleteRow(val);} };
void g(DBConn& x)
{
    action(x, MyDBConnAction());
}

int main()
{
    std::vector<int>    x;

    f(x);
}
于 2010-06-02T14:35:07.357 回答
0

您可以创建一个函数，该函数具有您调用的参数（...），并且该函数可以实现 f() 和 g() 中相同的逻辑。然后，您可以更改 f() 和 g() 的实现来调用这个新函数，而不是复制逻辑。但是，如果您在独特的线条之前和之后做重复的事情，请小心。在这种情况下，您可能需要两个函数。无论如何，我认为这比拥有重复的代码块更可取。

于 2010-06-02T13:50:46.613 回答