【C++】map和set的模拟实现

最新推荐文章于 2024-07-08 21:41:38 发布
最新推荐文章于 2024-07-08 21:41:38 发布
阅读量972 收藏 2
点赞数 2
分类专栏： C++ 文章标签： c++ 算法 数据结构
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_68609336/article/details/130438274
版权

一、思路

1. 改造RBTree

现在我们有一棵 R B T r e e RBTree RBTree，那么如何用它实现 m a p map map和 s e t set set？我们知道 m a p map map是 KV 结构， s e t set set是 K 结构，传统思路是两份 R B T r e e RBTree RBTree的代码一个改成 m a p map map，一个改成 s e t set set。这样可以实现但不够完美，重复性较高。那么如何优雅地实现呢？查看源码，学习大佬的思路：

m a p map map:

在这里插入图片描述

s e t set set:

在这里插入图片描述

查看源码发现： m a p map map和 s e t set set向 R B T r e e RBTree RBTree传模板参数时都是<key, value>， m a p map map传的是<Key, pair<const Key, Value>>， s e t set set传的是<Key, Key>。

再看 R B T r e e RBTree RBTree源码的实现：

在这里插入图片描述
也就是说map和set传进RBTree的Key（第一个模板参数）在RBTree的节点里是没有使用的，RBTree的节点只保存Value。

综上一起看：

在这里插入图片描述

R B T r e e RBTree RBTree这一层，第二个模板参数就能决定 R B T r e e RBTree RBTree是 m a p map map还是 s e t set set，那为什么要传第一个模板参数？

不要忘了 R B T r e e RBTree RBTree这一层有一个查找操作:iterator find(const Key& key)是要直接使用第一个模板参数的。

namespace RB
{
	// map --> RBTree<K, pair<const K, V>, MapKeyOfT> _t
	// set --> RBTree<K, K, SetKeyOfT> _t
	template<class K, class T, class KeyOfT>
	class RBTree
	{
	public:
		// 节点
		typedef RBTreeNode<T> Node;
	private:
		Node* _root = nullptr;
	};
}

2. 改造RBTree的节点

namespace RB
{
	// 红黑树的颜色
	enum Color
	{
		RED,
		BLACK
	};
	// 红黑树的节点
	// KV 改造为 T(T是 K 或 pair<const K, V>)
	// KV由map和set层传过来，RBTree这一层看到的都是T
	//template<class K, class V>
	template<class T>
	struct RBTreeNode
	{
		RBTreeNode<T>* _left;
		RBTreeNode<T>* _right;
		RBTreeNode<T>* _parent; //指向父节点的指针
		//pair<K, V> _kv;
		T _data;
		Color _col;
	
		//RBTreeNode(const pair<K, V>& kv)
		RBTreeNode(const T& data)
			:_left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _data(data)
			, _col(RED)
		{}
	};
}

这样一来新的问题出现了：我们在RBTree这一层看到的类型是T，T是 K 或 pair<const K, V>，那么在查找、插入比较大小时RBTree不知道是其中的哪一个，K可以直接比较大小，库中的pair实现了关系运算符的重载也可以直接比较大小，但是库中的实现并不符合我们的预期。

template <class T1, class T2>
bool operator== (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
{ return lhs.first==rhs.first && lhs.second==rhs.second; }

template <class T1, class T2>
bool operator!= (const pair<T1,T2>& lhs, const pair<T1,T2>& rhs)
{ return !(lhs==rhs); }

库中的实现是先比较first，再比较second，如果直接使用，在RBTree中就会出现[2, 3] < [2, 4]，[2, 3]插在[2, 4]的左。

如何解决？看看源码在比较大小时是如何做的：

在这里插入图片描述

源码中是使用第三个模板参数KeyOfValue传入一个仿函数用来获取Value中的Key，

二、实现

1. map和set的实现框架

namespace nb
{
	template<class K, class V>
	class map
	{
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};
	private:
		RB::RBTree<K, pair<const K, V>, MapKeyOfT> _t;
	};


	template<class K>
	class set
	{
		struct SetKeyOfT
		{
			const K& operator()(const K& key)
			{
				return key;
			}
		};
	private:
		RB::RBTree<K, K, SetKeyOfT> _t;
	};	
}

2. 改造insert

对于RBTree的insert只需要把所有比较大小的地方用KeyOfT获取key之后再比较

bool Insert(const T& data)
{
	// 是空树直接将新增节点作为根
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_col = BLACK;
		return true;
	}
	// KeyOfT
	KeyOfT kot;// kot的作用：获取Key用于比较大小
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		// pair的 > 不能满足要求
		// 获取插入data的key和cur->_data的key，比较大小
		if (kot(data) > kot(cur->_data))
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kot(data) < kot(cur->_data))
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			return false;
		}
	}

	cur = new Node(data);
	cur->_col = RED;

	if (kot(data) > kot(parent->_data))
	{
		parent->_right = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_left = cur;
		cur->_parent = parent;
	}

	// parent为空，则cur是根节点不用继续更新
	// parent节点颜色为红，需要继续相信向上调整
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		// p是g的左孩子
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// 所有情况 p、cur都是红，g都是黑，
			// 情况一：u存在且为红
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;// cur变g继续更新
				parent = cur->_parent;//更新p
			}
			else// u不存在 或 u存在且为黑
			{
				// 情况二：cur是p的左，p是g的左
				if (cur == parent->_left)
				{
					//      g
					//    p
					// cur
					// 对g右单旋
					RotateR(grandfather);
					// p变黑，g变红
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else// 情况三：cur是p的右，p是g的左
				{
					//     g
					//   p
					//     cur
					RotateL(parent);
					//      g
					//   cur
					// p
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;// 旋转完成后即可退出
			}
		}
		else// p是g的右孩子
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// 情况二：
				if (cur == parent->_right)
				{
					// g
					//   p
					//    cur
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					// 情况三：
					//   g
					//     p
					// cur
					RotateR(parent);
					//  g
					//    cur
					//       p
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;// 旋转完成后即可退出
			}
		}
	}
	// 避免更新出错，把根节点颜色直接给黑色
	_root->_col = BLACK;
	return true;
}

3. 实现迭代器

3. 1 RBTree的迭代器类

要实现map和set的迭代器实际上就是要实现RBTree的迭代器。

//RBTree迭代器类
template<class T, class Ref, class Ptr>
struct _RBTreeIterator
{
	typedef RBTreeNode<T> Node;
	typedef _RBTreeIterator<T, Ref, Ptr> Self;
	Node* _node;// 与list迭代器相同，有一个节点成员
	_RBTreeIterator(Node* node)// 构造函数：用节点构造一个迭代器
		:_node(node)
	{}
	//  * 和 ->
	Ref operator* ()
	{
		return _node->_data;
	}
	Ptr operator-> ()
	{
		return &_node->_data;
	}
	bool operator!= (const Self& s)
	{
		return _node != s._node;
	}
	// ++ 和 --
	// ……		
};

STL明确规定，begin()与end()代表的是一段前闭后开的区间，而对红黑树进行中序遍历后， 可以得到一个有序的序列

因此：begin()可以放在红黑树中最小节点（即最左侧节点）的位置，end()放在最大节点（最右侧节点）的下一个位置，关键是最大节点的下一个位置在哪里？ 能否给成nullptr呢？

答案是不能，因为对end()位置的迭代器进行--操作，必须要能找最 后一个元素，此处就不行，因此最好的方式是将end()放在头结点的位置

在这里插入图片描述

本文的实现与STL实现不同：不使用header节点。begin()一样是最左节点，end()是nullptr，end()位置的迭代器不能进行--操作。

template<class K, class T, class KeyOfT>
class RBTree
{
public:
	// 节点
	typedef RBTreeNode<T> Node;
	// 迭代器
	typedef _RBTreeIterator<T, T&, T*> iterator;
	typedef _RBTreeIterator<T, const T&, const T*> const_iterator;

	// 普通迭代器
	iterator begin()
	{
		Node* Left = _root;
		// 找最左节点
		while (Left && Left->_left)
		{
			Left = Left->_left;
		}
		return iterator(Left);
	}
	iterator end()
	{
		return iterator(nullptr);
	}
	// const迭代器
	const_iterator begin() const
	{
		Node* Left = _root;
		// 找最左节点
		while (Left && Left->_left)
		{
			Left = Left->_left;
		}
		return const_iterator(Left);
	}
	const_iterator end() const
	{
		return const_iterator(nullptr);
	}

3. 2 迭代器类的operator++

我们不需要考虑整棵树（无需递归），只需要考虑局部的子树的中序遍历（左 根 右），++走到中序的下一个，不需要考虑其他子树的节点。

在这里插入图片描述

Self& operator++()
{
	if (_node->_right)
	{
		Node* minRight = _node->_right;
		while (minRight->left)
		{
			minRight = minRight->_left;
		}
		_node = minRight;// ++到minRight
	}
	else
	{
		Node* parent = _node->_parent;
		Node* cur = _node;
		// cur 不是 parent 的左就一直往上走
		// cur 是 parent 的右说明以 parent 为根的树走完了
		// parent 为空说明走到根节点的 _parent
		while (parent && cur == parent->_right)
		{
			cur = cur->_parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	return *this;
}

3. 3 迭代器类的operator--

operator--与operator++是相反的逻辑

在这里插入图片描述

Self& operator--()
{
	if (_node->_left)
	{
		// 左子树的最大节点
		Node* maxLeft = _node->_left;
		while (maxLeft->_right)
		{
			maxLeft = maxLeft->_right;
		}
		_node = maxLeft;// --到maxLeft
	}
	else
	{
		Node* cur = _node;
		Node* parent = _node->_parent;
		while (parent && cur == parent->_left)
		{
			cur = cur->_parent;
			parent = parent->_parent;
		}
		_node = parent;
	}
	return *this;
}

3. 4 map的迭代器：

template<class K, class V>
class map
{
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
public:
	// 要使用关键字 typename 显式地指明iterator是一个类型
	// 否则编译器会误认为是一个静态成员变量而产生编译错误
	typedef typename RB::RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
	typedef typename RB::RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
	// 实现map的迭代器
	iterator begin()
	{
		return _t.begin();
	}
	iterator end()
	{
		return _t.end();
	}
	const_iterator begin() const
	{
		return _t.begin();
	}
	const_iterator end() const
	{
		return _t.end();
	}
	void Insert(const pair<K, V>& _kv)
	{
		_t.Insert(_kv);
	}

private:
	RB::RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};

3. 5 set的迭代器：

set的迭代器像下面这样实现是有问题的：

template<class K>
class set
{
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
public:
	// 要使用关键字 typename 显式地指明const_iterator是一个类型
	// 否则编译器会误认为是一个静态成员变量而产生编译错误
	typedef typename RB::RBTree<K, K, SetKeyOfT>::const_iterator iterator;
	typedef typename RB::RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;
	// 实现set的迭代器
	iterator begin()
	{
		return _t.begin();
	}
	iterator end()
	{
		return _t.end();
	}
	const_iterator begin() const
	{
		return _t.begin();
	}
	const_iterator end() const
	{
		return _t.end();
	}
	void Insert(const K& key)
	{
		_t.Insert(key);
	}
private:
	RB::RBTree<K, K, SetKeyOfT> _t;
};

我们知道set的值是不能修改的，因为它要保证RBTree的结构、性质。所以迭代器也不能修改值。

// 普通迭代器和const迭代器都是const_iterator
typedef typename RB::RBTree<K, K, SetKeyOfT>::const_iterator iterator;
typedef typename RB::RBTree<K, K, SetKeyOfT>::const_iterator const_iterator;

像下面的代码就会编译报错：

auto it = s.begin();
while (it != s.end())
{
	std::cout << (*it) << " ";
	*it *= 10;// 不能修改
	++it;
}

但是将修改操作的代码注释掉后：

在这里插入图片描述

下面代码中，_t.begin()是普通迭代器，而 set 的 iterator 是const迭代器，这两种类型是不兼容的，不能直接进行转换。

// 实现set的迭代器
iterator begin()
{
	return _t.begin();
}

源码里只提供普通迭代器的const修饰版本:

在这里插入图片描述

把set的普通迭代器用const修饰，删除const_iterator的：

// 实现set的迭代器
iterator begin() const
{
	return _t.begin();
}
iterator end() const
{
	return _t.end();
}

4. 实现map的operator[]

map的operator[]底层调用的是insert，所以我们要改造RBTree中的insert：

在所有返回的位置返回pair<iterator, bool>即可。

pair<iterator, bool> Insert(const T& data)
{
	// 是空树直接将新增节点作为根
	if (_root == nullptr)
	{
		_root = new Node(data);
		_root->_col = BLACK;
		// 返回新增节点位置的迭代器和是否插入成功	 
		return std::make_pair(iterator(_root), true);
	}

	KeyOfT kot;// kot的作用：获取Key用于比较大小
	Node* parent = nullptr;
	Node* cur = _root;
	while (cur)
	{
		// pair的 > 不能满足要求
		// 获取插入data的key和cur->_data的key，比较大小
		if (kot(data) > kot(cur->_data))
		{
			parent = cur;
			cur = cur->_right;
		}
		else if (kot(data) < kot(cur->_data))
		{
			parent = cur;
			cur = cur->_left;
		}
		else
		{
			// 返回已存在值的迭代器，充当查找
			return std::make_pair(iterator(cur), false);;
		}
	}

	cur = new Node(data);
	// cur可能会向上调整发生变化
	// 需要一个newNode用于返回新增节点的迭代器
	Node* newNode = cur;
	cur->_col = RED;

	if (kot(data) > kot(parent->_data))
	{
		parent->_right = cur;
		cur->_parent = parent;
	}
	else
	{
		parent->_left = cur;
		cur->_parent = parent;
	}

	// parent为空，则cur是根节点不用继续更新
	// parent节点颜色为红，需要继续相信向上调整
	while (parent && parent->_col == RED)
	{
		Node* grandfather = parent->_parent;
		// p是g的左孩子
		if (parent == grandfather->_left)
		{
			Node* uncle = grandfather->_right;
			// 所有情况 p、cur都是红，g都是黑，
			// 情况一：u存在且为红
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;// cur变g继续更新
				parent = cur->_parent;//更新p
			}
			else// u不存在 或 u存在且为黑
			{
				// 情况二：cur是p的左，p是g的左
				if (cur == parent->_left)
				{
					//      g
					//    p
					// cur
					// 对g右单旋
					RotateR(grandfather);
					// p变黑，g变红
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else// 情况三：cur是p的右，p是g的左
				{
					//     g
					//   p
					//     cur
					RotateL(parent);
					//      g
					//   cur
					// p
					RotateR(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;// 旋转完成后即可退出
			}
		}
		else// p是g的右孩子
		{
			Node* uncle = grandfather->_left;
			if (uncle && uncle->_col == RED)
			{
				parent->_col = uncle->_col = BLACK;
				grandfather->_col = RED;
				cur = grandfather;
				parent = cur->_parent;
			}
			else
			{
				// 情况二：
				if (cur == parent->_right)
				{
					// g
					//   p
					//    cur
					RotateL(grandfather);
					parent->_col = BLACK;
					grandfather->_col = RED;
				}
				else
				{
					// 情况三：
					//   g
					//     p
					// cur
					RotateR(parent);
					//  g
					//    cur
					//       p
					RotateL(grandfather);
					cur->_col = BLACK;
					grandfather->_col = RED;
				}
				break;// 旋转完成后即可退出
			}
		}
	}
	// 避免更新出错，把根节点颜色直接给黑色
	_root->_col = BLACK;
	return std::make_pair(iterator(newNode), true);
}

map中的insert和operator[]：

template<class K, class V>
class map
{
	// ……
public:
	// 要使用关键字 typename 显式地指明iterator是一个类型
	// 否则编译器会误认为是一个静态成员变量而产生编译错误
	typedef typename RB::RBTree<K, pair<const K, V>, MapKeyOfT>::iterator iterator;
	typedef typename RB::RBTree<K, pair<const K, V>, MapKeyOfT>::const_iterator const_iterator;
	// 实现map的迭代器
	// ……
	//void Insert(const pair<K, V>& kv)
	//{
	//	_t.Insert(kv);
	//}

	pair<iterator, bool> Insert(const pair<K, V>& kv)
	{
		return _t.Insert(kv);
	}

	V& operator[](const K& key)
	{
		pair<iterator, bool> ret = Insert(make_pair(key, V()));
		return ret.first->second;
	}

private:
	RB::RBTree<K, pair<const K, V>, MapKeyOfT> _t;
};

但是当我们把 set 中 insert 也改成：

pair<iterator, bool> Insert(const K& key)
{
	return _t.Insert(key);
}

又出现了下面的错误：
在这里插入图片描述

出现错误的原因是：RBTree层的迭代器是普通迭代器，set层的迭代器是const迭代器，无法直接转换。

那能不能像前面的begin一样在后面加一个 const 修饰呢？
答案是不能。因为使用 const 修饰符的成员函数，它们不会修改对象的状态，但是insert是需要向树中插入值的，会修改对象的状态。

那么如何解决？

源码是这样解决的：

在这里插入图片描述

照着源码解决：

pair<iterator, bool> Insert(const K& key)
{
	//return _t.Insert(key);
	pair<typename RB::RBTree<K, K, SetKeyOfT>::iterator, bool> ret = _t.Insert(key);
	return pair<iterator, bool>(ret.first, ret.second);
}

除了上面的方法，还可以实现下面的拷贝构造函数，迭代器一般是不需要写拷贝构造的，用一个迭代器拷贝出另一个迭代器，我们的期望就是两个迭代器指向同一个节点，系统默认生成的（浅拷贝）就符合要求。

下面的构造函数，对象是普通迭代器时，使用拷贝构造的方式来初始化新的迭代器，对象是 const 迭代器时，使用构造的方式来初始化 新的迭代器。

在这里插入图片描述

实现这个函数之后，就可以将普通迭代器直接构造转换成const迭代器，set的insert也就可以直接return了。

// 普通迭代器的时候，它是拷贝构造
// const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
template<class T, class Ref, class Ptr>
typedef _RBTreeIterator<T, T&, T*> iterator;
_RBTreeIterator(const iterator& cit)
	:_node(cit._node)
{
	//std::cout << "_RBTreeIterator(const iterator& cit)" << std::endl;
}

在这里插入图片描述

之前实现的list的如果没有下面这个函数是不能将普通迭代器直接构造转换成const迭代器

// 普通迭代器的时候，它是拷贝构造
// const迭代器的时候，它是构造，支持用普通迭代器构造const迭代器
typedef __list_iterator<T, T&, T*> iterator;
__list_iterator(const iterator& cit)
			:_pnode(cit._pnode)
{
	 //std::cout << "__list_iterator(const __list_iterator& cit)" << std::endl;
}

下图是没有上面的函数，会编译报错。

在这里插入图片描述

整体代码GitHub

二木 同学
关注
  • 2
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
map和set的模拟实现
06-06
在IT领域，数据结构是编程的基础，...总之，通过封装红黑树并结合C++的面向对象特性，我们可以构建出高性能的Map和Set模拟实现。这不仅可以加深对数据结构和算法的理解，也有助于在实际项目中构建高效的数据处理机制。
C++开源项目：模拟实现小型STL
11-27
6. **关联容器**：如`set`和`map`，它们是基于红黑树实现的，能提供快速的查找和插入操作。`stl_tree.h`可能包含了红黑树的相关实现。 7. **哈希表（Hash Tables）**：`stl_hashtable.h`可能是哈希表的实现，如`...
C++(14)判断map中key值是否存在
m0_67401417的博客
04-29 5734
map的使用过程中会有根据map中是否存在某个键值来决定是否向里面赋值的操作，这里介绍两种方式 1.find函数 iterator find ( const key_type& key ); 如果key存在，则find返回key对应的迭代器，如果key不存在，则find返回尾后迭代器 .end()。可以参考下面的示例来判断key值是否存在 if (mymap.find(key) == mymap.end()) cout << "没有这个key" << endl;
C++模拟题及模拟题答案
06-23
7. **STL**：容器（如vector、list、set、map）、算法和迭代器的运用。 其次，**C++模拟题答案.doc**则提供了对应的解答，详细解析每一道题目的解题思路和步骤，让学习者能更好地理解正确答案背后的逻辑。答案通常...
C++实现贪吃蛇案例，实时
09-10
在本项目中，我们将深入探讨如何使用C++编程语言实现一个实时的贪吃蛇游戏。贪吃蛇是一款经典的计算机游戏，玩家控制一条蛇在屏幕上移动，吃食物来增长，同时避免撞到自己的身体或边界。这里，我们主要关注C++语言的...
初始C++
2302_81016149的博客
07-08 634
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
c++习题08-计算星期几
码到成龚的博客
07-03 584
问题描述 假设今天是星期日，那么过a^b天之后是星期几？ 输入描述 两个正整数a，b，中间用单个空格隔开。0
c语言----队列
2302_80318761的博客
07-04 1037
好了，上面就是关于队列的大部分使用方法了。当然还有很多对于这个的延伸，这就可能会用在后面的题目上。后面的面试题之类的。那可以多尝试一下练题，然后就能加深一下对队列的一些的相关知识的巩固。那么接下来来我就这样所有的代码给大家看一下。}QueueNode;}Queue;assert(pq);assert(pq);free(cur);cur = next;assert(pq);exit(-1);else。
关键路径——C语言（理论）
2302_80790488的博客
06-28 853
关键路径，是项目网络中从起始事件到终止事件的最长路径，决定了项目的最短完成时间。 关键路径中的任务没有任何可调整的余地，如果任何一个任务被延迟，整个项目的完成时间也会被延迟。
Android 开发中 C++ 和Java 日志调试
小羊子的技术专栏
07-04 908
Android 开发中 C++ 和Java 日志调试方法小结
数学系C++ 继承派生多态 （十四十三）
m0_68339197的博客
07-08 174
可以使得派生类具有父类的各种属性和功能，而不需要再次编写相同的代码。类的继承：派生类继承了父类的特性（数据和函数）► 继承是可传递的：从父类继承的特性可以传递给新的子类► 继承方式：规定了如何访问从父类继承的成员► 继承方式有三种：public、protected、private► 派生类成员：从父类继承的成员+新增加的成员继承方式不同，访问控制不同 父类成员函数访问父类成员：正常访问 派生类成员函数访问派生类新增成员：正常访问 父类成员函数访问派生类新增成员：不能访问。
C++：CV::Point函数简介
Ethan_Rich的博客
07-08 206
cv::Point是 OpenCV 库中用于表示二维坐标系下点的一个基本数据类型。它提供了在图像处理、计算机视觉等领域中定位和操作点的能力。以下是关于cv::Point。
c++习题09-分离整数的各个数
码到成龚的博客
07-04 208
描述 给定一个整数n(1≤n≤100000000)，要求从个位开始分离出它的每一位数字。从个位开始按照从低位到高位的顺序依次输出每一位数字。 输入描述 输入一个整数，整数在1到100000000之间。 输出描述 从个位开始按照从低位到高位的顺序依次输出每一位数字。数字之间以一个空格分开。
探索C嘎嘎的奇妙世界:第十九关---STL(list的模拟实现)
2401_84006021的博客
07-05 693
探索C嘎嘎的奇妙世界:第十九关---STL(list的模拟实现)
C语言 | Leetcode C语言题解之第222题完全二叉树的节点个数
m0_59237910的博客
07-08 178
C语言 | Leetcode C语言题解之第222题完全二叉树的节点个数
【理解STL】
Pumpkin_O的博客
07-08 649
STL是惠普实验室开发的一系列标准化组件的统称。STL的一个基本理念就是将数据和操作分离，数据由容器加以管理，操作则由可定制的算法完成，迭代器在两者之间充当“黏合剂”。容器是存储其他对象的对象，它存储的对象可以是自定义数据类型的对象，也可以是内置数据类型的对象。这些被存储的对象必须是同一种数据类型，它们归容器所有，称为容器的元素。当容器失效时，容器中的元素也会失效。容器本身包含了处理这些数据的方法。另外，容器最重要的优点就是它可以扩展自身的大小。
【C++ STL】模拟实现 vector
最新发布
水墨不写bug
07-08 487
C++ STL 模拟实现vector
C++：求梯形面积
spp_1987的专栏
07-04 430
c++ 初学者 梯形面积
c++ primer plus 第15章友，异常和其他：异常,15.3.3 异常机制
zhyjhacker的博客
07-08 672
c++ primer plus 第15章友，异常和其他：异常,15.3.3 异常机制异常,15.3.3 异常机制。
Linux C轻量级白盒测试方法 (shell + c + signal)
AntigravityC的博客
07-08 224
linux C轻量级白盒测试方法（shell + c +signal）

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

二木 同学

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值