C++类模板中如何调用其基类模板中的函数(模板中使用虚函数)

已于 2024-01-26 09:38:43 修改
阅读量4.1k 收藏 9
点赞数 5
分类专栏： C++ and mysql 文章标签： c++ 开发语言
于 2022-07-02 11:02:12 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011436427/article/details/125568953
版权

文章目录

1.模板实现的virtual多态问题

#include <iostream>
#include <string>
#include <cstdio>
#include <vector>

template <typename T>
class Base {
public:
    virtual const std::string& Method() const = 0;
};

template <typename T>
class Base2 : public Base<T> {
public:
    void Func() const {
        std::cout << "Func:" << Method() << std::endl;
    }
};

class Derived : public Base2<double> {
public:
    const std::string& Method() const {
        static const std::string s("Derived");
        return s;
    }
};


int main(int argc, const char* argv[])
{
    Derived d;
    d.Func();

    system("pause");


}
  • 测试：
/home//test/broudcast/template.cpp: In member function ‘void Base2<T>::Func() const’:
/home//test/broudcast/template.cpp:16:33: error: there are no arguments to ‘Method’ that depend on a template parameter, so a declaration of ‘Method’ must be available [-fpermissive]
   16 |         std::cout << "Func:" << Method() << std::endl;
      |                                 ^~~~~~
/home//test/broudcast/template.cpp:16:33: note: (if you use ‘-fpermissive’, G++ will accept your code, but allowing the use of an undeclared name is deprecated)

原因：见2.C++模板的名字查找

  • Method与模板参数无关，因此是无依赖名字，编译器会在全局变量中查找Method，不会去Base类模板中查找Method，只会在Base2的定义体中及外围作用域查找Method。

如何解决呢？

  • 见：3中相关的解决办法

2.C++模板的名字查找

在编译模板的时候，编译器会分两个阶段去解析遇到的名称，

  • 第一个阶段解析不依赖于模板参数的名称
  • 第二个阶段解析依赖于模板参数的名称
  • eg：对于非类模板而言
    可以看到f()的返回类型变成了int
#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <string>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdb.h>
#include <ifaddrs.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <net/if.h>
#include <regex>
#include <type_traits>
#include <fstream>      // std::ofstream
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <typeinfo>
#include <cxxabi.h> //使用abi


using namespace std;

class X {
public:
	typedef int E;
};
 
typedef double E;
 
class Y : public X {
public:
	E f() {}
};
 
int main(){
 
	Y y;
	cout<<typeid(y.f()).name()<<endl;
    cout<<abi::__cxa_demangle(typeid(y.f()).name(),0,0,0 )<<endl;//ubuntu上必须这么用
	return 0;
}

  • 测试：
    在这里插入图片描述

  • eg：类模板而言
    因为f()不依赖与模板参数T，所以它在第一阶段就会被解析，而它的基类X在第二阶段才会被解析，所以解析f()的时候只能看到全局作用域里的typedef double E

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <string>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdb.h>
#include <ifaddrs.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <net/if.h>
#include <regex>
#include <type_traits>
#include <fstream>      // std::ofstream
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <typeinfo>
#include <cxxabi.h> //使用abi


using namespace std;


template<class T> class X {
public:
	typedef int E;
};
 
typedef double E;
 
template<class T> class Y : public X<T> {
public:
	E f() {}
};
int main(){
 
	Y<char> y;
	cout<<typeid(y.f()).name()<<endl;
     cout<<abi::__cxa_demangle(typeid(y.f()).name(),0,0,0 )<<endl;//ubuntu上必须这么用
	return 0;
}

  • 测试：
    在这里插入图片描述

  • eg：这个例子告诉我们，在类模板中，如果需要使用成员函数，需要通过this指针或其他方式来指定，而不能像在普通类中那样省略到this指针

#include <iostream>
#include <string>
#include <vector>
#include <unistd.h>
#include <stdlib.h>
#include <sys/types.h>
#include <unistd.h>
#include <string.h>
#include <string>
#include <thread>         // std::this_thread::sleep_for
#include <chrono>         // std::chrono::seconds
#include <netdb.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

#include <arpa/inet.h>
#include <sys/socket.h>
#include <netdb.h>
#include <ifaddrs.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <net/if.h>
#include <regex>
#include <type_traits>
#include <fstream>      // std::ofstream
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <typeinfo>
#include <cxxabi.h> //使用abi


using namespace std;

void g() { cout<<"gobal::g()"<<endl; }
 
template<class T> class X {
public:
	typedef int E;
	void g() { cout<<"X::g()"<<endl; }
};
 
typedef double E;
 
template<class T> class Y : public X<T> {
public:
	E f() { g(); this->g(); }
};


int main(){
 
	Y<char> y;
     cout<<abi::__cxa_demangle(typeid(y.f()).name(),0,0,0 )<<endl;//ubuntu上必须这么用
     y.f();
	return 0;
}
  • 测试：
    （1）第一种方式调用了全局的g()，
    （2）第二种方式调用了基类的g()，
    （3）原因在于当编译器遇到第一种方式的g()时，发现它没有表现出要依赖于模板参数，所以认为它不依赖于模板参数，因而在第一阶段就进行了解析，此时X尚未解析，所以g()是全局的g()；
    通过第二种方式调用时，用this指针指出g()是依赖于当前对象的，**也就依赖于模板参数，因而会在第二阶段解析，**那时基类也会先于Y进行了解析，所以this–>g()调用了基类的g()。
    在这里插入图片描述

总结，C++在对模板类和模板函数进行名字查找时，会分成两次进行：

  • 对于与模板参数无关的名字，或称无依赖名字，编译器会在第一阶段进行查找。
  • 对于与模板参数有关的名字，或称有依赖名字，编译器会在第二阶段进行查找。

3.错误解法与正确解法

错误解法1：指定基类类型调用

  • 假如我们调用Method时指定基类类型，这样Method就变成有依赖名字了，是否可行？
template <typename T>
class Base2: public Base<T> {
public:
    void Func() const {
        std::cout << "Func:" << Base<T>::Method() << std::endl;
    }
};
  • 测试：因为我们指定了Method的类型，对Method的调用就是静态绑定，没有了动态绑定的效果，我们运行的Method就是基类版本，也就是没有定义的那个版本。
/tmp/ccgToaEX.o: In function `Base2<double>::Func() const':
test.cpp:(.text._ZNK5Base2IdE4FuncEv[Base2<double>::Func() const]+0x12): undefined reference to `Base<double>::Method() const'
collect2: ld returned 1 exit status

正确解法1：using基类中的名字

  • 我们可以手动using基类中的名字，让名字查找时能看到Method，这样还表明Method是Base中的成员，也就意味着Method依赖T，它就是一个有依赖名字，会推迟到实例化时再查找(第二阶段查找)。这样我们仍然能让Method的调用是动态绑定：
template <typename T>
class Base2: public Base<T> {
public:
    using Base<T>::Method;
    void Func() const {
        std::cout << "Func:" << Method() << std::endl;
    }
};
  • 测试：
Func:Derived

正确解法2：使用this调用

  • 另一种解法是显式使用this，这样也可以将Method变成有依赖名字：
template <typename T>
class Base2: public Base<T> {
public:
    void Func() const {
        std::cout << "Func:" << this->Method() << std::endl;
    }
};
  • 测试：
Func:Derived

4.模板实现多态的其他方式

模板实现静态多态的其他方式

  • 一般，使用虚函数和继承实现的是动多态，即在运行期间确定调用者的类型。使用模板，可以实现静多态，在编译期间确定调用者的类型。
使用虚函数可以这样实现
class BaseType
{
public:
	virtual void action1(){...}
    virtual void action2(){...}
}

class SubType1 : BaseType
{
public:
    virtual void action1(){...}
    virtual void action2(){...}
}

class SubType2 : BaseType
{
public:
    virtual void action1(){...}
    virtual void action2(){...}
}

// 统一处理
void DoAction1(BaseType const& type)
{
    type.action1();
}

void DoAction2(BaseType* type)
{
    type->action2();
}

// 可以处理异类集合
void DoActions(std::vector<BaseType*> list) 
{
    ...
}


如果使用模板来实现，就会变成这样
class SubType1
{
public:
    void action1(){...}
    void action2(){...}
}

class SubType2
{
public:
    void action1(){...}
    void action2(){...}
}

// 统一处理
template<typename BaseType>
void DoAction1(BaseType const& type)
{
    type.action1();
}

template<typename BaseType>
void DoAction2(BaseType* type)
{
    type->action2();
}

// 不可以处理异类集合，因为要在编译期间确定，vector只能为一个类型的集合
template<typename BaseType>
void DoActions(std::vector<BaseType*> list)  // 处理异类集合会报错
{
    ...
}

eg：使用模板实现Bridge Pattern

  • 用一个指针引用具体的实现，然后把所有的调用都委托给这个 (包含这个指针)的类。
使用多态实现：
// 实现的接口基类
class Implementation
{
	virtual operationA() = 0;
    virtual operationB() = 0;
    virtual operationC() = 0;
}

// 实现A
class ImplementationA : Implementation
{
    virtual operationA(){...}
    virtual operationB(){...}
    virtual operationC(){...}
}

// 实现B
class ImplementationB : Implementation
{
    virtual operationA(){...}
    virtual operationB(){...}
    virtual operationC(){...}
}

class Bridge
{
public:
    // 通过将body指向不同的实现类来调用不同的实现
    Implementation* body;
    
    void operationA()
    {
        body->operationA();
    }
    
    void operationB()
    {
        body->operationB();
    }
}


使用模板实现，即使用静多态：
// 实现的接口基类
class Implementation
{
	virtual operationA() = 0;
    virtual operationB() = 0;
    virtual operationC() = 0;
}

// 实现A
class ImplementationA : Implementation
{
    virtual operationA(){...}
    virtual operationB(){...}
    virtual operationC(){...}
}

// 实现B
class ImplementationB : Implementation
{
    virtual operationA(){...}
    virtual operationB(){...}
    virtual operationC(){...}
}

template<typename Implementation>
class Bridge
{
public:
    // 使用不同的类型来生成不同实现的实例化类
    Implementation* body;
    
    void operationA()
    {
        body->operationA();
    }
    
    void operationB()
    {
        body->operationB();
    }   
}

动多态和静多态两者的优点
动多态：

  • 可以处理异类集合
  • 生成的代码比较小，只需要一个多态函数，而静多态会生成多个实例化函数

静多态：

喜欢打篮球的普通人
关注
专栏目录
C++模板元编程（17）成员函数模板和模板类的继承
二进制君
04-21 3192
模板类的继承包括四种： 1.普通类继承模板类 大家要区分模板类和类模板的概念，模板类是类模板具体化后得到的类。 template<class T> class Base { public: Base(T data) : data_(data) {} private: T data_; }; class Derived: public Base<int> { public: Derived(int data) : Base<int>(data) {}
C++语言学习（十四）——C++类成员函数调用分析
weixin_33981932的博客
07-22 2193
C++语言学习（十四）——C++类成员函数调用分析 一、C++成员函数 1、C++成员函数的编译 C++中的函数在编译时会根据命名空间、类、参数签名等信息进行重新命名，形成新的函数名。函数重命名的过程通过一个特殊的Name Mangling（名字编码）算法来实现。Name Mangling算法是一种可逆的算法，既可以通过现有函数名计算出新函数名，也可以通过新函数名逆向推导出原有函数名。Name M...
模板——函数模板的基本语法和调用规则
weixin_74207910的博客
07-15 398
4.1如果普通函数和模板函数都可以实现，优先使用普通函数（即使普通函数没有实现代码）5.2学习模板不是为了自己写模板，而是为了在STL中使用系统提供的模板。3.2函数模板在使用自动类型推导方式时，不会发生自动类型转换。3.3函数模板使用显示指定类型方式时，可以发生隐式类型转换。4.4如果函数模板可以产生更好的匹配，优先调用函数模板。2.1自动类型推导必须推导出一致的类型T才可以使用。5.1利用具体化的模板，可以解决自定义类型的通用化。2.2模板必须要确定T的数据类型才可以使用。
C++模板类虚函数
oracleworm的博客
09-30 525
当在C++中定义模板类时，可以使用虚函数来实现多态性。虚函数是通过基类指针或引用调用派生类的函数的一种机制。模板类中的虚函数可以根据模板参数的类型进行实例化。然后定义了一个模板类。指向派生类对象，并调用。这里定义了一个模板类。，其中包含一个虚函数。函数中，通过基类指针。函数，实现了多态性。
【C++】多态
最新发布
m0_72940975的博客
07-31 997
多态是不同继承关系的对象，去调用同一函数，产生了不同的行为。比如，Student和Soilder继承了Person。Person对象买票全价，Student对象买票半价，Soilder对象买票优先。那么在继承中构成多态需要两个条件必须通过基类的指针或者引用调用虚函数被调用的函数必须是虚函数，且派生类需对基类的虚函数进行重写。
C++怎么调用类中的函数
wangmengmeng99的博客
06-26 802
在C++中，可以通过创建类的对象来调用类中的函数。
Ｃ＋＋中的类中函数调用
12-26
Ｃ＋＋中的类中函数调用，只是基于简单的函数调用的例子
C++调用类成员函数
热门推荐
xikangsoon的博客
12-25 3万+
#ifndef _CLASS_H_ #define _CLASS_H_ class CanExtTxPDO_t { private: unsigned char i; public: unsigned char buffer[10]; CanExtTxPDO_t(unsigned char arg0, unsigned char arg1); ~CanExtTxPDO_t(v
c调用c++的类函数
aiwoziji13的专栏
06-09 6253
http://bbs.sjtu.edu.cn/bbscon?board=C&file=M.1300711242.A 在c++中定义了一个类，现在需要在c中调用这个类中的函数。add.h                                                                            1   2 class Add{  3     pu
Delegation:在 C++11 中编译时通过模板没有虚函数调用的委托
07-05
在C++中，虚函数是实现多态性的一种方式，它允许通过基类指针或引用调用派生类的重写版本。虚函数通常与继承关联，当类层次结构需要动态绑定行为时使用。然而，虚函数会带来一定的运行时开销，因为它们需要虚拟函数...
C++ 中纯虚函数与抽象基类
readyone的博客
01-13 1017
1. 纯虚函数定义 纯虚函数是在基类中声明的一个虚函数，它在基类中没有定义，但要求所有继承该基类的派生类都要实现该方法。 声明方式：虚函数后面加上 “=0” class A{ virtual void f1() = 0; // 纯虚函数，无需定义，只需声明 }; 2. 纯虚函数与虚函数的不同点 基类中的虚函数，在派生类中不一定要重写该方法；纯虚函数要求在派生类中必须实现各自的方法 纯虚函数不能在基类中定义 含有纯虚函数的类为抽象类，抽象类不能创建自己的对象，只能创建它的派生类的对象 3. 为什么
C++类间函数的相互调用的实例
12-02
为了验证C++类间函数的相互调用，利用VC6.0的对话框和任意一个逻辑类，实现了点击对话框按钮-〉调用逻辑类函数-〉在对话框显示运行结果的功能
后端 / C++ 类 封装 继承 多态 stl容器 虚函数 纯虚函数 友元函数 模板
01-08
在C++中，多态主要通过虚函数（virtual functions）实现，使得基类指针或引用可以调用派生类的重写方法，达到动态绑定的效果。 5. **虚函数(Virtual Functions)**：虚函数是基类中声明的函数，允许子类重写其行为。...
详解了C++中的模板,位运算,虚函数表 方面的东西
04-16
对象实例在内存中会包含一个指向虚函数表的指针，使得通过基类指针调用虚函数时，能够动态绑定到正确的派生类实现。这种动态绑定特性使得C++支持运行时多态，提高了代码的可扩展性和可重用性。 理解并熟练运用模板...
C++ 类成员函数是如何被调用的
weixin_61669837的博客
01-06 319
C++ 类成员函数是如何被调用的
C++函数调用步骤
xvjixiang的专栏
06-19 910
1、首先确定进行函数调用的对象、引用或指针的静态类型
C中如何调用C++函数、类内函数
weiwei_258的专栏
12-02 1153
[转]：C中如何调用C++函数、类内函数  在C中如何调用C++函数的问题，简单回答是将函数用extern "C"声明，当被问及如何将类内成员函数声明时，一时语塞，后来网上查了下，网上有一翻译C++之父的文章可以作为解答，遂拿来Mark一下。 将C++函数声明为``extern "C"''（在你的C++代码里做这个声明），然后调用它（在你的C或者C++代码里调用）。例如
C++类内各种函数在主函数中的调用方法
cpy3228839344的博客
03-17 882
【代码】C++类内各种函数在主函数中的调用方法。
C++ 调用类的函数
weixin_30849403的博客
11-24 1464
https://zhidao.baidu.com/question/159837017.html 转载于:https://www.cnblogs.com/niuniu0108/p/7889922.html
C++面向对象：函数模板与多态性（虚函数详解）
类模板下的虚函数（同样在派生类中声明为虚函数）进一步增强了多态性，使基类引用能够调用正确版本的函数，无论它指向的是哪个派生类的对象。 总结来说，多态性与虚函数在C++中扮演着至关重要的角色，它们是实现...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

喜欢打篮球的普通人

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值