C++ 是否可以通过c+；中的模板声明方法+；？_C++

C++ 是否可以通过c+；中的模板声明方法+；？

c++

C++ 是否可以通过c+；中的模板声明方法+；？,c++,C++,当我需要定义许多类似的方法时，我的意图是避免使用宏样式。所以我很感兴趣，我可以使用模板或类似的东西吗这是pseudo-c++的总体思想： template <class T, class U> void myMethod(T t, U u){ ..do a lot .. } class A { public: A(){} void myMethod<int, int>; void myMethod<float, char>; // ...

当我需要定义许多类似的方法时，我的意图是避免使用宏样式。所以我很感兴趣，我可以使用模板或类似的东西吗

这是pseudo-c++的总体思想：

template <class T, class U> void myMethod(T t, U u){ ..do a lot .. }

class A {
public:
  A(){}
  void myMethod<int, int>;
  void myMethod<float, char>;

  // ... etc
};

template void myMethod（T，U）{..做很多..}
甲级{
公众：
A（）{}
无效方法；
无效方法；
//…等等
};

没有，但您可以：

template <class T, class U> void struct myMethodWrapper
{
    void myMethod(T t, U u){ ..do a lot .. }
};

模板无效结构myMethodWrapper
{
void myMethod（T，U）{..做很多..}
};

然后：

class A : public myMethodWrapper<int, int>, 
          public myMethodWrapper<float, float>
{
};

类：公共myMethodWrapper，公共myMethodWrapper { }; 其行为类似。

否，但您可以：

template <class T, class U> void struct myMethodWrapper
{
    void myMethod(T t, U u){ ..do a lot .. }
};

template <class T, class U> class A 
{
public:
    void MemberSet( T t, U u );
};

模板无效结构myMethodWrapper
{
void myMethod（T，U）{..做很多..}
};

然后：

class A : public myMethodWrapper<int, int>, 
          public myMethodWrapper<float, float>
{
};

类：公共myMethodWrapper，公共myMethodWrapper { }; 其行为类似。

模板类A
template <class T, class U> class A 
{
public:
    void MemberSet( T t, U u );
};

{
公众：
无效成员集（T，U）；
};

增加：

#include <typeinfo>
#include <iostream>

using namespace std;
class A 
{
public:
    template <class T, class U> void MemberSet( T t, U u ) {
        cout << typeid(t).name() << " " << typeid(u).name() << endl;
    };
};

int main() 
{
    A a;
    a.MemberSet(5,5);
    a.MemberSet<char, long>(5,5);
}

#包括
#包括
使用名称空间std；
甲级
{
公众：
模板无效成员集（T，U）{
cout模板类A
{
公众：
无效成员集（T，U）；
};

增加：
#include <typeinfo>
#include <iostream>

using namespace std;
class A 
{
public:
    template <class T, class U> void MemberSet( T t, U u ) {
        cout << typeid(t).name() << " " << typeid(u).name() << endl;
    };
};

int main() 
{
    A a;
    a.MemberSet(5,5);
    a.MemberSet<char, long>(5,5);
}

#包括
#包括
使用名称空间std；
甲级
{
公众：
模板无效成员集（T，U）{
不能，但可以使用继承
template <class derived_T, class T, class U>
struct base {
  void myMethod_(T t, U u) { 
    // use this to access derived class members:
    static_cast<derived_T*>(this)->
  }
};

struct a : base<a, int, int>, base<a, float, float> {
  template <class T, class U>
  void myMethod(T&& t, U&& u) {
    base<a,T,U>::myMethod_(std::forward<T>(t), std::forward<U>(u));
  }
};

模板
结构基{
void myMethod_T（T，U）{
//使用此选项可以访问派生类成员：
静态播放（此）->
}
};
结构a:基础，基础{
模板
无效myMethod（T&&T，U&&U）{
基：：myMethod_uz（std：：forward（t），std：：forward（u））；
}
};
否，但您可以使用继承
template <class derived_T, class T, class U>
struct base {
  void myMethod_(T t, U u) { 
    // use this to access derived class members:
    static_cast<derived_T*>(this)->
  }
};

struct a : base<a, int, int>, base<a, float, float> {
  template <class T, class U>
  void myMethod(T&& t, U&& u) {
    base<a,T,U>::myMethod_(std::forward<T>(t), std::forward<U>(u));
  }
};

模板
结构基{
void myMethod_T（T，U）{
//使用此选项可以访问派生类成员：
静态播放（此）->
}
};
结构a:基础，基础{
模板
无效myMethod（T&&T，U&&U）{
基：：myMethod_uz（std：：forward（t），std：：forward（u））；
}
};
另一个选项是将模板代码放在类之外，并从类方法调用它
#include <iostream>

using namespace std;

namespace myTemplates
{
  // template method 'mult(a,b)'
  // returns a*b
  template <class T1, class T2>
    T1 mult(T1 a, T2 b)
    {
      T1 result = a * b;
      return result;
    }

  // template specialization 'mult(string aString, int m)'
  // returns a string repeated m times
  template <>
    string mult<string, int>(string input, int m)
    {
      string result;
      for (int i = 0; i < m; i++)
      {
        result += input;
      }
      return result;
    }
}

class A {
  public:
    A(){}
    int    mult(int    a , int   b ) { return myTemplates::mult(a, b ) ; }
    float  mult(float  a , float b ) { return myTemplates::mult(a, b ) ; }
    string mult(string a , int   b ) { return myTemplates::mult(a, b ) ; }
};

int main(void)
{
  int    iA = 2;
  int    iB = 3;
  int    iC = 0;   // result
  float  fA = 20.1;
  float  fB = 30.3;
  float  fC = 0.0; // result
  string sA = " -blah- ";
  string sC;       // result


  iC = myTemplates::mult(iA,iB);
  cout << "mult(" << iA << ", " << iB << ") = " << iC << endl;

  fC = myTemplates::mult(fA,fB);
  cout << "mult(" << fA << ", " << fB << ") = " << fC << endl;

  sC = myTemplates::mult(sA,iB); 
  cout << "mult(" << sA << ", " << iB << ") = " << sC << endl;

  A a; 

  iC = a.mult(iA,iB);
  cout << "a.mult(" << iA << ", " << iB << ") = " << iC << endl;

  fC = a.mult(fA,fB);
  cout << "a.mult(" << fA << ", " << fB << ") = " << fC << endl;

  sC = a.mult(sA,iB);
  cout << "a.mult(" << sA << ", " << iB << ") = " << sC << endl;

  return 1;
}

另一种选择是将模板代码放在类之外，并从类方法调用它
#include <iostream>

using namespace std;

namespace myTemplates
{
  // template method 'mult(a,b)'
  // returns a*b
  template <class T1, class T2>
    T1 mult(T1 a, T2 b)
    {
      T1 result = a * b;
      return result;
    }

  // template specialization 'mult(string aString, int m)'
  // returns a string repeated m times
  template <>
    string mult<string, int>(string input, int m)
    {
      string result;
      for (int i = 0; i < m; i++)
      {
        result += input;
      }
      return result;
    }
}

class A {
  public:
    A(){}
    int    mult(int    a , int   b ) { return myTemplates::mult(a, b ) ; }
    float  mult(float  a , float b ) { return myTemplates::mult(a, b ) ; }
    string mult(string a , int   b ) { return myTemplates::mult(a, b ) ; }
};

int main(void)
{
  int    iA = 2;
  int    iB = 3;
  int    iC = 0;   // result
  float  fA = 20.1;
  float  fB = 30.3;
  float  fC = 0.0; // result
  string sA = " -blah- ";
  string sC;       // result


  iC = myTemplates::mult(iA,iB);
  cout << "mult(" << iA << ", " << iB << ") = " << iC << endl;

  fC = myTemplates::mult(fA,fB);
  cout << "mult(" << fA << ", " << fB << ") = " << fC << endl;

  sC = myTemplates::mult(sA,iB); 
  cout << "mult(" << sA << ", " << iB << ") = " << sC << endl;

  A a; 

  iC = a.mult(iA,iB);
  cout << "a.mult(" << iA << ", " << iB << ") = " << iC << endl;

  fC = a.mult(fA,fB);
  cout << "a.mult(" << fA << ", " << fB << ") = " << fC << endl;

  sC = a.mult(sA,iB);
  cout << "a.mult(" << sA << ", " << iB << ") = " << sC << endl;

  return 1;
}

AWWW-宏有什么问题；）？无论如何，请查看此链接：我不确定您希望此代码做什么…不要为了避免“邪恶”而进行大量扭曲构造。宏，甚至goto都有它们的位置。awww-宏有什么问题；）？无论如何，请查看此链接：我不确定您希望此代码做什么…不要为了避免“邪恶”而进行很多扭曲构造。宏甚至goto都有它们的位置。这创建了一堆类a
，而不是一个类a
，有一堆方法。是的，我需要创建一堆重载methods@DmitryKachko：我的解决方案适合您的任务吗？事实上，我正在考虑一些可以使用重载方法而无需直接类型定义的方法首先，调用方不关心参数类型，但你让我重新考虑整件事，为什么不..如果我理解正确，没有直接类型定义的需要，类型可能会被推导，我编辑。这创建了一堆类a
，而不是一个类a
和一堆方法。是的，我需要创建一堆ove装载methods@DmitryKachko：我的解决方案适合您的任务吗？事实上，我正在考虑一些可以使用重载方法而无需直接类型定义的方法，这样调用者就不会关心参数类型，但您让我重新考虑整个问题，为什么不呢..如果我理解正确，不需要直接类型定义，类型可能是推断，我编辑了。我也想到了这一点，但我不确定每个基的同名函数是否能正确组合。@R.MartinhoFernandes，这实际上比我想象的要好-我不知道其中一个是否会影响另一个，但要得到错误，必须考虑它们。只需明确你打算调用哪一个a.myMethod（0,0）；
。如果参数差异太大，甚至不需要。有趣的解决方案，尽管如果我需要25个方法，从25个基类继承类看起来很奇怪：）但它可以工作..我也想到了这一点，但我不确定每个基类的同名函数是否能正确组合。@R.MartinhoFernandes实际上情况比我想象的要好——我不知道其中一个是否会影响另一个，但要得到你所做的错误，它们都必须被考虑。只需明确你打算调用哪一个a.myMethod（0，0）；
。如果参数差异太大，甚至没有必要。有趣的解决方案，尽管如果我需要25个方法，从25个基类继承类看起来很奇怪：）但它可以工作…@R.MartinhoFernandes应该是固定的now@R.MartinhoFernandes现在应该修好了