C++学习总结——内存管理和模板初阶

目录

一、new和delete

二、operator new函数和operator delete 函数

三、malloc/free和new/delete的区别

四、模板

1、 泛型编程

2、函数模板

3、类模板

---

一、new和delete

1、首先需要明确的是：它们两个是操作符，并不是像malloc那样是一个函数。

new:

int* p1 = new int;
int* p2 = new int(5);
int* p3 = new int[5];
int* p4 = new int[5]{1,2,3};
int* p5 = (int*)malloc(sizeof(int) * 5);

​

说明：第一个是直接申请一个int，第二个是申请一个int并且初始化为5，第三个是申请5个int的数组，第四个是申请5个int的数组并且初始化。

delete：

delete p1;
delete p2;
delete[] p3;
delete[] p4;
free(p5);

2、

对于内置类型，new / delete与malloc / free 的作用完全相同，都是在堆上申请空间，只有用法的区别。

但是对于自定义类型new和delete中的new可以自动调用构造函数去初始化类。delete会先调用析构函数，再去释放空间。

new失败不需要检查返回值，它失败是抛异常。

---

二、operator new函数和operator delete 函数

new和delete是用户进行动态内存申请和释放的操作符，operator new 和operator delete是

系统提供的全局函数，new在底层调用operator new全局函数来申请空间，delete在底层通过

operator delete全局函数来释放空间。

//new -> operator + 构造函数
//默认情况下operator new使用全局库里的
//每个类可以去实现自己专属的operator new -> new这个类对象，就会调用自己的operator new。

struct ListNode
{
	int _val;
	ListNode* _next;

	//内存池:预先开辟好的空间，想要就可以直接拿来用
	static allocator<ListNode> alloc;

	void* operator new(size_t n)
	{
		void* obj = alloc.allocate(1);
		return obj;
	}

	void operator delete(void* ptr)
	{
		alloc.deallocate((ListNode*)ptr, 1);
	}

	struct ListNode(int val) : _val(val), _next(nullptr)
	{}
};

int main()
{
//频繁申请ListNode就可以自己写operator new，这样可以不去malloc,自己订制内存池，提高效率
	ListNode* p1 = new ListNode(1);
	ListNode* p2 = new ListNode(2);
	ListNode* p3 = new ListNode(3);
    
    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后跟的是空间的类型。

5、 malloc申请空间失败时，返回的是NULL，因此使用时必须判空，new不需要，但是new需

要捕获异常。

6、 申请自定义类型对象时，malloc/free只会开辟空间，不会调用构造函数与析构函数，而new

在申请空间后会调用构造函数完成对象的初始化，delete在释放空间前会调用析构函数完成

空间中资源的清理。

---

四、模板

1、 泛型编程

泛型编程：编写与类型无关的通用代码，是代码复用的一种手段。模板是泛型编程的基础。

如何实现一个通用的交换函数呢？一般来说，我们能想到下面的方式。

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;
}

​

使用函数重载虽然可以实现，但是有一下几个不好的地方：

1、 重载的函数仅仅是类型不同，代码复用率比较低，只要有新类型出现时，就需要用户自己增加对应的函数。

2、 代码的可维护性比较低，一个出错可能所有的重载均出错。

那能否告诉编译器一个模子，让编译器根据不同的类型利用该模子来生成代码呢？于是C++就产生了模板。

2、函数模板

函数模板概念：函数模板代表了一个函数家族，该函数模板与类型无关，在使用时被参数化，根据实参类型产生函数的特定类型版本。

格式：

template<typename T1, typename T2,......,typename Tn>

返回值类型 函数名(参数列表){}

template<typename T>
void Swap( T& left, T& right)
{
     T temp = left;
     left = right;
     right = temp;
}

template<class T>
T Add(const T& left, const T& right)
{
     return left + right;
}

int main()
{
     int a = 10;
     double b = 20.0;
     
     // 显式实例化
     Add<int>(a, b);
     return 0;
}

在编译器编译阶段，对于模板函数的使用，编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如：当用double类型使用函数模板时，编译器通过对实参类型的推演，将T确定
为double类型，然后产生一份专门处理double类型的代码，对于字符类型也是如此。

注：注意：typename是用来定义模板参数关键字，也可以使用class(切记：不能使用struct代替class)。

3、类模板

template<class T1, class T2, ..., class Tn>
class 类模板名
{
 // 类内成员定义
};

例如一个栈的模板：

​
template<typename T>
class Stack
{
public:
    Stack(int capacity = 4) : _a(nullptr), _capacity(0), _top(0)
    {
        if(capacity > 0)
        {
            _a = new T[capacity];
            _capacity = capacity;
            _top = 0;
        }
    }
    
    ~Stack()
    {
        delete[] _a;
        _capacity = 0;
        _top = 0;
    }

private:
    T* _a;
    int _top;
    int _capacity;
};

int main()
{
    Stack<int> s1;
    Stack<char> s2;
    return 0;
}

注：类模板都是显示实例化。