与模板功能过载

Overloading with a template function

本文关键字：功能      更新时间：2023-10-16

我在这里识别问题时遇到了困难我能想到的方式：

class.h：

class baseClass{
public:
    virtual void myfunction(double dA, double dB) = 0; //Pure virtual function
    virtual void myfunction(double dC) = 0;//Overloaded pure virtual function
};
class derivedClass1 :baseClass{
public:
    void myfunction(double dA, double dB)override;
    void myfunction(double dC)override;
};
class derivedClass2 :baseClass{
public:
    void myfunction(double dA, double dB)override;
    void myfunction(double dC)override;
};

class.cpp：

#include"classes.h"
void derivedClass1::myfunction(double dA, double dB){
    //DO STUFF
}
void derivedClass2::myfunction(double dA, double dB){
    //Do different stuff to derivedClass1
}
template <class type>
void type::myfunction(double dC){
    double dA = dC;
    double dB = 0; //In place of a complex calculation
    myfunction(dA, dB)  //Call the function for the
//relevant class and 2 input arguments.
}

主：

#include"classes.h"
int main(){
    derivedClass1 example;
    example.myfunction(1.0);
}

我想做的就是超载所有函数与模板函数的一个输入参数。由于有许多派生类，我想使用模板。但是，当我做这样的事情时，我会得到这个错误：

错误c2063：'myFunction'：不是函数

是否有一种简单的方法可以做到这一点，或者有一种更好的方法？我尝试将模板放在标题文件中并删除类声明，但这也不起作用。

您根本不需要模板。多态性将为您解决这个问题。这个可以为您服务：

class baseClass{
public:
    virtual void myfunction(double dA, double dB) = 0; //Pure virtual function
    virtual void myfunction(double dC) {
      double dA = dC;
      double dB = 0;
      myfunction(dA, dB)  // Calls the function of the derived class
    }
};

然后您的主要功能看起来像：

#include"classes.h"
int main(){
    derivedClass1 example;
    baseClass *caller = &example;    
    caller.myfunction(1.0);
}

    I think you want to write general function outside any class to call the respective class function.
    1) You don't need to put type::myfunction
        template <class type> 
        void myfunction(baseClass *caller, double dc) 
        {
            double dA = dC;
            double dB = 0; //In place of a complex calculation
            caller->myfunction(double dA, double dB)  //Call the function for the
        }
    2) actually, you don't need type template for it if there are not multiple data types
       void myfunction(baseClass *caller,double dc)
       {
            double dA = dC;
            double dB = 0; //In place of a complex calculation
            caller->myfunction(double dA, double dB)  //Call the function for the
       }

int main(){
    derivedClass1 example;
    myfunction(&example,1.0);
    derivedClass2 example2;
    myfunction(&example2,2.0);
    baseClass example3;
    myfunction(&example3,4.0);
}

我认为您提供的上述代码中有很多问题，如以下

void type::myfunction(double dC)

在以上语句中，"类型"应该是我的功能为会员的类名。相反，您将其作为模板类型。

我已将您的代码重写如下，

class baseClass
{
  public:
    template<typename Type>
    void myfunction(Type dA, double dB)
    {};
    template<typename Type>
    void myfunction(Type dC)
    {};
};
class derivedClass1 :baseClass
{
  public:
   template<typename Type>
   void myfunction(Type dA, double dB)
   {
     //DO STUFF
   }

   template<typename Type>
   void myfunction(Type dC)
   {
      Type dA = dC;
      double dB = 0; //In place of a complex calculation
      myfunction(dA, dB);
   };
};
class derivedClass2 :baseClass
{
  public:
  template<typename Type>
  void myfunction(Type dA, double dB)
  {
    //Do different stuff to derivedClass1
  }
  template<typename Type>
  void myfunction(Type dC)
  {
     Type dA = dC;
    double dB = 0; //In place of a complex calculation
    myfunction(dA, dB);
  };
};
int main()
{
  derivedClass1 example;
  example.myfunction(1.0);
}
相关文章：