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 << "a: " << 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++ 修饰符类型用于修改基本数据类型的属性,如有符号、无符号、长、短等。
- signed: 表示有符号类型(可以是正数或负数)
- unsigned: 表示无符号类型(只能是非负数)
- long: 表示长整数类型(范围大于普通整数)
- short: 表示短整数类型(范围小于普通整数)
语法用途模板:
应用场景: C++ 修饰符类型适用于各种类型的项目,用于根据需求调整数据类型的属性,如表示较大的整数、仅表示非负数等。
语法详细代码:
#include <iostream>
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++ 存储类用于描述变量的存储和作用域。它影响变量的生命周期和可见性。
- auto: 用于声明自动变量,存储在栈上。在 C++11 及以后的版本中,auto 关键字还可以用于自动类型推导。
- register: 用于声明寄存器变量,存储在 CPU 寄存器中。这些变量的访问速度非常快,但数量有限。
- static: 用于声明静态变量,存储在全局数据区。静态变量的生命周期是整个程序执行期间。
- extern: 用于声明外部变量,即在其他文件中定义的变量。这允许在多个文件之间共享变量。
语法用途模板:
应用场景: 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++ 命名空间适用于需要组织代码和避免名称冲突的项目,提高代码的可读性和可维护性。
语法详细代码:
#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也有这个操作符。
#include <stdio.h> #include <stdlib.h> int x = 0; int main() { int x = 10; // 域限定操作符: 到达指定的域寻找指定的元素。 printf("%dn", ::x); // 前面留空白,是指去全局域寻找变量 x return 0; }
-
// 命名空间可以嵌套 #include <stdio.h> #include <stdlib.h> namespace Space { int rand = 0; int sub(int x, int y) { return x - y; } namespace Space2 { int rand = 0; int sub(int x, int y) { return x - y; } } } int main() { printf("%d n", Space::rand); printf("%d n", Space::sub(2, 1)); printf("%d n", Space::Space2::rand); printf("%d n", Space::Space2::sub(2, 1)); return 0; }
-
命名空间只能初始化声明在全局域中,同一个文件里命名空间之间也会出现命名冲突问题,在多个不同文件里,重名的命名空间会被合并。
// list.h namespace List { struct Node { // ...; } void ListInit(); void ListPushBack(); } // list.c namespace List { void ListInit() { // ... } void ListPushBack() { // ... } }
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++ 常量是固定值的标识符,其值在程序执行期间不能被改变。
- 使用 #define 预处理器指令定义常量
- 使用 const 关键字定义常量,在C++中,被const修饰的变量会被赋予常属性,同#define宏定义作用一样。(在C语言中被const修饰的常变量本质还是属于变量)
- 使用枚举常量(enum)
语法用途模板:
应用场景: 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++ 支持以下运算符:
- 算术运算符: +, -, *, /, %, ++, –
- 关系运算符: ==, !=, >, <, >=, <=
- 逻辑运算符: &&, ||, !
- 位运算符: &, |, ^, ~, <<, >>
- 赋值运算符: =, +=, -=, *=, /=, %=, &=, |=, ^=, <<=, >>=
- 条件运算符(三目运算符): ?:
- sizeof 运算符: 用于获取数据类型或对象的大小
- 逗号运算符: 用于连接两个表达式,使它们按顺序求值
- 类型转换运算符: 用于显式类型转换
应用场景: 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 && 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++ 控制结构用于在程序中实现条件判断、循环和跳转等功能。
- 顺序结构: 按照代码顺序执行语句
- 选择结构: 使用 if, if-else, if-else if, switch 等语句实现条件判断
- 循环结构: 使用 for, while, do-while 等语句实现循环
- 跳转结构: 使用 break, continue, return, goto 等语句实现跳转
应用场景: 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++ 中被广泛应用于动态内存分配、函数参数传递、数据结构和算法等场景。
语法模板:
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++又提出了自己的内存管理方式:通过new和delete操作符进行动态内存管理。
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会调用析构函数,而malloc与free不会。
- 申请和释放单个元素的空间,使用new和delete操作符;
- 申请和释放连续的空间,使用new[]和delete[]。
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)
-
operator new 实际也是通过malloc来申请空间,如果malloc申请空间成功就直接返回,否则执行用户提供的空间不足应对措施,如果用户提供该措施就继续申请,否则就抛异常;
抛异常并非是强制终止程序或返回空指针,而是使用try–catch语句进行异常捕获并处理,如果不捕获异常则会出现断言错误:未被捕获的异常。
以下是捕获new申请空间失败异常的实例(以32位操作系统为例)
#include <iostream> int main() { try { char* p = new char[0x7fffffff]; } catch (const exception & e) { cout << e.what() << endl; } return 0; } // 输出:bad allocation
-
operator delete 最终是通过free来释放空间的。
ps: delete和free一般不会失败,如果失败了,一般都是释放空间上存在越界或者释放指针位置不对。
new和delete的运行原理
-
内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本类似。
不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
-
自定义类型
定位new表达式(了解)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象。
使用格式:
- new (place_address) type或者new (place_address) type(initializer–list);
- 其中:place_address必须是一个指针,initializer–list是类型的初始化列表 。
使用场景:
定位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的共同点是:都是从堆上申请空间,并且需要用户手动释放。
不同的地方是:
- malloc和free是函数,new和delete是操作符;
- malloc申请的空间不会初始化,new可以初始化;
- malloc申请空间时,需要手动计算空间大小并传递,new只需在其后跟上空间的类型即可;
- malloc的返回值为void*, 在使用时必须强转,new不需要,因为new后跟的是空间的类型;
内存泄漏
概念
什么是内存泄漏:内存泄漏指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况。内存泄漏并不是指内存在物理上的消失,而是应用程序分配某段内存后,因为设计错误,失去了对该段内存的控制,因而造成了内存的浪费。
危害
内存泄漏的危害:长期运行的程序出现内存泄漏,影响很大,如操作系统、后台服务等等,出现内存泄漏会导致响应越来越慢,最终卡死。
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++程序中一般我们关心两种方面的内存泄漏:
-
堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存,用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放,那么以后这部分空间将无法再被使用,就会产生Heap Leak。
-
指程序使用系统分配的资源,比方套接字、文件描述符、管道等没有使用对应的函数释放掉,导致系统资源的浪费,严重可导致系统效能减少,系统执行不稳定。
如何避免内存泄漏
- 工程前期良好的设计规范,养成良好的编码规范,申请的内存空间记着匹配的去释放。ps:这个理想状态。但是如果碰上异常时,就算注意释放了,还是可能会出问题。需要下一条智能指针来管理才有保证。
- 采用RAII思想或者智能指针来管理资源。
- 有些公司内部规范使用内部实现的私有内存管理库。这套库自带内存泄漏检测的功能选项。
- 出问题了使用内存泄漏工具检测。ps:不过很多工具都不够靠谱,或者收费昂贵。
总结:
内存泄漏非常常见,解决方案分为两种:1、事前预防型。如智能指针等。2、事后查错型。如泄漏检测工具。
扩展:使用new开出4G的内存空间
int main() { void* p = new char[0xfffffffful]; system("pause") // 打开任务管理器查看你的内存变化,切记,正常使用一定要注意释放掉!! return 0;
C++ 引用
简介: C++ 引用是一种别名机制,它允许为已存在的变量创建另一个名称。引用在内存中不占用额外空间,使用引用可以实现更高效和安全的函数参数传递、返回值等。
详细介绍: C++ 引用具有以下特点:
语法模板:
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++ 引用与指针的区别
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; }
缺省参数的重点
-
缺省参数不能在函数声明和定义中同时出现,因为如果生命与定义位置同时出现,恰巧两个位置提供的值不同,那编译器就无法确定到底该用那个缺省值;
// 错误的写法 // 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) {}
-
缺省值必须是常量或者全局变量;
C++函数重载
简介: 函数重载是 C++ 中的一种特性,允许在同一作用域内定义多个具有相同名称但参数列表不同的函数。编译器会根据函数调用时提供的参数自动选择合适的函数版本执行。
注意:函数的返回类型不能作为重载的依据,即仅返回类型不同的函数无法实现重载。
示例代码:
#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进行投诉反馈,一经查实,立即删除!