C++学习笔记——提高篇（二）

明天会是晴天吗

已于 2023-12-21 20:01:39 修改

阅读量319

点赞数 10

文章标签： c++ 算法开发语言前端笔记

于 2023-11-01 20:20:10 首次发布

本文链接：https://blog.csdn.net/LZH58658/article/details/134168916

版权

前言：本部分内容主要是C++语言中关于模板中的类模板的相关知识。类模板与函数模板一样，都是模板，都具有提高代码复用性等作用，在优化代码上有很大的作用。

类模板

1、类模板的语法

1.1、类模板的作用

建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表

1.2、语法

第一行：template<typename T>
第二行：类

2、解释

                        template：声明创建模板
                       typename：表明其后面的符号是一种数据类型，可以用 class 代替
                       T：通用的数据类型，名称可以替换，通常为大写字母
                           eg、

 //类模板
template<class NameType, class AgeType>
class Person
{
    public:
        Person(NameType name, AgeType age)
        {
            this->m_Name = name;
            this->m_Age = age;
        }

        void showPerson()
        {
            cout << "姓名：" << this->m_Name << "  " << "年龄：" << this->m_Age << endl;
        }

        NameType m_Name;
        AgeType m_Age;
};

void test01()
{
    Person<string, int> p1("Tom", 18);
    p1.showPerson();
}

3、类模板与函数模板的区别

两个区别：
1、类模板没有自动类型推导的使用方式，只能用显示指定类型的方式
2、类模板在模板参数列表中可以有默认参数

4、类模板中成员函数创建时机

类模板中的成员函数和普通类中成员函数创建时机是有区别的：
1、普通类中的成员函数一开始就可以创建
2、类模板中的成员函数在调用时才创建

5、类模板对象做函数参数

学习目标：类模板实例化出的对象，向函数传参的方式

一共有三种传参方式：
1、指定传入的类型 ---直接显示对象的数据类型（类模板的对象做函数中的参数）
2、参数模板化 ---将对象中的参数变为模板进行传递
3、整个类模板化 ---将这个对象类型模板化进行传递

eg、

//类模板对象做函数参数
template<class T1, class T2>
class Person
{
    public:
        Person(T1 name, T2 age)
        {
            this->m_Name = name;
            this->m_Age = age;
        }

        void ShowPerson()
        {
            cout << "姓名：" << m_Name << "  " << "年龄：" << m_Age << endl;
        }

        T1 m_Name;
        T2 m_Age;
};

//1、指定传入类型（最常用）
void printPerson1(Person<string, int> &p)
{
    p.ShowPerson();
}

void test01()
{
    Person<string, int>p("孙悟空", 100);
    printPerson1(p);
}

//2、参数模板化
template<class T1, class T2>
void printPerson2(Person<T1, T2>&p)
{
    p.ShowPerson();
    //用于查看 T1 类型的名字：typeid().name()
    cout << "T1 的类型为：" << typeid(T1).name() << endl;    
}

void test02()
{
    Person<string, int>p("猪八戒",90);
    printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3(T &p)
{
    p.ShowPerson();
    用于查看 T 类型的名字： typeid().name()
    cout << "T 的数据类型为：" << typeid(T).name() << endl;   
}

void test03()
{
    Person<string, int>p("唐僧", 30);
    printPerson3(p);
}

6、类模板与继承

当类模板碰到继承时，需要注意一下几点：
1、当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中 T 的类型
2、如果不指定，编译器则无法给子类分配内存
3、如果想灵活指定出父类中的 T 的类型，子类也需要为类模板

eg、

//类模板与继承
template<class T>
class Base
{
    T m;
};

//1、当子类继承的父类是一个类模板时，子类在声明时，要指定出父类中 T 的类型
class Son :public Base<int>    
{

};

void test01()
{
    Son s1;
}

//3、如果想灵活指定出父类中的 T 的类型，子类也需要为类模板
template<class T1, class T2>
class Son2:public Base<T1>
{
    public:
        Son2()
        {
            cout << "T1 的数据类型：" << typeid(T1).name() << endl;
            cout << "T2 的数据类型：" << typeid(T2).name() << endl;
        }
        T2 obj;
};

void test02()
{
    Son2<int, char>son;
}

7、类模板成员函数类外实现

为了体现是类模板的成员函数，在类外表示作用域时，要带上类模板的参数列表
eg、

template<class T1, class T2>
class Person
{
    public:
        Person(T1 name, T2 age);

        void PerosnShow();

        T1 m_Name;
        T2 m_Age;
};
//构造函数的类外实现
template<class T1, class T2>
Person<T1,T2>::Person(T1 name, T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}

//成员函数的类外实现
template<class T1, class T2>
void Person<T1,T2>::PerosnShow()
{
    cout << "姓名：" << m_Name << "  年龄：" << m_Age << endl;
}

void test01()
{
    Person<string, int>p1("Tom",18);
    p1.PerosnShow();
}

8、类模板分文件编写

学习目标：
掌握类模板成员函数分文件编写产生的问题以及解决方式

问题产生的原因：
类模板中成员函数创建时机是在调用阶段，导致分文件编写时链接不到

解决：
解决方式1：直接包含 .cpp 源文件（很少这么做）
解决方式2：将声明和实现写到同一个文件中，并更改后缀名为 .hpp ，.hpp是约定的名字（类模板），并不是强制（主流的解决方式）

9、类模板与友元

学习目标：
掌握类模板配合友元函数的类内和类外实现

全局函数类内实现：直接在类内声明友元即可
全局函数类外实现：需要提前让编译器知道全局函数的存在

//提前让编译器知道Person类的存在
template<class T1,class T2>
class Person;

//全局函数配合友元  类外实现
//需先做函数模板声明，下方再做函数模板定义，再做友元
//若先做函数模板声明，可以将实现写在后面，否则需要将实现体写到类的前面让编译器提前看到
template<class T1, class T2>
void ShowPerson2(Person<T1, T2>& p)
{
    cout << "类外实现———姓名：" <<p. m_Name << "  年龄：" << p.m_Age << endl;
}

template<class T1, class T2>
class Person
{
    public:
        Person(T1 name, T2 age);
        //全局函数配合友元  类内实现
        friend void ShowPerson(Person<T1,T2> &p)
        {
            cout << "类内实现-----姓名：" << p.m_Name << "  年龄：" <<p. m_Age << endl;
        }

        //全局函数 类外实现
        //加空模板参数列表
        //若全局函数为类外实现，需要让编译器提前知道该函数的存在
        friend void ShowPerson2<>(Person<T1, T2>& p);
        T1 m_Name;
        T2 m_Age;
};

//Person类构造函数的类外实现
template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age)
{
    this->m_Name = name;
    this->m_Age = age;
}

//全局函数 类内实现测试
void test01()
{
    Person<string, int>p("Tom", 28);
    ShowPerson(p);
}

//全局函数 类外实现测试
void test02()
{
    Person<string, int>p("Tom", 28);
    ShowPerson2(p);
}