06-C++ 模板

最新推荐文章于 2024-06-19 20:37:33 发布
最新推荐文章于 2024-06-19 20:37:33 发布
阅读量494 收藏 11
点赞数 8
分类专栏： C/C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhb_feng/article/details/135308561
版权

模板、类型转换

模板

1. 简介

一种用于实现 通用编程 的机制。

将 数据类型 可以作为参数进行传递 。

通过使用模板，我们可以编写可复用的代码，可以适用于多种数据类型。

c++模板的语法使用尖括号 < > 来表示泛型类型，并使用关键字 template 来定义和声明模板。

示例：

#include <iostream>

using namespace std;
// 定义一个模板函数,此处 typename 可以替换成 class 二者作用相同
template<typename T>
T add(T a, T b)
{
    return a + b;
}

int main(int argc, char *argv[])
{
    int x = 5, y = 10;
    float f1 = 2.5, f2 = 3.7;
    // 调用模板函数
    std::cout << "Sum of integers: " << add(x, y) << std::endl;
    std::cout << "Sum of floats: " << add(f1, f2) << std::endl;
    return 0;
}

1.1 原理

  • 编译器并不是把函数模板处理成能够处理任何类型的函数；

  • 函数模板通过具体类型产生不同的函数

  • 编译器会对函数模板进行 两次编译：

    • 在 声明 的地方对 模板代码本身 进行编译；
    • 在 调用 的地方对 参数替换后的代码 进行编译

1.2 分类

函数模板

类模板

2. 函数模板

2.1 步骤

  1. 声明
  2. 使用

2.2 声明语法

//class 和 typename 都是一样的，用哪个都可以
template<class 模板名,class 模板名,...>
//或
template<typename 模板名,typename 模板名,...>

注意：

位置：函数上

2.3 使用语法

在该函数 任何一处 使用 数据类型 的地方都可以使 用模板名替换 。

2.4 注意

  1. 函数模板 可以 自动推导参数的类型，但是 不会进行类型转换
  2. 函数模板 可以自动类型推导，也可以显式指定类型
  3. 只能在 声明的 所在函数中使用

2.5 示例

#include <iostream>

using namespace std;
template<class X>
void add(X a, X b)
{
    cout << "a+b=" << a + b << endl;
}
void add02(int a, int b)
{
    cout << "a+b=" << a + b << endl;
}

int main(int argc, char *argv[])
{
    add(10, 20); //a+b=30
    add(10.2, 20.3); //a+b=30.5
    add('a', 'b'); //a+b=195
    //模板可以推导其对应的数据类型,但是无法进行自动转换
    //add(1, 'a'); // 报错

    //普通函数可以进行自动类型转换
    add02(1, 'a'); //a+b=98

    //模板可以显示替换
    add<int>(1,2); //a+b=3
    add<int>(1,'a'); //a+b=3
    return 0;
}

2.6 普通函数和模板函数的区别

(1)、函数模板不允许自动类型转化，普通函数能够自动进行类型转；

示例：

同上面示例

(2)、函数模板和普通函数同时识别，优先使用普通函数 ，加<>强制使用函数模板

示例：

template<typename T>
void func(T a, T b){
	cout<<"函数模板"<<endl;
} 
//普通函数
void func(int a, int b){
	cout<<"普通函数"<<endl;
} 
void test02()
{ 
    //普通函数
	func(10, 20);
    //显示调用函数模板
	func<>(10, 20);
}

(3)、函数模板可以使用<>，普通函数不行

2.7 函数模板的局限性

在函数模板的数据类型 为对象的时候，打印对象会报错，因为 没有 重载<< 运算符

解决方案：

  • 重载 << 运算符
  • 函数模板具体化

示例：

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

template <class X>
void print(X x)
{
    cout << x << endl;
}

class Person{
//    friend ostream& operator <<(ostream& out,Person& p);
    friend void print<Person>(Person p);
private:
    char name[50];
    int age;
public:
    Person(){}
    Person(char *name,int age){
        strcpy(this->name,name);
        this->age = age;
    }
};

//1、重载运算符
//ostream& operator <<(ostream& out,Person& p)
//{
//    out << p.name << "\t" << p.age << endl;
//    return out;
//}

//2、函数模板具体化
template<> void print<Person>(Person p)
{
    cout << p.name << "\t" << p.age << endl;
}
int main(int argc, char *argv[])
{
    print(10);
    Person p("张三",18);
    print(p);
    return 0;
}

//10
//张三	18

3. 类模板

3.1 步骤、语法

同函数模板

3.2 位置

在类上

3.3 使用

3.3.1 创建对象

用法：

类名<实际数据类型1,实际数据类型2,...> 对象名(实参列表);

注意：

  • 类模板 实例化对象 是 不能自动推导类型，需指定

示例：

#include <iostream>
#include <string>
using namespace std;
template<class X,class Y>
class Data{
private:
    X x;
    Y y;
public:
    Data(){}
    Data(X x,Y y)
    {
        this->x = x;
        this->y = y;
    }

    void print()
    {
        cout << "x = " << x << endl;
        cout << "y = " << y << endl;
    }
};

int main(int argc, char *argv[])
{
    //类模板创建对象
    Data<int,char> d01(10,'a');
    d01.print();

    Data<string,int> d02("张三",18);
    d02.print();
//    类模板创建对象时必须说明其模板的数据类型
//    Data d03("张三",18); //报错
//    d03.print();

    return 0;
}

//x = 10
//y = a
//x = 张三
//y = 18
3.3.2 类模板的派生
  • 类模板派生 普通子类
  • 类模板派生 类 模板

示例：

#include <iostream>
#include <string>
using namespace std;
template<class X,class Y>
class Data{
private:
    X x;
    Y y;
public:
    Data(){}
    Data(X x,Y y)
    {
        this->x = x;
        this->y = y;
    }

    void print()
    {
        cout << "x = " << x << endl;
        cout << "y = " << y << endl;
    }
};
//子类继承与类模板,要么说明其模板的数据类型
class Content:public Data<int,int>{
public:
    Content(){}
    Content(int x,int y):Data(x,y){}
};
//要么自己也是类模板
template <class X,class Z>
class Context:public Data<X,Z>{
public:
    Context(){}
    Context(X x,Z y):Data<X,Z>(x,y){}
};
int main(int argc, char *argv[])
{
    Content c01(10,20);
    c01.print();

    Context<string,string> c02("德玛","男");
    c02.print();
    return 0;
}

//x = 10
//y = 20
//x = 德玛
//y = 男
3.3.3 类模板成员函数外部实现

注意：外部实现函数时也需定义与类相同的函数模板

示例：

#include <iostream>

using namespace std;
template<class X,class Y>
class Data{
private:
    X x;
    Y y;
public:
    Data();
    Data(X x,Y y);
    void print();
};
//外部实现，也需要定义类的模板
template<class X,class Y>
Data<X,Y>::Data()
{

}
template<class X,class Y>
Data<X,Y>::Data(X x,Y y)
{
    this->x = x;
    this->y = y;
}
template<class X,class Y>
void Data<X,Y>::print()
{
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
}

int main(int argc, char *argv[])
{
    Data<int,double> d01(10,20.0);
    d01.print();
    return 0;
}

//x = 10
//y = 20
3.3.4 类模板的分文件实现
在实例化模板之前，编译器对模板的定义体是不处理的
在实例化模板时编译器必须在上下文中可以查看到其定义实体
因此模板的实例化与定义体必须放到同一文件中。
但是如果文件名为.h皆为是头文件,在头文件中定义函数不符合头文件的将声明与实例分开的规则
顾将头文件名改为hpp,并在前内部进行示例化

data.hpp 头文件

#include <iostream>

using namespace std;
template<class X,class Y>
class Data{
private:
    X x;
    Y y;
public:
    Data();
    Data(X x,Y y);
    void print();
};
template<class X,class Y>
Data<X,Y>::Data()
{

}
template<class X,class Y>
Data<X,Y>::Data(X x,Y y)
{
    this->x = x;
    this->y = y;
}
template<class X,class Y>
void Data<X,Y>::print()
{
    cout << "x = " << x << endl;
    cout << "y = " << y << endl;
}

main.cpp

#include <iostream>
#include "data.hpp"
using namespace std;

int main(int argc, char *argv[])
{
    Data<int,double> d01(10,20.0);
    d01.print();
    return 0;
}

//x = 10
//y = 20
3.3.5 类模板作为函数参数

注意：该函数必须是类模板的友元函数

  • 类模板的对象作为参数，数据类型写死，就是int,char等，

    • 弊端：在调用该函数时，传递的对象的数据类型就只能是写死的类型

  • 将该函数也创建成与类模板相同的函数模板，函数的参数是 同类模板的数据类型的类模板对象

示例：

#include <iostream>

using namespace std;
template<class X,class Y>
class Data{
    //
//    friend void showData(Data<int,char> & data);
    template<class Z,class W>
    friend void showData(Data<Z,W> & data);
private:
    X x;
    Y y;
public:
    Data(){}
    Data(X x,Y y){
        this->x = x;
        this->y = y;
    }
};

//类模板的对象作为参数，数据类型写死，就是int,char,
//弊端：在调用该函数时，传递的对象的数据类型就只能是写死的类型
//void showData(Data<int,char> & data)
//{
//    cout << data.x << "\t" << data.y << endl;
//}

//将该函数也创建成与类模板相同的函数模板，
//函数的参数是 同类模板的数据类型的类模板对象
template<class X,class Y>
void showData(Data<X,Y> & data)
{
    cout << data.x << "\t" << data.y << endl;
}

int main(int argc, char *argv[])
{
    Data<int,char> d01(100,'a');
    showData(d01); //100    a

    Data<int,double> d02(100,1.0);
    showData(d02); //100    1
    return 0;
}

4.练习：自定义集合

示例：数组长度可变，可以存储基本类型数据，也可以存储对象

arraylist.hpp 头文件

#include <iostream>
#include <cstring>
#include <cstdlib>

using namespace std;
template<class T>
class ArrayList{
private:
    //记录数组的地址
    T *data;
    //记录已存数组的个数
    int size;
    //记录可容纳数组的个数
    int count;
public:
    ArrayList();
    ~ArrayList();

    //添加数据函数
    void add(T t);
    //获取集合函数
    T& get(int index);
    //获取集合长度
    int getSize();
};
//实现无参构造
template<class T>
ArrayList<T>::ArrayList()
{
    this->count = 2;
    this->size = 0;
    this->data = new T[count];
}
//实现析构
template<class T>
ArrayList<T>::~ArrayList()
{
    if(data != NULL)
    {
        delete [] data;
        data = NULL;
    }
}
//实现添加数据函数
template<class T>
void ArrayList<T>::add(T t)
{
    if(size == count)
    {
        //满了，扩容
        count = count * 2;
        T *newData = new T[count];
        memcpy(newData, data, size*sizeof(T));
        delete [] data;
        data = newData;
    }
    data[size] = t;
    size++;
}
//实现获取数据函数
template<class T>
T& ArrayList<T>::get(int index)
{
    return data[index];
}
//实现获取集合长度函数
template<class T>
int ArrayList<T>::getSize()
{
    return size;
}

main.cpp

#include <iostream>
#include "arraylist.hpp"

using namespace std;

void fun01()
{
    ArrayList<int> a1;
    a1.add(1);
    a1.add(3);
    a1.add(5);
    a1.add(7);
    a1.add(9);

    int size = a1.getSize();
    cout << "长度为:" << size << endl;

    for(int i = 0; i < size; i++)
    {
        cout << a1.get(i) << endl;
    }
}

class Person{
private:
    char *name;
    int age;
public:
    Person(){}
    Person(char *name, int age)
    {
        //指针直接赋值
        this->name = name;
        //字符串指针不可以使用strcpy,字符串指针存储的是字符串的首地址，使用strcpy会出现内存污染
//        strcpy(this->name, name);
        this->age = age;
    }
    ~Person(){}
    void print_info()
    {
        cout << "姓名: " << name << "\t年龄:" << age << endl;
    }
};

void fun02()
{
    Person p1("张三", 18);
    Person p2("李四", 13);
    Person p3("王五", 13);
    Person p4("钱⑥", 12);
//    p1.print_info();

    ArrayList<Person> a1;
    a1.add(p1);
    a1.add(p2);
    a1.add(p3);
    a1.add(p4);

    int size = a1.getSize();
    cout << "长度为:" << size << endl;

    for(int i = 0; i < size; i++)
    {
        a1.get(i).print_info();
    }

}

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

//长度为:5
//1
//3
//5
//7
//9
//长度为:4
//姓名: 张三	年龄:18
//姓名: 李四	年龄:13
//姓名: 王五	年龄:13
//姓名: 钱⑥	年龄:12

类型转换

1.上行转换、下行转换

  • 上行转换

    • 父类指针指向子类空间 安全的

  • 下行转换

    • 子类指针指向父类空间 不安全的

2. 类型转换

2.1 C提供的强制转换
语法: (转换后的类型)要转换的数据或变量
2.2 静态转换

语法：

static_cast<T>(要转换的数据)

示例：

//基本类型转换 支持
int num = static_cast<int>(3.14f);

//基本指针类型转换 不支持
float f=0.0f;
//int *p1 = static_cast<int *>(&f);

//上行转换 支持（安全）
Base *p2 = static_cast<Base *>(new Son);

//下行转换 支持（不安全）
Son *p3 = static_cast<Son *>(new Base);

//不相关类型转换 不支持
//Son *p4 = static_cast<Son *>(new Other);
2.3 动态类型转换

语法：

dynamic_cast<T>(要转换的数据)

示例：

//基本类型转换 不支持
//int num = dynamic_cast<int>(3.14f);

//基本指针类型转换 不支持
float f=0.0f;
//int *p1 = dynamic_cast<int *>(&f);

//上行转换 支持（安全）
Base *p2 = dynamic_cast<Base *>(new Son);

//下行转换 不支持（不安全）
//Son *p3 = dynamic_cast<Son *>(new Base);

//不相关类型转换 不支持
//Son *p4 = dynamic_cast<Son *>(new Other);
2.4 常量转换

语法：

const_cast<T>

注意：

只能对指针与引用的变量使用

示例：

//将非const 转换成 const
int num = 10;
const int *p1 = const_cast<const int *>(&num);

//将const 转换成 非const
const int data=0;
int *p = const_cast<int *>(&data);
2.5 重新解释转换

简介：

这是最不安全的一种转换机制，最有可能出问题。
主要用于将一种数据类型从一种类型转换为另一种类型。它可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针.

语法：

reinterpret_cast<T>

示例：

//基本类型转换 不支持
//int num = reinterpret_cast<int>(3.14f);

//基本指针类型转换 支持
float f=0.0f;
int *p1 = reinterpret_cast<int *>(&f);

//上行转换 支持（安全）
Base *p2 = reinterpret_cast<Base *>(new Son);

//下行转换 支持（不安全）
Son *p3 = reinterpret_cast<Son *>(new Base);

//不相关类型转换 支持
Son *p4 = reinterpret_cast<Son *>(new Other);
小玖工作坊
关注
  • 8
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
c++模板 --- 模板的嵌套
weixin_60569662的博客
02-06 3662
明白类型是什么即可，可以适当运用using语法起别名 简化代码 函数模板嵌套 template <class _Ty1,class _Ty2> class MM { public: MM(_Ty1 one, _Ty2 two) :one(one), two(two) {} friend ostream& operator<<(ostream& out, const MM& mm) { out << mm.one <&..
C++--模板函数
gaoxiaochan的博客
04-21 3363
15.模板template函数：是对对每种类型求最小值时方便采用的一种函数。使用模板函数可以对任何能比较大小(<)的类型使用一个定义好的模板让编译器自动生成一个针对该数据类型的具体函数。 #include <iostream> using namespace std; /* int minValue(int a,int b) {//定义一个整型变量的最小值函数return a<b?a: b if (a< b) return a; else return b; d
requires表达式 ---C++ 20 模板
qq_42896106的博客
06-19 2284
还可以接一个表达式,该表达式也是一个纯右值表达式,表达式为时满足约束条件,则不满足约束条件表达式的判定标准:对表达式进行模板实参的替换,如果替换之后出现无效类型,或者违反约束条件,则值为,反之为 失败原因由于没有操作,所以编译失败除此之外,我们还可以使用更灵活的方式,进行更多的限定: 在上面的requires表达式中，和可以说是对模板实参的两个要求，这些要求在C++标准中称为要求序列。要求序列分为4种，包括简单要求、类型要求、复合要求以及嵌套要求只要语法正确就行,编译器不会计算其结果 类型要求 type
C++---模板进阶
qq_47406941的博客
04-24 2657
目录 一、非类型模板参数 1、非类型模板参数的介绍 2、非类型模板参数的使用 二、模板的特化 1、模板特化的概念 2、函数模板的特化 3、类模板的特化 三、模板的分离编译 1、什么是分离编译 2、模板的分离编译 四、模板的优点和缺点 一、非类型模板参数 1、非类型模板参数的介绍 模板参数分为类类型模板参数和非类型模板参数。 类类型模板参数：出现在模板参数中，跟在class或者typename后面的参数类型名称。 非类型模板参数：用一个常量作为类或者函数模板的一...
Dev-c++入门教程1（模板及使用）
zzz209的博客
11-22 2442
上次我们说道改中文。这节教程正式开始教授。 #使用 点击右上角的这个图标 选择源代码 现在变成了这样 模板 这是Dev-c++的通用模板，大部分程序都是这样的 #include <iostream> using namespace std; int main(){ //主代码部分 return 0; } 先用上面的模板编一个Hello worlld的程序 #include <iostream> using namespace std; int main()
基于C++的ACM-ICPC模板
02-22
基于C++的ACM-ICPC模板
朱老师C++课程第3部分3.1-C++模板编程入门
06-30
《朱老师带你学C++》属于系列课程《朱有鹏老师热门编程语言全解》的第一部分，主要针对C++语言学习。本课程可以看做是嵌入式linux核心课程中《C语言专题》课程的延续，在学好了C语言前提下继续深度学习C++语言。整个...
小熊猫c++开发工具(Dev-C++升级版本)免安装版本
04-14
补全时插入用户代码模板等 支持STL容器类 支持C++11智能指针 修正了代码分析器的一系列bug，更好的支持C++，能够正确的解析和补全提示mingw gcc 9.2, mingw-w64 gcc 10.2自带标准头文件 代码分析器优化和速度提升。...
谷歌 B-Tree C++ 模板库
03-15
谷歌开源团队近日发布了C++ B-Tree，这是一个C++模板库，实现了基于B-tree数据结构的有序内存容器。类似于STL的map、set、multimap和multiset模板，C++ B-tree也提供了btree_map、btree_set、btree_multimap和btree_...
阅读材料-C++ 模板中的typename、class关键字.rar_C++ typename_class
09-23
C++ Template中的typename、class关键字，模板中关键字的class与typename的作用
2024华为OD机试真题-生成哈夫曼树-(C++/Python)-C卷D卷-100分
goldarmour的博客
06-19 463
给定长度为 n 的无序的数字数组，每个数字代表二叉树的叶子节点的权值，数字数组的值均大于等于1。请完成一个函数，根据输入的数字数组，生成哈夫曼树，并将哈夫曼树按照中序遍历输出。为了保证输出的二叉树中序遍历结果统一，增加以下限制： 二叉树节点中，左节点权值小于右节点权值，根节点权值为左右节点权值之和。当左右节点权值相同时，左子树高度小于等于右子树高度。
C++ Thead互斥量死锁，mutex如何防止死锁---C++11多线程快速学习
最新发布
weijia3624的专栏
06-19 131
例如，都先获取 mtx1 的所有权，再获取 mtx2 的所有权，或者都先获取 mtx2 的所有权，再获取 mtx1 的所有权。这样就可以避免死锁问题。因为 T1 获取了 mtx1 的所有权，但是无法获取 mtx2 的所有权，而 T2 获取了 mtx2 的所有权，但是无法获取 mtx1 的所有权，两个线程互相等待对方释放互斥量，导致死锁。而 T2 也是先获取 mtx2 的所有权，再获取 mtx1 的所有权，T1 先获取 mtx2 的所有权，再获取 mtx1 的所有权，这样就避免了死锁问题。
C++ Primer Chapter 10 Generic Algorithms
qq_22609521的博客
06-12 246
其中，capture list（捕获列表）是一个lambda所在函数中定义的局部变量的列表（通常为空）；单数，与普通函数不同，lambda必须使用尾置返回来指定返回类型。一个lambda表达式表示一个可调用的代码单元。与任何函数类似，一个lambda具有一个返回类型、一个参数列表和一个函数体。即，如果e是一个可调用的表达式，则我们可以编写代码e(args)，其中args是一个逗号分隔的一个或多个参数的列表。对于一个对象或一个表达式，如果对其使用调用运算符，则称它为可调用的。
C++回溯算法(2)
BanyeBirth的博客
06-19 58
【代码】C++回溯算法(2)
C语言猜输赢游戏
qq_69383179的博客
06-15 1637
这里有关于C语言猜输赢游戏的程序
4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例
qq_43071699的博客
06-12 158
【代码】4 最简单的 C 程序设计—顺序程序设计-4.6 顺序结构程序设计举例。
C++|哈希结构封装unordered_set和unordered_map
weixin_68201503的博客
06-11 873
上一篇章，学习了unordered系列容器的使用，以及哈希结构，那么这一篇章将通过哈希结构来封装unordered系列容器，来进一步的学习他们的使用以及理解为何是如此使用。其实，哈希表的封装方式和红黑树的封装方式形式上是差不多的，如果有了红黑树的封装理解经验，我相信在理解哈希封装的过程会减少负担的。当然，在使用哈希结构中采用的是更具代表的哈希桶，接下来进行封装。
华为OD机试C卷（100分）-最大N个数与最小N个数的和（C语言）
欢迎来到我的博客~
06-16 171
给定一个数组，编写一个函数来计算它的最大N个数与最小N个数的和。你需要对数组进行去重。说明 最大2个数[100,95],最小2个数[83,64], 输出为342。说明 最大2个数[4,3],最小2个数[3,2], 有重叠输出为-1。最大N个数与最小N个数不能有重叠，如有重叠，输入非法返回-1。第三行输入N，N表达需要计算的最大、最小N个数。数组中数字范围[0, 1000]第一行输入M， M标识数组大小。第二行输入M个数，标识数组内容。输出最大N个数与最小N个数的和。
【C++】循环、控制流语句、
因为热爱所以坚持
06-19 452
我们约定成俗是这样使用的：当我们确实是想无限持续循环的，比如游戏，就是想让一帧帧一直循环，我们不在意究竟循环了多少次，循环到哪里，就是不介意是否要去声明i，也不介意i究竟是多少了，就是想无限循环下去，那我们就使用while循环。如果条件是true，就执行循环体，一直执行到for循环的最后的花括号}，跳回到for语句，此时首先执行的是i++，然后再判断条件，条件true就是上面的一套流程；如此循环，直到B不满足条件，也就是B返回false，指令指针跳出for循环，也就是执行E后面的代码行(第12行)。
dev-c++5.10
02-08
而且，它还提供了丰富的代码模板和自动完成功能，帮助开发者提高编码效率。 另外，dev-c 5.10还支持多种版本控制系统，如Git和SVN，方便开发团队进行协作开发和代码的版本管理。它还提供了丰富的插件和扩展，可以...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值