此篇目是之后各种C++库的基础
目录
内存管理
内存分布
内存管理方式
new和delete
operator new 与 operator delete函数
实现原理
定位new表达式(placement-new)
模板基础
泛型编程
模板
函数模板
类模板
STL
组成部分
内存管理
内存分布
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";//指针 栈 但是"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);
}栈 存储非静态局部变量/函数参数/返回值 向下增长
内存映射段 高效的I/O映射方式,用于装载一个共享的动态内存库
堆 程序运行时动态内存分配,向上生长
数据段 全局数据与静态数据
代码段 可执行的代码/只读的常量
内存管理方式
内存管理方式有 malloc/calloc/realloc/free
malloc
- 内存来源：在堆区申请一块连续的指定大小的内存块区域。
- 初始化：不会进行内存初始化，即分配的内存区域可能包含任意数据。
calloc
- 内存来源：与malloc类似，也是用于动态地分配内存空间。
- 初始化：会在分配内存时自动将内存清零，即将分配的内存区域的每一位都初始化为零。因此，calloc也被称为“零初始化内存分配器”。
realloc
- 内存来源：用于重新分配之前通过malloc、calloc或realloc分配的内存块。
- 初始化：realloc本身不会进行初始化操作，但它会调整已分配内存块的大小，并根据需要调整内存块的位置。如果重新分配的内存区域比原来的大，则新分配的部分不会进行初始化。
但是在C++中 引入了新的内存管理方式
new和delete
因为有一些方面 原始的申请会有些无力 因此C++推出了自己的申请函数
int main()
{
int* ptr1 = new int;//申请一个int空间
int* ptr2 = new int(10);//申请一个int空间 并初始化为10
int* ptr3 = new int[3];//申请3个int空间 可以认为是 数组
delete ptr1;//普通的就用delete删除
delete ptr2;
delete[] ptr3; //[]出来的要用[]删除
}new和delete在对自定义类型操作时 也会有不同的变化
对自定义类型操作时
new会调用自定义类型的构造函数
delete会调用自定义类型的析构函数
malloc和free不会去调用
class A
{
public:
A(int num = 0) :a(num) { cout << "A()" << endl;}
~A() { cout << "~A()" << endl;}
private:
int a;
};
int main()
{
A* ptra = new A(1);
delete ptra;
A* ptrb = new A[5];
delete[] ptrb;
return 0;
} 
operator new 与 operator delete函数
new与delete 是用户进行内存申请和释放的 操作符
operator new与operator delete 是系统提供的 全局函数
new 在底层 调用 operator new
delete 在底层 调用 operator delete
operator new 是通过 malloc 申请空间
operator delete 是通过 free 释放空间
实现原理
new原理
调用operator new申请空间 然后用构造函数完成对象构造
delete原理
调用析构函数清理对象 然后调用operator delete函数释放对象空间
new T[N]原理
调用operator new[]函数,在operator new[]中调用operator new函数完成对N个对象的空间申请 然后用N此构造函数
delete[]原理
在要释放的对象空间上完成N次析构函数,然后对N个对象中资源的清理,然后调用operator delete[]释放空间,也就是在operator
定位new表达式(placement-new)
解释
定位new表达式是在已经分配的原始内存空间中调用构造含初始化了一个对象
使用格式
new (place_address)type 或者 new(place_address) type(initializer-list)
place_address必须是一个指针initializer-list是类型的初始化列表
使用场景
定位new表达式一般是配合内存池使用,因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调用构造函数进行初始化.
class A
{
public:
A(int num = 0) :a(num) { cout << "A()"<< a;}
~A() { cout << "~A()";}
private:
int a;
};
int main()
{
A* p1 = (A*)malloc(sizeof(A));
new(p1)A;//new重定位
p1->~A();
free(p1);
cout << endl;
A* p2 = (A*)malloc(sizeof(A));
new(p2)A(10);//new重定位 然后给初始值
p2->~A();
free(p2);
}
模板基础
泛型编程
用函数重载实现交换函数
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;
}从例子中看到,重载的函数仅仅只是类型不同,复用成度并不高,如果出现新的类型,就需要用户自己新增,而且无法一起修正错误,往往伴随着,错一个就错一堆,那么就要用到"模板" 了
模板
C++中存在一个模具,根据模具中填充的不同类型,获得不同的代码,泛型编程解释编译与类型无关的通用代码,方便代码复用.
模板分 函数模板 和 类模板
函数模板
概念
函数模板代表了一个函数家族,该函数模板与类型无关,在使用时被参数化,根据实参类型产生的函数的特定类型的版本
格式
templat<typename T1,typename T2....>
返回值 函数名 参数
template<typename T1, class T2>
void Swap(T1& left, T2& right)
{
T1 temp = left;
left = right;
right = temp;
}原理
通过编译器使用的特殊方式产生具体类型函数的模具,模板就是将本应该我们做的重复的事情交给了编译器
实例化
隐式调用
template<typename T1, class T2>
void Swap(T1& left, T2& right)
{
T1 temp = left;
left = right;
right = temp;
}
int main()
{
int a = 1;
double b = 2;
Swap(a, b);
cout << a << b << endl;
return 0;
}显式调用
template<typename T1, class T2>
void Swap(T1& left, T2& right)
{
T1 temp = left;
left = right;
right = temp;
}
int main()
{
int a = 1;
double b = 2;
Swap<int,double>(a, b);
cout << a << b << endl;
return 0;
}模板参数匹配原则
我称之为:最多匹配优先原则,就是匹配拟合度最高的优先被调用
而且无论是已存在的还是模板,都是按照拟合度最高的匹配
void Swap(int left, int right)//优先匹配 int int
{
int temp = left;
left = right;
right = temp;
}
template<typename T1>//匹配 两个相同参数
void Swap(T1& left, T1& right)
{
T1 temp = left;
left = right;
right = temp;
}
template<typename T1,int>//匹配 T1 和 int 优先
void Swap(T1& left, int& right)
{
T1 temp = left;
left = right;
right = temp;
}
template<typename T1, class T2>//任意两个类型
void Swap(T1& left, T2& right)
{
T1 temp = left;
left = right;
right = temp;
}类模板
也就是 使用模板参数当作类里面参数
定义格式
template<class T1,class T2>
class name
{
public:
//...
private:
T1 _t1;
T2 _t2:
//...
};注意
模版不建议声明和定义分离到两个文件.h 和.cpp会出现链接错误
实例化
template<class T1,class T2>
class name
{
public:
//...
private:
T1 _t1;
T2 _t2:
//...
};
int main()
{
name<int, int> A;
name<int, char> B;
}STL
STL是C++标准库的重要组成部分,是标准模板库,不仅是一个可复用的组件库,而且是一个包含数据机构与算法的软件框架
组成部分
仿函数 算法 迭代器 空间配置器 容器 配接器
本章结言
我将会在下一章开始写
string
vector
list
stack
queue
等基础STL的应用与实现
