1.2、类模板

最新推荐文章于 2023-09-05 11:14:16 发布
最新推荐文章于 2023-09-05 11:14:16 发布
阅读量75 收藏
点赞数
分类专栏： C++语法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42847094/article/details/119476575
版权

文章目录

1.2、类模板

1.2.1、类模板语法

#include <iostream>
using namespace std;

//类模板
template<class NameType , class AgeType>
class Person
{
public:

    Person(NameType name , AgeType age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }

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

    NameType m_Name;
    AgeType m_Age;
};

void test01()
{
    Person<string , int> p1("小红" , 33);
    p1.showPerson();
}

int main() {
    test01();


    return 0;
}

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

  • 类模板使用只能用显示指定类型方式
  • 类模板中的模板参数列表可以有默认参数
#include <iostream>
using namespace std;


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

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

    NameType m_Name;
    AgeType m_Age;
};

//1、类模板没有自动类型推导使用方式
void test01()
{
    //Person p ("小红",111); //错误，无法自动类型推导

    //正确
    Person<string,int> p("小红",111);
    p.show();
}
//2、类模板在模板参数列表中可以有默认参数
void test02()
{
    Person<string> p ("猪",22);
    p.show();
}

int main() {
   // test01();
    test02();

    return 0;
}

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

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

类模板中的成员函数并不是一开始就创建的，在调用时才创建

#include <iostream>
using namespace std;

//类模板中成员函数创建时机
//类模板中成员函数在调用时才去创建
class Person1
{
public:
    void ShowPerson1()
    {
        cout << "Person1 show()" << endl;
    }
};

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

template<class T>
class MyClass
{
public:
    T obj;

    //类模板中的成员函数
    void func1()
    {
        obj.ShowPerson1();
    }

    void func2()
    {
        obj.ShowPerson2();
    }
};

void test()
{
    MyClass<Person2> m;
   // m.func1();
    m.func2();
}

int main() {
    test();


    return 0;
}

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

三种传入方式：

  • 指定传入的类型 （最常用）
  • 参数模板化
  • 整个类模板化
#include <iostream>
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 show()
    {
        cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
    }
    T1 m_Name;
    T2 m_Age;
};

//1、指定传入类型
void printPerson1(Person<string,int> &p)
{
    p.show();
}
void test01()
{
    Person<string,int> p("小猪",22);
    printPerson1(p);
}

//2、参数模板化
template<class T1 , class T2>
void printPerson2(Person<T1 , T2> &p)
{
    p.show();
    cout << "T1 的类型为：" << typeid(T1).name() << endl;
    cout << "T2 的类型为：" << typeid(T2).name() << endl;
}
void test02()
{
    Person<string,int> p("柚子",22);
    printPerson2(p);
}

//3、整个类模板化
template<class T>
void printPerson3(T &p)
{
    p.show();
    cout << "T 的类型为：" << typeid(p).name() << endl;
}
void test03()
{
    Person<string,int> p("柚子",22);
    printPerson3(p);
}
int main() {

    //test01();
    //test02();
    test03();
    return 0;
}

1.2.5、类模板与继承

  • 当子类继承的父类是一个类模板时，子类在声明的时候，要指定出父类中T的类型
  • 如果不指定，编译器无法给子类分配内存
  • 如果想灵活指定出父类中T类型，子类也需要变为类模板
#include <iostream>
using namespace std;

//类模板与继承

template<class T>
class Base
{
   
    T m;
};

//class Son :public Base //错误，必须要知道父类中的T类型，才能继承给子类
class Son : public Base<int>
{

};

void test01()
{
    Son s1;
}

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


};

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

}
int main() {

   // test01();

    test02();
    return 0;
}

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

#include <iostream>
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 << "姓名 ：" << this->m_Name << " 年龄：" << 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 << "姓名 ：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
void test01()
{
    Person<string,int> p("小猪",22);
    p.showPerson();
}
int main() {
    test01();


    return 0;
}

1.2.7、类模板分文件编写

问题：

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

解决：

  • 方法一：直接包含.cpp源文件

  • 方法二：将声明和实现写到同一个文件中，并更改后缀为 .hpp是约定的名称，并不是强制

person.hpp中代码

#include <iostream>

using namespace std;

template<class T1 , class T2>
class Person
{
public:

    Person(T1 name, T2 age);

    void showPerons();

    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>::showPerons()
{
    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

person.h中代码

//
// Created by Administrator on 2021/8/6.
//

#ifndef _03_STL_PERSON_H
#define _03_STL_PERSON_H

#include <iostream>

using namespace std;

template<class T1 , class T2>
class Person
{
public:

    Person(T1 name, T2 age);

    void showPerons();

    T1 m_Name;
    T2 m_Age;
};


#endif //_03_STL_PERSON_H

person.cpp中代码

//
// Created by Administrator on 2021/8/6.
//
#include "person.h"
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>::showPerons()
{
    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}

测试

#include <iostream>
using namespace std;

//第一种解决方法，直接包含 源文件
//#include "person.cpp"

//第二种解决方法，将.h和 .cpp的内容放到一起，将后缀名改为 .hpp (常用）
#include "Person.hpp"


//类模板分文件编写问题以及解决
/*

template<class T1 , class T2>
class Person
{
public:

    Person(T1 name, T2 age);

    void showPerons();

    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>::showPerons()
{
    cout << "姓名：" << this->m_Name << " 年龄：" << this->m_Age << endl;
}
*/


void test01()
{
    Person<string,int> p ("小猪" ,22);
    p.showPerons();
}


int main() {

    test01();

    return 0;
}

1.2.8、类模板与友元

  • 全局函数类实现 — 直接在类内声明友元就可以了
  • 全局函数类外实现 – 需要提前让编译器知道全局函数的存在
#include <iostream>
using namespace std;

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

//全局函数 类外实现
template<class T1 , class T2>
void printPerson2(Person<T1,T2> p)
{
    cout << "类外实现 ------------姓名：" << p.m_Name << " 年龄：" << p.m_Age << endl;
}


//通过全局函数 打印Person信息
template<class T1 , class T2>
class Person
{
    //全局函数 类内实现
    friend void printPerson(Person<T1,T2> p)
    {
        cout << "姓名：" << p.m_Name << " 年龄：" << 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 ("猪",22);
    printPerson(p);
}

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

int main() {

    //test01();
    test02();
    return 0;
}

1.2.9、类模板案例

实现一个通用的数组类，要求如下 ：

  • 可以对内置数据类型以及自定义数据类型的数据进行存储
  • 将数组中的数据存储到堆区
  • 构造函数可以传入数组的容量
  • 提供对应的拷贝构造函数以及operator=防止线拷贝问题
  • 提供尾插法和尾删除法对数组中的数据进行增加和删除
  • 可以通过下标的方式访问数组中的元素
  • 可以获取数组中当前元素个数和数组的容量

MyArray.hpp

#ifndef _03_STL_MYARRAY_H
#define _03_STL_MYARRAY_H

//自己的通用的数组类
#include <iostream>
using namespace std;

template<class T>
class MyArray
{
public:

    //有参构造  参数 容量
    MyArray(int capacity)
    {
       // cout << "有参构造函数" << endl;
        this->m_Capacity = capacity;
        this->m_Size = 0;
        this->pAddress = new T[this->m_Capacity];
    }

    //拷贝构造
    MyArray(const MyArray &arr)
    {
        //cout << "拷贝构造函数" << endl;
        this->m_Capacity = arr.m_Capacity;
        this->m_Size = arr.m_Size;
        //this->pAddress = arr.pAddress; //系统提供的线拷贝

        //深拷贝
        this->pAddress = new T[arr.m_Capacity];

        //将arr中的数据都拷贝过来
        for(int i = 0 ; i < this->m_Size ; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
    }

    //operator= 防止线拷贝问题
    MyArray& operator=(const MyArray &arr)
    {
        //cout << "operator= 函数" << 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];
        for(int i = 0 ; i < this->m_Capacity ; i++)
        {
            this->pAddress[i] = arr.pAddress[i];
        }
        return *this;

    }

    //尾插法
    void Push_Back(const T & val)
    {
        //判断容量是否等于大小
        if(this->m_Capacity == this->m_Size)
        {
            return;
        }
        this->pAddress[this->m_Size] = val; //在数组末尾插入数据
        this->m_Size++; //更新数组大小
    }

    //尾删法
    void Pop_Back()
    {
        //让用户访问不到最后一个元素，即为尾删，逻辑删除
        if(this->m_Size == 0)
        {
            return;
        }
        this->m_Size --;
    }

    //通过下标方式访问数组中的元素 arr[0] = 100
    T operator[] (int index)
    {
        return this->pAddress[index];
    }

    //返回数组容量
    int getCapacity()
    {
        return this->m_Capacity;
    }

    //返回数组大小
    int getSize()
    {
        return this->m_Size;
    }


    //析构函数
    ~MyArray()
    {
        //cout << "析构函数调用" << endl;
        if(this->pAddress != NULL)
        {
            delete[] this->pAddress;
            this->pAddress;
        }
    }
private:
    T * pAddress; //指针指向堆区开辟的真实数组

    int m_Capacity; //数组容量

    int m_Size; //数组大小
};

#endif //_03_STL_MYARRAY_H
  • 测试代码
#include <iostream>
using namespace std;
#include "MyArray.hpp"

void printIntArray(MyArray<int> &arr)
{
    for(int i = 0 ; i < arr.getSize() ; i++)
    {
        cout << arr[i] << endl;
    }
}

void test01()
{
    MyArray<int> arr1(5);

    for(int i = 0 ; i < 5 ; i++)
    {
        //利用尾插法向数组中插入数据
        arr1.Push_Back(i);
    }

    cout << "arr1的打印输出为：" << endl;
    printIntArray(arr1);

    cout << "arr1的容量为： " << arr1.getCapacity() << endl;
    cout << "arr1的大小为： " << arr1.getSize() << endl;

    MyArray<int> arr2 (arr1);
    cout << "arr2的打印输出为：" << endl;
    printIntArray(arr2);

    //尾删
    arr2.Pop_Back();
    cout << "arr2尾删除后" << endl;
    cout << "arr2的容量为： " << arr2.getCapacity() << endl;
    cout << "arr2的大小为： " << arr2.getSize() << endl;


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

}

//测试自定义数据类型
class Person
{
public:
    Person(){};
    Person(string name , int age)
    {
        this->m_Name = name;
        this->m_Age = age;
    }
    string m_Name;
    int m_Age;
};

void printPerosnArray(MyArray<Person> &arr)
{
    for(int i = 0 ; i < arr.getSize() ; i++)
    {
        cout << "姓名: " << arr[i].m_Name << " 年龄：" << arr[i].m_Age << endl;
    }
}

void test02()
{
    MyArray<Person> arr(10);

    Person p1("小a",22);
    Person p2("小b",2212);
    Person p3("小c",232);
    Person p4("小d",224);
    Person p5("小e",212);

    //将数据插入到数组中
    arr.Push_Back(p1);
    arr.Push_Back(p2);
    arr.Push_Back(p3);
    arr.Push_Back(p4);
    arr.Push_Back(p5);

    printPerosnArray(arr);
}
int main() {
   // test01();
    test02();

    return 0;
}
CodeCode!
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
类模板 Class Templates
Dong_HFUT的博客
06-18 4026
本系列是对 C++ Templates The Complete Guide Second Edition 的学习和解读。本文介绍类模板。
C++类模板
好好学习，天天向上
05-04 1019
C++类模板和相关知识
类模板
江南又一春
12-12 288
1、什么是类模板？ 在定义类的时候,加上一个多个类型参数。在使用类模板时,指 定类型参数应该如何替换成具体类型,编译器据此生成相应的模板类。 2、为什么引入类模板？ 我们常见的一种数据类型：数组。由于数据存储的数据的类型不同，他们可以细分为：整数数组、结构数组、字符串数组等等。我们可以将数组及其上的操作抽象成一个类。而大多时候，我们对于数组的操作是类似的： 查看数组长度 获取其中一个元素 对其中...
模板类详解
最新发布
zgg1985658560的博客
09-05 1953
函数模板就是函数参数使用了通用类型，就是函数模板。template <typename（旧用class）>// 类型参数列表，其中typename可以写成class{}// 以下是对函数模板的调用someFuncconst// 类型参数列表，其中typename可以写成class template < typename T1 , typename T2 > void someFunc(T1 a , T2 a) {
一篇文章读懂类模板
Li5566123的博客
03-30 1945
使用template关键字不仅可以定义函数模版，也可以定义类模板。类模板代表一族类，是用来描述通用数据类型或处理方法的机制。它使类中的成员函数和数据成员可以取任意的数据类型。类模板可以说是说是用类生成类，减少了类的定义数量。 1.类模板的定义与声明： 类模板的一般定义形式如下： template<类型形式参数表>class 类模板名 ｛ //类模版体 ｝ 类模板成员函数形式定义如下： template<类型形式参数表> 返回类型 类模版名 <类型名表>
typecho下载网站模板 v1.2
12-04
typecho下载网站模板是一款基于typecho程序开发的下载网站模板，模板简单大方并且是自适应版本在PC端和移动端都能完美展现，非常适用于做下载网站或者模板分享站点。 模板说明： 1、采用顶部大图背景+标题 2、默认...
opencart 模板1.2.zip
01-15
"Opencart模板1.2.zip"是一个专为Opencart设计的皮肤或主题包，适用于1.2版本的系统。这个压缩包包含了用于改变商店外观和用户体验的文件集合。 在电子商务网站中，模板是至关重要的，因为它不仅影响着网站的视觉...
图表类PPT模板.zip
02-18
1.2 设计目的：图表类PPT模板旨在简化数据分析报告的制作过程，通过视觉化手段增强数据的可读性和吸引力，使复杂的统计结果更易理解。 二、常见图表类型及其应用场景 2.1 折线图：用于展示趋势变化，如销售额随...
ace模板1.2和1.3
03-16
Ace模板1.2和1.3是该框架的两个不同版本，它们在用户体验、性能优化以及功能扩展上都有所改进。 1. Ace框架介绍 Ace是一个基于Bootstrap的前端开发框架，它提供了丰富的UI组件，如导航栏、表单、按钮、模态框等，...
创建一个数据类型为T的链表类模板List，实现以下成员函数的模拟测试.cpp
06-04
1) 用List模板定义一个List类型的模板类对象int_listB，从键盘读入m个整数，调用Push_back函数将这m个整数依次插入到该链表中；（4分） 2) 用List模板定义一个List类型的模板类对象int_listC，从键盘读入n个整数，...
【C++】类模板(template)作用对比举例
皓皓松的博客
07-07 1万+
一、类模板 类模板是后期C++加入的一种可以大大提高编程效率的方法 关键字template 用法 template class T {      //.... }   二、举个栗子 我们要写一个比较类，类里面有两个私有成员 在类里有求私有成员中的最大值和最小值的两个公有成员 用来判断两个数的大小   下面我们来进行有无类模板的比较 （1）不用类模板 class
C++模板的实现（模板函数和模板类，附带模板实现顺序表和链表代码）
龙跃十二
05-05 3133
模板 一、模板函数 模板函数的格式： 模板参数隐式实例化 模板参数显示实例化 二、模板类 模板类的格式 模板类示例 模板  当我们实现一个交换函数时，我们可以写成如下。 void Swap(int&amp; x, int&amp; y) { int tmp = x; x = y; y = tmp; }  这里只能交换两个整数...
类的成员模板的类内和类外定义方法
程序员黄老师的精品课！
04-24 4856
#include "stdafx.h"  #include   using namespace std; //---------------------------------情况1: 类模板中成员模板的类体内定义方法：-------------------------------------------- template//类模板 class A { public
C++ Template 基础篇（二）：类模板
lezardfu的专栏
02-26 2万+
Template所代表的泛型编程是C++语言中的重要的组成部分，我将通过几篇blog对这半年以来的学习做一个系统的总结，本文是基础篇的第二部分。 类模板定义 类模板 类模板中的成员函数模板 类模板Tips 类模板中的static成员 类模板成员函数实例化 类模板别名 特化与偏特化 类模板的特化与偏特化 类模板成员特化 类模板定义类模板也是公共逻辑的抽象，通常用来作为容器（例如：vector）或者行为
类模板和模板类
热门推荐
low5252的博客
07-04 5万+
类模板和模板类 所谓类模板，实际上是建立一个通用类，其数据成员、成员函数的返回值类型和形参类型不具体指定，用一个虚拟的类型来代表。使用类模板定义对象时，系统会实参的类型来取代类模板中虚拟类型从而实现了不同类的功能。 定义一个类模板与定义函数模板的格式类似，必须以关键字template开始，后面是尖括号括起来的模板参数，然后是类名，其格式如下： template <typename 类型参数&...
C++ 类模板与模板类详解
weixin_30907935的博客
11-18 6254
　　在C++的Template中很多地方都用到了typename与class这两个关键字，有时候这两者可以替换，那么这两个关键字是否完全一样呢？ 　　事实上class用于定义类，在模板引入c++后，最初定义模板的方法为:template<class T>,这里class关键字表明T是一个类型，后来为了避免class在这两个地方的使用可能给人带来混淆，所以引入了typename这个关键...
ADS1.2新手入门：LED闪烁程序示例
"ADS1.2新手使用教程，通过ADS开发ARM环境进行编程，结合周立功单片机的实验套件进行学习。教程提供了一个简单的ADS使用例程，以控制EasyARM2104实验板上的LED1闪烁，旨在帮助初学者入门。" 在深入学习ADS1.2之前，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值