1. C++内存管理方式
1.1 new/delete操作内置类型 VS malloc/free操作内置类型
#include <iostream>
using namespace std;
void Test1()
{
int* p1 = (int*)malloc(sizeof(int));
free(p1);
int* p2 = (int*)calloc(4, sizeof(int));
int* p3 = (int*)realloc(p2, sizeof(int) * 10);
// 这里不需要free(p2)，因为p3是在p2的空间上reallocd的
free(p3);
}
void Test2()
{
int* p1 = (int*)malloc(sizeof(int));
int* p2 = new int;
// 申请5个int的数组
int* p3 = new int[5];
// 申请1个int对象，初始化为5
int* p4 = new int(5);
// 申请5个int的数组,初始化为1,2,3,4,5
int* p5 = new int[5] {1, 2, 3, 4, 5};
free(p1);
delete p2;
delete[] p3;
delete p4;
delete[] p5;
}
int main()
{
Test1();
Test2();
return 0;
}- C++11支持new[] 用{}初始化 ，C++98不支持
- 当new了一堆对象之后,需要使用delete [] 指针
- 针对内置类型，new/delete跟malloc/free没有本质的区别，只有用法的区别，
- new/delete 用法简化了代码的书写
1.2 new/delete操作自定义类型 VS malloc/free操作自定义类型
#include <iostream>
using namespace std;
class A
{
public:
A(int a = 0)
: _a(a)
{
cout << "A():" << this << endl;
}
~A()
{
cout << "~A():" << this << endl;
}
private:
int _a;
};
int main()
{
// malloc和free动态开辟内置类型的空间
A* p1 = (A*)malloc(sizeof(A));
if (p1 == NULL)
{
perror("malloc fail");
return 0;
}
free(p1);
cout << "-------------" << endl;
// new和delete动态开辟类置类型的空间
//A* p2 = new A;
A* p2 = new A(10);
delete p2;
cout << endl << endl;
A* p3 = new A[2];
delete[] p3;
return 0;
}
- new和delete对自定义类型，是会调用构造和析构进行初始化和清理的
- new申请空间，是不需要检查返回值的，申请失败会直接报异常
1.3 一次在堆上申请4G的内存
//0xffffffff转换为十进制就是4G
#include <iostream>
using namespace std;
int main()
{
//0xffffffff转换为十进制就是4G
void* p = malloc(0xfffffffful);
cout << p << endl;
return 0;
}
-
1G = 2 ^ 10 mb = 2 ^ 20 kb = 2 ^ 30 byte
-
4G = 2 ^ 32 byte -> 1 0000 0000(十六进制) = 4,294,967,296 byte
-
0xFFFFFFFF = 1 0000 0000(十六进制) - 1 = 2 ^ 32 - 1 = 4,294,967,295 byte
2. operator new与operator delete函数
首先说明这两个不是运算符重载，它们是两个全局函数，一个申请空间，一个释放空间
- 从底层上看，一个是通过malloc申请的，另一个是通过free释放的，但是做了封装
2.1 malloc/free和new/delete的区别
- 相同点：都是从堆上申请空间，并且需要用户手动释放。
- 不同点：
- malloc和free是函数，new和delete是操作符
- malloc申请的空间不会初始化，new申请的空间会初始化,即调用构造函数
- malloc申请空间时，需要手动计算空间大小并传递，new只需在其后跟上空间的类型即可
- malloc的返回值是void*，在使用时必须强转，new不需要，因为new后跟的是空间的类型
- malloc申请失败时，返回的是NULL，因此使用时必须判空，
new不需要，但是new需要捕获异常
3. 定位new和表达式(placement-new)
定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象
使用格式：
new(place_address)type 或者 new(place_address)type(initializer-list)
其中place_address必须是一个指针，initializer-list是类型的初始化列表。
使用场景：
定位new表达式在实际中一般是配合内存池使用，因为内存池分配出的内存没有初始化，所以如果是自定义类型的对象，就需要使用定位new表达式进行显示调用构造函数进行初始化
#include <iostream>
using namespace std;
class A
{
public:
A(int a = 0) //构造函数
:_a(a)
{}
~A() //析构函数
{}
private:
int _a;
};
int main()
{
//new(place_address)type 形式
A* p1 = (A*)malloc(sizeof(A));
new(p1)A;
//new(place_address)type(initializer-list) 形式
A* p2 = (A*)malloc(sizeof(A));
new(p2)A(2021);
//析构函数也可以显示调用
p1->~A();
p2->~A();
return 0;
}
- 在未使用定位new表达式进行显示调用构造函数进行初始化之前，malloc申请的空间还不能算是一个对象，它只不过是与A对象大小相同的一块空间，因为构造函数还没有执行。
4. 内存泄漏问题
内存泄漏是指因为疏忽或错误造成程序未能释放已经不再使用的内存的情况
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;
}
如何避免内存泄漏？
1、工程前期良好的设计规范，养成良好的编码规范，申请的内存空间记住匹配的去释放。
2、采用RAII思想或者智能指针来管理资源。
3、有些公司内部规范使用内部实现的私有内存管理库，该库自带内存泄漏检测的功能选项。
4、出问题了使用内存泄漏工具检测
内存泄漏非常常见，解决方案分为两种：
1、事前预防型。如智能指针等。
2、事后查错型。如泄漏检测工具
4. 泛型编程
4.1 函数模板
实现一个通用的交换函数
#include <iostream>
using namespace std;
//template<typename T>
template<class T>
void Swap(T& left, T& right)
{
T tmp = left;
left = right;
right = tmp;
}
int main()
{
int i = 1, j = 2;
double x = 1.1, y = 2.2;
char m = 'A', n = 'B';
Swap(i, j);
cout << i << endl;
Swap(x, y);
cout << x << endl;
Swap(m, n);
cout << m << endl;
return 0;
}
- template<typename 名字>，typename后面类型名字是随便取的，Ty、K、V，一般是大写字母或者单词首字母大写，这里的T 代表是一个模板类型(虚拟类型)
- 这里的typename也可以改成class，在这里是没有区别的，但是不能使用struct代替class
4.2 隐式实例化和显式实例化
模板参数推演->模板参数实例化
- 隐式实例化：让编译器根据实参推演模板参数的实际类型
-
显式实例化：在函数名后的<>中指定模板参数的实际类型
#include <iostream>
using namespace std;
template<class T>
T Add(const T& left, const T& right)
{
return left + right;
}
int main()
{
//Add(1.1, 2); // 推演实例化矛盾，报错
// 编译器自动推演，隐式实例化
cout << Add(1, 2) << endl;
cout << Add((int)1.1, 2) << endl;
cout << Add(1.1, (double)2) << endl;
// 显示实例化
cout << Add<int>(1.1, 2) << endl;
cout << Add<double>(1.1, 2) << endl;
return 0;
}
- 类型不匹配，编译器会尝试进行隐式类型转换，如果无法转换成功编译器将会报错
- 所以对于Add(1.1,2)报错的解决方案，
- 一是在隐式实例化前通过强置转换，使类型保持一致
- 二是将隐式实例化Add(1.1,2)变成显式实例化Add<类型>(1.1,2)
- 三是用两个函数参数对象，template<class T1,class T2>
4.3 必须显示实例化的情况
#include <iostream>
using namespace std;
template<class T>
T* Func(int n)
{
T* a = new T[n];
return a;
}
int main()
{
// 必须显示实例化才能调用
Func<int>(10);
return 0;
}- 这里的Func模板，必须用显示实例化才能调用
4.4 模板参数的匹配原则
#include <iostream>
using namespace std;
// 专门处理int的加法函数
int Add(int left, int right) {
return left + right;
}
// 通用加法函数
template<class T>
T Add(T left, T right) {
return left + right;
}
int main()
{
Add(1, 2); // 与非模板函数匹配，编译器不需要特化
Add<int>(1, 2); // 调用编译器特化的Add版本
return 0;
}-
一个非模板函数可以和一个同名的函数模板同时存在，而且该函数模板还可以被实例化为这个非模板函数
-
对于非模板函数和同名函数模板，如果其他条件都相同，会优先调用非模板函数
-
模板函数不允许自动类型转换auto，但普通函数可以进行自动类型转换
-
类模板是不支持编译分离的
4.2 非类型模板参数
#include <iostream>
using namespace std;
//非类型模板参数 -- 常量
namespace lyc {
template<class T, size_t N = 10>
class array
{
private:
T _a[N];
};
}
int main()
{
lyc::array<int> a0;
lyc::array<int, 100> a1; // 100
lyc::array<double, 1000> a2; // 1000
return 0;
}-
上面代码中的N就是一个非类型模板参数
- 浮点数、类对象以及字符串是不允许作为非类型模板参数的,非类型的模板参数必须在编译期就能确认结果
4.3 函数模板的特化
#include <iostream>
using namespace std;
struct Date
{
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{}
bool operator>(const Date& d) const
{
if ((_year > d._year)
|| (_year == d._year && _month > d._month)
|| (_year == d._year && _month == d._month && _day > d._day))
{
return true;
}
else
{
return false;
}
}
int _year;
int _month;
int _day;
};
// 函数模板 -- 参数匹配
template<class T>
bool Greater(T left, T right)
{
return left > right;
}
// 特化--针对某些类型进行特殊化处理
template<>
bool Greater<Date*>(Date* left, Date* right)
{
return *left > *right;
}
int main()
{
cout << Greater(1, 2) << endl; // 可以比较，结果正确
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
cout << Greater(d1, d2) << endl; // 可以比较，结果正确
Date* p1 = &d1;
Date* p2 = &d2;
cout << Greater(p1, p2) << endl; // 可以比较，结果错误
return 0;
}
- 如果没有函数模板的特化,第三个Greater(p1,p2)比较的就是日期的地址,而不是日期
4.4 类模板的特化
#include <iostream>
#include <queue>
using namespace std;
struct Date
{
Date(int year, int month, int day)
:_year(year)
, _month(month)
, _day(day)
{}
bool operator<(const Date& d) const
{
if ((_year < d._year)
|| (_year == d._year && _month < d._month)
|| (_year == d._year && _month == d._month && _day < d._day))
{
return true;
}
else
{
return false;
}
}
int _year;
int _month;
int _day;
};
// 类模板
namespace bit
{
template<class T>
struct less
{
bool operator()(const T& x1, const T& x2) const
{
return x1 < x2;
}
};
//特化
template<>
struct less<Date*>
{
bool operator()(Date* x1, Date* x2) const
{
return *x1 < *x2;
}
};
}
int main()
{
Date d1(2022, 7, 7);
Date d2(2022, 7, 8);
bit::less<Date> lessFunc1;
cout << lessFunc1(d1, d2) << endl;
Date* p1 = &d1;
Date* p2 = &d2;
bit::less<Date*> lessFunc2;
cout << lessFunc2(p1, p2) << endl;
return 0;
}
4.4.1 全特化
- 全特化即是将模板参数列表中所有的参数都确定化
4.4.2 偏特化
- 部分特化：将模板参数类表中的一部分参数特化
4.4.3 小结
- 特化和函数重载有点类似,特化要和原来的模板产生不同,才能够区别并分开
4.5 模板分离编译
4.5.1 模板分离编译报错的原因
- 在类里面定义的函数,编译器默认会把它当作内联函数,在vector<int>实例化的时候, 这些成员函数也会实例化,直接就有定义,编译阶段就确定地址了
- push_back和insert这两个函数在.h中只有声明,没有定义,那么地址就只能在链接阶段中去找了
4.5.2 链接阶段找不到报错的原因
- 在模板定义的.cpp文件中,包含了模板的声明.h,在.cpp中就会展开.h
- 但是.cpp(实现)中的T无法确定,就不能实例化,
- 那么push_back,insert就没有进入符号表,所以在链接阶段就会找不到,然后报错
扫一扫
496
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
