Question

我想对一项职能的争论进行同样的处理。是否有办法推翻所有论点? 我在这样做时遵循了守则,但希望看到这样做有条不紊。

 void methodA(int a1, int a2, int b1, double b2){   
        //.. some code 
        methodB(a1, f(a1));
        methodB(a2, f(a2));
        methodB(b1, f(b1));
        methodB(b2, f(b2));
        // more code follows ...

   }

int f(int a){
      // some function. 
   return a*10;
}

double  f(double b){
   return b/2.0;
}

Answer 1

You could use variadic templates:

template <typename T, typename ...Args>
void methodAHelper(T && t, Args &&... args)
{
  methodB(t, f(t));
  methodAHelper(std::forward<Args>(args)...);
}

void methodAHelper() { }

template <typename ...Args>
void methodA(Args &&... args)
{
  // some code
  methodAHelper(std::forward<Args>(args)...);
  // some other code
}

You can possibly get rid of the && and the forwarding if you know that your methodB call doesn t know about rvalue references, that would make the code a bit simpler (you d have const Args &... instead), for example:

methodAHelper(const T & t, const Args &... args)
{
  methodB(t, f(t));
  methodAHelper(args...);
}

You might also consider changing methodB: Since the second argument is a function of the first argument, you might be able to only pass the first argument and perform the call to f() inside the methodB(). That reduces coupling and interdependence; for example, the entire declaration of f would only need to be known to the implementation of methodB. But that s depends on your actual situation.

或者,如果只有one超载methodB 第一个论点是<代码>T,然后由您通过<代码>std:vector<T> to methodA,并随附:

void methodA(const std::vector<T> & v)
{
  // some code
  for (auto it = v.cbegin(), end = v.cend(); it != end; ++it)
    methodB(*it, f(*it));
  // some more code
}

int main() { methodA(std::vector<int>{1,2,3,4}); }

Answer 2

是的,你回顾的概念称为variadic=。

Answer 3

取决于你试图做什么。最简单的事可能是重新审视你的职能,看看看它是否能够采取阵列或 st:作为论据。单程航道的通向更简单

友情链接