Bootstrap

c++ 类模板

1. 类模板语法

类模板
类模板作用：
建立一个通用类，类中的成员 数据类型可以不具体指定，用一个虚拟的类型来代表。

语法：

template<templayer T>
class 类名{}

template<class NameType, class AgeType>
class Person{
public:
    Person(NameType name, AgeType age){
        m_Name = name;
        m_Age = age;
    }
    NameType m_Name;
    AgeType m_Age;
    void showPerson(){
        cout << "Name:" << m_Name << "\tAge: " << m_Age << endl;
    }
};

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



int main(int argc, char const *argv[]) {
    test01();
    return 0;
}

2. 类模板和函数模板区别

类模板和函数模板区别

1. 类模板没有自动类型推导
2. 类模板在模板参数列表中可以有默认参数

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

template<class NameTpye, class AgeTpye = int>
class Person{
public:
    Person(NameTpye name, AgeTpye age) {
        this->m_Name = name;
        this->m_Age = age;
    }
    NameTpye m_Name;
    AgeTpye m_Age;

    void showPerson() {
        cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    }
};

void test01(){
    // 1. 类模板没有自动类型推导. 在C++11中可以使用自动类型推导
    Person p("西施", 18);
    p.showPerson();
    // 2. 类模板在模板参数列表中可以有默认参数
    Person<string> p2("貂蝉", 19);
    p2.showPerson();
}



int main(int argc, char const *argv[]) {
    test01();
    return 0;
}

3. 类模板中成员函数创建时机

类模板中成员函数和普通类中的成员函数创建时机不同

普通类型成员函数一开始就可以创建
类模板成员函数在调用时才创建

#include <iostream>
#include <fstream>
#include <string>
using namespace std;


// 类模板中成员函数和普通类中的成员函数创建时机不同

class Person{
public:
    void showPerson(){
        cout << "Person show" << endl;
    }
};

class Person2{
public:
    void showPerson2(){
        cout << "Person2 show" << endl;
    }
};

template<class T> 
class MyClass{
public:
    T obj;
    // 类模板中的成员函数，并不是一开始就创建的，而是在模板调用时再创建的
    void fun1(){
        obj.showPerson();
    }
    void fun2(){
        obj.showPerson2();
    }
};

void test01(){

    MyClass<Person> m;
    m.fun1();
    // m.fun2();
    MyClass<Person2> m2;
    m2.fun2();
    
}



int main(int argc, char const *argv[]) {
    test01();
    return 0;
}

4. 类模板对象做函数参数

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

  1. 指定传入的类型 – 直接显示对象的数据类型
  2. 参数模板化 – 将对象中的参数变为模板进行传递
  3. 整个类模板化 – 将这个类模板实例化化对象数据类型，进行传递
// 类模板实例化出的对象，向函数传参的方式


template<class T1, class T2>
class Person{
public:
   Person(T1 name, T2 age){
        this->m_Name = name;
        this->m_Age = age;
   }
   void showPerson(){
     cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
   }
   T1 m_Name;
   T2 m_Age;
};

// 三种传入方式
// 1. 指定传入的类型    -- 直接显示对象的数据类型
void printPerson1(Person<string, int> &p){
    p.showPerson();
}


void test01(){

    Person<string, int> p1("貂蝉", 18);
    printPerson1(p1);
    
}


// 2. 参数模板化       -- 将对象中的参数变为模板进行传递

template<class T1, class T2>
void printPerson2(Person<T1, T2> &p){
    p.showPerson();
    cout << "T1的类型为: " << typeid(T1).name() << endl;
    cout << "T2的类型为: " << typeid(T2).name() << endl;
}

void test02(){
    Person<string, int> p2("西施", 19);
    printPerson2(p2);
}

// 3. 整个类模板化      -- 将这个类模板实例化化对象数据类型，进行传递

template<class T>
void printPerson3(T &p){
    p.showPerson();
    cout << "T的类型为: " << typeid(T).name() << endl;
}

void test03(){
    Person<string, int> p3("王昭君", 17);
    printPerson3(p3);
}


int main(int argc, char const *argv[]) {
    test03();
    return 0;
}

5 类模板与继承

// 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
// 如果不指定，编译器无法给子类分配内存
// 如果想灵活的指定出父类中T的类型，子类也必须是一个类模板

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

template<class T>
class Base {
public:    
    T m;
    void func() {
        cout << "Base T: " << typeid(T).name() << endl;
    }
};

// 缺少 类模板 "Base" 的模板实参列表, 必须指定出父类中T的类型

class Son : public Base<int> {

};

void test01() { 
    Son s;
}

// 如果想灵活的指定出父类中T的类型，子类也必须是一个类模板
template<class T1, class T2>
class Son2 : public Base<T2> {
public:    
    Son2() {
        cout << "Son2 T1:" << typeid(T1).name() << " T2:" << typeid(T2).name() << endl;
    }
    T1 obj;
};

void test02() {
    Son2<int, char> s2;
    s2.func();

}

int main(int argc, char const *argv[]) {
    test02();
    return 0;
}

5 类模板成员函数类外实现

#include <iostream>
#include <fstream>
#include <string>
using namespace std;


// 类模板成员函数类外实现

template<class T1, class T2>
class Person {
public:
    Person(T1 name, T2 age);
    // {
    //     this->m_Name = name;
    //     this->m_Age = age;
    // }
    void showPerson();
    // {
    //     cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
    // }
    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>::showPerson() {
    cout << "name: " << this->m_Name << " age: " << this->m_Age << endl;
}

void test01() {
    Person<string, int> p("西施", 18);
    p.showPerson();
}

int main(int argc, char const *argv[]) {
    test01();
    return 0;
}

7 类模板分文件编写

问题：

  1. 类模板中成员函数创建时机是在调用阶段，导致分文件编写时连接不到

解决：
2. 解决方式一：直接包含.cpp源文件
3. 解决方式二：将声明和实现写到同一个文件中，并将后缀名改为.hpp，hpp是约定的名称，不是强制的

person.hpp

#pragma once
#include <string>
using namespace std;

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

template<class T1, class T2>
Person<T1, T2>::Person(T1 name, T2 age) {
    this->name = name;
    this->age = age;
}

template<class T1, class T2>
void Person<T1, T2>::showPerson() {
    cout << "name: " << this->name << " age: " << this->age << endl;
}

main.cpp

#include <iostream>
#include <fstream>
#include <string>
// 第一种方式 直接包含源文件
// #include "person.cpp"
// 将声明和实现写到同一个文件中，并将后缀名改为.hpp
#include "person.hpp"
using namespace std;

void test01() {
    Person<string, int> p("西施", 18);
    p.showPerson();
}

int main(int argc, char const *argv[]) {
    test01();
    return 0;
}

类模板与友元

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

#include <iostream>
#include <fstream>
#include <string>
using namespace std;

// 类模板与友元


// 提前让编译器知道Person的存在
template<class T1, class T2>
class Person;
// 全局函数 类外实现
template<class T1, class T2>
void printPerson2(Person<T1, T2> &p) {
    cout << "类外实现 name: " << p.m_name << " age: " << p.m_age << endl;
}


template<class T1, class T2>
class Person {

    // 全局函数 类内实现
    friend void printPerson(Person<T1, T2> &p) {
        cout << "name: " << p.m_name << " age: " << p.m_age << endl;
    }
    // 全局函数 类外实现 
    // 加一个空模板参数列表
    friend void printPerson2<>(Person<T1, T2> &p);
public:
    Person(T1 name, T2 age) {
        this->m_name = name;
        this->m_age = age;
    }
private:    
    T1 m_name;
    T2 m_age;
};

// 全局函数类内实现：直接在类内声明友元即可
void test01() {
    Person<string, int> p("西施", 18);
    printPerson(p);
}

// 全局函数类外实现：需要提前让编译器知道 友元 函数的存在
void test02() {
    Person<string, int> p("西施", 18);
    printPerson2(p);
}

int main(int argc, char const *argv[]) {
    test02();
    return 0;
}

类模板案例

MyArray.hpp

#pragma once // 防止重复引用
#include <iostream>
using namespace std;

// 通用数组类
template <class T>
class MyArray{
public:
    // 构造函数, capacity 代表数组容量
    MyArray(int capacity){
        // cout << "MyArray 构造函数调用" << endl;
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity]; // 创建数组
    }
    // 拷贝构造函数
    MyArray(const MyArray &arr){
        // cout << "MyArray 拷贝构造函数调用" << endl;
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[arr.m_Capacity]; // 创建数组
        // 将arr中的数据全部拷贝到新创建的空间中
        for (int i = 0; i < this->m_Size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
    }

    // 重载赋值运算符 防止浅拷贝
    MyArray & operator=(const MyArray &arr){
        // cout << "MyArray 重载的赋值运算符调用" << endl;
        // 先判断原来堆区是否有数据
        if (this->pAddress != NULL){
            delete [] this->pAddress;
            this->pAddress = NULL;
            this->m_Capacity = 0;
            this->m_Size = 0;
        }
        // 深拷贝
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        this->pAddress = new T[arr.m_Capacity]; // 创建数组
        // 将arr中的数据全部拷贝到新创建的空间中
        for (int i = 0; i < this->m_Size; i++){
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;
    }

    // 尾插法
    void Push_Back(const T &val){
        // 判断容量是否已满
        if(this->m_Size >= this->m_Capacity){
            cout << "数组已满" << endl;
            return;
        }
        this->pAddress[this->m_Size] = val; 
        this->m_Size++;
    }
    // 尾删法
    void Pop_Back(){
        // 让用户访问不到最后一个元素
        if (this->m_Size == 0){
            return;
        }
        this->m_Size--;
    }
    // 通过下标访问数组中的元素
    T & operator[](int index){
        return this->pAddress[index];
    }
    // 获取数组的容量
    int getCapacity(){
        return this->m_Capacity;
    }
    // 返回数组的长度
    int getSize(){
        return this->m_Size;
    }

    //析构函数
    ~MyArray(){
        if (MyArray::pAddress != NULL)
        {
            // cout << "MyArray 析构函数调用" << endl;
            delete [] this->pAddress;
            this->pAddress = NULL;
        }
    }
private:
    T * pAddress; // 指向堆区中开辟的具体的空间;
    int m_Capacity; // 数组的容量
    int m_Size; // 数组中存放数据的个数
};

Main.cpp

#include <iostream>
#include <fstream>
#include <string>
#include "MyArray.hpp"
using namespace std;

// 
void printIntArray(MyArray<int> &arr) {
    for (size_t i = 0; i < arr.getSize(); i++)
    {
        cout << "arr[" << i << "] =" << arr[i] << endl;
    }
    
}
// 
void test01() {
    MyArray<int> arr1(5);
    for (size_t i = 0; i < 5; i++)
    {
        arr1.Push_Back(i);// 利用尾插法插入数据
    }
    printIntArray(arr1);
    cout << "容量" << arr1.getCapacity() << endl;
    cout << "大小" << arr1.getSize() << endl;

    


    MyArray<int> arr2(arr1);
    printIntArray(arr2);
    cout << "尾删后" << endl;
    arr2.Pop_Back();
    printIntArray(arr2);
    cout << "容量" << arr2.getCapacity() << endl;
    cout << "大小" << arr2.getSize() << endl;

    // MyArray<int> arr3(100);
    // arr3 = arr1;
}

// 测试自定义数据类型
class Person {
public:
    // 构造函数, 无参（调用无参构造函数），如果这里不写，在nwe Person[]时会报错
    Person() {
        cout << "Person 构造函数调用" << endl;
    }
    Person(string name, int age) {
        this->name = name;
        this->age = age;
    }
    string name;
    int age;
};

void printPersonArray(MyArray<Person> &arr) {
    for (size_t i = 0; i < arr.getSize(); i++){
        cout << "姓名：" << arr[i].name << " 年龄：" << arr[i].age << endl;
    }
}

void test02() {
    MyArray<Person> arr(10);
    Person p1("孙悟空", 100);
    Person p2("唐僧", 30);
    Person p3("猪八戒", 20);
    Person p4("西施", 15);
    Person p5("貂蝉", 20);
    // 将数据插入到数组中
    arr.Push_Back(p1);
    arr.Push_Back(p2);
    arr.Push_Back(p3);
    arr.Push_Back(p4);
    arr.Push_Back(p5);
    // 测试获取数据
    printPersonArray(arr);
}


int main(int argc, char const *argv[]) {
    test02();
    return 0;
}

悦读

道可道，非常道；名可名，非常名。 无名，天地之始，有名，万物之母。 故常无欲，以观其妙，常有欲，以观其徼。 此两者，同出而异名，同谓之玄，玄之又玄，众妙之门。

最新收录
基于ssm的宠物商城网站设计与实现
Go 语言 UUID 库 google/uuid 源码解析：UUID version1 的实现
虚拟机Ubuntu操作系统最基本终端命令（安装包+详细解释+详细演示）
索尼的hlg是什么_索尼摄像机上的hlg是什么意思
用 VB.net，VBA 两种方式 读取单元格内的 换行数据，并出力到 CSV文件
Python进阶篇（一）-- Django快速上手
Linux命令大全（非常详细）从零基础入门到精通，看完这一篇就够了_linux 命令
从业10多年，我总结了这几款程序员必备实用工具
diskmark使用教程
netcore使用minio的PresignedPutObjectAsync方法,实现通过浏览器直接上传图片到minio服务器
;