【C++】C++ 11 智能指针

news2024/11/26 0:41:25

【C++】C++ 11 智能指针

文章目录

  • 【C++】C++ 11 智能指针
    • 1.为什么需要智能指针
    • 2. C++中智能指针和指针的区别是什么？
    • 3. C++中的智能指针有哪些？分别解决的问题以及区别？
      • （1）`auto_ptr`（C++98的方案，C++11已经弃用）
      • （2）`unique_ptr`（替换`auto_ptr`）
      • （3）`shared_ptr`
      • （4）`weak_ptr`
    • 4.`weak_ptr`如何解决`shared_ptr`的循环引用问题
    • 5. `weak_ptr` 能不能知道对象计数为0，为什么？
    • 6.`shared_ptr`怎么知道跟他共享对象的指针释放掉了
    • 7.说说`shared_ptr`线程安全性
    • 8.说说智能指针有没有内存泄漏的情况
    • 9.`shared_ptr`循环引用问题
    • 10.如果不是new出来的对象如何通过智能指针管理呢？
    • 11.你知道Boost库中的智能指针吗

1.为什么需要智能指针

C++11引入智能指针的主要原因是为了避免程序员手动管理动态内存分配和释放时可能出现的内存泄漏和悬空指针问题。在C++中，手动管理内存需要调用new和delete操作符，但是这种方式容易出错，特别是在多线程环境下使用。

智能指针可以自动管理动态内存的生命周期，并保证在不再需要这段内存时，自动释放它，从而避免了悬空指针和内存泄漏。

C++11引入了两种类型的智能指针：std::shared_ptr和std::unique_ptr。std::shared_ptr实现了共享所有权，可以被多个指针共享。std::unique_ptr则实现了“独占所有权”，只有一个指针可以拥有它的所有权。

使用智能指针可以:

  1. 在函数结束时自动释放内存空间，避免了手动释放内存空间。
  2. 简化代码，提高代码的可读性和健壮性，同时也可以减少程序员的工作量和出错的机会。

2. C++中智能指针和指针的区别是什么？

  1. 智能指针

    如果在程序中使用new从堆分配内存，等到不需要的时候，应使用delete将其释放。C++引入了智能指针以帮助自动完成这个过程。随后的编程体验(尤其是使用STL)表明，需要有更精致的机制。基于程序员的编程体验和BOOST库提供的解决方案，C++11摒弃了auto_ptr,并新增了三种智能指针：sunique_ptr,shared_ptr和weak_ptr。所有新增的智能指针都能与STL容器和移动语义协同工作。

  2. 指针

    C 语言规定所有变量在使用前必须先定义，指定其类型，并按此分配内存单元。指针变量不同于 整型变量和其他类型的变量，它是专门用来存放地址的，所以必须将它定义为“指针类型”。

  3. 智能指针和普通指针的区别

    智能指针和普通指针的区别在于智能指针实际上是对普通指针加了一层封装机制，区别是它负责自动 释放所指的对象，这样的一层封装机制的目的是为了使得智能指针可以方便的管理一个对象的生命期。

3. C++中的智能指针有哪些？分别解决的问题以及区别？

C++中的智能指针有4种，分别为：shared_ptr、unique_ptr、weak_ptr、auto_ptr，其中

auto_ptr被C++11弃用。

（1）auto_ptr（C++98的方案，C++11已经弃用）

https://cplusplus.com/reference/memory/auto_ptr/

auto_ptr的实现原理：管理权转移的思想，下面简化模拟实现了一份auto_ptr来了解它的原 理

#pragma once

namespace lxy
{
	template<class T>
	class auto_ptr
	{
	public:
		auto_ptr(T* ptr):_ptr(ptr){}
		auto_ptr(auto_ptr<T>& sp)
			:_ptr(sp._ptr)
		{
			//管理权转移
			sp._ptr = nullptr;
		}
		auto_ptr<T>& operator=(auto_ptr<T>& sp) 
		{
			if(this != &sp)
			{
				if (_ptr)	delete _ptr;
				//转移sp中的资源到当前对象中
				_ptr = sp._ptr;
				sp._ptr = nullptr;
			}
			return *this;
		}
		~auto_ptr()
		{
			if(_ptr)
			{
				std::cout << "delete:" << _ptr << std::endl;
				delete _ptr;
			}
		}

		T& operator*() { return *_ptr; }
		T* operator->() { return _ptr; }
	private:
		T* _ptr;
	};
}

此时不会报错，sp2剥夺了sp1的所有权，但是当程序运行时访问sp1将会报错。所以auto_ptr的缺点是：存在潜在的内存崩溃问题。

（2）unique_ptr（替换auto_ptr）

http://www.cplusplus.com/reference/memory/unique_ptr/

unique_ptr实现独占式拥有或严格拥有概念，保证同一时间内只有一个智能指针可以指向该对象。它对于避免资源泄露，例如，以new创建对象后因为发生异常而忘记调用delete时的情形特别 有用。

unique_ptr的实现原理：简单粗暴的防拷贝，下面简化模拟实现了一份unique_ptr来了解它的原理

#pragma once

namespace lxy
{
	template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr)
			:_ptr(ptr)
		{}
		~unique_ptr() 
		{
			if (_ptr)
			{
				cout << "delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		unique_ptr(const unique_ptr<T>& sp) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>& sp) = delete;

	private:
		T* _ptr;
	};
}

（3）shared_ptr

https://cplusplus.com/reference/memory/shared_ptr/

C++11中开始提供更靠谱的并且支持拷贝的shared_ptr

shared_ptr的原理：是通过引用计数的方式来实现多个shared_ptr对象之间共享资源。

  1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共 享。

  2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减 一。

  3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

  4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对 象就成野指针了。

shared_ptr 是为了解决 auto_ptr 在对象所有权上的局限性(auto_ptr 是独占的), 在使用引用计 数的机制上提供了可以共享所有权的智能指针。

#pragma once

namespace lxy
{
	template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr = nullptr)
			:_ptr(ptr)
			,_pRefCount(new int(1))
			,_pmtx(new mutex)
		{ }
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pRefCount(sp._pRefCount)
			, _pmtx(sp._pmtx)
		{
			AddRef();
		}

		void AddRef() 
		{
			_pmtx->lock();
			++(*_pRefCount);
			_pmtx->unlock();
		}

		void Release()
		{
			_pmtx->lock();
			bool flag = false;
			if (--(*_pRefCount) == 0 && _ptr)
			{
				std::cout << "delete:" << _ptr << std::endl;
				delete _ptr;
				delete _pRefCount;
				flag = true;
			}
			_pmtx->unlock();
			if (flag == true)
			{
				delete _pmtx;
			}
		}

		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				Release();
				_ptr = sp._ptr;
				_pRefCount = sp._pRefCount;
				_pmtx = sp._pmtx;
				AddRef();
			}
			return *this;
		}

		int use_count() { return *_pRefCount; }

		~shared_ptr()
		{
			Release();
		}

		// 像指针一样使用
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
		T* get() const
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pRefCount;
		mutex* _pmtx;
	};
}

（4）weak_ptr

weak_ptr 是一种不控制对象生命周期的智能指针, 它指向一个 shared_ptr 管理的对象。进行该对象的内存管理的是那个强引用的 shared_ptr。weak_ptr只是提供了对管理对象的一个访问手段。weak_ptr 设计的目的是为配合 shared_ptr 而引入的一种智能指针来协助 shared_ptr 工作， 它只可以从一个shared_ptr或另一个 weak_ptr 对象构造, 它的构造和析构不会引起引用记数的增加或减少。weak_ptr是用来解决shared_ptr相互引用时的死锁问题，如果说两个shared_ptr相互引用，那么这两个指针的引用计数永远不可能下降为0,资源永远不会释放。它是对对象的一种弱引用，不会增加对象的引用计数，和shared_ptr之间可以相互转化，shared_ptr可以直接赋值给 它，它可以通过调用lock函数来获得shared_ptr。

	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{}

		weak_ptr(const shared_ptr<T>& sp)
			:_ptr(sp.get())
		{}

		weak_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.get();
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

4.weak_ptr如何解决shared_ptr的循环引用问题

为了解决循环引用导致的内存泄漏，引入了弱指针weak_ptr，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共享内存， 但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

5. weak_ptr 能不能知道对象计数为0，为什么？

不能。

weak_ptr是一种不控制对象生命周期的智能指针，它指向一个shared_ptr管理的对象。进行该对象管理的是那个引用的shared_ptr。weak_ptr只是提供了对管理 对象的一个访问手段。weak_ptr设计的目的只是为了配合shared_ptr而引入的一种智能指针，配合shared_ptr工作，它只可以从一个shared_ptr或者另一个weak_ptr对象构造，它的构造和析构不会引起计数的增加或减少。

6.shared_ptr怎么知道跟他共享对象的指针释放掉了

多个shared_ptr对象可以同时托管一个指针，系统会维护一个托管计数。当无shared_ptr托管该指针 时，delete该指针。

7.说说shared_ptr线程安全性

多线程环境下，调用不同shared_ptr实例的成员函数是不需要额外的同步手段的，即使这些shared_ptr拥有的是同样的对象。但是如果多线程访问（有写操作）同一个shared_ptr，则需要 同步，否则就会有race condition 发生。也可以使用 shared_ptr overloads of atomic functions来防止race condition的发生。

多个线程同时读同一个shared_ptr对象是线程安全的，但是如果是多个线程对同一个shared_ptr对象进行读和写，则需要加锁。

多线程读写shared_ptr所指向的同一个对象，不管是相同的shared_ptr对象，还是不同的shared_ptr对象，也需要加锁保护。

8.说说智能指针有没有内存泄漏的情况

智能指针有内存泄露的情况发生。

  • 智能指针发生内存泄露的情况

当两个对象同时使用一个shared_ptr成员变量指向对方，会造成循环引用，使引用计数失效， 从而导致内存泄露。

  • 智能指针的内存泄漏如何解决？

为了解决循环引用导致的内存泄漏，引入了弱指针weak_ptr，weak_ptr的构造函数不会修改引用计数的值，从而不会对对象的内存进行管理，其类似一个普通指针，但是不会指向引用计数的共 享内存，但是可以检测到所管理的对象是否已经被释放，从而避免非法访问。

class Child;
class Parent {
private:
	std::shared_ptr<Child> ChildPtr;
public:
	void setChild(std::shared_ptr<Child> child) {
		this->ChildPtr = child;
	}
	void doSomething() {
		if (this->ChildPtr.use_count()) {
		}
	}
	~Parent() {}
};

class Child {
private:
	std::shared_ptr<Parent> ParentPtr;
public:
	void setPartent(std::shared_ptr<Parent> parent) {
		this->ParentPtr = parent;
	}
	void doSomething() {
		if (this->ParentPtr.use_count()) {
		}
	}
	~Child() {}
};

int main() 
{
	std::weak_ptr<Parent> wpp;
	std::weak_ptr<Child> wpc;
	{
		std::shared_ptr<Parent> p(new Parent);
		std::shared_ptr<Child> c(new Child);
		p->setChild(c);
		c->setPartent(p);
		wpp = p;
		wpc = c;
		std::cout << p.use_count() << std::endl;
		std::cout << c.use_count() << std::endl;
	}
	std::cout << wpp.use_count() << std::endl;
	std::cout << wpc.use_count() << std::endl;
	return 0;
}

/* 
 程序运行结果：
        2
        2
        1
        1
*/

上述代码中，parent有一个shared_ptr类型的成员指向孩子，而child也有一个shared_ptr类型的成 员指向父亲。然后在创建孩子和父亲对象时也使用了智能指针c和p，随后将c和p分别又赋值给child的 智能指针成员parent和parent的智能指针成员child。从而形成了一个循环引用。

9.shared_ptr循环引用问题

看看这段代码：

struct ListNode
{
	int _data;
	shared_ptr<ListNode> _prev;
	shared_ptr<ListNode> _next;
	~ListNode() {
		cout << "~ListNode()" << endl;
	}
};

int main()
{
	shared_ptr<ListNode> node1(new ListNode);
	shared_ptr<ListNode> node2(new ListNode);
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;

	node1->_next = node2;
	node2->_prev = node1;
	//连接之后use_count++ 了
	cout << node1.use_count() << endl;
	cout << node2.use_count() << endl;
	return 0;
}
/*运行结果：
		1
		1
		2
		2
*/

循环引用分析：

  1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。

  2. node1的_next指向node2，node2的_prev指向node1，引用计数变成2。

  3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上 一个节点。

  4. 也就是说_next析构了，node2就释放了。

  5. 也就是说_prev析构了，node1就释放了。

  6. 但是next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2成员，所以这就叫循环引用，谁也不会释放。

在这里插入图片描述

解决方案：

在引用技术的场景下，把节点的prev和next改成weak_ptr就可以了。

原理：

node1-> next = node2;和node2->prev = node1;时weak_ptr的next和_prev不会增加node1和node2的引用计数。

struct ListNode
{
	int _data;
	weak_ptr<ListNode> _prev;
	weak_ptr<ListNode> _next;
	~ListNode() {
		cout << "~ListNode()" << endl;
	}
};

10.如果不是new出来的对象如何通过智能指针管理呢？

其实shared_ptr设计了一个删除其来解决这个问题

class A {};

template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		cout << "free:" << ptr << endl;
		free(ptr);
	}
};

template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		cout << "delete[]" << ptr << endl;
		delete[] ptr;
	}
};

int main()
{
	FreeFunc<int> freeFunc;
	std::shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	std::shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
	std::shared_ptr<A> sp4(new A[10], [](A* p) {delete[] p; });
	std::shared_ptr<FILE> sp5(fopen("test.txt", "w"), [](FILE* p)
		{fclose(p); });
	return 0;
}

11.你知道Boost库中的智能指针吗

C++ boost给出了更实用的scoped_ptr和shared_ptr和weak_ptr。需要注意的是unique_ptr对应boost的scoped_ptr。并且这些智能指针的实现原理是参考boost中的实现的。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/598842.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

JavaEE进阶（Mybatis）5/31

JavaEE进阶（Mybatis）5/31

目录 1. SQL注入 2.concat&#xff08;&#xff09;用于like模糊查询 3.resultMap 4. 5.动态SQL 6.foreach标签 1. SQL注入 $问题会导致SQL注入 因为$是直接替换的&#xff0c;and的优先级高于or true or false #不存在SQL注入的问题&#xff0c;因为他是预编译的&…
阅读更多...
坚持的工作好习惯

坚持的工作好习惯

工作好习惯 目录概述需求&#xff1a; 设计思路实现思路分析1.工作好习惯的重要性2.谈下自己的工作方法2.希望有时也从别人那里也学习一下看看 参考资料和推荐阅读 Survive by day and develop by night. talk for import biz , show your perfect code,full busy&#xff0c;s…
阅读更多...
windows xp 上 Task Scheduler服务 启动后停止，导致数据库自动备份无法编辑和使用问题解决

windows xp 上 Task Scheduler服务 启动后停止，导致数据库自动备份无法编辑和使用问题解决

项目中使用了mysql数据库&#xff0c;大多数人都会选择Navicat来连接数据库&#xff0c;一般会设置计划来自动备份数据库&#xff0c;但我在编辑自动备份的计划时&#xff0c;弹出task scheduler服务无法启动&#xff0c;退出回到桌面&#xff0c;启动windows的服务&#xff0c…
阅读更多...
牛客网C++面试宝典（一）C/C++基础之语言基础

牛客网C++面试宝典（一）C/C++基础之语言基础

此系列为在学习牛客网C面试宝典过程中记录的笔记&#xff0c;本篇记录第一章C/C基础部分的第一节&#xff1a;语言基础。 牛客网C面试宝典链接&#xff1a;https://www.nowcoder.com/issue/tutorial?tutorialId93&uuida34ed23d58b84da3a707c70371f59c21 文章目录 1.1 简述…
阅读更多...
Docker 数据持久化方案详解

Docker 数据持久化方案详解

目录 一、Docker数据持久化概述 1.1联合文件系统 1.2容器的数据卷 1.2.1 什么是数据卷 1.2.2 数据卷特点 1.2.3 Docker提供三种方式将数据从宿主机挂载到容器 二、 Docker持久化方案 2.1 查看volume 基本命令使用方法 2.2 volume持久化方案 2.2.1volume简介 2.2.2.v…
阅读更多...
【JavaSE】Java基础语法(四十一)：TCP通信程序

【JavaSE】Java基础语法(四十一)：TCP通信程序

文章目录 1. TCP发送数据2. TCP接收数据【应用】3. TCP程序练习4. TCP程序文件上传练习【应用】 1. TCP发送数据 Java中的TCP通信 Java对基于TCP协议的的网络提供了良好的封装&#xff0c;使用Socket对象来代表两端的通信端口&#xff0c;并通过Socket产生IO流来进行网络通信。…
阅读更多...
Android 易忽略小知识

Android 易忽略小知识

1.设置hint的字体大小 在Android xml文件中并没有直接设置hint字体大小的属性。如果hint文字的大小不希望跟正常字体的大小一样&#xff0c;就只能通过代码的方式来进行处理。 提供两种方式&#xff1a; //设置"用户名"提示文字的大小 EditText etUserName (Ed…
阅读更多...
教育硬件“老玩家”进入智能手机新赛道，小度胜算几何？

教育硬件“老玩家”进入智能手机新赛道，小度胜算几何？

从5月8日有传言称“百度旗下小度将进军智能手机市场”&#xff0c;到5月17日小度官宣将推出旗下新物种产品——小度青禾学习手机&#xff0c;小度在短短10天时间成为市场关注的焦点。 而5月22日&#xff0c;其也拿出了真正的成果&#xff0c;这部专门为青少年打造的学习手机正…
阅读更多...
MySQL——在Linux环境下安装（在线安装）

MySQL——在Linux环境下安装（在线安装）

MySQL的安装&#xff08;在线安装&#xff09; mysql的安装并不是比赛的内容&#xff0c;所以我们用比较方便的在线安装的方法&#xff0c;比起安装&#xff0c;我们更要知道如何去使用&#xff1a; 首先看一下自己有没有安装MySQL的服务&#xff0c;或者自己的服务器上有没有…
阅读更多...
application.yml中的配置怎么写

application.yml中的配置怎么写

1.问题 application.yml中可以做很多组件的配置，比如redis,mongo, 但是这些的key是什么，value怎么写呢？ 2.分析问题 为了搞清楚这个问题，我们需要先了解application.yml中的配置是怎么加载的，以MongoProperties配置加载为例， 在Spring Boot中，可以使用application.y…
阅读更多...
【OJ比赛日历】快周末了，不来一场比赛吗？ #06.03-06.09 #18场

【OJ比赛日历】快周末了，不来一场比赛吗？ #06.03-06.09 #18场

CompHub[1] 实时聚合多平台的数据类(Kaggle、天池…)和OJ类(Leetcode、牛客…&#xff09;比赛。本账号会推送最新的比赛消息&#xff0c;欢迎关注&#xff01; 以下信息仅供参考&#xff0c;以比赛官网为准 目录 2023-06-03&#xff08;周六&#xff09; #7场比赛2023-06-04…
阅读更多...
【数据结构】---二叉树类型部分练习解析让你更深程度了解二叉树

【数据结构】---二叉树类型部分练习解析让你更深程度了解二叉树

文章目录 前言&#x1f31f;一、第一种&#xff1a;二叉树性质类型&#xff1a;&#x1f30f;1.1 第一题&#xff1a;&#x1f4ab;1.1.1 理论&#xff1a;&#x1f4ab;1.1.2 图解&#xff1a;&#x1f4ab;1.1.3 解析&#xff1a; &#x1f30f;1.2 第二题&#xff1a;&#…
阅读更多...
小明给大家分享几个CSDN涨粉小技巧，期待大家多多涨粉

小明给大家分享几个CSDN涨粉小技巧，期待大家多多涨粉

今天和大家一起来聊聊CSDN涨粉相关几个的技巧&#xff0c;希望对热爱技术分享&#xff0c;并且想快速涨粉提升自身曝光度的朋友们提供一些经验&#xff0c;本文都是自己的一些想法&#xff0c;有说的不对的地方希望大家指正&#xff01; 一、个人介绍 我叫小明&#xff0c;我的…
阅读更多...
京东国际销售数据查询（京东国际行业/品牌数据分析）

京东国际销售数据查询（京东国际行业/品牌数据分析）

根据京东平台官方数据显示&#xff0c;今年京东国际的贡献力度也高于以往。 京东618开门红5分钟&#xff0c;京东国际成交额已突破去年开门红前两小时的成交额&#xff0c;跨境酒水、跨境手机通讯、跨境箱包皮具等3个品类成交额同比增长超100%。&#xff0c;开门5分钟&#xff…
阅读更多...
Unreal5 第三人称射击游戏 角色基础制作2

Unreal5 第三人称射击游戏 角色基础制作2

接上一篇 Unreal5 第三人称射击游戏 角色基础制作1 角色蹲伏效果 上面是需要的操作映射&#xff0c;蹲伏实现&#xff0c;首先要开启相应功能&#xff0c;你需要在角色移动组件上面开启可蹲伏 蹲伏还有一些其它设置&#xff0c;比如蹲下角色高度&#xff0c;蹲下以后行走的…
阅读更多...
MySQL基础2

MySQL基础2

一.常见数据类型 数值类型&#xff1a; TINYINT&#xff1a;占用1字节&#xff0c;默认为有符号 BIT(M)&#xff1a;位类型&#xff1a;M指定位数&#xff0c;默认值为1&#xff0c;范围为1-64&#xff0c;bit类型在显示时&#xff0c;按照ASCII码对应的值进行显示。 FLOAT[(M,…
阅读更多...
华为OD机试（41-60）老题库解析Java源码系列连载ing

华为OD机试（41-60）老题库解析Java源码系列连载ing

华为OD机试算法题新老题库练习及源码 41.寻找相同子串42.找出经过特定点的路径长度43.全量和已占用字符集44.密钥格式化45.数字字符串组合倒序 郑重声明&#xff1a; 1.博客中涉及题目为网上搜索而来&#xff0c;若侵权&#xff0c;请联系作者删除。 源码内容为个人原创&#…
阅读更多...
git --- git merge用法

git --- git merge用法

1 git merge介绍 在Git中，合并是一个连接分叉历史的过程。它将两个或多个开发历史连接在一起。git merge命令可以帮助你把git分支创建的数据整合到一个分支中。git merge会将一系列的提交关联到一个统一的历史。 在上图中，有两个分支 master 和 feature。我们可以看到，我们…
阅读更多...
《priority_queue》

《priority_queue》

本文主要介绍优先级队列的使用&#xff0c;以及一个TOPK问题的OJ 文章目录 一、priority_queue的介绍二、priority_queue的使用三、[数组中第k个大的元素](https://leetcode.cn/problems/kth-largest-element-in-an-array/) 一、priority_queue的介绍 优先队列是一种容器适配器…
阅读更多...
代码创造童话--Python为六一儿童节送专属礼物

代码创造童话--Python为六一儿童节送专属礼物

前言&#xff1a; Hello大家好&#xff0c;我是Dream。 六一儿童节到啦&#xff0c;祝所有的朋友们六一儿童节快乐&#xff01; 在这个节日里&#xff0c;孩子们可以接受父母、老师、社会各界人士的关爱和祝福&#xff0c;同时也可以享受到各种各样的礼物和活动。Python作为一门…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023