使用模板函数重载

Question

由于我使用了多种技术，我不太熟悉（将代码拆分成文件，模板），所以我用最简单的方法重新创建了它认为：

classes.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; 
}; 

classes.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); 
} 

我想要做的是只为一个输入参数用模板函数重载所有函数。由于有很多派生类我想使用模板。然而，当我做这样的事情时，我得到这个错误：

error C2063: 'myfunction' : not a function

有没有简单的方法来做到这一点或更好的方法？我已经尝试将模板放在头文件中，并删除类中的声明，但这也不起作用。

Answer 1

根本不需要模板。多态性将为您解决这个问题。这会为你工作：

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); 
} 

Answer 2

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); 
} 

Answer 3

我觉得有很多的问题，在你提供像下面

void type::myfunction(double dC) 

上面的代码

在上面的语句中，“type”应该是myfunction成员的类名。相反，您将其作为模板类型。

我重写你的代码如下，

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); 
}