C++泛编程

已于 2023-07-04 14:19:58 修改
阅读量99 收藏 1
点赞数
分类专栏： C++11简单的使用方法 文章标签： c++ 算法 开发语言
于 2023-03-25 23:19:23 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41701723/article/details/129771721
版权

泛编程

在这里插入图片描述

自动推导类型

在C++11中，赋予了auto全新的含义，不再用于修饰变量，而是作为一个类型指示符，指示编译器在编译时推导auto声明的变量的数据类型。

auto 变量名 = 初始值;

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          

int main()
{
    auto a = 3; cout<<"a="<<a<<endl;
    auto b = 3.3; cout<<"b="<<b<<endl;
    auto c = "西施"; cout<<"c="<<c<<endl;
}

不要滥用auto，auto在编程时真正的用途如下：
1）代替冗长复杂的变量声明。
2）在模板中，用于声明依赖模板参数的变量。
3）函数模板依赖模板参数的返回值。
4）用于lambda表达式中。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
double func(double b, const char* c, float d, short e, long f)
{
	cout << ",b=" << b << ",c=" << c << ",d=" << d << ",e=" << e << ",f=" << f << endl;
	return 5.5;
}
          
int main()
{
    cout<<"使用函数指针"<<endl;
	double (*pf)( double , const char* , float , short , long );    // 声明函数指针pf。
  	pf = func;
	pf( 2, "西施", 3, 4, 5);

    cout<<"使用auto"<<endl;
	auto pf1 = func;
	pf1(2, "西施2", 3, 4, 5);
}

函数模板

函数模板是通用的函数描述，使用任意类型（泛型）来描述函数。

编译的时候，编译器推导实参的数据类型，根据实参的数据类型和函数模板，生成该类型的函数定义。

创建交换两个变量的函数模板：

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

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
template <typename T>
void Swap(T &a, T &b)
{
	T tmp = a;
	a = b;
	b = tmp;
}
    
int main()
{
    int a,b;
    a = 1;
    b = 2;
    Swap(a,b);
    cout<<a<<"   "<<b<<endl;
}

函数模板使用typename,类模板使用class

1）可以为类的成员函数创建模板，但不能是虚函数和析构函数。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
class CGirl{
public:
    template <typename T>
    CGirl(T a){
        cout<<"a = "<<a<<endl;
    }
    template <typename T>
    void show(T b){
        cout<<"b = "<<b<<endl;
    }
};

    
int main()
{
    CGirl girl("aa");
    girl.show(111);

    CGirl girl2(2);
    girl2.show(222);

    return 0;
}

2）使用函数模板时，必须明确数据类型，确保实参与函数模板能匹配上。
3）使用函数模板时，推导的数据类型必须适应函数模板中的代码。
4）使用函数模板时，如果是自动类型推导，不会发生隐式类型转换，如果显式指定了函数模板的数据类型，可以发生隐式类型转换。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
template <typename T>
T Add(T a, T b){

    return a+b;
}

    
int main()
{
    int a = 10;
    char b = 20;

    int c = Add<int>(a,b);
    cout<<"c = "<<c<<endl;

    return 0;
}

5）函数模板支持多个通用数据类型的参数。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
template <typename T1,typename T2>
void show(T1 a, T2 b){

    cout<<"a = "<<a<<"  b = "<<b<<endl;
}

    
int main()
{
    int a = 1;
    string b = "b";
    show(a,b);
}

6）函数模板支持重载，可以有非通用数据类型的参数。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

 template <typename T1>
void show(T1 a){

    cout<<"a = "<<a<<endl;
}

template <typename T1,typename T2>
void show(T1 a, T2 b){

    cout<<"a = "<<a<<"  b = "<<b<<endl;
}

template <typename T1,typename T2,typename T3>
void show(T1 a, T2 b,T3 c){

    cout<<"a = "<<a<<"  b = "<<b<<"c = "<<c<<endl;
}

    
int main()
{
    int a = 1;
    string b = "b";
    float c = 1.1111;
    show(a,b);
    show(a,b,c);
}

函数模板的具体化

可以提供一个具体化的函数定义，当编译器找到与函数调用匹配的具体化定义时，将使用该定义，不再寻找模板。

template<> void 函数模板名<数据类型>(参数列表)
template<> void 函数模板名 (参数列表)
{
	// 函数体。
}

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
                      
class CGirl            // 超女类。
{
public:
	int m_bh;              // 编号。
	string m_name;   // 姓名。
	int m_rank;          // 排名。
};
              
template <typename T>
void Swap(T& a, T& b);      // 交换两个变量的值函数模板。
            
template<> 
void Swap<CGirl>(CGirl& g1, CGirl& g2);      // 交换两个超女对象的排名。
// template<> 
// void Swap(CGirl& g1, CGirl& g2);      // 交换两个超女对象的排名。
           
int main()
{
	int a = 10, b = 20;
	Swap(a, b);           // 使用了函数模板。
	cout << "a=" << a << ",b=" << b << endl;
            
	CGirl g1, g2;
	g1.m_rank = 1; g2.m_rank = 2;
	Swap(g1, g2);     // 使用了超女类的具体化函数。
	cout << "g1.m_rank=" << g1.m_rank << ",g2.m_rank=" << g2.m_rank << endl;
}
            
template <typename T>
void Swap(T& a, T& b)      // 交换两个变量的值函数模板。
{
	T tmp = a;
	a = b;
	b = tmp;
	cout << "调用了Swap(T& a, T& b)\n";
}
        
template<> 
void Swap<CGirl>(CGirl& g1, CGirl& g2)      // 交换两个超女对象的排名。
// template<> 
// void Swap(CGirl& g1, CGirl& g2)      // 交换两个超女对象的排名。
{
	int tmp = g1.m_rank;
	g1.m_rank = g2.m_rank;
	g2.m_rank = tmp;
	cout << "调用了Swap(CGirl& g1, CGirl& g2)\n";
}

具体代码如下：
在这里插入图片描述
在这里插入图片描述

对于给定的函数名，可以有普通函数、函数模板和具体化的函数模板，以及它们的重载版本。

1）具体化优先于常规模板，普通函数优先于具体化和常规模板。
2）如果希望使用函数模板，可以用空模板参数强制使用函数模板。

Swap<>(1,2);

3）如果函数模板能产生更好的匹配，将优先于普通函数。
在这里插入图片描述

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

void Swap(int a, int b)      // 普通函数。
{ 	
	cout << "使用了普通函数。\n";  
}

template <typename T> 
void Swap(T a, T b)          // 函数模板。
{	
	cout << "使用了函数模板。\n";  
}

template <> 
void Swap(int a, int b)     // 函数模板的具体化版本。
{ 	
	cout << "使用了具体化的函数模板。\n";  
}
         
int main()
{
	Swap('c', 'd');
    float a = 1.11;
    float b =2.222;
    Swap(a,b);
	Swap<>(1,2);
}

普通函数优于具有函数模板
在这里插入图片描述

具体函数模板化优于普通函数模板
在这里插入图片描述

使用空模板参数强制使用函数模板
在这里插入图片描述

函数模板分文件编写

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述

  1. 函数模板只是函数的描述，没有实体，创建函数模板的代码放在头文件中。
  2. 函数模板的具体化有实体，编译的原理和普通函数一样，所以，声明放在头文件中，定义放在源文件中。
/
// public.h
#pragma once
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

void Swap(int a, int b);      // 普通函数。

template <typename T>
void Swap(T a, T b)         // 函数模板。
{
	cout << "使用了函数模板。\n";
}

template <>
void Swap(int a, int b);    // 函数模板的具体化版本。
/

/
// public.cpp
#include "public.h"

void Swap(int a, int b)      // 普通函数。
{
	cout << "使用了普通函数。\n";
}

template <>
void Swap(int a, int b)     // 函数模板的具体化版本。
{
	cout << "使用了具体化的函数模板。\n";
}
/

/
// demo01.cpp
#include "public.h"

int main()
{
	Swap(1,2);         // 将使用普通函数。
	Swap(1.3, 3.5);  // 将使用具体化的函数模板。
	Swap('c', 'd');    // 将使用函数模板。
}
/

在这里插入图片描述

在这里插入图片描述

函数模板高级

decltype关键字

在C++11中，decltype操作符，用于查询表达式的数据类型。
语法：

decltype(expression) var;

decltype分析表达式并得到它的类型，不会计算执行表达式。函数调用也一种表达式，因此不必担心在使用decltype时执行了函数。

推导规则：

  1. 如果expression是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符。
  2. 如果expression是一个函数调用，则var的类型与函数的返回值类型相同（函数不能返回void，但可以返回void *）。
  3. 如果expression是一个左值（能取地址）(要排除第一种情况)、或者用括号括起来的标识符，那么var的类型是expression的引用。
  4. 如果上面的条件都不满足，则var的类型与expression的类型相同。
#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。


// 1）如果expression是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符。
// 2）如果expression是一个函数调用，则var的类型与函数的返回值类型相同（函数不能返回void，但可以返回void *）。
// 3）如果expression是一个左值（能取地址）(要排除第一种情况)、或者用括号括起来的标识符，那么var的类型是expression的引用。
// 4）如果上面的条件都不满足，则var的类型与expression的类型相同。

         
int func1(){
    cout<<"调用了func"<<endl;

    return 1;
};

int main()
{
    cout<<"如果expression是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符。"<<endl;
    short a = 5;
    decltype(a) da;

    short* b = &a;
    decltype(b) db;

    short& c = a;
    decltype(c) dc = a;
    cout<<dc<<endl;

    cout<<"如果expression是一个函数调用，则var的类型与函数的返回值类型相同（函数不能返回void，但可以返回void *）。"<<endl;
    int a1 = 1;
    cout<<"不会调用函数"<<endl;
    decltype(func1())dfunc = a1;
    cout<<"传递函数名，并使用函数指针.."<<endl;
    decltype(func1)* pfunc = func1;
    pfunc();

    cout<<"如果expression是一个左值（能取地址）(要排除第一种情况)、或者用括号括起来的标识符，那么var的类型是expression的引用。"<<endl;
    decltype((a1)) a2=a1;
    cout<<a1<<endl;
    decltype((func1)) myFunc = func1;
    myFunc();

    return 0;
}

如果expression是一个没有用括号括起来的标识符，则var的类型与该标识符的类型相同，包括const等限定符。

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

如果expression是一个函数调用，则var的类型与函数的返回值类型相同（函数不能返回void，但可以返回void *）
在这里插入图片描述

没有调用函数

在这里插入图片描述
如果expression是一个左值（能取地址）(要排除第一种情况)、或者用括号括起来的标识符，那么var的类型是expression的引用。
在这里插入图片描述
在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

decltype的结果要么和表达式的类型相同，要么就是表达式类型的引用

decltype和auto的区别

在这里插入图片描述

函数后置返回类型

int func(int x,double y);
等同：
auto func(int x,double y) -> int;

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

template <typename T1, typename T2>
auto func(T1 x, T2 y) -> decltype(x + y)
{
	// 其它的代码。

	decltype(x+y)  tmp = x + y;
	cout << "tmp=" << tmp << endl;

	return tmp;
}

int main()
{
	cout<<func(3, 5.8)<<endl;

    return 0;
}

C++14的返回值使用auto关键字

C++14标准对函数返回类型推导规则做了优化，函数的返回值可以用auto，不必尾随返回类型。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。

template <typename T1, typename T2>
auto func(T1 x, T2 y) 
{
	// 其它的代码。

	decltype(x+y)  tmp = x + y;
	cout << "tmp=" << tmp << endl;

	return tmp;
}

int main()
{
	cout<<func(3, 5.8)<<endl;

    return 0;
}

类模板

类模板是通用类的描述，使用任意类型（泛型）来描述类的定义。

函数模板建议用typename描述通用数据类型，类模板建议用class

template <class T>
class 类模板名
{
	类的定义;
};

1）在创建对象的时候，必须指明具体的数据类型。
2）使用类模板时，数据类型必须适应类模板中的代码。
3）类模板可以为通用数据类型指定缺省的数据类型（C++11标准的函数模板也可以）。
4）模板类的成员函数可以在类外实现。
5）可以用new创建模板类对象。
6）在程序中，模板类的成员函数使用了才会创建。

#include <iostream>         // 包含头文件。
using namespace std;        // 指定缺省的命名空间。
          
template <class T1, class T2=string>
class AA
{
public:
	T1 m_a;      // 通用类型用于成员变量。
	T2 m_b;      // 通用类型用于成员变量。
          
	AA() {  }        // 默认构造函数是空的。
	// 通用类型用于成员函数的参数。
	AA(T1 a,T2 b):m_a(a),m_b(b) {  }
	// 通用类型用于成员函数的返回值。
	T1 geta()            // 获取成员m_a的值。
	{
		T1 a = 2;        // 通用类型用于成员函数的代码中。
		return m_a + a;
	}
	T2 getb();            // 获取成员m_b的值。
};
           
template <class T1, class T2>
T2 AA<T1,T2>::getb()            // 获取成员m_b的值。
{
	return m_b;
}
            
int main()
{
	AA<int, string>* a = new AA<int, string>(3, "西施");     // 用模板类AA创建对象a。
	
	cout << "a->geta()=" << a->geta() << endl;
	cout << "a->getb()=" << a->getb() << endl;
         
	delete a;
}

在这里插入图片描述

在这里插入图片描述
在这里插入图片描述

模板可以为通用数据类型指定缺省的数据类型（C++11标准的函数模板也可以）。
在这里插入图片描述
在这里插入图片描述

计算机CV民工
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
关于C++泛型编程的一些杂感
03-02
可以说我是对它有很复杂的感情的，其实GP这种东西最好是建立在无类型语言上面，就C++0X目前对GP的支持的趋势来看，确实如此，auto/varadictemplates这些特性的加入象征着C++GP的形式正越来越转向一种更纯粹的泛性...
C++泛编程1自动推导
weixin_42976038的博客
01-31 57
参考：https://www.bilibili.com/video/BV1et4y1u75A/?在C++11中，auto是一个类型指示符，指示编译器在编译时推导auto声明的变量的数据类型。2）初始化的右值可以是具体的数值，也可以是表达式和函数的返回值等。
C++泛编程（4）
weixin_54929649的博客
02-05 704
类模板高级（1） 1.类模板具体化 部分具体化 完全具体化 2.类模板与继承 2.1模板类继承普通类 2.2普通类继承模板类的实例化版本 2.3普通类继承类模板 2.4模板类继承模板类 2.5模板类继承模板参数给出的类
C++泛编程（3）
weixin_54929649的博客
02-04 1016
类模板基础 1.类模板的基本概念 2.类模板的分文件编写 3.类模板的嵌套
高质量C、C++编程指南，编程质量大于一切
04-09
文件结构、程序版式、命名规则、表达式基本语句、变量、函数设计、内存管理 C++高级特性 面向对象、编程经验、C++试题。 是企业代码规范的指标、是成为程序员大神的必备基础。
c++入门经典
01-06
本书全面介绍了 C++ 语言。作为一本入门书（Primer），它以教程的形式 对 C++ 语言进行清晰的讲解，并辅以丰富的示例和...泛可用，我们现在能够比以往任何时候更高效地学习和使用 C++。本书这一版本 充分体现了这一点。
C++Primer第四版中文版
04-09
本书全面介绍了 C++ 语言。作为一本入门书（Primer），它以教程的形式 对 C++ 语言进行清晰的讲解，并辅以丰富的示例和...泛可用，我们现在能够比以往任何时候更高效地学习和使用 C++。本书这一版本 充分体现了这一点。
数据结构与算法学习笔记七--二叉树(C++)
我叫柱子哥
04-23 601
在计算机科学中，树（Tree）是一种抽象数据类型，用于模拟具有树状结构特征的数据集合。树是由一组节点（Nodes）和连接这些节点的边（Edges）组成的，其中一个节点被指定为根节点（Root），其余节点分层组织成子树（Subtrees）。树的每个节点除了根节点外，都恰好连接到一条来自另一个节点的边，这个节点被称为其父节点（Parent Node）。每个节点可以连接到零个或多个子节点，子节点的节点被称为父节点的孩子节点（Child Node）。根节点（Root）：树中的唯一顶层节点，没有父节点。
【C】 初识C语言
努力学习C/C++
04-21 752
从本篇开始，带你从不会C语言到精通C语言。这篇是让大家对C语言有个初步的了解。下面的内容会拆分不同篇幅单独进行详细讲叙。数据类型变量、常量字符串转义字符注释选择语句循环语句函数数组操作符常见关键字define定义常量和宏指针结构体1.什么是C语言？C语言是一门面向过程的计算机编程语言，与C++、C#、Java等面向对象编程语言有所不同。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、仅产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
[C++] 内存布局完整解读
wangdsh的博客
04-19 813
右值引用和移动语义：虽然这些特性主要影响临时对象的处理和函数参数的传递，但它们也可能间接影响内存布局，因为它们允许更高效的资源转移和避免不必要的复制。总之，C++11在内存布局方面提供了更多的控制和标准化，使得开发者能够更精确地管理数据结构在内存中的排列，同时也提高了代码的可移植性和性能。继承和多重继承：在多重继承中，基类的数据成员会先于派生类的数据成员排列，且每个基类的数据成员会按照它们在基类中的顺序排列。统一的内存对齐模型：C++11提供了跨编译器和平台的一致内存对齐模型，这有助于提高代码的可移植性。
[C++]异常
m0_62327743的博客
04-19 412
[C++]异常
C语言：贪吃蛇游戏（万字解读超详细）
2301_80655639的博客
04-20 1031
贪吃蛇这个游戏应该我们小时候都玩过吧我相信能够点进这个博客的应该都很熟悉这个游戏了如果对这个游戏不熟悉的可以网上查查怎么玩，这样才能对这个游戏有个清晰的认知该篇博客需要拥有C语言基础（对指针熟悉、会链表的使用）下面我们需要先学习一些C语言之外的东西认真坚持看完，我相信你一定能完成这个接近500行的C语言贪吃蛇项目该类型内部封装了两个成员，一个x，一个y，代表坐标我们可以将我们的控制台理解为一个平面坐标图横向正方向是x轴正方向，竖向负方向是y轴正方向。
【动态规划】C++ dp子数组问题（最大/最长：环形/子数组和、乘积最大/为正数、单词拆分、子串）
卜及中的博客
04-22 758
文章介绍了子数组类的dp问题，并通过一系列算法题加深对该类问题的解法理解。
C语言 | Leetcode C语言题解之第40题组合总和II
m0_59237910的博客
04-20 445
C语言 | Leetcode C语言题解之第40题组合总和II
ColBERT和ColBERTv2:兼具Bi-encoder和cross-encoder优势的多向量排序模型
beingstrong的博客
04-20 954
ColBERT是一种多向量排序模型，因为引入了延迟交互机制(late interaction architecture)相比与cross-encoder效率提升了很多。ColBERTv2针对ColBERT的缺点进一步优化了性能和效率。在RAG大热的这一年，ColBERT也引起了一些关注。
c语言内存函数
2301_80412235的博客
04-19 779
memcmp 会从第一个字节开始比较，发现前两个字节相同（都是 97 和 98），但在第三个字节上发现不同（99 vs 100）。如果返回 0，则两个字符串在指定的比较长度内是相等的。在比较字符串时， memcmp 会逐字节比较两个字符串的字节序列，直到遇到不同的字节或者达到指定的比较长度。在 ASCII 编码中，每个字符对应一个字节的数值，数值较小的字符在字典序上排在前面。它按照字节比较，从 str1 和 str2 的第一个字节开始，逐字节比较，
C语言--基础面试真题
小张的博客
04-22 1106
在预编译时将宏名替换成字符串的过程称为"宏展开"(也叫宏替换)。宏名一般用大写，以便于与变量区别宏定义不作语法检查，只有在编译被宏展开后的源程序才会报错宏定不要不要行末加分号(a) : (b))​int b = a;​FUNC(10);​return 0;指针（Pointer）是一种特殊的变量类型，它用于存储内存地址。指针的实质就是内存“地址”。
(C++) this_thread 函数介绍
最新发布
cuber-lotus的博客
04-24 1070
在C++11起，标准规定了标注的并发库。头文件为并发支持库 (C++11 起) - cppreference.com其包含线程、原子操作、互斥、条件变量和 future 的内建支持。而其中有一个namespace为，里面有四个重要的全局函数，其实现都与当前系统环境和编译器强绑定。std::this_thread 符号索引 - cppreference.comget_id()yield()返回当前线程的id。这个id是一个的内部类型。其实现依附于所在平台。
C++ socket编程
11-02
C++ socket编程是指使用C++语言进行网络编程，通过socket接口实现网络通信。在C++中，可以使用socket库提供的函数来创建、连接、发送和接收数据等操作。其中，常用的函数包括socket()、bind()、listen()、accept()、...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值