【C++】是内存管理,但C++ !! && 模板初阶

这篇具有很好参考价值的文章主要介绍了【C++】是内存管理,但C++ !! && 模板初阶。希望对大家有所帮助。如果存在错误或未考虑完全的地方,请大家不吝赐教,您也可以点击"举报违法"按钮提交疑问。

目录

一,回望C语言内存

二, C++  内存管理方式 

1. 内置类型

2. 自定义类型

3. new & malloc 返回内容区别

4. operator new   & operator  delete 

5. malloc/free和new/delete的区别总结

6. 定位new表达式(placement-new) (了解)

三,模板初阶

1.  泛型编程——概念

2. 函数模板

(1. 模板实例化

   概念 

(2. 显式实例化

(3. 隐式实例化

3.  类模板——【练习】实现栈的Push


【C++】是内存管理,但C++ !! && 模板初阶

一,回望C语言内存

尝试给出下面答案:

【C++】是内存管理,但C++ !! && 模板初阶

结果:

【C++】是内存管理,但C++ !! && 模板初阶

解析:

【C++】是内存管理,但C++ !! && 模板初阶

二, C++  内存管理方式 

C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因此C++又提出了自己的 内存管理方式通过new和delete操作符进行动态内存管理

1. 内置类型

 对于内置类型 new / delete 与 malloc & free 没有本质的区别

void Test()
{   // 申请一个int空间
	int* z1 = new int;
    // 申请5个int的数组
	int* z2 = new int[5];
	// 申请一个int空间,初始化为5
	int* z3 = new int(5);

    // 销毁
	delete z1;
	delete[] z2; // 销毁类型要匹配
	delete z3;
	// 对于内置类型 new / delete 与 malloc & free 没有本质的区别
	// 仅仅new只是用法上简化了
}

注意: C++里面没有支持 C语言 realloc 的创新,C++接口不支持扩容。 

2. 自定义类型

new 的原理
  1. 调用 operator new 函数申请空间
  2. 在申请的空间上执行构造函数,完成对象的构造
delete 的原理
  1. 在空间上执行析构函数,完成对象中资源的清理工作
  2. 调用 operator delete 函数释放对象的空间
new T[N] 的原理
  1. 调用 operator new[] 函数,在 operator new[] 中实际调用 operator new 函数完成 N 个对
象空间的申请
  2. 在申请的空间上执行 N 次构造函数
delete[] 的原理
  1. 在释放的对象空间上执行 N 次析构函数,完成 N 个对象中资源的清理
  2. 调用 operator delete[] 释放空间,实际在 operator delete[] 中调用 operator delete 来释
放空间
struct  B
{
public:
	B(int b)
	{
		k = b;
		cout << "B" << endl;
	}

	~B()
	{
		cout << "~B" << endl;
	}
private:
	int k;
};

struct  A
{
public:
	A(int sum, int b)
		: _sum(sum)
		, _b(b)
	{
		cout << "A" << endl;
	}

	~A()
	{
		cout << "~A" << endl;
	}
private:
	int _sum;
	B _b;
};

int func()
{
	A* p1 = new A(10, 20); // 1.内置类型初始化  2. 自定义类型调用其构造函数
	A* p2 = new A[10];     
	A* p3 = new A[10]{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}; // 多实例,并且初始化
	delete p1;             // 1. 销毁内置类型   2. 调用析构函数
	delete[] p2;           // 销毁类型一定要匹配使用, 否则可能出现报错
	delete[] p3;
	return 0;  // 返回码
}

3. new & malloc 返回内容区别

(1) malloc 失败 返回 null 指针

(2) new  失败    会返回异常 (异常后面再着重开始讲)

void test()
{
	try   // 其中如果new失败会进入异常,也就是catch
	{
		// 当内存申请超过一定限度,会申请失败
	// malloc 失败会返回null
		char* p1 = (char*)malloc(sizeof(char) * 1024u * 1024u * 1024u * 1024u * 1024 * 1024);
		printf("%p\n", p1);
		// new  失败会抛异常
		char* p2 = new char[1024 * 1024 * 1024 * 1024 * 1024 * 1024];
		printf("%p\n", p2);

		free(p1);
		delete[] p2;
	}
	catch (const std::exception& e)   // 打印最近的异常信息
	{
		cout << e.what() << endl;
	}
}

注意: 面对new 失败返回异常 会用一个try 来包含 需要new 的代码。

4. operator new   & operator  delete 

       new和delete是用户进行 动态内存申请和释放的操作符operator new 和operator delete是系统提供的 全局函数new在底层调用operator new全局函数来申请空间, delete在底层通过 operator delete全局函数来释放空间。
(总得来说 operator new & delete,并不是函数重载,而是帮助new,delete实现其机制的全局函数)

 【C++】是内存管理,但C++ !! && 模板初阶

operator new该函数实际通过malloc来申请空间,当malloc申请空间成功时直接返回;申请空间失败,尝试执行空间不足应对措施,如果改应对措施用户设置了,则继续申请否则抛异常。( new -> operator new ->  malloc  ->  指针 或  异常

operator delete: 该函数最终是通过free来释放空间的。 

5. 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在释放空间前会调用析构函数完成空间中资源的清理。

6. 定位new表达式(placement-new) (了解)

定位new表达式是在已分配的原始内存空间中调用构造函数初始化一个对象

如: new  (p1)  A (10)  // 其中 p1 通过malloc已开辟空间但未初始化,A是类型 , 10是调用自定义构造函数初始化的值。

使用场景:
定位new表达式在实际中一般是配合 内存池(后面我们再提)使用。因为内存池分配出的内存没有初始化,所以如果是自定义类型的对象,需要使用new的定义表达式进行显示调构造函数进行初始化。
struct  B
{
public:
	B(int b)
	{
		k = b;
		cout << "B" << endl;
	}

	~B()
	{
		cout << "~B" << endl;
	}
private:
	int k;
};

void test1()
{
	B* p3 = (B*)malloc(sizeof(B));
	// malloc 的空间并未初始化
	new (p3) B(100); // 给构造函数参数 100
	p3->~B();
	delete p3;
}

三,模板初阶

1.  泛型编程——概念

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

我们肯定写过这样的编程

void Swap(int& z1, int& z2)
{
	int tmp = z2;
	z2 = z1;
	z1 = tmp;
}

交换函数,一般只能处理一种数据; 而一个程序需要交换多种类型数据,这样我们需要创建多种类型交换函数,这个过程是重复,低效的

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

【C++】是内存管理,但C++ !! && 模板初阶

2. 函数模板

原理:函数模板是一个蓝图,它本身并不是函数,是编译器用使用方式产生特定具体类型函数的模具。所以其实模 板就是将本来应该我们做的重复的事情交给了编译器。

编译器使用模板步骤:

1. 推演 类型

2. 模板实例化

【C++】是内存管理,但C++ !! && 模板初阶

下面简单展示一下:

template <class T>   // 或者 <template T> T只是取名字
void Swap(T& z1, T& z2)
{
	T tmp = z2;
	z2 = z1;
	z1 = tmp;
}

int main()
{
	int i = 1, b = 2;
	Swap(i, b);
	return 0;
}

在编译器编译阶段,对于模板函数的使用,编译器需要根据传入的实参类型来推演生成对应类型的函数以供调用。比如:当用double类型使用函数模板时,编译器通过对实参类型的推演,将T确定为double类型,然后产生一份专门处理double类型的代码,同理这就是我们交换函数的模板, 中间编译器会进行推导类型,编译更复杂,时间会稍久一些。

注意:交换用的是同一套模板,但调用的函数并不是同一个函数。(编译器自动帮我们创建不同类型的交换函数)

【C++】是内存管理,但C++ !! && 模板初阶

关键的来了: 以后不需要自己创建交换函数C++库中有一套交换函数,在std 命名空间里面。

操作如下:

#include <iostream>
using namespace std;
int main()
{
	int i = 1, b = 2;
	double z = 1.1, k = 2.2;
	swap(i, b);   // 小写就行
	swap(z, k);   // 模板推导,需要类型相同,否则报推导类型不确定
	return 0;
}

(1. 模板实例化

概念 

用不同类型的参数使用函数模板时,称为函数模板的 实例化。  模板参数实例化分为 隐式实例化    和    显式实例化

(2. 显式实例化

在函数名后的<>中   指定模板参数   的实际类型

template <class T>   // 或者 <template T>
T* func1(int n)
{
	T* k1 = new T(n);
}


int main(void)
{
 int a = 10;
 double b = 20.0;
 
 // 显式实例化
 Add<int>(a, b);  1. 普通
 func1<A>(10);    2. 特殊,必须要显式否则怎么推演?计算机:二进制给你,你来推演!
 return 0;
}

(3. 隐式实例化

让编译器根据实参   推演模板 参数的实际类型

#include <iostream>
using namespace std;

int ADD(size_t & z1, size_t & z2)  // size_t是标准C库中定义的,它是一个基本的与机器相关的无符号整数的C/C + +类型
  // 就简单理解为 unsiged int 主要防止 负数
{
	return z1 + z2;
}

template <class T>   // 或者 <template T>
T ADD(const T& z1, const T& z2)
{
	return z1 + z2;
}

template <class B1, class B2> // 可以提供多个模板
B1 ADD(B1& b1, B2& b2)
{
	return b1;
}

int main()
{
	// 隐式实例 ——通过编译器自动推导, 不人为干预。
	int i = 1, b = 2;
	double z = 1.1, k = 2.2;
	cout << ADD(i, (int)z) << endl; // 模板 不支持1.1 -> 1 隐式转化,但可以提前,进入的是
	cout << ADD(1.2, (double)1) << endl;

	// 思考;调用哪一个函数
	cout << ADD(i, b) << endl;  // 计算机会调用现成的函数,
	// 调用 int ADD(int& z1, int& z2) ; 模板实例化需要通过编译器,所以优先级比较低。
	cout << ADD(z, i) << endl;  // 两种类型,则会选择多类型模型 B1 ADD(B1& b1, B2& b2)
	return 0;
}

3.  类模板——【练习】实现栈的Push

#include <iostream>
using namespace std;
#include <assert.h>

template <class T>
class stack
{
public:
	stack(int capacity = 4)
		: _size(0)
		, _capacity(capacity)
		, plist(nullptr)
	{
		plist = new T[_capacity];
	}

	void Push(T x)
	{
		assert(plist);
		if (_size == _capacity)
		{
			// 1. 开空间
			// 2. 拷贝旧数据
			T* tmp = new T[_capacity * 2];
			if (plist)   // plist 首先是空指针,如果是是第一次不需要拷贝旧数据
			{
				memcpy(tmp, plist, sizeof(T) * _capacity);
				// 如果申请成功
				_capacity *= 2;
				delete[] plist;
				plist = tmp;
			}
		}
		plist[_size++] = x;
		cout << plist[_size - 1] << endl;
	}

	void Pop()
	{
		assert(_size > 0)
		_size--;
	}

	const T& TopStack()  // 返回栈顶元素,用的是引用,可以修改 私密成员,所以需要const修饰
	{
		assert(_size > 0);  // 防止栈为空
		return plist[_size - 1];
	}

	~stack()
	{
		delete[] plist;
		_size = _capacity = 0;
	}
private:
	T* plist;
	int _size;
	int _capacity;
};

void func()
{
	try
	{
		stack<int> p1;  // 其中如果new失败会进入异常,也就是catch
		stack<char> p2;
		p1.Push(1);
		p1.Push(2);
		p1.Push(3);
		p1.Push(4);
		p1.Push(5);

		cout << p1.TopStack() << endl;
	}
	catch (const std::exception& e)
	{
		cout << e.what() << endl; // 打印最近的异常信息
	}
}

总结:

  • 类模板定义与声明不能分离(同文件允许分离),否则会报错。
  • 一般类实例化时,不带类型,所以一般类模板都要使用显示实例化。
  • 在C++中,类模板在头文件中定义,因此可以写成“ .hpp”的头文件,意思是不仅有声明而且还有实现,一般是类模板实现。

结语

本小节就到这里了,感谢小伙伴的浏览,如果有什么建议,欢迎在评论区评论;如果给小伙伴带来一些收获请留下你的小赞,你的点赞和关注将会成为博主创作的动力。文章来源地址https://www.toymoban.com/news/detail-476036.html

到了这里,关于【C++】是内存管理,但C++ !! && 模板初阶的文章就介绍完了。如果您还想了解更多内容,请在右上角搜索TOY模板网以前的文章或继续浏览下面的相关文章,希望大家以后多多支持TOY模板网!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处: 如若内容造成侵权/违法违规/事实不符,请点击违法举报进行投诉反馈,一经查实,立即删除!

领支付宝红包 赞助服务器费用

相关文章

  • 【C++初阶】七、内存管理(C/C++内存分布、C++内存管理方式、operator new / delete 函数、定位new表达式)

    ========================================================================= 相关代码gitee自取 : C语言学习日记: 加油努力 (gitee.com)  ========================================================================= 接上期 : 【C++初阶】六、类和对象(初始化列表、static成员、友元、内部类)-CSDN博客  ==================

    2024年02月05日
    浏览(45)
  • C++动态内存管理+模板

    💓博主个人主页:不是笨小孩👀 ⏩专栏分类:数据结构与算法👀 C++👀 刷题专栏👀 C语言👀 🚚代码仓库:笨小孩的代码库👀 ⏩社区:不是笨小孩👀 🌹欢迎大家三连关注,一起学习,一起进步!!💓 C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使

    2024年02月09日
    浏览(45)
  • 【C++初阶】第五站:C/C++内存管理 (匹配使用,干货到位)

    前言: 本文知识点: 1. C/C++内存分布2. C语言中动态内存管理方式3. C++中动态内存管理4. operator new与operator delete函数         5. new和delete的实现原理 ( 干货在此 ) 6. 定位new表达式(placement-new)7. 常见面试题 目录 C/C++内存分布 1.内存划分题 2.sizeof 和 strlen 区别? 3.计算siz

    2024年03月11日
    浏览(32)
  • C++的内存管理和模板

    这是在C语言中的内存分布,C++的内存分布也是这样。下面让我们看看C++中的动态内存开辟是什么样的吧。 C语言内存管理方式在C++中可以继续使用,但有些地方就无能为力,而且使用起来比较麻烦,因此C++又提出了自己的内存管理方式: 通过new和delete操作符进行动态内存管理

    2024年02月08日
    浏览(38)
  • 【C++初阶】第六站 : 模板初阶

    前言: 本章知识点:泛型编程、函数模板、类模板 专栏: C++初阶 目录 泛型编程 函数模板 1.函数模板概念 2.函数模板格式 3.函数模板的原理 4.函数模板的实例化 5.模板参数的匹配原则 类模板 类模板的定义格式 类模板的实例化 如何实现一个通用的交换函数呢? 代码如下:

    2024年03月17日
    浏览(47)
  • 【C++】模板初阶——函数模板和类模板

    🚀 作者简介:一名在后端领域学习,并渴望能够学有所成的追梦人。 🚁 个人主页:不 良 🔥 系列专栏:🛸C++  🛹Linux 📕 学习格言:博观而约取,厚积而薄发 🌹 欢迎进来的小伙伴,如果小伙伴们在学习的过程中,发现有需要纠正的地方,烦请指正,希望能够与诸君一同

    2024年02月10日
    浏览(44)
  • 【C++】模板初阶 【 深入浅出理解 模板 】

    如何实现一个通用的交换函数呢? 使用函数重载虽然可以实现 ,但是有一下几个不好的地方: 重载的函数 仅仅是类型不同 ,代码复用率比较低, 只要有新类型出现时,就需要用户自己增加对应的函数 代码的可维护性比较低,一个出错可能所有的重载均出错 那能否 告诉编

    2024年02月05日
    浏览(59)
  • C++:模板初阶

    本篇文章主要对模板有个简单的认识,方便我们后面对模板进行更加深入的学习。 目录 1.泛型编程 2.函数模板 2.1 函数模板的概念 2.2 函数模板格式 2.3 函数模板的原理 2.4 函数模板的实例化 2.5 模板参数的匹配原则 3.类模板 3.1 类模板的格式定义 3.2 类模板的实例化 如何实现一

    2024年02月08日
    浏览(36)
  • C++初阶--类型模板

    先看一个例子: 这是一些对于Swap重载的函数,区别是类型不同; 虽然能够重载使用,但 代码复用率比较低 ,如果我们让别人直接调用我们的函数,只使用整形类型的Swap(),那么其他函数就有点浪费了; 而且 代码的维护性比较低 ,一个出错可能会导致重载都出错。 所以

    2024年02月05日
    浏览(39)
  • <C++> 四、模板初阶

    泛型编程:编写与类型无关的通用代码,是代码复用的一种手段。模板是泛型编程的基础。 如何实现一个通用的交换函数呢?使用 函数重载 可以实现 使用函数重载虽然可以实现,但是有一下几个不好的地方: 重载的函数仅仅是类型不同,代码 复用率 比较 低 ,只要有新类

    2023年04月12日
    浏览(34)

觉得文章有用就打赏一下文章作者

支付宝扫一扫打赏

博客赞助

微信扫一扫打赏

请作者喝杯咖啡吧~博客赞助

支付宝扫一扫领取红包,优惠每天领

二维码1

领取红包

二维码2

领红包