STL set 和 map

最新推荐文章于 2024-07-22 09:38:37 发布
最新推荐文章于 2024-07-22 09:38:37 发布
阅读量501 收藏 19
点赞数 20
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_70793373/article/details/133029502
版权

文章目录

一、标准库中 set 和 multiset 的使用

在这里插入图片描述

在这里插入图片描述

set 是一颗 K 模型的红黑树，可以存储任意类型，multiset 和 set 的区别是 multiset 允许插入重复值，set 不允许

模板参数 T 表示存储元素的类型，Compare 表示存储元素的比较方法，Alloc 是空间配置器，一般不用传

set 和 multiset 常用接口使用：

#include <iostream>
#include <set>

using namespace std;

void setUsing()
{
	// set 不允许插入重复值
	// insert 返回值为 pair<iterator, bool>
	// 如果插入的值不存在，则返回值 pair 中的 first 指向新插入的元素，second 设置为 true
	// 如果插入的值已存在，则返回值 pair 中的 first 指向已有的元素，second 设置为 false
	set<int> s;
	cout << s.insert(3).second << " ";
	cout << s.insert(1).second << " ";
	cout << s.insert(1).second << " ";
	cout << s.insert(4).second << " ";
	cout << s.insert(2).second << " ";
	cout << s.insert(1).second << " ";
	cout << endl; // 输出 1 1 0 1 1 0

	// set 不允许修改元素内容，因此 iterator 和 const_iterator 是相同的
	set<int>::iterator sit = s.begin();
	while (sit != s.end())
	{
		// *sit *= 10;
		cout << *sit << " ";
		++sit;
	}
	cout << endl; // 输出 1 2 3 4

	// find 成功返回指向该元素的迭代器，失败返回 end()
	sit = s.find(1);
	if (sit != s.end()) cout << *sit << endl; // 输出 1

	// 返回 set 中元素的数目
	cout << s.count(1) << endl; // 输出 1
}

void multisetUsing()
{
	// multiset 允许插入重复值
	std::multiset<int> s;
	s.insert(3);
	s.insert(1);
	s.insert(1);
	s.insert(4);
	s.insert(2);
	s.insert(1);

	for (auto e : s) cout << e << " ";
	cout << endl; // 输出 1 1 1 2 3 4

	// find 成功返回指向该元素的迭代器，失败返回 end()
	std::set<int>::iterator sit = s.find(1);
	if (sit != s.end()) cout << *sit << endl; // 输出 1

	// 返回 set 中元素的数目
	cout << s.count(1) << endl; // 输出 3
}

int main()
{
	setUsing();
	cout << endl;

	multisetUsing();
	cout << endl;

	return 0;
}

二、标准库中 map 和 multimap 的使用

在这里插入图片描述

在这里插入图片描述

map 是一颗 KV 模型的红黑树，可以存储任意类型，multimap 和 map 的区别是 multimap 允许插入 key 值重复的 <key, value> 键值对，map 不允许

模板参数 Key 表示 <key, value> 中 key 的类型，T 表示 <key, value> 中 value 的类型，Compare 表示存储元素的比较方法，Alloc 是空间配置器，一般不用传

map 和 multimap 常用接口使用：

#include <iostream>
#include <map>
#include <string>

using namespace std;

void mapUsing1()
{
	// map 不允许插入 key 值重复的 <key, value> 键值对
	// insert 返回值为 pair<iterator, bool>
	// 如果插入的 key 值不存在，则返回值 pair 中的 first 指向新插入的元素，second 设置为 true
	// 如果插入的 key 值已存在，则返回值 pair 中的 first 指向已有的元素，second 设置为 false
	map<string, string> dict;
	cout << dict.insert(make_pair("sort", "排序")).second << " ";
	cout << dict.insert(make_pair("string", "字符串")).second << " ";
	cout << dict.insert(make_pair("count", "计数")).second << " ";
	cout << dict.insert(make_pair("string", "\"字符串\"")).second << " ";
	cout << endl; // 输出 1 1 1 0

	// map 不允许修改元素内容，因此 iterator 和 const_iterator 是相同的
	map<string, string>::iterator mit = dict.begin();
	while (mit != dict.end())
	{
		cout << mit->first << ":" << mit->second << " ";
		++mit;
	}
	cout << endl; // 输出 count:计数 sort:排序 string:字符串 

	// find 通过 key 查找，成功返回指向该元素的迭代器，失败返回 end() 
	mit = dict.find("string");
	if (mit != dict.end()) cout << mit->second << endl; // 输出 字符串

	// 返回 map 中 key 的数目
	cout << dict.count("string") << endl; // 输出 1

	// operator[key] 等价于 ( *(( this->insert(make_pair(key, mapped_type())) ).first) ).second
	// 如果 key 存在，则返回对应的 <key, value> 中 value 的引用
	// 如果 key 不存在，则先插入 <key, mapped_type()> ，再返回 <key, mapped_type()> 中 value 的引用(这里的 mapped_type 是指 value 的类型)
	dict["string"] = "\"字符串\"";
	dict["right"] = "右边";
	for (auto& e : dict) cout << e.first << ":" << e.second << " ";
	cout << endl; // 输出 count:计数 right:右边 sort:排序 string:"字符串" 
}

// 统计每种水果出现的次数
void mapUsing2()
{
	string fruit[] = {"西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨"};
	map<string, int> fruitCount;

	for (auto &e : fruit) fruitCount[e]++;
	for (auto &e : fruitCount) cout << e.first << ":" << e.second << " ";
	cout << endl; // 输出 梨:1 苹果:5 西瓜:4 香蕉:2
}

void multimapUsing()
{
	// multimap 允许插入 key 值重复的 <key, value> 键值对
	std::multimap<std::string, std::string> m;
	m.insert(std::make_pair("string", "字符串"));
	m.insert(std::make_pair("string", "\"字符串\""));

	for (auto &e : m) cout << e.first << ":" << e.second << " ";
	cout << endl; // 输出 string:字符串 string:"字符串" 

	// 返回 map 中 key 的数目
	cout << m.count("string") << endl; // 输出 2
}

int main()
{
	mapUsing1();
	cout << endl;

	mapUsing2();
	cout << endl;

	multimapUsing();
	cout << endl;

	return 0;
}

三、set 和 map 底层红黑树的模拟实现

#pragma once

#include <utility>

namespace starrycat
{
	// 结点的颜色
	enum Color { RED, BLACK };

	// 红黑树的结点
	template<class VALUE>
	struct RBTreeNode
	{
		VALUE _data;
		RBTreeNode<VALUE>* _left;
		RBTreeNode<VALUE>* _right;
		RBTreeNode<VALUE>* _parent;
		Color _color;	// 结点的颜色

		RBTreeNode<VALUE>(const VALUE& data = VALUE())
			: _data(data)
			, _left(nullptr)
			, _right(nullptr)
			, _parent(nullptr)
			, _color(RED)	// 为了方便树的结构调整，新结点默认为红色
		{}
	};

	template<class T, class Ref, class Ptr>
	struct __rb__iterator
	{
		typedef RBTreeNode<T> Node;
		typedef __rb__iterator<T, Ref, Ptr> Self;
		typedef __rb__iterator<T, T&, T*> iterator;

		__rb__iterator<T, Ref, Ptr>(Node* node) : _node(node) {}
		__rb__iterator<T, Ref, Ptr>(const iterator& it) : _node(it._node) {}

		bool operator==(const Self& s) const { return _node == s._node; }
		bool operator!=(const Self& s) const { return _node != s._node; }
		Ref operator*() const { return _node->_data; }
		Ptr operator->() const { return &_node->_data; }

		void increment()
		{
			if (_node->_right)
			{
				// 根据中序遍历(左根右)，如果右子树存在，则迭代器的下一个位置为右子树的最左结点
				Node* cur = _node->_right;
				while (cur->_left) cur = cur->_left;

				_node = cur;
			}
			else
			{
				// 根据中序遍历(左根右)，如果右子树不存在，则迭代器的下一个位置为左子树包含当前结点的最近祖先结点
				Node* cur = _node;
				Node* parent = _node->_parent;
				while (parent && parent->_right == cur)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_node = parent;
			}
		}

		Self& operator++()
		{
			increment();
			return *this;
		}

		Self operator++(int)
		{
			Self tmp = *this;
			increment();
			return tmp;
		}

		void decrement()
		{
			if (_node->_left)
			{
				// 根据中序遍历(右根左)，如果左子树存在，则迭代器的下一个位置为左子树的最右结点
				Node* cur = _node->_left;
				while (cur->_right) cur = cur->_right;

				_node = cur;
			}
			else
			{
				// 根据中序遍历(右根左)，如果左子树不存在，则迭代器的下一个位置为右子树包含当前结点的最近祖先结点
				Node* cur = _node;
				Node* parent = _node->_parent;
				while (parent && parent->_left == cur)
				{
					cur = parent;
					parent = parent->_parent;
				}

				_node = parent;
			}
		}

		Self& operator--()
		{
			decrement();
			return *this;
		}

		Self operator--(int)
		{
			Self tmp = *this;
			decrement();
			return tmp;
		}

		Node* _node;
	};

	template<class K>
	struct Less
	{
		bool operator()(const K& key1, const K& key2)
		{
			return key1 < key2;
		}
	};

	// 在查找删除数据时，map 需要用 K 作为参数的类型
	// T 是红黑树结点存储的类型，作为 set 的底层时只存储 key，作为 map 的底层时存储 <const key, value>
	// 在插入数据时，set 可以直接比较红黑树结点中的 data，而 map 则需要比较红黑树结点中的 data.first
	// 如果是 set，KEYOFT(data) 返回 data，如果是 map，KEYOFT(data) 返回 data.first
	template<class K, class T, class KEYOFT, class COMPARE = Less<K>>
	class RBTree
	{
		typedef RBTreeNode<T> Node;
	public:
		typedef __rb__iterator<T, T&, T*> iterator;
		typedef __rb__iterator<T, const T&, const T*> const_iterator;
	public:
		RBTree<K, T, KEYOFT, COMPARE>()
			: _root(nullptr)
		{}

		iterator begin()
		{
			// 根据中序遍历(左根右)，迭代器的起始位置为树的最左结点 
			Node* cur = _root;
			while (cur && cur->_left) cur = cur->_left;

			return cur;
		}

		iterator end()
		{
			return nullptr;
		}

		const_iterator begin() const
		{
			// 根据中序遍历(左根右)，迭代器的起始位置为树的最左结点 
			Node* cur = _root;
			while (cur->_left) cur = cur->_left;

			return cur;
		}

		const_iterator end() const
		{
			return nullptr;
		}

		// 插入
		std::pair<iterator, bool> Insert(const T& data)
		{
			KEYOFT kot;
			COMPARE cmp;

			// 按照二叉搜索树的方式插入结点，保证该树插入结点之后还是二叉搜索树
			if (_root == nullptr)
			{
				_root = new Node(data);
				_root->_color = BLACK;
				return std::make_pair(iterator(_root), true);;
			}

			Node* parent = nullptr;
			Node* cur = _root;
			while (cur)
			{
				if (cmp(kot(data), kot(cur->_data)))
				{
					parent = cur;
					cur = cur->_left;
				}
				else if (cmp(kot(cur->_data), kot(data)))
				{
					parent = cur;
					cur = cur->_right;
				}
				else return std::make_pair(iterator(cur), false);
			}

			Node* newnode = new Node(data);
			cur = newnode;
			if (cmp(kot(data), kot(parent->_data))) parent->_left = cur;
			else parent->_right = cur;

			cur->_parent = parent;

			// 更新颜色
			while (parent && parent->_color == RED)
			{
				Node* grandfather = parent->_parent;
				if (grandfather->_left == parent)
				{
					Node* uncle = grandfather->_right;
					
					// u 存在且为红
					// u 不存在或存在且为黑
					if (uncle && uncle->_color == RED)
					{
						grandfather->_color = RED;
						parent->_color = BLACK;
						uncle->_color = BLACK;

						// 继续判断是否违反了红黑树的性质
						cur = grandfather;
						parent = grandfather->_parent;
					}
					else
					{
						// p 为 g 的左，cur 为 p 的左 右单旋
						// p 为 g 的左，cur 为 p 的右 先左旋再右旋
						if (parent->_left == cur)
						{
							RotateR(grandfather);
							grandfather->_color = RED;
							parent->_color = BLACK;
						}
						else
						{
							RotateL(parent);
							RotateR(grandfather);
							grandfather->_color = RED;
							cur->_color = BLACK;
						}
					}
				}
				else
				{
					Node* uncle = grandfather->_left;

					// u 存在且为红
					// u 不存在或存在且为黑
					if (uncle && uncle->_color == RED)
					{
						grandfather->_color = RED;
						parent->_color = BLACK;
						uncle->_color = BLACK;

						// 继续判断是否违反了红黑树的性质
						cur = grandfather;
						parent = grandfather->_parent;
					}
					else
					{
						// p 为 g 的右，cur 为 p 的右 左单旋
						// p 为 g 的右，cur 为 p 的左 先右旋再左旋
						if (parent->_right == cur)
						{
							RotateL(grandfather);
							grandfather->_color = RED;
							parent->_color = BLACK;
						}
						else
						{
							RotateR(parent);
							RotateL(grandfather);
							grandfather->_color = RED;
							cur->_color = BLACK;
						}
					}
				}
			}

			_root->_color = BLACK;
			return std::make_pair(iterator(newnode), true);
		}

		iterator Find(const K& key)
		{
			KEYOFT kot;
			COMPARE cmp;

			Node* cur = _root;
			while (cur)
			{
				if (cmp(key, kot(cur->_data))) cur = cur->_left;
				else if (cmp(kot(cur->_data), key)) cur = cur->_right;
				else return cur;
			}

			return nullptr;
		}

	private:
		void RotateR(Node* parent)
		{
			Node* pparent = parent->_parent;
			Node* subL = parent->_left;
			Node* subLR = subL->_right;

			parent->_left = subLR;
			if (subLR) subLR->_parent = parent;

			subL->_right = parent;
			parent->_parent = subL;

			if (pparent == nullptr) _root = subL;
			else
			{
				if (pparent->_left == parent) pparent->_left = subL;
				else pparent->_right = subL;
			}
			subL->_parent = pparent;
		}

		void RotateL(Node* parent)
		{
			Node* pparent = parent->_parent;
			Node* subR = parent->_right;
			Node* subRL = subR->_left;

			parent->_right = subRL;
			if (subRL) subRL->_parent = parent;

			subR->_left = parent;
			parent->_parent = subR;

			if (pparent == nullptr) _root = subR;
			else
			{
				if (pparent->_left == parent) pparent->_left = subR;
				else pparent->_right = subR;
			}
			subR->_parent = pparent;
		}

	private:
		Node* _root;
	};
}

四、set 类 和 map 类的模拟实现

set 类 和 map 类常用接口模拟实现：

// test.cc
#include "set.hpp"
#include "map.hpp"

int main()
{
	starrycat::setTest1();

	starrycat::mapTest1();
	starrycat::mapTest2();
	
	return 0;
}

// set.hpp
#pragma once

#include "RBTree.h"
#include <iostream>
#include <utility>

namespace starrycat
{
	template <class K>
	struct SET_KEYOFT
	{
		const K &operator()(const K &key)
		{
			return key;
		}
	};

	template <class K>
	class set
	{
	public:
		// set 不允许修改元素内容，因此 iterator 和 const_iterator 是相同的
		typedef typename RBTree<K, K, SET_KEYOFT<K>>::const_iterator iterator;
		typedef typename RBTree<K, K, SET_KEYOFT<K>>::const_iterator const_iterator;

	public:
		// 红黑树底层实现了 iterator 构造 const_iterator
		iterator begin() const { return _rb.begin(); }
		iterator end() const { return _rb.end(); }
		std::pair<iterator, bool> insert(const K &key) { return _rb.Insert(key); }

	private:
		RBTree<K, K, SET_KEYOFT<K>> _rb;
	};

	void setTest1()
	{
		set<int> s;
		int a[] = {16, 3, 7, 11, 9, 26, 18, 14, 15};
		for (auto e : a) s.insert(e);

		set<int>::iterator sit = s.begin();
		while (sit != s.end())
		{
			// *sit *= 10;
			std::cout << *sit << " ";
			++sit;
		}
		std::cout << std::endl; // 输出 3 7 9 11 14 15 16 18 26
	}
}

// map.hpp
#pragma once

#include "RBTree.h"
#include <iostream>
#include <string>

namespace starrycat
{
	template<class K, class V>
	struct MAP_KEYOFT
	{
		const K& operator()(const std::pair<const K, V>& data)
		{
			return data.first;
		}
	};

	template<class K, class V>
	class map
	{
	public:
		typedef typename RBTree<K, std::pair<const K, V>, MAP_KEYOFT<K, V>>::iterator iterator;
		typedef iterator const_iterator;
	public:
		iterator begin() { return _rb.begin(); }
		const_iterator begin() const { return _rb.begin(); }
 		iterator end() { return _rb.end(); }
 		const_iterator end() const { return _rb.end(); }
		std::pair<iterator, bool> insert(const std::pair<K, V>& data) { return _rb.Insert(data); }
		V& operator[](const K& key) { return ( *(( insert(std::make_pair(key, V())) ).first) ).second; }

	private:
		RBTree<K, std::pair<const K, V>, MAP_KEYOFT<K, V>> _rb;
	};

	void mapTest1()
	{
		map<std::string, std::string> dict;
		std::cout << dict.insert(std::make_pair("sort", "排序")).second << " ";
		std::cout << dict.insert(std::make_pair("string", "字符串")).second << " ";
		std::cout << dict.insert(std::make_pair("count", "计数")).second << " ";
		std::cout << dict.insert(std::make_pair("string", "\"字符串\"")).second << " ";
		std::cout << std::endl; // 输出 1 1 1 0

		map<std::string, std::string>::iterator mit = dict.begin();
		while (mit != dict.end())
		{
			std::cout << mit->first << ":" << mit->second << " ";
			++mit;
		}
		std::cout << std::endl; // 输出 count:计数 sort:排序 string:字符串 

		dict["string"] = "\"字符串\"";
		dict["right"] = "右边";
		for (auto& e : dict) std::cout << e.first << ":" << e.second << " ";
		std::cout << std::endl; // 输出 count:计数 right:右边 sort:排序 string:"字符串" 
	}

	// 统计每种水果出现的次数
	void mapTest2()
	{
		std::string fruit[] = {"西瓜", "西瓜", "苹果", "西瓜", "苹果", "苹果", "西瓜", "苹果", "香蕉", "苹果", "香蕉", "梨"};
		map<std::string, int> fruitCount;

		for (auto &e : fruit) fruitCount[e]++;
		for (auto &e : fruitCount) std::cout << e.first << ":" << e.second << " ";
		std::cout << std::endl; // 输出 梨:1 苹果:5 西瓜:4 香蕉:2
	}
}
[Pokemon]大猫猫
关注
  • 20
    点赞
  • 踩
  • 19
    收藏
    觉得还不错? 一键收藏
  • 21
    评论
专栏目录
windbg导出stl map和set的插件
07-28
在处理复杂的系统问题时，尤其是对于C++程序中的STL（Standard Template Library，标准模板库）容器，如map和set，理解其内部结构和内容至关重要。这个插件“stlkit.dll”就是为了帮助开发者更便捷地在Windbg中查看...
浅析stl序列容器(map和set)的仿函数排序
09-05
在本文中，我们将深入探讨如何使用仿函数对STL序列容器`map`和`set`进行自定义排序。 `set`和`map`都是STL中有序的容器。`set`是一个无重复元素的集合，而`map`则是一组键值对，其中键是唯一的。它们都使用红黑树...
C++ STL set 和 map 的区别
catalpeak的博客
03-21 347
map和set都是关联式容器，底层也都是由红黑树实现的。 set称为集合、map称为键值对的集合。即set只有key没有value或者说只有value没有key，但是map既有key也有value二者是相关联的。通过寻找map的key来提取value。 ...
STL详解---set和map
分享学习的知识，记录我的技术成长道路
05-31 1241
在我们之前的学习中，已经了解了STL的部分容器，比如：vector，list，deque，forward_list等等，这些容器统称为序列式容器，而我们今天要将的map和set称之为关联式容器，序列式容器和关联式容器的区别就在于，序列式容器单纯为了存储数据而存在。而关联式容器不仅仅存储数据还对结构进行了存储。 在了解set和map之前，我们需要了解搜索二叉树是什么，因为set和map的底层就是一棵搜索二叉树。
STL中set与map介绍
异样旧日的博客
06-19 412
pair,set,map,mulset和mulmap的类声明以及基本使用
STL——map和set
weixin_50601177的博客
08-25 383
map和set
C++ STL中 set和map介绍以及使用方法
qq_61635026的博客
07-30 754
C++ STL中 set和map介绍以及使用方法
C++ STL中的set和map
火柴的初心的博客
04-05 716
目录 1.set 头文件 初始化 基本方法 插入 删除 功能 参考： 1.set 头文件 #include <set> using namespace std; 初始化 template < class T, // 键 key 和值 value 的类型 class Co...
C++ STL中，map和set有什么区别，分别又是怎么实现的？
学无止尽，谨言慎行！
04-03 5533
map和set都是C++的关联容器，其底层实现都是红黑树（RB-Tree）。由于 map 和set所开放的各种操作接口，RB-tree 也都提供了，所以几乎所有的 map 和set的操作行为，都只是转调 RB-tree 的操作行为。 map和set区别在于： （1）map中的元素是key-value（关键字—值）对：关键字起到索引的作用，值则表示与索引相关联的数据；Set与之相对就是关键字的简单集...
C++【STL】【map和set】
芊樱烛渊的博客
10-29 1303
map和set是关联性容器在我们的STL中分为两类序列式容器：vector list deque关联式容器：map set。
【C++】--- STL之 set 和 map
weixin_75128035的博客
05-30 1015
multimap容器与map容器的底层实现一样，也都是平衡搜索树（红黑树），其次，multimap容器和map容器所提供的成员函数的接口都是基本一致的，这里也就不再列举了，multimap容器和map容器的区别与multiset容器和set容器的区别一样，multimap允许键值冗余，即。比如：现在要建立一个英汉互译的字典，那该字典中必然有英文单词与其对应的中文含义，而且，英文单词与其中文含义是一一对应的关系，即通过该应该单词，在词典中就可以找到与其对应的中文含义。是最常用的，也是最简洁的！
【STL】容器 - set和map的使用与实现
Hello_World_213的博客
11-05 1312
STL - set与map的使用与实现(常用及重点接口详解)
map和set的模拟实现
06-06
通过这样的实现，我们能够获得与STL中map和set类似的功能，同时可以根据具体需求进行定制，例如优化比较函数、添加额外的成员函数或改变内存管理策略。 在实际编码过程中，可以参考开源的红黑树实现，如Linux内核中...
Map和Set的区别
12-21
在C++标准模板库（STL）中，`Map` 和 `Set` 是两种关联容器，它们都提供了高效的数据存储和检索能力。然而，它们在数据结构、存储方式以及使用场景上有着显著的区别。 首先，`Map` 是一个键值对（Key-Value Pair）...
map和set的异同
09-28
map和set的异同map和set的异同map和set的异同map和set的异同
C语言 之 理解指针（1）
fallzzzzz的博客
07-20 1115
就是先获取该数组的首元素的地址，从前面我们知道，指针的类型的作用是指针+1 所跳过的字节数，int为整形，大小为4个字节，所以p+1就跳过4个字节，p+2就跳过8个字节，计算机的CPU（中央处理器）在处理数据的时候，需要的数据是在内存中读取的，处理后数据也会放回内存中，如果想对这些空间进行高效的管理，就可以。并且我们知道，数组的元素存放是随着下标增长，内存地址变大的。上面的代码创建了一个整型变量n，因为一个整形的大小是4个字节，所以内存中申请了4个字节，⽤于存放整数10，其中每个字节都有地址。
C++二叉搜索树
Jk_Mr的博客
07-20 1121
树结构是一种重要的数据结构。树是一种非线性的数据结构，它是由n（n>=0）个有限结点组成一个具有层次关系的集合。把它叫做树是因为它看起来像一棵倒挂的树，也就是说它是根朝上，而叶朝下的。
C++笔试强训7
m0_74189279的博客
07-21 963
这意味着编译器会尝试将函数的代码直接插入到每个调用该函数的地方，而不是像通常那样进行函数调用（即，生成调用指令，跳转到函数代码，执行函数体，然后返回）。友元函数是在类外部定义的普通函数，它只能通过传入的参数（如果有的话）来访问类的成员，或者通过类的对象显式地访问（如果该函数设计为接受类的对象作为参数）。函数参数默认值又叫缺省参数，缺省参数必须从右向左开始缺省，必须连续给定缺省值，也就是说，从左到右，一旦遇到一个参数是缺省的，那么之后的参数也必须都是缺省的。指针是类成员函数特有的，用于指向调用该函数的对象。
商品信息管理系统(C语言)
最新发布
zeyeqianli的博客
07-22 306
该案例使用了C语言中最具特色的结构体，将每个商品的所有信息存在结构体中，并且定义一个结构体类型的数组保存所有商品的信息，并且按照模块化的编程思想，将要实现的每个功能编写成独立的函数，这样即方便阅读同时也方便差错修改。该系统的主要功能如下：(1) 登录系统。(2) 创建商品信息。(3) 打印商品信息。(4) 查询商品信息。(5) 修改商品信息。(6) 删除商品信息。(7) 商品价格排名显示。(8) 退出系统。
STL MAP, STL SET 数据结构基础及优势分析
STL map和set的使用虽然并不复杂，但是很多地方并不容易理解。例如，为何map和set的插入删除效率比使用其他序列容器要高？为何每次insert之后，以前保存的iterator不会失效？为何map和set不能像vector一样有个...
评论 21
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值