C++入门系列:
【C++】从C丝滑入门C++——初始C++
【C++】类和对象(一)
【C++】类和对象(二)
【C++】类和对象(三)
加粗样式>—
感兴趣的同学点击支持一下!
前言
在 c 语言中我们使用 malloc 和 free 进行堆空间的动态内存管理,C++ 中为了配合类的使用,引入了 new 和 delete 来进行对动态内存的管理。并且在 C++ 中引入了泛型的概念,引入了模板。本文笔者将带大家了解这两个知识点。
动态内存
C++ 的内存分布
在 C / C++ 代码中的内存常常有几个区,分别是栈区、堆区、数据段(静态区)、代码段。栈区在内存中向下增长由高地址向低地址处保存,一般来保存临时变量和函数参数与返回地址(也称函数栈帧)。堆是我们程序员手动开辟的内存区域,其向上增长。数据段存储着全局变量和静态变量。代码段存储着可执行程序(仅可读,不能进行写入)。
下面我们可以看一下下面的问题加深一下概念:
int globalVar = 1;
static int staticGlobalVar = 1;
void Test()
{
static int staticVar = 1;
int localVar = 1;
int num1[10] = { 1, 2, 3, 4 };
char char2[] = "abcd";
const char* pChar3 = "abcd";
int* ptr1 = (int*)malloc(sizeof(int) * 4);
int* ptr2 = (int*)calloc(4, sizeof(int));
int* ptr3 = (int*)realloc(ptr2, sizeof(int) * 4);
free(ptr1);
free(ptr3);
}
1. 选择题:
选项: A.栈 B.堆 C.数据段(静态区) D.代码段(常量区)
globalVar在哪里?____ staticGlobalVar在哪里?____
staticVar在哪里?____ localVar在哪里?____
num1 在哪里?____
char2在哪里?____ *char2在哪里?___
pChar3在哪里?____ *pChar3在哪里?____
ptr1在哪里?____ *ptr1在哪里?____
C++ 中的动态内存开辟
在 C 中我们常用 malloc 、calloc 、free 等函数进行动态内存的开辟和释放。这些方法在 C++ 中仍然可以使用,但是在对一个类进行内存开辟时,我们使用这种方法后仍然需要对类进行初始化使用起来比较麻烦,因此 C++ 中又引入了新的动态内存开辟的方法: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;
}
如果我们定义一个 int 数组对其初始化我们可以:
int* ptr = new int[5]{1,2,3,4,5};
注意:在申请自定义类型的空间时,new会调用构造函数,delete会调用析构函数,而malloc与
free不会。
new 与 delete 的底层组成
在 C++ 中提供了一个全局的 operator new 和 operator delete 函数,new在底层调用operator new全局函数和构造函数来申请空间,delete在底层通过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 new 和 operator delete 的代码实现可以发现其底层仍然是用 malloc 与 free 复用出的函数,不过其在此基础上添加了异常处理,在开辟失败时会抛出异常。
内置类型
如果申请的是内置类型的空间,new和malloc,delete和free基本类似,不同的地方是:new/delete申请和释放的是单个元素的空间,new[]和delete[]申请的是连续空间,而且new在申请空间失败时会抛异常,malloc会返回NULL。
自定义类型
new的原理
- 调用operator new函数申请空间
- 在申请的空间上执行构造函数,完成对象的构造
delete的原理
- 在空间上执行析构函数,完成对象中资源的清理工作
- 调用operator delete函数释放对象的空间
new T[N]的原理
- 调用operator new[]函数,在operator new[]中实际调用operator new函数完成N个对象空间的申请
- 在申请的空间上执行N次构造函数
delete[]的原理
- 在释放的对象空间上执行N次析构函数,完成N个对象中资源的清理
- 调用operator delete[]释放空间,实际在operator delete[]中调用operator delete来释放空间
定位new
我们写代码时可能会存在我们想先开辟一块空间,再对这片空间进行初始化。我们可以单独写一个初始化函数对其进行初始化,可是这样仍然增加了我们的工作量,因此 C++ 引入定位new的概念。我们可以使用下面的方法使用:
new(指针)[自定义变量类型]
new(指针)[自定义变量类型](初始化值)
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
// 定位new/replacement new
int main()
{
// p1现在指向的只不过是与A对象相同大小的一段空间,还不能算是一个对象,因为构造函数没有执行
A* p1 = (A*)malloc(sizeof(A));
new(p1)A; // 注意:如果A类的构造函数有参数时,此处需要传参
p1->~A();
free(p1);
A* p2 = (A*)operator new(sizeof(A));
new(p2)A(10);
p2->~A();
operator delete(p2);
return 0;
}
模板
在 C++ 中我们有了函数的重载,可以实现了一个函数名不同参数的函数调用,可以实现了同一函数名的通用交换函数:
void Swap(int& left, int& right)
{
int temp = left;
left = right;
right = temp;
}
void Swap(double& left, double& right)
{
double temp = left;
left = right;
right = temp;
}
void Swap(char& left, char& right)
{
char temp = left;
left = right;
right = temp;
}
---
我们虽然实现了一个通用的交换函数,但是我们需要手动的编写不同数据类型的函数重载。当我们每次出现一个新的数据类型时,我们都需要自己再添加一个函数,非常的麻烦。而模板则可以帮助我们解决这个问题。
函数模板
函数模板格式:在函数定义前添加
template<typename T1,typename T2,...,typename Tn > 或
template<class T1,class T2,...,class Tn >
注意:T1、T2… 可以看作变量名,使用者可以自行更改。
template<typename T>
void Swap( T& left, T& right)
{
T temp = left;
left = right;
right = temp;
}
这样我们在调用时,函数模板会自动转为我们需要的函数:
函数模板的实例化
用不同类型的参数使用函数模板时,称为函数模板的实例化。模板参数实例化分为:隐式实例化和显式实例化。
隐式实例化:让编译器根据实参推演模板参数的实际类型:
在编译器编译阶段,函数调用的过程中,模板会自动化识别传入实参的数据类型,如果传入的是 int 类型则 T1 全部被替换为 int。然后专门生成一分 int 类型的代码。
显式实例化:在函数名后的<>中指定模板参数的实际类型
int main(void)
{
int a = 10;
double b = 20.0;
// 显式实例化
Add<int>(a, b);
return 0;
}
类模板
类模板的定义格式
template<class T1, class T2, ..., class Tn>
class 类模板名
{
// 类内成员定义
};
类模板只能显示的实例化:类模板实例化需要在类模板名字后跟<>,然后将实例化的类型放在<>
中即可,类模板名字不是真正的类,而实例化的结果才是真正的类。
其中在一个普通的类中,类的名字就是类的类型,而在类模板中类名不是类的类型,类名<实例化类型> 才是类型。