cpp primer笔记090-动态内存

已于 2023-10-06 16:36:50 修改
阅读量132 收藏
点赞数
分类专栏： c++ 文章标签： 笔记 c++
于 2023-10-06 16:05:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LEVIATHANq/article/details/133612424
版权
  1. shared_ptr和unique_ptr都支持的操作，加上shared_ptr独有的操作
    ![[Pasted image 20230923103844.png]]

![[Pasted image 20230923103855.png]]

  1. 每个shared_ptr都有一个关联的计数器，通常称其为引用计数，当调用了shared_ptr的构造函数时就会递增，当调用析构函数时就会递减，一旦一个shared_ptr的计数器为0的时候，它就会自动释放自己所管理的对象。
    #include <iostream>
#include <fstream>
#include <array>
#include <vector>
#include <string>
#include <exception>
#include <algorithm>
#include <stack>
#include <deque>
#include <numeric>
#include <memory>
int main()
{
	std::shared_ptr<int> ptr1 = std::make_shared<int>(10);
	std::cout << ptr1.unique() << " " << ptr1.use_count() << std::endl;
	std::shared_ptr<int> ptr2 = std::make_shared<int>(10);
	std::cout << ptr1.unique() << " " << ptr1.use_count() << std::endl;
std::shared_ptr<int> ptr3(ptr1);
std::cout << ptr1.unique() << " " << ptr1.use_count() << std::endl;

}
cpp
1 1
1 1
0 2

```

  1. 如果想让STL的容器产生类似于shared_ptr指针的效果，可以进行下面的操作:(如果一个shared_ptr指向的对象的引用次数为0，则该对象会被销毁)

    #include <iostream>
#include <fstream>
#include <array>
#include <vector>
#include <string>
#include <exception>
#include <algorithm>
#include <deque>
#include <numeric>
#include <memory>
#include <initializer_list>
#include <exception>
class StrBlob
{
public:
	typedef std::vector<std::string>::size_type size_type;
	StrBlob() :
		data(std::make_shared<std::vector<std::string>>()) {};
	StrBlob(std::initializer_list<std::string> il) :
		data(std::make_shared<std::vector<std::string>>(il)) {};
	StrBlob(std::vector<std::string> vec) :
		data(std::make_shared<std::vector<std::string>>(vec)) {};
	~StrBlob() = default;

	size_type size() const;
	void push_back(const std::string& t);
	void pop_back();
	std::string front() const;
	std::string back() const;
	auto cbegin() -> decltype(std::cbegin(std::vector<std::string>()));
	auto cend() -> decltype(std::cend(std::vector<std::string>()));
private:
	std::shared_ptr<std::vector<std::string>> data;
	void check(size_type i, const std::string& msg) const throw(const std::string&);
};
std::vector<std::string>::size_type StrBlob::size() const
{
	return data->size();
}

void StrBlob::push_back(const std::string& t)
{
	data->push_back(t);
}

void StrBlob::pop_back()
{
	data->pop_back();
}

std::string StrBlob::front() const
{
	check(0, "front on empty StrBlob");
	return data->front();
}

std::string StrBlob::back() const
{
	check(0, "back on empty StrBlob");
	return data->back();
}

void StrBlob::check(std::vector<std::string>::size_type i, const std::string& msg) const throw(const std::string&)
{
	if (i >= data->size())
	{
		throw std::out_of_range(msg);
	}
}

auto StrBlob::cbegin() -> decltype(std::cbegin(std::vector<std::string>()))
{
	return this->data->cbegin();
}

auto StrBlob::cend() -> decltype(std::cend(std::vector<std::string>()))
{
	return this->data->cend();
}

int main()
{
	StrBlob str1({ "123", "fsdf","zcxv" });
	StrBlob str2 = str1;
	str1.push_back("sdfsdfz");
	str1.~StrBlob();
	std::ostream_iterator<std::string> os(std::cout, " ");
	std::for_each(str2.cbegin(), str2.cend(), [&os](std::string val) { os = val; });
	return 0;
}

    123 fsdf zcxv sdfsdfz

  2. 智能指针不允许进行内置指针到智能指针间的隐式转换，只能显示转换。下面是shared_ptr和new结合使用的各种函数

    #include <iostream>
#include <fstream>
#include <array>
#include <vector>
#include <string>
#include <exception>
#include <algorithm>
#include <deque>
#include <numeric>
#include <memory>
#include <initializer_list>
#include <exception>
std::shared_ptr<int> clone(int p)
{
	//return new int(p);不能隐式转换
	return std::shared_ptr<int>(new int(p));
}
int main()
{
	std::shared_ptr<int> ptr1;
	std::shared_ptr<double> ptr2(new double(42));//可以通过构造函数转换
	//std::shared_ptr<int> ptr3 = new int(1024);不能隐式转换
	return 0;
}

    ![[Pasted image 20230923144221.png]]

    ![[Pasted image 20230923153455.png]]

    ![[Pasted image 20230923161047.png]]

  3. 不要混用普通指针和智能指针，尽量都是用智能指针，如果混用二者会产生以下未定义行为。智能指针相对于普通指针的区别有当函数使用智能指针的时候，如果抛出异常，则栈解退的时候会自动调用析构函数释放内存，而使用普通指针的时候则不会delete掉

    void process(std::shared_ptr<int> ptr)
{
	;
}
int main()
{
	std::shared_ptr<int> p(new int(42));
	process(p);
	int i = *p;
	std::cout << i << std::endl;
	int* x(new int(1024));
	//process(x); 不能将int*显式转换为一个shared_ptr<int>()类型的指针
	process(std::shared_ptr<int>(x));//如果将x显式类型转换，则可能导致x的内存被释放
	int j = *x;//未定义行为:x是一个悬空指针！
	std::cout << j << std::endl;
	return 0;
}

    42
-572662307

  4. unique_ptr操作，一般情况下是不允许拷贝unique_ptr，但是如果从函数返回一个unique_ptr值或者返回一个局部对象拷贝的情况下是允许的。
    ![[Pasted image 20230923154021.png]]

![[Pasted image 20230923161112.png]]

	#include <vector>
	#include <string>
	#include <exception>
	#include <algorithm>
	#include <deque>
	#include <numeric>
	#include <memory>
	#include <initializer_list>
	#include <exception>
	std::unique_ptr<std::string> clone1(std::string str)
	{
		return std::unique_ptr<std::string>(new std::string(str));
	}
	std::unique_ptr<std::string> clone2(std::string str)
	{
		std::unique_ptr<std::string> ret(new std::string(str));
		return ret;
	}
	int main()
	{
		std::unique_ptr<std::string> ptr1(new std::string("sjkdfskdf"));
		std::unique_ptr<std::string> ptr2(ptr1.release());
		std::unique_ptr<std::string> ptr3(new std::string("kxcnsd"));
		std::cout << *ptr2 << std::endl;
		ptr2.reset(ptr3.release());
		std::cout << *ptr2 << std::endl;
		return 0;
	}

  1. weak_ptr的一些操作:
    ![[Pasted image 20230923160922.png]]

  2. 由于分配的内存并不是一个数组类型，因此不能对动态数组调用begin和end函数，也不能用范围for语句来处理动态数组中的元素，我们所说的动态数组并不是数组类型

  3. 指向数组的unique_ptr支持一下操作，由于shared_ptr不支持通过[]访问的操作，因此需要使用get函数。
    ![[Pasted image 20230923163322.png]]

	#include <iostream>
	#include <fstream>
	#include <array>
	#include <vector>
	#include <string>
	#include <exception>
	#include <algorithm>
	#include <deque>
	#include <numeric>
	#include <memory>
	#include <initializer_list>
	#include <exception>
	int main()
	{
		std::unique_ptr<int[]> up(new int[10]);
		std::shared_ptr<int> sp(new int[10], [](int* p) {delete[] p; });
		for (size_t i = 0; i != 10; ++i)
		{
			up[i] = i;
			*(sp.get() + i) = 2 * i;
		}
		for (size_t i = 0; i < 10; ++i)
		{
			std::cout << up[i] << "/" << *(sp.get() + i) << " ";
		}
		return 0;
	}
  1. allocate的使用:
    ![[Pasted image 20230923170327.png]]
	#include <iostream>
	#include <fstream>
	#include <array>
	#include <vector>
	#include <string>
	#include <exception>
	#include <algorithm>
	#include <deque>
	#include <numeric>
	#include <memory>
	#include <initializer_list>
	#include <exception>
	int main()
	{
		int n;
		std::allocator<std::string> alloc;//可以分配string内存的allocator对象
		std::cin >> n;
		auto const start = alloc.allocate(n);//分配十个内存，start是指向该内存开头的指针
		auto end = const_cast<decltype(alloc.allocate(n))>(start);//end即构造完成的内存的下一个位置
		alloc.construct(end++, 10, 'c');//构造一个含有10个c的字符串
		alloc.construct(end++, "sdfksd");//构造一个sdfksd的字符串
		for (auto it = start; it != end; ++it)
		{
			std::cout << *it << " ";//输出已经构造的空间的字符串
		}
		std::cout << std::endl;
		alloc.destroy(--end);//重置一个已经构造的空间，但是并不会销毁
		for (auto it = start; it != end; ++it)
		{
			std::cout << *it << " ";
		}
		alloc.deallocate(start, n);//销毁所有已分配的空间
		return 0;
	}

	5
	cccccccccc sdfksd
	cccccccccc

![[Pasted image 20230923171456.png]]在这里插入图片描述

	#include <iostream>
	#include <fstream>
	#include <array>
	#include <vector>
	#include <string>
	#include <exception>
	#include <algorithm>
	#include <deque>
	#include <numeric>
	#include <memory>
	#include <initializer_list>
	#include <exception>
	int main()
	{
		std::allocator<int> a,b;
		auto beginPtrA = a.allocate(10);
		auto beginPtrB = b.allocate(10);
		std::uninitialized_fill_n(beginPtrA, 10, 5);
		for (size_t i = 0; i < 10; ++i)
		{
			std::cout << *(beginPtrA + i) << " ";
		}
		std::cout << std::endl;
		std::uninitialized_copy_n(beginPtrA, 10, beginPtrB);
		for (size_t i = 0; i < 10; ++i)
		{
			std::cout << *(beginPtrA + i) << " ";
		}
		return 0;
	}

5 5 5 5 5 5 5 5 5 5
5 5 5 5 5 5 5 5 5 5
  1. 智能指针shared_ptr和unique_ptr重载删除器,都可以用普通函数，仿函数和未捕获任何类型的lambda表达式，但是unique需要传递一个函数指针
    #define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
#include <string>
#include <memory>
#include <deque>
#include <vector>
#include <algorithm>
#include <functional>
void deleter(int* x)
{
    std::cout << "普通函数删除器" << std::endl;
    delete[] x;
}
class Deleter
{
public:
    void operator() (int* x) {
        std::cout << "仿函数删除器" << std::endl;
        delete[] x;
    }
};

int main() 
{
    std::shared_ptr<int> shPtr1(new int[5], deleter);
    std::shared_ptr<int> shPtr2(new int[2], std::function<void(int*)>(Deleter()));
    std::shared_ptr<int> shPtr3(new int[7], [](int* x) {
        std::cout << "lambda表达式删除器" << std::endl;
    delete[] x;
        });
    std::unique_ptr<int[], std::function<void(int*)>> unPtr1(new int[5], deleter);
    std::unique_ptr<int[], std::function<void(int*)>> unPtr2(new int[6], std::function<void(int*)>(Deleter()));
    std::unique_ptr<int[], std::function<void(int*)>> unPtr3(new int[7], [](int* x) {
        std::cout << "lambda表达式删除器" << std::endl;
    delete[] x;
        });
    return 0;
}
北极星璇
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
cpp primer笔记100-拷贝控制
LEVIATHANq的博客
10-06 64
移动构造函数需要notexcept修饰的原因是，如果在对vector进行push_back重新分配空间时，移动失败的话vector内的元素会发生改变，可能已经不存在，导致程序后面发生错误，拷贝失败的话，vector旧元素并不发生改变，vector原有元素还是会存在的。移动构造函数基本是针对指针进行操作的，移动是将原有的指针指向的位置传递给新的指针，并且将原有的指针置空，拷贝是将原有的指针指向的数据copy一份给新的指针，所以移后原对象基本可以说是报废不可用，所以说不建议对移后原对象进行操作。
cpp primer笔记030-参数传递
LEVIATHANq的博客
10-06 65
CPP定义了一组异常类，分别被放在4个头文件中，其中exception头文件定义类最通用的异常类exception，只报告异常的发生，不提供任何额外信息；CPP11引入begin和end函数，其使用和STL的begin和end类似，只不过需要传递一个数组首元素地址，如果有两个指针指向同一个数组的元素，或者指向该数组的尾元素的下一位置。c_str函数返回的是const char*类型的C风格字符串指针，c_str无法保证返回值一直有效，事实上，如果后续的操作改变了s的值就可能让之前返回的数组失去效用。
cpp primer笔记110-面向对象程序设计
LEVIATHANq的博客
10-06 62
修改类D1和D2，把覆盖的虚函数去掉，那么D1和D2作用域内就没有名字func了，使用b1调用func(int)或者func()函数，都无法在D1作用域内找到函数名，于是在外层作用域中继续寻找，也就是在base作用域中查找，能找到重载的两个版本的函数，接着进行正常的函数匹配，也不会出现编译错误。如果基类的指针通过派生类构造，如果基类的构造函数不是虚函数，则该指针的(派生类)对象会调用基类的析构函数，因此最好将基类的析构函数用virtual修饰，从而让该指针的对象调用派生类的析构函数。
cpp primer笔记070-算法函数
LEVIATHANq的博客
10-06 85
lambda表达式一般构成部分为一下四种，(注意:lambda表达式不能有默认参数，捕获列表只能用于局部非静态变量，对于局部静态变量和全局变量可以直接使用，如果采取值捕获的方式，则变量可以被拷贝，并且被捕获的变量的值是在lambda创建时拷贝的，而不是调用的时候。accumulate的第三个参数的类型决定了函数中使用哪个加法运算符以及返回值的类型，如果返回值是自定义类型，需要使用accumlate，则需要重载运算符，该接口的第三个参数返回的是一个需要处理的数据类型的一个变量。(这里如果a不加&号会报错)
Cpp-Primer-Practice-master.zip
09-19
c语言学习笔记！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ c语言学习笔记！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ c语言学习笔记！！！！！！！！！！！...
Cpp-Primer:C ++ Primer解决方案第五答案
04-01
第十二章动态内存 第三部分：面向班级作者的工具 Chapter 13.复制控制 第14章重载的操作和转换 第15章面向对象的编程 第16章模板和泛型编程 第四部分：高级主题 第十七章专业图书馆设施 Chapter 18.大型程序的工具 ...
CppPrimer阅读笔记
04-16
自己几年前整理的C++ Primer的学习笔记
Cpp-primer-notes:阅读cpp入门5版时要注意的事项
03-08
9. **内存管理**：了解栈和堆的区别，掌握动态内存分配（new、delete）和智能指针（shared_ptr、unique_ptr、weak_ptr）的使用，防止内存泄漏。 10. **编译与链接**：理解预处理器、编译器、链接器的工作原理，以及...
C++primer笔记
06-25
1、C++程序 程序源文件的名字，一般包括两部分：文件名以及文件后缀。文件后缀一般用来标识文件的内容 头文件：一般以.h后缀结尾 程序文本文件：C++一般以.cpp后缀结尾
C语言复习（笔记加例题）第一章：数据类型及其运算
weixin_55021541的博客
07-17 1035
通常在其他编程语言中用作字符串的缩写，但在 C 语言中，字符串是通过字符数组char a[]来表示的。：以下哪个类型是 C 语言中用来存储布尔值的？：以下哪个类型是 C 语言中用来存储字符的？：以下哪个不是 C 语言中的基本数据类型？2. C 运算符的种类、运算优先级和结合性。3. 不同类型数据间的转换与运算。4. C 表达式的类型和求值规则。并不是一个基本数据类型。：A，在 C 语言中，
OpenGL笔记十四之GLM数学库的配置与使用
小勇博客
07-20 303
— 2024-07-20 中午。
【Blockly图形化积木编程二次开发学习笔记】5.自动保存与恢复
乙酸氧铍的博客
07-21 81
/ 用户离开页面时自动将块备份到本地存储中。关闭后再次打开，工作区仍存在。// 从本地存储中恢复块。
算法刷题笔记 排列数字（C++实现）
hanmo22357的博客
07-17 290
一道简单的深度优先搜索（DFS）模板题，给出了DFS问题的一般思路以及C++代码实现
C++笔记3：基类指针delete子类对象的内存泄漏问题
最新发布
subtitle_的博客
07-21 133
C++笔记3：基类指针delete子类对象的内存泄漏问题
Vue3企业级项目开发实战课-笔记记录
tuku0801的专栏
07-20 806
实践 Vue 3 自研组件库开发、Node.js 服务端开发、Vue 3 结合 Node.js 的全栈项目开发以及全栈项目的单元测试等大厂常见的项目技术场景
Java并发编程与高并发解决方案笔记
tuku0801的专栏
07-17 1057
将结合大量图示及代码演示，带你掌握多线程并发编程（线程安全，线程调度，线程封闭，同步容器等）与高并发处理思路与手段（扩容，缓存，队列，拆分等），构建完整的并发与高并发知识体系
cs224w笔记（p5）
m0_51118873的博客
07-19 465
它特别关注两个节点共有的邻居节点，并给予那些在网络中不太常见的共有邻居更高的权重，而对于那些更常见的共有邻居则给予较低的权重。其中，Γ(𝑢)Γ(u) 表示节点 𝑢u 的邻居节点集合，Γ(𝑣)Γ(v) 表示节点 𝑣v 的邻居节点集合，Γ(𝑢)∩Γ(𝑣)Γ(u)∩Γ(v) 表示 𝑢u 和 𝑣v 的共有邻居节点集合。其中，𝐴A 和 𝐵B 分别代表两个集合，∣𝐴∩𝐵∣∣A∩B∣ 表示集合 𝐴A 与 𝐵B 的交集元素的数量，而 ∣𝐴∪𝐵∣∣A∪B∣ 表示集合 𝐴A 与 𝐵B 的并集元素的数量。
cs224w笔记（p1-p4）
m0_51118873的博客
07-18 589
图元是小的、固定的图结构，通常由少量的节点和边组成，它们在较大的图中频繁出现。它基于这样一个理念：一个节点的重要性不仅取决于它直接连接的节点数量，还取决于它所连接的节点的重要性。个人理解：首先有G图抽取出来的图元有以上3个，其次在这3个图元中不出现同构的位置有a，b，c，d，，然后将abcd依次放入v位置得出的具有不重复的表示有a->2种,b->1种,c->0种,d->2种。白话：如果一个节点到其余各点的最短的路径和是最短的，那么他是最重要的。白话：描述的是一个节点于周围节点之间的连接程度。
C++primer笔记：程序源文件、预处理器指示符和名字空间
C++primer笔记 C++primer笔记是关于C++语言的基础知识笔记，涵盖了C++程序的基本组成部分、头文件、程序文本文件、C++标准库、预处理器指示符等内容。 一、C++程序的基本组成部分 C++程序的基本组成部分包括...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值