C++速查手册

C++基本语法

简介: C++ 是一种通用的编程语言支持过程编程面向对象编程泛型编程。C++的基本语法类似于C语言

详细介绍: C++ 的基本语法包括:

应用场景: C++ 基本语法适用于各种类型项目,包括桌面应用服务器应用嵌入式系统游戏等。

C++ 数据类型

简介: C++ 数据类型用于表示变量类型和大小。C++ 提供了一组内置数据类型,如整数浮点数字符等。

详细介绍: C++ 的基本数据类型包括:

语法用途模板:

应用场景: C++ 数据类型适用于各种类型的项目,可用于表示各种类型的值,如计数器、金额、距离等。

语法详细代码:

#include <iostream>

int main() 
{
    int a = 10;            // 整数类型
    float b = 3.14f;       // 浮点类型
    char c = 'A';          // 字符类型
    bool d = true;         // 布尔类型

    std::cout &lt;&lt; "a: " &lt;< a << std::endl;
    std::cout << "b: " << b << std::endl;
    std::cout << "c: " << c << std::endl;
    std::cout << "d: " << std::boolalpha << d << std::endl;

    return 0;
}

C++ 修饰符类型

简介: C++ 修饰符类型用于修改基本数据类型的属性,如有符号、无符号、长、短等。

详细介绍: C++ 支持以下修饰符类型:

语法用途模板:

应用场景: C++ 修饰符类型适用于各种类型的项目,用于根据需求调整数据类型的属性,如表示较大的整数、仅表示非负数等。

语法详细代码:

#include <iostream&gt;

int main()
{
    // 定义有符号整数
    signed int a = -10;

    // 定义无符号整数
    unsigned int b = 20;

    // 定义长整数
    long int c = 1234567890L;

    // 定义短整数
    short int d = 1000;

    std::cout << "Signed integer: " << a << std::endl;
    std::cout << "Unsigned integer: " << b << std::endl;
    std::cout << "Long integer: " << c << std::endl;
    std::cout << "Short integer: " << d << std::endl;

    return 0;
}

C++ 存储

简介: C++ 存储类用于描述变量的存储作用域。它影响变量的生命周期和可见性。

详细介绍: C++ 支持以下存储类:

语法用途模板:

应用场景: C++ 存储类适用于各种类型的项目,用于控制变量的存储作用域,以实现代码的封装模块化

语法详细代码:

#include <iostream>

// 外部变量声明
extern int externVar;

// 静态变量定义
static int staticVar = 50;

void exampleFunction() 
{
    // 自动变量定义
    auto int localVar = 10;
    std::cout << "Local
	variable: " << localVar << std::endl;
	// 寄存器变量定义
    register int regVar = 20;
    std::cout << "Register variable: " << regVar << std::endl;
}

// 外部变量定义
int externVar = 30;

int main() 
{
    // 调用函数显示自动变量和寄存器变量
    exampleFunction();
        // 显示静态变量
    std::cout << "Static variable: " << staticVar << std::endl;

    // 显示外部变量
    std::cout << "Extern variable: " << externVar << std::endl;

    return 0;
}

C++ 变量类型

简介: C++ 变量类型用于存储程序中的数据。变量类型是由数据类型定义的,并根据数据类型分配内存

详细介绍: C++ 变量类型包括:

语法用途模板:

应用场景: C++ 变量类型适用于各种类型的项目,用于存储和管理数据。

语法详细代码:

#include <iostream>

// 全局变量
int globalVar = 100;

void exampleFunction() 
{
    // 局部变量
    int localVar = 10;
    std::cout << "Local variable: " << localVar << std::endl;
}

int main() 
{
    // 访问全局变量
    std::cout << "Global variable: " << globalVar << std::endl;
    // 调用函数,显示局部变量
    exampleFunction();
    return 0;
}

C++ 命名空间

简介: C++ 命名空间是一种用于组织代码的方式,避免名称冲突

详细介绍: C++ 命名空间具有以下特点:

应用场景: C++ 命名空间适用于需要组织代码和避免名称冲突的项目,提高代码的可读性和可维护性。

语法详细代码:

#include <iostream>

// 定义命名空间
namespace ns1
{
    int x = 10;

    void display() 
    {
        std::cout << "ns1::display" << std::endl;
    }
}

namespace ns2
{
    int x = 20;

    void display() 
    {
        std::cout << "ns2::display" << std::endl;
    }
}

using ns2::x; // 展开ns2命名空间内的ns2内的x变量;
using namespace ns1;    // 展开命名空间ns1,内置的所有元素会直接放在全局区,就不再需要使用ns1作为域作用限定符访问元素了,但这样会破坏封装性


int main() 
{
    // :: 是域作用操作符访问对应作用域内的数据
    // 需要用命名空间里的数据只需要  命名空间::变量名即可
    // 使用命名空间成员
    std::cout << "ns1::x = " << ns1::x << std::endl;
    std::cout << "ns2::x = " << ns2::x << std::endl;
    

    ns1::display();
    ns2::display();

    return 0;
}

命名空间细节

C++ 变量作用域

简介: C++ 变量作用域是变量在程序中的可见性和生命周期。变量作用域决定了在哪些代码段可以访问变量。

详细介绍: C++ 变量作用域包括:

语法用途模板:

  • 局部作用域: 限制变量只能在定义它们的代码块内访问
  • 全局作用域: 允许在整个程序中访问变量
  • 类作用域: 限制变量只能在类的成员数中访问
  • 命名空间作用域: 允许在整个命名空间内访问变量

应用场景: C++ 变量作用域适用于各种类型的项目,用于控制变量的可见性和生命周期,以实现代码的封装模块化

语法详细代码:

#include <iostream>

// 全局作用域
int globalVar = 100;

// 命名空间作用域
namespace MyNamespace
{
    int namespaceVar = 200;
}

class MyClass
{
public:
    // 类作用域
    int classVar;
    void display() 
    {
        std::cout << "Class variable: " << classVar << std::endl;
    }
};

void exampleFunction() 
{
    // 局部作用域
    int localVar = 10;
    std::cout << "Local variable: " << localVar << std::endl;
}

int main() 
{
    // 访问全局作用域变量
    std::cout << "Global variable: " << globalVar << std::endl;
    // 访问命名空间作用域变量
    std::cout << "Namespace variable: " << MyNamespace::namespaceVar << std::endl;

    // 访问类作用域变量
    MyClass obj;
    obj.classVar = 300;
    obj.display();

    // 调用函数,显示局部作用域变量
    exampleFunction();

    return 0;
}

C++ 常量

简介: C++ 常量固定值的标识符,其值在程序执行期间不能被改变。

详细介绍:
C++ 常量可以通过以下方式定义:

语法用途模板:

应用场景: C++ 常量适用于各种类型的项目,用于表示不会在程序执行过程中改变的值,如圆周率、重力加速度等。

语法详细代码:

#include <iostream>

// 使用 const 关键字定义常量
const double PI = 3.14159;

// 使用 #define 预处理器指令定义常量
#define GRAVITY 9.81

// 使用枚举常量定义
enum WeekDays { MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY };

int main()
{
    std::cout << "Constant PI: " << PI << std::endl;
    std::cout << "Constant GRAVITY: " << GRAVITY << std::endl;
    std::cout << "Constant MONDAY: " << MONDAY << std::endl;

    return 0;
}

C++ 运算符

简介: C++ 运算符用于对一个多个操作执行特定的操作,如算术运算逻辑运算、比较运算等。

详细介绍:
C++ 支持以下运算符:

应用场景: C++ 运算符适用于各种类型的项目,用于执行各种计算逻辑判断操作

语法详细代码:

#include <iostream>

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

    // 算术运算
    std::cout << "a + b: " << a + b << std::endl;
    std::cout << "a - b: " << a - b << std::endl;
    std::cout << "a * b: " << a * b << std::endl;
    std::cout << "a / b: " << a / b << std::endl;
    std::cout << "a % b: " << a % b << std::endl;

    // 关系运算
    std::cout << "a == b: " << (a == b) << std::endl;
    std::cout << "a != b: " << (a != b) << std::endl;
    std::cout << "a > b: " << (a > b) << std::endl;
    std::cout << "a < b: " << (a < b) << std::endl;
    std::cout << "a >= b: " << (a >= b) << std::endl;
    std::cout << "a <= b: " << (a <= b) << std::endl;

    // 逻辑运算
    std::cout << "a &amp;& b: " << (a && b) << std::endl;
    std::cout << "a || b: " << (a || b) << std::endl;
    std::cout << "!a: " << (!a) << std::endl;
    // 位运算
    std::cout << "a & b: " << (a & b) << std::endl;
    std::cout << "a | b: " << (a | b) << std::endl;
    std::cout << "a ^ b: " << (a ^ b) << std::endl;
    std::cout << "~a: " << (~a) << std::endl;
    std::cout << "a << 2: " << (a << 2) << std::endl;
    std::cout << "a >> 2: " << (a >> 2) << std::endl;

    // 赋值运算
    a += b;
    std::cout << "a += b: " << a << std::endl;

    // 条件运算
    std::cout << "a > b ? a : b: " << (a > b ? a : b) << std::endl;

    // sizeof 运算
    std::cout << "sizeof(int): " << sizeof(int) << std::endl;

    // 逗号运算
    int c = (a = 5, b = 10, a + b);
    std::cout << "c: " << c << std::endl;

    // 类型转换运算
    float d = static_cast<float>(a) / static_cast<float>(b);
    std::cout << "d: " << d << std::endl;

    return 0;
}

C++ 控制结构

简介: C++ 控制结构用于在程序中实现条件判断循环跳转功能

详细介绍:
C++ 支持以下控制结构

应用场景: C++ 控制结构适用于各种类型的项目,用于实现程序的逻辑控制流程控制。

语法详细代码:

#include <iostream>

int main()
{
    int a = 5;

    // 顺序结构
    std::cout << "Sequential structure" << std::endl;

    // 选择结构
    if (a > 0)
    {
        std::cout << "a is positive" << std::endl;
    } 
    else 
    {
        std::cout << "a is non-positive" << std::endl;
    }

    // 循环结构
    for (int i = 0; i < a; i++) 
    {
        std::cout << "Loop iteration: " << i << std::endl;
    }

    // 跳转结构
    if (a > 0)
    {
        std::cout << "Jump to return" << std::endl;
        return 0;
    }

    std::cout << "This will not be executed" << std::endl;
    return 0;
}

C++ 指针

简介: C++ 指针是一种变量类型,用于存储内存地址通过指针我们可以间接访问和操作内存中的数据。指针在 C++ 中被广泛应用于动态内存分配、函数参数传递、数据结构算法等场景。

详细介绍: C++ 指针具有以下特点:

  • 存储变量的内存地址
  • 可以进行指针运算,如递增和递减等
  • 可以被声明为 void 类型,表示通用指针

语法模板:

type* pointer_name;

应用场景: C++ 指针适用于需要操作内存地址的场景,如动态内存分配数组操作、函数指针等。

语法详细代码:

#include <iostream>

int main() 
{
    int x = 42;
    int *ptr = &x;

    std::cout << "Value of x: " << x << std::endl;
    std::cout << "Address of x: " << &x << std::endl;
    std::cout << "Value of ptr: " << ptr << std::endl;
    std::cout << "Value pointed by ptr: " << *ptr << std::endl;

    return 0;
}

C++内存管理方式:动态内存

C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式:通过newdelete操作符进行动态内存管理。

new/delete操作内置类型

void Test()
{
	// 动态申请一个int类型的空间
	int* ptr4 = new int;
    
	// 动态申请一个int类型的空间并初始化为10
	int* ptr5 = new int(10);
    
	// 动态申请10个int类型的空间
	int* ptr6 = new int[3];
	delete ptr4;
	delete ptr5;
	delete[] ptr6;
}

注意:

new/delete的理解

new和delete是用户进行动态内存申请和释放的操作符operator new 和operator delete是系统提供的全局函数,事实上new在底层是调用operator new全局函数来申请空间,同理delete在底层通过operator delete全局函数来释放空间。

// operator new 和operator delete 底层代码

/*
operator new:该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败尝试执行空 间不足应对措施,如果改应对措施用户设置了,则继续申请,否则抛异常。
*/
void* __CRTDECL operator new(size_t size) _THROW1(_STD bad_alloc)
{
	// try to allocate size bytes
	void* p;
	while ((p = malloc(size)) == 0)
		if (_callnewh(size) == 0)
		{
			// report no memory
			// 如果申请内存失败了,这里会抛出bad_alloc 类型异常
			static const std::bad_alloc nomem;
			_RAISE(nomem);
		}
	return (p);
}

/*
operator delete: 该函数最终是通过free来释放空间的
*/
void operator delete(void* pUserData)
{
	_CrtMemBlockHeader* pHead;
	RTCCALLBACK(_RTC_Free_hook, (pUserData, 0));
	if (pUserData == NULL)
		return;
	_mlock(_HEAP_LOCK); /* block other threads */
	__TRY
		/* get a pointer to memory block header */
		pHead = pHdr(pUserData);
	/* verify block type */
	_ASSERTE(_BLOCK_TYPE_IS_VALID(pHead->nBlockUse));
	_free_dbg(pUserData, pHead->nBlockUse);
	__FINALLY
		_munlock(_HEAP_LOCK); /* release other threads */
	__END_TRY_FINALLY
		return;
}
/*
free的实现
*/
#define free(p) _free_dbg(p, _NORMAL_BLOCK)

通过上述两个全局函数的实现知道

C++提出new和delete,主要是解决两个问题

  1. 自定义类型对象自动申请的时候,初始化和清理问题。new/delete会调用构造函数和析构函数
  2. new失败了以后要求抛异常,这样才符合面向对象语言的出错处理机制。

ps: delete和free一般不会失败,如果失败了,一般都是释放空间上存在越界或者释放指针位置不对。

new和delete的运行原理

  • 内置类型

    如果申请的是内置类型的空间,new和malloc,delete和free基本类似。

    不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常malloc返回NULL。

  • 自定义类型

    • new的原理

      1. 调用operator new函数申请空间;
      2. 在申请的空间上执行构造函数,完成对象构造
    • new T[N]的原理

      1. 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请

      2. 在申请的空间上执行N次构造函数

    • delete的原理

      1. 在空间上执行析构函数,完成对象资源清理工作
      2. 调用operator delete函数释放对象的空间
    • delete[]的原理

      1. 在释放的对象空间上执行N次析构函数,完成N个对象中资源清理
      2. 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释放空间

定位new表达式(了解)

定位new表达式是在分配的原始内存空间中调用构造函数初始化一个对象

使用格式

使用场景:

定位new表达式在实际中一般是配合内存池使用。因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调构造函数进行初始化。

class Test
{
public:
	Test()
		: _data(0)
	{
		cout << "Test():" << this << endl;
	}
	~Test()
	{
		cout << "~Test():" << this << endl;
	}
private:
	int _data;
};

int main()
{
	
	Test* pt = (Test*)malloc(sizeof(Test));  
    // pt现在指向的只不过是与Test对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
    
	new(pt) Test; // 注意:如果Test类的构造函数有参数时,此处需要传参
	
	return 0;
}

malloc/free和new/delete的区别

malloc/free和new/delete的共同点是:都是从堆上申请空间,并且需要用户手动释放。

不同的地方是:

用法上的区别

  1. malloc和free是函数,new和delete是操作符;
  2. malloc申请的空间不会初始化,new可以初始化;
  3. malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可
  4. malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型;

底层上的区别

  1. malloc申请空间失败时,返回的是NULL,因此使用时必须判空,new不需要,但是new需要捕获异常;

  2. 申请自定义类型对象时,malloc/free只会开辟空间,不会调用构造函数与析构函数,而new在申请空间后会调用构造函数完成对象的初始化,delete在释放空间前会调用析构函数完成空间中资源清理

内存泄漏

概念

什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。

危害

内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死

void MemoryLeaks()
{
	// 1.内存申请了忘记释放
	int* p1 = (int*)malloc(sizeof(int));
	int* p2 = new int;
	// 2.异常安全问题
	int* p3 = new int[10];
	Func(); // 如果这里Func函数抛异常,则导致 delete[] p3未执行=p3没被释放.
	delete[] p3;
}

void TalentFunc()
{
    // 因为这一行代码,你不仅会成为项目组里的交际花,还是公司里不可多得的人才
    void* p = new char[0xfffffffful];		
    return;
}
内存泄漏分类(了解)

C/C++程序中一般我们关心两种方面的内存泄漏:

  • 堆内存泄漏**(Heap leak)**

    堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak

  • 系统资源泄漏

    指程序使用系统分配的资源,比方套接字文件描述符管道等没有使用对应的函数释放掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。

如何避免内存泄漏
  1. 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。
  2. 采用RAII思想或者智能指针来管理资源
  3. 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测功能选项
  4. 出问题了使用内存泄漏工具检测ps:不过很多工具都不够靠谱,或者收费昂贵。

总结:

内存泄漏非常常见,解决方案分为两种:1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具

扩展:使用new开出4G的内存空间

int main()
{
 void* p = new char[0xfffffffful];
 system("pause")						// 打开任务管理器查看你的内存变化,切记,正常使用一定要注意释放掉!!
 return 0;

C++ 引用

简介: C++ 引用是一种别名机制,它允许为已存在的变量创建另一个名称。引用在内存中不占用额外空间,使用引用可以实现更高效和安全的函数参数传递、返回值等。

详细介绍: C++ 引用具有以下特点:

  • 必须在声明时进行初始化,不能为 NULL
  • 一旦初始化,不能重新绑定到另一个对象
  • 对引用的修改会直接影响到原始变量

语法模板:

type &reference_name = variable_name;

应用场景: C++ 引用适用于需要提高效率的场景,如作为函数参数传递,避免不必要的数据拷贝

语法详细代码:

#include <iostream>

// 使用引用作为函数参数交换两个整数的值
void swap(int &x, int &y) 
{
    int temp = x;
    x = y;
    y = temp;
}

int main() 
{
    int a = 5;
    int b = 10;

    std::cout << "Before swap: a = " << a << ", b = " << b << std::endl;
    
    swap(a, b);
    
    std::cout << "After swap: a = " << a << ", b = " << b << std::endl;

    return 0;
}

在上述示例中,swap 函数接收两个整数引用作为参数。由于引用直接指向原始变量,因此在函数内部交换引用的值会直接影响到原始变量,从而实现了有效地交换两个整数的值。

C++ 引用与指针的区别

  1. 引用在定义时必须初始化,指针没有要求

  2. 引用在初始化时引用一个实体后,就不能再引用其他实体,而指针可以在任何时候指向任何一个同类型实体

  3. 没有NULL引用,但有NULL指针

  4. sizeof中含义不同:引用结果为引用类型的大小,但指针始终是地址空间所占字节个数(32位平台下占4个字节)

  5. 引用自加即引用的实体增加1,指针自加即指针向后偏移一个类型的大小6.有多级指针,但是没有多级引用;

  6. 访问实体方式不同,指针需要显式解引用,引用编译器自己处理

  7. 引用比指针使用起来相对安全

C++ 函数

简介: C++ 函数是一段完成特定任务独立代码块,可以接收输入参数并返回结果

详细介绍:
C++ 函数具有以下特点:

语法用途模板:

应用场景: C++ 函数适用于各种类型的项目,用于实现代码的模块化和复用

语法详细代码:

#include <iostream>

// 函数声明
int add(int a, int b);

int main() 
{
    int a = 5, b = 10;

    // 函数调用
    int result = add(a, b);
    std::cout << "a + b = " << result << std::endl;

    return 0;
}

// 函数定义
int add(int a, int b)
{
    return a + b;
}

C++函数缺省参数

大家知道什么是备胎吗?出门远行路途遥远常常需要准备一个备胎,C++中函数的参数也可以配备胎。

缺省参数的概念

缺省参数是声明函数时为函数的参数指定一个默认值。在调用该函数时如果没有指定实参则采用该默认值,否则使用指定的实参。 缺省参数只能用在.h/.hpp文件内使用,否则编译失败

void Func(int a = 0)
{
	cout << a << endl;
}

int main()
{
	Func(); 	  	// 没有传参时,使用参数的默认值
	TestFunc(10); 	// 传参时,使用指定的实参
}
缺省参数的分类
  • 全缺省参数

    // 指定了全部参数
    void TestFunc(int a = 10, int b = 20, int c = 30)
    {
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    	cout << "c = " << c << endl;
    }
    
  • 半缺省参数

    // 缺省部分参数 -- 必须从右往左缺省,必须连续缺省 未赋值的在前面赋值的在后面
    void TestFunc(int a, int b = 10, int c = 20)
    {
    	cout << "a = " << a << endl;
    	cout << "b = " << b << endl;
    	cout << "c = " << c << endl;
    }
    

缺省参数的重点

  1. 半缺省参数必须从右往左依次来给出,不能间隔着给;

  2. 缺省参数不能在函数声明和定义中同时出现,因为如果生命与定义位置同时出现,恰巧两个位置提供的值不同,那编译器就无法确定到底该用那个缺省值;

    // 错误写法
    // a.h
    void TestFunc(int a = 10);
    
    // a.c
    void TestFunc(int a = 20)
    {}
    // 注意:如果生命与定义位置同时出现,恰巧两个位置提供的值不同,那编译器就无法确定到底该用那个缺省值。此时编译会提出重定义错误
    
    // 正确写法要么在声明,要么在定义。推荐写在声明
    // a.h
    void TestFunc(int a = 10);
    
    // a.c
    void TestFunc(int a)
    {}
    
  3. 缺省值必须是常量或者全局变量

  4. C语言不支持(编译器不支持)。

C++函数重载

简介: 函数重载是 C++ 中的一种特性,允许在同一作用域内定义多个具有相同名称但参数列表不同的函数。编译器会根据函数调用时提供的参数自动选择合适的函数版本执行。

函数重载的形式和规则:

  1. 参数数量不同:重载的函数具有不同数量的参数。
  2. 参数类型不同:重载的函数具有相同数量但类型不同的参数。
  3. 参数顺序不同:重载的函数具有相同数量和类型的参数,但顺序不同。

注意:函数的返回类型不能作为重载的依据,即仅返回类型不同的函数无法实现重载。

示例代码:

#include <iostream>

// 原函数
void print(const std::string& str)
{
    std::cout << "void print(const std::string& str)" << std::endl;
}

// 函数重载 - 参数数量不同
void print(const std::string& str, int times) 
{

    std::cout << "void print(const std::string& str, int times) " << std::endl;

}

// 函数重载 - 参数类型不同
void print(int num)
{
    std::cout << "void print(int num)" << std::endl;
}

// 函数重载 - 参数顺序不同
void print(int num, const std::string& str)
{
    std::cout << "void print(int num, const std::string& str)" << std::endl;
}

// 参数名称不同
void print(const std::string& str, int num) 
{
    std::cout << "void print(const std::string& str, int num)" << std::endl;
}

int main() 
{
    print("Hello, World!");
    print("Hello, World!", 3);
    print(42);
    print(42, "Hello, World!");
    print("Hello, World!", 42);
    return 0;
}

C++ 模板

简介: C++ 模板是一种泛型编程技术,允许在编译时根据实际类型生成函数和类的特定版本

详细介绍: C++ 模板具有以下特点:

应用场景: C++ 模板适用于需要实现通用函数和类的项目,提高代码的复用性和灵活性。

语法详细代码:

#include <iostream>

// 函数模板定义 typename 是关键字,用于代表一个模板类型
template <typename T>
T max(T a, T b)
{
    return (a > b) ? a : b;
}

// 类模板定义 class 也代表类型
template <class T>
class Stack {
private:
    T data[10];
    int top;

public:
    Stack() : top(-1) {}

    void push(T item) 
    {
        if (top == 9)
        {
            std::cerr << "Stack is full." << std::endl;
            return;
        }
        data[++top] = item;
    }

    T pop()
    {
        if (top == -1)
        {
            std::cerr << "Stack is empty." << std::endl;
            return T();
        }
        return data[top--];
    }
};

int main() 
{
    // 使用函数模板
    std::cout << "Max(3, 4) = " << max(3, 4) << std::endl;
    std::cout << "Max(3.1, 4.2) = " << max(3.1, 4.2) << std::endl;

    // 使用类模板
    Stack<int> intStack;
    intStack.push(1);
    intStack.push(2);
    std::cout << "Pop: " << intStack.pop() << std::endl;

    return 0;
}

原文地址:https://blog.csdn.net/weixin_43654363/article/details/134711469

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任

如若转载,请注明出处:http://www.7code.cn/show_20394.html

如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除

发表回复

您的邮箱地址不会被公开。 必填项已用 * 标注