C++进阶编程 --- 1.模板

已于 2024-05-17 13:30:31 修改
阅读量961 收藏 30
点赞数 24
分类专栏： C++进阶编程 文章标签： c++ 算法 开发语言
于 2024-03-31 21:30:08 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhongziqia/article/details/137209894
版权
本文详细介绍了C++中的函数模板和类模板，包括它们的概念、语法、使用场景、区别、调用规则以及局限性，如自动类型推导、模板重载和友元等。同时提及了模板在类继承中的应用和分文件编写的解决方案。
摘要由CSDN通过智能技术生成

文章目录

第一章：

1.模板

1.1 模板概念

模板就是建立通用的模具，提高复用性。

特点：

  • 模板不可直接使用，它只是一个框架

  • 模板的通用并不是万能的

1.2 函数模板

作用：建立一个通用的函数，让其函数返回值类型和形参类型可不具体设定，用一个虚拟的类型来表示。

C++另一种编程思想称为泛型编程，运用的主要技术就是模板。

C++中提供了两种模板机制：函数模板和类模板。

1.2.1 函数模板语法

语法：

template<typename T>
函数声明或定义

  • template：声明创建模板

  • typename：表其后面的符号是一种数据类型，可用class代替

  • T：通用的数据类型，名称可替换，通常为大写字母

两种方式使用函数模板：

  • 自动类型推导

  • 显示指定类型

#include <iostream>
using namespace std;

template<typename T>
void Swap(T &a, T &b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;

    //Swap(a, b);    //自动类型推导
    Swap<int>(a, b); //显示指定类型
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.2.2 函数模板注意事项

  • 自动类型推导，需推导出一致的数据类型T，才可使用

  • 模板需确定T的数据类型，才可使用

#include <iostream>
using namespace std;

template<typename T>
void Swap(T& a, T& b)
{
    T temp = a;
    a = b;
    b = temp;
}

void test01()
{
    int a = 10;
    int b = 20;
    char c = 'A';
    Swap(a, b);  //正确
    //Swap(a, c);  //报错，自动类型推导，需推导出一致的数据类型T，才可使用
    cout << "a = " << a << endl;
    cout << "b = " << b << endl;
}

template <typename T>
void func()
{
    cout << "func 函数的调用" << endl;
}

void test02()
{
    func<int>(); //正确 
    //func();    //报错，模板需确定T的数据类型，才可使用
}

int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
1.2.3 函数模板案例

  • 使用函数模板封装一个排序的函数，可对不同数据类型数组进行排序

  • 排序规则从大到小，排序算法为选择排序

  • 分别利用char数据和int数组进行测试

    #include <iostream>
using namespace std;

template<class T>
void MySwap(T& a, T& b) //交换函数
{
    T temp = a;
    a = b;
    b = temp;
}

template <class T>
void MySort(T arr[], int len) //排序函数
{
    for (int i = 0; i < len; i++)
    {
        int max = i; //默认最大值的下标
        for (int j = i + 1; j < len; j++)
        {
            if (arr[max] < arr[j])
            {
                max = j;
            }
        }
        if (max != i)
        {
            MySwap(arr[max], arr[i]); 
        }
    }
}

template <class T>
void printArray(T arr[], int len)   //打印数组函数
{
    for (int i = 0; i < len; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

void test01()
{
    //测试char类型数组
    char chArray[10] = "dbcaefg";
    int chLength = sizeof(chArray) / sizeof(char); //计算数组长度
    MySort(chArray, chLength);
    printArray(chArray, chLength);

    //测试int类型数组
    int intArray[] = { 6,2,4,3,9,8,1,5,7 }; 
    int intLength = sizeof(intArray) / sizeof(int); 计算数组长度
    MySort(intArray, intLength);
    printArray(intArray, intLength);
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.2.4 普通函数与函数模板的区别

  • 普通函数调用时可发生自动类型转换(隐式类型转换)

  • 函模板调用时，如果用自动类型转换，将不会发生隐式类型转换

  • 如果用显示指定类型的方式，可发生隐式类型转换

#include <iostream>
using namespace std;

int myAdd_1(int a, int b)
{
    return a + b;
}

template <class T>
int myAdd_2(T a, T b)
{
    return a + b;
}

void test01()
{
    int a = 10;
    int b =  20;
    char c = 'a';

    cout << myAdd_1(a, c) << endl; //107,普通函数调用时可发生自动类型转换(隐式类型转换)

    //cout << myAdd_2(a, c) << endl; //报错,函模板调用时，如果用自动类型转换，将不会发生隐式类型转换

    cout << myAdd_2<int>(a, c) << endl; //107,如果用显示指定类型的方式，可发生隐式类型转换
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.2.5 普通函数与函数模板的调用规则

  • 函数模板和普通函数都可实现的情况下，优先调用普通函数

  • 函数模板可以产生更好的匹配的情况下，优先调用函数模板

  • 可通过空模板参数列表来强制调用函数模板

  • 函数模板也可发生重载

    #include <iostream>
using namespace std;

int myAdd(int a, int b)
{
    cout << "普通函数调用" << endl;
    return a + b;
}

template <class T>
int myAdd(T a, T b)
{
    cout << "函数模板调用" << endl;
    return a + b;
}

template <class T>
int myAdd(T a, T b, T c)
{
    cout << "函数模板重载调用" << endl;
    return a + b + c;
}

void test01()
{
    int a = 10;
    int b = 20;
    char ch1 = 'a';
    char ch2 = 'b';

    myAdd(a, b);     //普通函数调用

    myAdd<>(a, b);   //函数模板调用

    myAdd(a, b, 30); //函数模板重载调用

    myAdd(ch1, ch2); //函数模板调用 
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.2.6 模板的局限性
  • 模板的通用性不是万能的
template<class T>
void assignment(T a, T b)
{
    a = b
}

如果传入的a和b是数组，就没法实现。

template<class T>
void compare(T a, T b)
{
    if(a > b)
    {
       ...
    }
}

如果传入的是自定义数据类型，也无法实现。

为了解决这种问题，提供了模板的重载，为特定的类型提供具体化的模板

#include <iostream>
using namespace std;

class Student
{
public:
    Student(string name, int age)
    {
        this->m_name = name;
        this->m_age = age;
    }
    string m_name;
    int m_age;
};

template <class T>
bool myCompare(T &a, T &b)
{
    if (a == b)
    {
        return true;
    }
    else
    {
        return false;
    }
}

template<> bool myCompare(Student & p1, Student& p2) //使用具体化Student版本实现代码，具体化优先调用
{
    if (p1.m_age == p2.m_age && p1.m_name == p2.m_name)
    {
        return true;
    }
    else
    {
        return false;
    }
}
void test01()
{
    Student s1("小明", 20);
    Student s2("小红", 18);

    bool result = myCompare(s1, s2);
    if (result)
    {
        cout << "s1 = s2" << endl;
    }
    else
    {
        cout << "s1 != s2" << endl;
    }
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.3 类模板

作用：建立一个通用类，类中成员数据类型可不具体设定，用一个虚拟的类型表示。

1.3.1 类模板语法

语法：

template<class T>
类

  • template：声明创建模板

  • typename：表其后面的符号是一种数据类型，可用typename代替

  • T：通用的数据类型，名称可替换，通常为大写字母

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

template <class T1, class T2>
class Student
{
public:
    Student(T1 name, T2 age)
    {
        this->m_name = name;
        this->m_age = age;
    }

    void showStuInfo()
    {
        cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
    }

    T1 m_name;
    T2 m_age;
};

void test01()
{
    Student<string, int> s1("小明", 18);
    s1.showStuInfo();
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.3.2 类模板与函数模板的区别

  • 类模板没有自动类型推导的使用方式

  • 类模板在模板参数列表中可以有默认参数

#include <iostream>
using namespace std;

template<class T1, class T2 = int>
class Student
{
public:
    Student(T1 name, T2 age)
    {
        this->m_name = name;
        this->m_age = age;
    }

    void showStuInfo()
    {
        cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
    }

    T1 m_name;
    T2 m_age;
};

void test01()
{
    //Student s1("小明", 18); //报错，类模板没有自动类型推导
    Student<string> s1("小明", 18);
    s1.showStuInfo();

}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.3.3 类模板中成员函数创建时机

  • 普通类中的成员函数一开始就可创建

  • 类模板中的成员函数在调用时才创建

#include <iostream>
using namespace std;

class Student1
{
public:
    void printStudent1()
    {
        cout << "Student1" << endl;
    }
};


class Student2
{
public:
    void printStudent2()
    {
        cout << "Student2" << endl;
    }
};

template<class T>
class Class
{
public:
    T student;

    void func1()
    {
        student.printStudent1();
    }

    void func2()
    {
        student.printStudent2();
    }

};

void test01()
{
    Class<Student1>s1;
    s1.func1();
    //s1.func2(); //报错，函数调用才会去创建成员函数
}

int main()
{
    test01();
    system("pause");
    return 0;
}
1.3.4 类模板对象做函数参数

三种传入方式：

  • 指定传入的类型 — 直接显示对象的数据类型

  • 参数模板化 — 将该对象中的参数变为模板进行传递

  • 整个类模板化 — 将该对象类型模板化进行传递

#include <iostream>
using namespace std;

template<class T1, class T2>
class Student
{
public:
    Student(T1 name, T2 age)
    {
        this->m_name = name;
        this->m_age = age;
    }

    void showStuInfo()
    {
        cout << "姓名：" << this->m_name << " 年龄：" << this->m_age << endl;
    }

    T1 m_name;
    T2 m_age;
};

void printStuInfo(Student<string, int>&s) //传入指定类型
{
    s.showStuInfo();
}

void test01()
{
    Student<string, int>s("小明", 18);
    printStuInfo(s);
}

template<class T1, class T2>
void printStuInfo2(Student<T1, T2>& s) //参数模板化
{
    s.showStuInfo();
    cout << "T1的类型：" << typeid(T1).name() << endl; //T1的类型：class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >
    cout << "T2的类型：" << typeid(T2).name() << endl; //T2的类型：int 
}

void test02()
{
    Student<string, int>s("小红", 19);
    printStuInfo2(s);
}

template<class T>
void printStuInfo3(T& s) //整个类模板化
{
    s.showStuInfo();
    cout << "T的类型：" << typeid(T).name() << endl; //T的类型：class Student<class std::basic_string<char,struct std::char_traits<char>,class std::allocator<char> >,int>
}

void test03()
{
    Student<string, int>s("小王", 20);
    printStuInfo3(s);
}
int main()
{
    test01();
    test02();
    test03();
    system("pause");
    return 0;
}
1.3.5 类模板与继承

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定父类中T的类型

  • 不知道类型的话，编译器无法给子类分配内存空间

  • 想灵活指定父类中T的类型，子类需也变成类模板

#include <iostream>
using namespace std;

template<class T>
class Base
{
public:
    T m_age;
};

//class Son :public Base //报错，子类在声明的时候，要指定父类中T的类型
class Son :public Base<int>
{

};

void test01()
{
    Son s1;
}

template<class T1, class T2>
class Son2 :public Base<T2> //想灵活指定父类中T的类型，子类需也变成类模板
{
public:
    void showType()
    {
        cout << "T1的类型：" << typeid(T1).name() << endl; //T1的类型：int
        cout << "T2的类型：" << typeid(T2).name() << endl; //T2的类型：char
    }
    T1 m_a;
};

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

int main()
{
    test01();
    test02();
    system("pause");
    return 0;
}
1.3.6 类模板成员函数类外实现
#include <iostream>
using namespace std;

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

	void printStuInfo();

	T1 m_Name;
	T2 m_Age;
};

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

template<class T1, class T2>
void Student<T1, T2>::printStuInfo()
{
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}

void test01()
{
	Student<string, int> s("小明", 18);
	s.printStuInfo();
}

int main()
{
	test01();
	system("pause");
	return 0;
}
1.3.7 类模板分文件编写

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

解决方法：

  1. 直接包含.cpp源文件

  2. 将声明和实现写在同一文件中，更改后缀名.hpp，hpp约定名称，不强制

test.cpp:

#include <iostream>
using namespace std;

//#include "Student.cpp" //解决方法1 - 包含源文件

#include "Student.hpp" //解决方法2 - .h和.cpp内容写一起，改后缀.hpp文件

void test01()
{
	Student<string, int>s("小明", 18);
	s.printStuInfo();
}

int main()
{
	test01();
	system("pause");
	return 0;
}

Student.cpp:

#include "Student.h"

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

template<class T1, class T2>
void Student<T1, T2>::printStuInfo()
{
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}

Student.h:

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

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

	void printStuInfo();

	T1 m_Name;
	T2 m_Age;
};

Student.hpp:

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

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

	void printStuInfo();

	T1 m_Name;
	T2 m_Age;
};

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

template<class T1, class T2>
void Student<T1, T2>::printStuInfo()
{
	cout << "姓名： " << this->m_Name << " 年龄：" << this->m_Age << endl;
}
1.3.8 类模板与友元

  • 全局函数类内实现 - 在类内声明友元即可

  • 全局函数类外实现 - 需提前让编译器知道全局函数的存在

#include <iostream>
using namespace std;

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

//类外实现
template<class T1, class T2>
void printStuInfo(Student<T1, T2>s)
{
	cout << "姓名：" << s.m_Name << " 年龄：" << s.m_Age << endl;
}

template<class T1,class T2>
class Student
{
public: 
	Student(string name, int age)
	{
		this->m_Name = name;
		this->m_Age = age;
	}

	//全局函数 - 类内实现
	friend void printStuInfo(Student<T1, T2>s)
	{
		cout << "姓名：" << s.m_Name << " 年龄：" << s.m_Age << endl;
	}

	//全局函数 - 类外实现
	//提前让编译器知道函数的存在
	//加空模板参数列表
	friend void printStuInfo<>(Student<T1, T2>s);

	T1 m_Name;
	T2 m_Age;
};

void test01()
{
	Student<string, int>s("小明", 18);
	printStuInfo(s);

	Student<string, int>s2("小红", 19);
	printStuInfo(s2);
}

int main()
{
	test01();
	system("pause");
	return 0;
}

下一章：C++进阶编程 — 2.初始STL

子期cod
关注
专栏目录
c++进阶前置-环境准备+shell编程
07-08
C++进阶前置-环境准备+shell编程 C++是高级语言编程的必备知识，环境准备和shell编程是 Linux 后端服务器方面的基础知识。 C++编程语言概述 C++是由Bjarne Stroustrup于1983年开发的高级语言，具有面向对象、...
C++之模板编程
u010378559的博客
05-04 2175
C++模板编程总结
c++模板编程
习惯有你
12-13 3301
模板引入 模板主要是用来解决类库与类库使用不是一个人，编写类库时，不能确定使用类库的人会传入什么类型的数据，而做的一个类型抽象，编译器根据具体调用类库的时候，调用者传入的参数自动推导出数据类型，来替换类库中的数据类型。template关键字定义一个模板，typename关键字指定模板类型抽象名称。示例如下： template<typename T> void myswp(T &a,T &b) //交换数据 { T temp; temp=a; ...
C++之模板
m0_74893211的博客
06-22 5051
C++泛型编程和STL技术详细讲解。
C++模板完整版
顾得泉的博客
03-04 1530
本文主要对C++中的模板进行了完整的总结。
C++中模板讲解
aaaaauaan的博客
10-16 359
模板1. 泛型函数2. 函数模板函数模板概念函数模板格式函数模板的原理函数模板的实例化模板参数的匹配原则3. 类模板类模板的定义格式类模板的实例化 1. 泛型函数 如何实现一个通用的交换函数呢？ void Swap(int& left, int& right) { int temp = left; left = right; right = temp; } void Swap(double& left, double& right) { double temp = l
这是一个c++进阶编程的文档
03-08
这是一个c++进阶编程的文档，包含了实现stl容器，C++的内存管理，深度探索c++对象模型，ACE网络编程，UNIX网络编程，多线程编程，模板的扩展使用，c专家编程，C的缺陷和漏洞.zip这是一个c++进阶编程的文档，包含了...
C++开发工程师高级进阶课程-提升C++面试和开发能力.zip
01-20
《C++开发工程师高级进阶课程-提升C++面试和开发能力》的资源包，旨在帮助C++开发者进一步提升自己的专业技能，以适应更高级别的面试挑战和开发工作。这份资料集涵盖了C++语言的核心知识，包括但不限于C++面试常见...
C++基础-进阶.rar
11-06
1. **模板**：学习如何创建函数模板和类模板，实现代码复用。 2. **STL（Standard Template Library）**：包括容器（如vector、list、set、map等）、迭代器、算法和函数对象，这些都是C++编程的强大工具。 3. **...
C++进阶算法合集--ACM必备
08-04
《C++进阶算法合集--ACM必备》是一份专为ACM竞赛准备的C++算法学习资源，涵盖了各种核心算法的实现和应用。ACM（国际大学生程序设计竞赛）对参赛者的算法理解与编程能力有着高要求，这份资料正是为了提升这方面的...
C++模板(详解)
qq_61213622的博客
05-27 1622
C++模板(详解)
C++ 模板保姆级详解——template＜class T＞(什么是模板？模板分哪几类
最新发布
2401_84976219的博客
05-15 943
网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取一个人可以走的很快，但一群人才能走的更远！不论你是正从事IT行业的老鸟或是对IT行业感兴趣的新人，都欢迎加入我们的的圈子（技术交流、学习资源、职场吐槽、大厂内推、面试辅导），让我们一起学习成长！ 网上学习资料一大堆，但如果学到的知识不成体系，遇到问题时只是浅尝辄止，不再深入研究，那么很难做到真正的技术提升。需要这份系统化的资料的朋友，可以添加戳这里获取
【C++】模板（泛型编程）
qq_50563459的博客
01-22 576
将声明和实现写在同一个文件中，并更改后缀名为.hpp，hpp是约定的名称，并不是强制。利用具体化的模板，可以解决自定义类型的通用化，学习模板并不是为了写模板，而是再STL能够运用系统提供的模板。建立一个通用函数，其函数返回值类型和形参类型可以不具体制定，用一个虚拟的类型来代表。1、当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型。建立一个通用类，类中的成员 数据类型可以不具体制定，用虚拟的类型来表示。模板不可以直接使用，它只是一个框架，模板的通用不是万能的。
C++模板
qq_43491149的博客
11-06 1106
liitdar 2018-06-05 20:51:03 2789 收藏 23 分类专栏： C/C++语言 文章标签： C++ 模板 概述 C++是一门强类型语言，所以无法做到像一些动态语言（如 python 、 javascript ）那样：编写出一段通用的逻辑，然后把任意类型的变量传入进行处理。不过，泛型编程弥补了C++的这个缺点，通过把通用逻辑设计为模板，摆脱了类型的限制，提供了继承机制以外的另一种抽象机制，极大地提升了代码的可重用性。 模板是泛型编程的基础，泛型编程是一种代码编写方式，通过使用泛型编程
C++编程——类模板
热门推荐
professor_tao的博客
05-08 3万+
文章目录1 类模板语法2 类模板与函数模板的区别3 类模板中成员函数创建时机4 类模板对象做函数参数 1 类模板语法 类模板的作用：建立一个通用类，类中的成员数据类型可以不具体制定，用一个虚拟的类型来代表 语法： template<typename T> 类 解释： template声明创建模板 typename表明其后面的符号是一种数据类型，可以用class代替 T是通用的数据类型，名称可以替换，通常为大写字母 示例： //类模板 template<class NameType, cl
C++模板详解
qq_52905520的博客
10-21 1万+
C++模板详解
一篇文章带你了解C++模板编程详解
转载和创作优秀的博客
09-21 662
一篇文章带你了解C++模板编程详解
C++编程之模板与泛型
qq_39344902的博客
05-18 2760
模板是一种对类型进行参数化的工具，模板是泛型编程的基础，而泛型编程指的就是编写与类型无关的代码，是C++中一种常见的代码复用方式。模板分为模板函数和模板类；模板函数针对参数类型不同的函数；模板类主要针对数据成员和成员函数类型不同的类。简单的提及了模板的概念，那么模板究竟是怎样实现的呢？我们先举一个模板函数的例子，比如在c语言和c++中使用频率相当之高的swap函数，以前我们写的swap函数通常是针...
C++进阶：函数模板详解-ucos-iii STM32应用
C++进阶教程中详细讲解了函数模板的使用，包括但不限于以下内容： 1. **基础概念**：理解模板的作用，以及它是如何通过类型推导来实现函数的泛型行为。 2. **数据类型和模板应用**：展示了如何使用类模板（如`...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值