C++学习笔记（12）

bluestar啦啦

已于 2022-03-17 21:04:59 修改

阅读量1.1k

点赞数 1

分类专栏： C++学习文章标签： c++ 学习开发语言经验分享

于 2022-03-17 21:01:56 首次发布

本文链接：https://blog.csdn.net/m0_60958852/article/details/123557702

版权

C++学习专栏收录该内容

13 篇文章 1 订阅

订阅专栏

8.set/multiset/bitset

一.STL容器

1.array

使用时要包含 <array> 头文件

其实用起来很简单，只要明白他其实是一个模板类就足够了。下面自己来简单实现一下（只是让他看起来像，没有内置迭代器，后面会讲）：

class myArray
{
public:
	myArray()
	{
		memory = new _Ty[size];
	}
	~myArray()
	{
		delete[] memory;
	}
	_Ty& operator[](int idex)
	{
		return memory[idex];
	}
protected:
	_Ty* memory;
};
int main()
{
	
	myArray<int, 3> arr;
	for (int i = 0; i < 3; i++)
	{
		arr[i] = i;
	}
	return 0;
}

可以定义，可以插入，但是跟标准库中的还是有很大差别，因为标准库中很多操作都是建立在迭代器之上的，前面我有粗略地提过迭代器的使用，现在来仔细地讲一讲：

迭代器：就是一个类中类，通过运算符重载通过类中类的对象去遍历容器

迭代器的分类
- 正向迭代器: iterator
  - begin();
  - end();
- 反向迭代器: reverse_iterator
  - rbegin();
  - rend();
- 常正向迭代器: const_iterator
  - cbegin();
  - cend();
- 常反向迭代器:const_reverse_iterator
  - crbegin();
  - crend();
按功能分类
- 正向迭代
- 双向迭代
- 随机访问迭代器

根据这个，我们可以自己简单实现一下（之前推文有写过）：

class myArray
{
public:
	myArray()
	{
		memory = new _Ty[size];
	}
	~myArray()
	{
		delete[] memory;
	}
	_Ty& operator[](int idex)
	{
		return memory[idex];
	}
	_Ty* begin()
	{
		return memory;
	}
	_Ty* end()
	{
		return memory + size;
	}
	class iterator
	{
	public:
		iterator(_Ty* pmove = nullptr):pmove(pmove){}
		//运算符重载
		void operator=(_Ty* pmove)
		{
			this->pmove = pmove;
		}
		bool operator!=(_Ty* pmove)
		{
			return this->pmove != pmove;
		}
		iterator operator++(int)
		{
			this->pmove++;
			return *this;
		}
		_Ty operator*()
		{
			return *pmove;
		}
	protected:
		_Ty* pmove;
	};
protected:
	_Ty* memory;
};
int main()
{
	
	myArray<int, 3> arr;
	for (int i = 0; i < 3; i++)
	{
		arr[i] = i;
	}
	myArray<int, 3>::iterator iter;
	for (iter = arr.begin(); iter != arr.end(); iter++)
	{
		cout << *iter << '\t';
	}
	return 0;
}

可以发现，array跟数组没什么差别，所以，实际上数组也可以看作是容器。

下面是容器的一些基本操作：

class Man
{
public:
	Man(){}
	Man(string name,int age):name(name),age(age){}
	void print()
	{
		cout << name << '\t' << age << endl;
	}
protected:
	string name;
	int age;
};
int main()
{
	//可以定义时初始化
	array<int, 3> arr1 = { 1,2,3 };
	array<int, 3> arr2;
	//可以交换，但长度一定要一样长
	arr1.swap(arr2);
	//有迭代器可以使用新版本的for循环打印
	for (auto v : arr2)
	{
		cout << v << '\t';
	}
	//处理自定义类型数据
	array<Man, 3> arr3;
	for (int i = 0; i < arr3.size(); i++)
	{
		string name = "name";
		arr3[i] = Man(name + to_string(i), i);
	}
	for (auto v : arr3)
	{
		v.print();
	}
	return 0;
}

2.vector

使用时要包含 <vector> 头文件
使用时可以带长度，也可以不带，可以初始化，也可以不初始化

下面是各种初始化方式汇总：

//辅助函数，遍历容器
template <class _Ty>
void printVector(vector<_Ty>& temp)
{
	for (auto v : temp)
	{
		cout << v << '\t';
	}
	cout << endl;
}
int main()
{
	vector<int> vecData;
	//采用成员函数的方式做插入.插入多少个元素都可以--->会自动扩建
	for (int i = 0; i < 3; i++)
	{
		vecData.push_back(i);	//尾插法 0 1 2
	}
	printVector(vecData);

	//带初始化
	vector<double> dData = { 1.1,1.23,1.44 };  //自动推断长度为3
	printVector(dData);

	vector<string> strData(3);		//当前动态数组的长度是3
	for (int i = 0; i < 3; i++)     //确定长度,可以直接使用数组法插入
	{
		string name = "name";
		//只有在确定长度范围以内的可以直接采用数组法（下标）插入
		strData[i] = name + to_string(i);
	}
	printVector(strData);
	//strData[3] = "name3";    vector subscript out of range 引发中断
	strData.push_back("name3");	    //超过的必须用成员函数插入(会自动扩增)
	printVector(strData);

	return 0;
}

如果数据是自定义类型，那最好重载一下流运算符，老生常谈了，这里就不演示，接下来附上vector常用操作：

int main()
{
	vector<int> vec = { 1,2,3,4 };
	cout << vec.size() << endl;		//当前容器中的元素个数
	cout << vec.empty() << endl;		//判断是否为空  
	cout << vec.front() << endl;		//访问第一个元素
	cout << vec.back() << endl;		//访问最后一个元素
	cout << vec.at(2) << endl;		//直接用下标法访问,返回当前下标下面的值
	cout << vec[2] << endl;		    //和at(2)一样效果 不能&vec[2]没有重载&
	//修改某个元素,通过下标来修改
	vec.emplace(vec.begin() + 2, 100); /*在指定位置插入一个新的元素,用迭代器去指位置,传入
											 的是位置,往第2个位置插入100 */
	vec.emplace(vec.begin(), 1111);	//往第一个位置插入元素			
	printVector(vec);
	vec.emplace_back(999);			//和 push_back 一样的功能

	//vec.erase(vec.begin() + 2);   //数组只有伪删除,没有删除操作(万金油函数,链表中有用)
	printVector(vec);

	//批量复制 想把一个数组的内容拷贝到一个向量中去--->用迭代器去指定位置
	int array[] = { 1,2,3 };            //一个普通数组赋值为1,2,3
	vector<int> vecData;                //不需要起始长度--->构建的是对象,会自动释放
	vecData.assign(array, array + 3);   /*赋值的方式,把数组中的东西赋值给另一个数组(把元素的
										  第一个位置到最后一个位置拷贝到容器中)*/
	printVector(vecData);

	return 0;
}

3.list

包含头文件 <list>

双向链表可以头插和尾插。

基本操作如下：

int main()
{
    list<int> iNum;
    list<string> strNum;
    //插入
    strNum.push_back("string1");    //尾插发
    strNum.push_back("string2");
    strNum.push_front("string3");
    //string3 string1  string2
    //遍历
    //不删除方式遍历
    list<string>::iterator iter;
    for (iter = strNum.begin(); iter != strNum.end(); iter++)
    {
        cout << *iter << " ";
    }
    cout << endl;
    cout << "是否为空:" << boolalpha << !strNum.empty() << endl;
    cout << "元素个数:" << strNum.size() << endl;
    //删除方式遍历
    //string3 string1  string2
    while (!strNum.empty())
    {
        cout << strNum.front() << " ";    //back()
        strNum.pop_front();                //头部删除  pop_front();
    }
    cout << endl;
    cout << "元素个数:" << strNum.size() << endl;
    //指定位置操作
    //iterator find(iterator begin,iterator end,data);
    for (int i = 0; i < 3; i++)
    {
        iNum.push_back(i);
    }
    auto result = find(iNum.begin(), iNum.end(), 2);//find返回的是迭代器
    //没找到返回是end结束的位置
    if (result == iNum.end())
    {
        cout << "未找到指定位置" << endl;
    }    
    //insert：在指定的迭代器前插入，返回指向插入数据的迭代器
    iNum.insert(result, 100);
    //删除函数：使作为参数的迭代器失效，并返回指向该迭代器下一参数的迭代器
    iNum.erase(result);
    //其他操作
    iNum.reverse();                //反转链表
    iNum.sort(less<int>());                //排序
	return 0;
}

其中要注意的是erase函数，如果用它做删除，应该这么写：

int main()
{
	int array[4] = { 1,2,2,3 };
	list<int>data;
	data.assign(array, array + 4);  //初始化list---把数据拷贝到data中,把2全部删除
		//相同元素的删除
	for (list<int>::iterator iter = data.begin(); iter != data.end(); )
	{
		if (*iter == 2)
		{
			iter = data.erase(iter);  //函数返回下一个迭代器
		}
		else
		{
			iter++;
		}
	}
	return 0;
}

4.stack

包含头文件 <stack>

使用方式很简单，先进后出，可以用在游戏数据保存，实现回退功能。下面是常用的方法：

int main()
{
    stack<int> intStack;
    for (int i = 0; i < 3; i++)
    {
        intStack.push(i);//入栈
    }
    while (!intStack.empty())
    {
        cout << intStack.top() << "\t";
        intStack.pop();//出栈
    }
	return 0;
}

5.queue

包含头文件 <queue>

先进先出，跟栈相反。

int main()
{
    queue<int> qData;
    for (int i = 0; i < 3; i++)
    {
        qData.push(i);    //入队
    }
    while (!qData.empty())
    {
        cout << qData.front() << " ";  //获取队头元素
        qData.pop();    //出队
    }
    cout << endl;
    cout << qData.size() << endl;
	return 0;
}

6.deque

包含头文件 <deque>

双向队列，头尾能进能出

//从头出来
void pop_front_dequeue(deque<int> dData)
{
    while (!dData.empty())
    {
        cout << dData.front() << " ";
        dData.pop_front();
    }
    cout << endl;
}
//从尾出来
void pop_back_dequeue(deque<int> dData)
{
    while (!dData.empty())
    {
        cout << dData.back() << " ";
        dData.pop_back();
    }
    cout << endl;
}
int main()
{
    deque<int> deData;
    for (int i = 0; i < 3; i++)
    {
        deData.push_back(i);        //尾插法入队
        deData.push_front(i);        //头插法入队
    }
    deData.push_back(999);
    //0 0
    //1 0 0 1
    //2 1 0 0 1 2
    pop_front_dequeue(deData);
    pop_back_dequeue(deData);
	return 0;
}