C++ vector类

最新推荐文章于 2025-10-15 00:05:13 发布

原创最新推荐文章于 2025-10-15 00:05:13 发布 · 1.1k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言 #vector #OJ

1. 会引起其底层空间改变的操作，使迭代器失效

2. 指定位置元素的删除操作 —— erase

一.vector的介绍及使用

同样我们可以借助文档学习和vector有关的知识：vector介绍。

vector - C++ Reference。

1.1vector的构造函数

常见构造：

vector::vector - C++ Reference

vector()（重点）：无参构造。

vector（size_type n, const value_type& val = value_type()）：构造并初始化n个value。

vector (const vector& x); （重点）：拷贝构造。

vector (InputIterator first, InputIterator last); : 使用迭代器进行初始化构造。

1.2 vector迭代器

1.3 vector 空间增长问题

1.capacity的代码在vs和g++下分别运行会发现，vs下capacity是按1.5倍增长的，g++是按2

倍增长的。这个问题经常会考察，不要固化的认为，vector增容都是2倍，具体增长多少是

根据具体的需求定义的。vs是PJ版本STL，g++是SGI版本STL。

2.reserve只负责开辟空间，如果确定知道需要用多少空间，reserve可以缓解vector增容的代

价缺陷问题。

3.resize在开空间的同时还会进行初始化，影响size。

1.4vector 增删查改

test.cpp

#include<iostream>
#include<vector>
using namespace std;

void test_vector1()
{
	vector<int> v1;
	vector<int> v2(10, 1);

	vector<int> v3(++v2.begin(), --v2.end());

	for (size_t i = 0; i < v3.size(); i++)
	{
		cout << v3[i] << " ";
	}
	cout << endl;

	vector<int>::iterator it = v3.begin();
	while (it != v3.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;

	for (auto e : v3)
	{
		cout << e << " ";
	}
	cout << endl;
}


void TestVectorExpand()
{
	size_t sz;
	vector<int> v;
	v.reserve(100);

	sz = v.capacity();
	cout << "capacity changed: " << sz << '\n';

	cout << "making v grow:\n";
	for (int i = 0; i < 100; ++i)
	{
		v.push_back(i);
		if (sz != v.capacity())
		{
			sz = v.capacity();
			cout << "capacity changed: " << sz << '\n';
		}
	}
}

void test_vector2()
{
	//TestVectorExpand();

	vector<int> v(10, 1);
	v.reserve(20);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.reserve(15);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.reserve(5);
	cout << v.size() << endl;
	cout << v.capacity() << endl;
}

void test_vector3()
{
	//TestVectorExpand();

	vector<int> v(10, 1);
	v.reserve(20);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.resize(15, 2);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.resize(25, 3);
	cout << v.size() << endl;
	cout << v.capacity() << endl;

	v.resize(5);
	cout << v.size() << endl;
	cout << v.capacity() << endl;
}

void test_vector4()
{
	vector<int> v(10, 1);
	v.push_back(2);
	v.insert(v.begin(), 0);

	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	v.insert(v.begin() + 3, 10);

	for (auto e : v)
	{
		cout << e << " ";
	}
	cout << endl;

	vector<int> v1(5, 0);
	for (size_t i = 0; i < 5; i++)
	{
		cin >> v1[i];
	}

	for (auto e : v1)
	{
		cout << e << ",";
	}
	cout << endl;

	vector<char> v2;
	string s2;

}

void test_vector5()
{
	vector<string> v1;
	string s1("xxxx");
	v1.push_back(s1);

	v1.push_back("yyyyy");
	for (const auto& e : v1)
	{
		cout << e << " ";
	}
	cout << endl;

	// 10*5
	vector<int> v(5, 1);
    //二维数组
	vector<vector<int>> vv(10, v);
	vv[2][1] = 2;
    for (size_t i = 0; i < vv.size(); i++)
	{
		for (size_t j = 0; j < vv[i].size(); ++j)
		{
			cout << vv[i][j] << " ";
		}
		cout << endl;
	}
	cout << endl;
}

int main()
{
	test_vector5();
	return 0;
}

二维数组存储结构

二.迭代器失效问题

迭代器的主要作用就是让算法能够不用关心底层数据结构，其底层实际就是一个指针，或者是对

指针进行了封装，比如：vector的迭代器就是原生态指针T* 。因此迭代器失效，实际就是迭代器

底层对应指针所指向的空间被销毁了，而 使用一块已经被释放的空间，造成的后果是程序崩溃(即

如果继续使用已经失效的迭代器，程序可能会崩溃) 。

对于vector可能会导致其迭代器失效的操作有：

1. 会引起其底层空间改变的操作，使迭代器失效

比如：resize、reserve、insert、 assign、push_back等。

我们看下面这一段代码：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
	vector<int> v{ 1,2,3,4,5,6 };
	auto it = v.begin();
	// 将有效元素个数增加到100个，多出的位置使用8填充，操作期间底层会扩容
	v.resize(100, 8);
	// reserve的作用就是改变扩容大小但不改变有效元素个数，操作期间可能会引起底层容量改变
    v.reserve(100);
	// 插入元素期间，可能会引起扩容，而导致原空间被释放
	v.insert(v.begin(), 0);
	v.push_back(8);
	// 给vector重新赋值，可能会引起底层容量改变
	v.assign(100, 8);
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

调试结果：

运行结果：

出错原因：以上操作，都有可能会导致vector扩容，也就是说vector底层原理旧空间被释
放掉，而在打印时，it还使用的是释放之间的旧空间，在对it迭代器操作时，实际操作的是一块
已经被释放的空间，而引起代码运行时崩溃。
解决方式：在以上操作完成之后，如果想要继续通过迭代器操作vector中的元素，只需给
it重新赋值即可。

2. 指定位置元素的删除操作 —— erase

我们看下面一段代码：

#include <iostream>
using namespace std;
#include <vector>
int main()
{
	int a[] = { 1, 2, 3, 4 };
	vector<int> v(a, a + sizeof(a) / sizeof(int));
	// 使用find查找3所在位置的iterator
	vector<int>::iterator pos = find(v.begin(), v.end(), 3);
	// 删除pos位置的数据，导致pos迭代器失效。
	v.erase(pos);
	cout << *pos << endl; // 此处会导致非法访问
	return 0;
}

运行结果：

错误原因：erase删除pos位置元素后，pos位置之后的元素会往前搬移，没有导致底层空间的改变，理论上讲迭代器不应该会失效，但是：如果pos刚好是最后一个元素，删完之后pos刚好是end 的位置，而end位置是没有元素的，那么pos就失效了。因此删除vector中任意位置上元素时，vs就认为该位置迭代器失效了。

所以当我们要是删除vector中所有的偶数时候，代码应该这样写：

//正确
int main()
{
	vector<int> v{ 1, 2, 3, 4 };
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			it = v.erase(it);
		else
			++it;
	}
	return 0;
}

3. 注意

Linux下，g++编译器对迭代器失效的检测并不是非常严格，处理也没有vs下极端。

例1:

int main()
{
	vector<int> v{ 1,2,3,4,5 };
	for (size_t i = 0; i < v.size(); ++i)
		cout << v[i] << " ";
	cout << endl;
	auto it = v.begin();
	cout << "扩容之前，vector的容量为: " << v.capacity() << endl;
	// 通过reserve将底层空间设置为100，目的是为了让vector的迭代器失效
	v.reserve(100);
	cout << "扩容之后，vector的容量为: " << v.capacity() << endl;
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

vs：

linux：

经过上述reserve之后，it迭代器肯定会失效，在vs下程序就直接崩溃了，但是linux下不会，虽然可能可以运行，但是输出的结果是不对的。

例2：

#include <vector>
#include <algorithm>
int main()
{
	vector<int> v{ 1,2,3,4,5 };
	vector<int>::iterator it = find(v.begin(), v.end(), 3);
	v.erase(it);
	cout << *it << endl;
	while (it != v.end())
	{
		cout << *it << " ";
		++it;
	}
	cout << endl;
	return 0;
}

vs：

linux：程序可以正常运行

例3：

可以调试查看it的变化。

int main()
{
	vector<int> v{ 1,2,3,4,5 };
	// vector<int> v{1,2,3,4,5,6};
	auto it = v.begin();
	while (it != v.end())
	{
		if (*it % 2 == 0)
			v.erase(it);
		++it;
	}
	for (auto e : v)
		cout << e << " ";
	cout << endl;
	return 0;
}

vs:两组数据都会报错。

linux：第一组数据下不会报错。

但是换第二组数据，linux下会发生段错误。

从上述三个例子中可以看到：SGI STL中，迭代器失效后，代码并不一定会崩溃，但是运行

结果肯定不对，如果it不在begin和end范围内，肯定会崩溃的。

4. 与vector类似，string在插入+扩容操作+erase之后，迭代器也会失效。

#include <string>
void TestString()
{
	string s("hello");
	auto it = s.begin();
	// 放开之后代码会崩溃，因为resize到20会string会进行扩容
	// 扩容之后，it指向之前旧空间已经被释放了，该迭代器就失效了
	// 后序打印时，再访问it指向的空间程序就会崩溃
	//s.resize(20, '!');
	while (it != s.end())
	{
		cout << *it;
		++it;
	}
	cout << endl;
	it = s.begin();
	while (it != s.end())
	{
		it = s.erase(it);
		// 按照下面方式写，运行时程序会崩溃，因为erase(it)之后
		// it位置的迭代器就失效了
		// s.erase(it);
		++it;
	}
}

总之，为了解决一系列迭代器失效的问题，迭代器失效解决办法：在使用前，对迭代器重新赋值即可。

三.vector类的实现

1.vector.h

#pragma once
#include<assert.h>
#include<list>
#include<string>

namespace sy
{
	template<class T>
	class vector
	{
	public:
		typedef T* iterator;
		typedef const T* const_iterator;

		/*vector()
		{}*/

		// C++11 前置生成默认构造
		vector() = default;

		//拷贝构造
		vector(const vector<T>& v)
		{
			reserve(v.size());
			for (auto& e : v)
			{
				push_back(e);
			}
		}

		//类模板的成员函数，还可以继续是函数模版
		//迭代器构造
		template <class InputIterator>
		vector(InputIterator first, InputIterator last)
		{
			while (first != last)
			{
				push_back(*first);
				++first;
			}
		}

		//用n个value构造
		vector(size_t n, const T& val = T())
		{
			reserve(n);
			for (size_t i = 0; i < n; i++)
			{
				push_back(val);
			}
		}
		//用n个value构造
		vector(int n, const T& val = T())
		{
			reserve(n);
			for (int i = 0; i < n; i++)
			{
				push_back(val);
			}
		}

		void clear()
		{
			_finish = _start;
		}

		// v1 = v3
		/*vector<T>& operator=(const vector<T>& v)
		{
			if (this != &v)
			{
				clear();

				reserve(v.size());
				for (auto& e : v)
				{
					push_back(e);
				}
			}

			return *this;
		}*/

		void swap(vector<T>& v)
		{
			std::swap(_start, v._start);
			std::swap(_finish, v._finish);
			std::swap(_end_of_storage, v._end_of_storage);
		}

		// v1 = v3
		//vector& operator=(vector v)
		vector<T>& operator=(vector<T> v)
		{
			swap(v);
			return *this;
		}

		~vector()
		{
			if (_start)
			{
				delete[] _start;
				_start = _finish = _end_of_storage = nullptr;
			}
		}

		iterator begin()
		{
			return _start;
		}

		iterator end()
		{
			return _finish;
		}

		const_iterator begin() const
		{
			return _start;
		}

		const_iterator end() const
		{
			return _finish;
		}

		void reserve(size_t n)
		{
			if (n > capacity())
			{
				size_t old_size = size();
				T* tmp = new T[n];
				//memcpy(tmp, _start, old_size * sizeof(T));
				for (size_t i = 0; i < old_size; i++)
				{
					tmp[i] = _start[i];
				}
				delete[] _start;

				_start = tmp;
				_finish = tmp + old_size;
				_end_of_storage = tmp + n;
			}
		}

		void resize(size_t n, T val = T())
		{
			if (n < size())
			{
				_finish = _start + n;
			}
			else
			{
				reserve(n);
				while (_finish < _start + n)
				{
					*_finish = val;
					++_finish;
				}
			}
		}

		size_t size() const
		{
			return _finish - _start;
		}

		size_t capacity() const
		{
			return _end_of_storage - _start;
		}

		bool empty() const
		{
			return _start == _finish;
		}

		void push_back(const T& x)
		{
			// 扩容
			if (_finish == _end_of_storage)
			{
				reserve(capacity() == 0 ? 4 : capacity() * 2);
			}
			*_finish = x;
			++_finish;
		}

		void pop_back()
		{
			assert(!empty());
			--_finish;
		}

		iterator insert(iterator pos, const T& x)
		{
			assert(pos >= _start);
			assert(pos <= _finish);

			// 扩容
			if (_finish == _end_of_storage)
			{
				size_t len = pos - _start;
				reserve(capacity() == 0 ? 4 : capacity() * 2);
				//重新更新pos位置的值防止迭代器失效
				pos = _start + len;
			}

			iterator end = _finish - 1;
			while (end >= pos)
			{
				*(end + 1) = *end;
				--end;
			}
			*pos = x;

			++_finish;

			return pos;
		}

		void erase(iterator pos)
		{
			assert(pos >= _start);
			assert(pos < _finish);

			iterator it = pos + 1;
			while (it != end())
			{
				*(it - 1) = *it;
				++it;
			}

			--_finish;
		}

		T& operator[](size_t i)
		{
			assert(i < size());

			return _start[i];
		}

		const T& operator[](size_t i) const
		{
			assert(i < size());

			return _start[i];
		}

	private:
		iterator _start = nullptr;
		iterator _finish = nullptr;
		iterator _end_of_storage = nullptr;
	};

	/*void print_vector(const vector<int>& v)
	{
		vector<int>::const_iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}*/

	template<class T>
	void print_vector(const vector<T>& v)
	{
		// 规定，没有实例化的类模板里面取东西，编译器不能区分这里const_iterator
		// 是类型还是静态成员变量
		//typename vector<T>::const_iterator it = v.begin();
		auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	template<class Container>
	void print_container(const Container& v)
	{
		/*auto it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;*/

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;
	}

	void test_vector1()
	{
		vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);

		for (size_t i = 0; i < v.size(); i++)
		{
			cout << v[i] << " ";
		}
		cout << endl;

		vector<int>::iterator it = v.begin();
		while (it != v.end())
		{
			cout << *it << " ";
			++it;
		}
		cout << endl;

		for (auto e : v)
		{
			cout << e << " ";
		}
		cout << endl;

		print_vector(v);

		vector<double> vd;
		vd.push_back(1.1);
		vd.push_back(2.1);
		vd.push_back(3.1);
		vd.push_back(4.1);
		vd.push_back(5.1);

		print_vector(vd);
	}

	void test_vector2()
	{
		std::vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);
		v.push_back(5);
		print_container(v);
		int x;
		cin >> x;
		auto p = find(v.begin(), v.end(), x);
		if (p != v.end())
		{
			// insert以后p就是失效，不要直接访问，要访问就要更新这个失效的迭代器的值
			/*v.insert(p, 20);
			(*p) *= 10;*/

			p = v.insert(p, 40);
			(*(p + 1)) *= 10;
		}
		print_container(v);
	}

	void test_vector3()
	{
		std::vector<int> v;
		v.push_back(1);
		v.push_back(2);
		v.push_back(3);
		v.push_back(4);

		print_container(v);

		// 删除所有的偶数
		auto it = v.begin();
		while (it != v.end())
		{
			if (*it % 2 == 0)
			{
				it = v.erase(it);
			}
			else
			{
				++it;
			}
		}

		print_container(v);
	}

	void test_vector4()
	{
		int i = int();
		int j = int(1);
		int k(2);

		vector<int> v;
		v.resize(10, 1);
		v.reserve(20);

		print_container(v);
		cout << v.size() << endl;
		cout << v.capacity() << endl;

		v.resize(15, 2);
		print_container(v);

		v.resize(25, 3);
		print_container(v);

		v.resize(5);
		print_container(v);
	}

	void test_vector5()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		print_container(v1);

		vector<int> v2 = v1;
		print_container(v2);

		vector<int> v3;
		v3.push_back(10);
		v3.push_back(20);
		v3.push_back(30);

		v1 = v3;
		print_container(v1);
		print_container(v3);
	}

	void test_vector6()
	{
		vector<int> v1;
		v1.push_back(1);
		v1.push_back(2);
		v1.push_back(3);
		v1.push_back(4);
		v1.push_back(4);
		v1.push_back(4);

		vector<int> v2(v1.begin(), v1.begin() + 3);
		print_container(v1);
		print_container(v2);

		list<int> lt;
		lt.push_back(10);
		lt.push_back(10);
		lt.push_back(10);
		lt.push_back(10);
		vector<int> v3(lt.begin(), lt.end());
		print_container(lt);
		print_container(v2);

		vector<string> v4(10, "1111111");
		print_container(v4);

		vector<int> v5(10);
		print_container(v5);

		vector<int> v6(10, 1);
		print_container(v6);

		vector<int> v7(10, 1);
		print_container(v7);
	}

	void test_vector7()
	{
		vector<string> v;
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		v.push_back("11111111111111111111");
		print_container(v);

		v.push_back("11111111111111111111");
		print_container(v);
	}
}

2.test.cpp

#include<iostream>
#include<vector>
using namespace std;

#include"vector.h"

int main()
{
	sy::test_vector7();

	return 0;
}

3.memcpy浅拷贝问题

当我们使用memcpy时候，运行test_vector7() ，运行结果出现了奇怪的打印结果，程序也出现了崩溃，这是什么情况呢？

memcpy是内存的二进制格式拷贝，将一段内存空间中内容原封不动的拷贝到另外一段内存空间中，如果拷贝的是自定义类型的元素，memcpy既高效又不会出错，但如果拷贝的是自定义类型元素，并且 自定义类型元素中涉及到资源管理 时，就会出错，因为 memcpy的拷贝实际是浅拷贝 。

这点我们可以通过调试体现，执行memcpy之后tmp和_start指向同一块空间，执行下一条delete[] _start;之后,这段空间被释放，当tmp继续被使用就会发生错误。

如下图，出现了莫名其妙的字符：

结论：如果对象中涉及到资源管理时，千万不能使用memcpy进行对象之间的拷贝，因为

memcpy是浅拷贝，否则可能会引起内存泄漏甚至程序崩溃。

四.vector 在线OJ题目

136. 只出现一次的数字 - 力扣（LeetCode）

class Solution {
public:
    int singleNumber(vector<int>& nums) 
    {
        int value = 0;
        for(auto e : nums)
        {
            value ^= e;
        }
        return value;   
    }
};

118. 杨辉三角 - 力扣（LeetCode）

class Solution {
public:
    vector<vector<int>> generate(int numRows) 
    {
        vector<vector<int>> vv(numRows);
        for(size_t i=0;i<numRows;i++ )
        {
            vv[i].resize(i+1,1);
        }
        for(int i=2;i<vv.size();i++)
        {
            for(int j =1; j< vv[i].size()-1;++j)
            {
                vv[i][j]=vv[i-1][j]+vv[i-1][j-1];
            }
        }
        return vv;
    }

};

26. 删除有序数组中的重复项 - 力扣（LeetCode）

class Solution {
public:
    int removeDuplicates(vector<int>& nums) 
    {
        int count = 0;
        int single = 0;
        vector<int>::iterator it = nums.begin();
        while (it != nums.end() && count < nums.size()-1)
        {
            if (*it != *(it + 1))
            {
                it++;
                count++;
            }
            else
            {
                nums.erase(it + 1);
            }
        }
        single = nums.size() - count;
        if (count !=nums.size())
        {
            count += single;
        }
        return count;
    }
};

137. 只出现一次的数字 II - 力扣（LeetCode）

class Solution {
public:
    int singleNumber(vector<int>& nums) 
    {
        std::sort(nums.begin(), nums.end());
        size_t i = 0;
        vector<int> v;
        while (i < nums.size()) 
        {

            size_t j = i + 1;
            // 检查是否越界
            if (j >= nums.size() || nums[i] != nums[j]) 
            {
                v.push_back(nums[i]);
                i++;
            } 
            else 
            {
                i += 3; 
            }
        }
        return v[0];
    }
};

260. 只出现一次的数字 III - 力扣（LeetCode）

class Solution {
public:
    vector<int> singleNumber(vector<int>& nums) {
        std::sort(nums.begin(), nums.end());
        size_t i = 0;
        vector<int> v;

        while (i < nums.size()) {
            size_t j = i + 1;

            // 检查是否越界
            if (j >= nums.size() || nums[i] != nums[j]) {
                v.push_back(nums[i]);
                i++;  // 只移动一位
            } else {
                i += 2;  // 跳过匹配的成对数字
            }

            // 找到两个单独出现的数字后，停止循环
            if (v.size() == 2) {
                break;
            }
        }

        return v;
    }
};

数组中出现次数超过一半的数字_牛客题霸_牛客网

class Solution {
public:
    /**
     * 代码中的类名、方法名、参数名已经指定，请勿修改，直接返回方法规定的值即可
     *
     * 
     * @param numbers int整型vector 
     * @return int整型
     */
    int MoreThanHalfNum_Solution(vector<int>& numbers)
    {
        if (numbers.size() == 1)
        {
            return numbers[0];
        }

        int leftsize = numbers.size() / 2;
        vector<int> tmp(50001, 0);

        for(size_t i = 0; i < numbers.size(); i++)
        {
            tmp[numbers[i]] += 1;
        }

        int j = 0;
        while (j < tmp.size())
        {
            j++;
            if (tmp[j] > leftsize)
            {
                break;
            }
        }

        return j;
    }
};

17. 电话号码的字母组合 - 力扣（LeetCode）

class Solution {
public:
string fun(char number)
{
    if (number == '2')
    {
        return "abc";
    }
    else if (number == '3')
    {
        return "def";
    }
    else if (number == '4')
    {
        return "ghi";
    }
    else if (number == '5')
    {
        return "jkl";
    }
    else if (number == '6')
    {
        return "mno";
    }
    else if (number == '7')
    {
        return "pqrs";
    }
    else if (number == '8')
    {
        return "tuv";
    }
    else
    {
        return "wxyz";
    }
}

string charadd(char s1, char s2)
{
    string tmp;
    tmp.push_back(s1);
    tmp.push_back(s2);
    return tmp;
}
string charadd(char s1, char s2, char s3)
{
    string tmp;
    tmp.push_back(s1);
    tmp.push_back(s2);
    tmp.push_back(s3);

    return tmp;
}
string charadd(char s1, char s2, char s3, char s4)
{
    string tmp;
    tmp.push_back(s1);
    tmp.push_back(s2);
    tmp.push_back(s3);
    tmp.push_back(s4);


    return tmp;
}
string char_turn_to_stirng(char s)
{
    string tmp;
    tmp.push_back(s);
    return tmp;
}
vector<string> letterCombinations(string digits)
{
    vector<string> vs;

    if (digits.size() == 0)
        return vs;
    if (digits.size() == 1)
    {
        string tmp = fun(digits[0]);
        for (size_t i = 0; i < tmp.size(); i++)
        {
            string s = char_turn_to_stirng(tmp[i]);
            vs.push_back(s);
        }
        return vs;
    }
    if (digits.size() == 2)
    {
        string::iterator it = digits.begin();
        string s1 = fun(*it);
        string s2 = fun(*(it + 1));
        for (size_t i = 0; i < s1.size(); i++)
        {
            for (size_t j = 0; j < s2.size(); j++)
            {
                string tmp = charadd(s1[i], s2[j]);
                vs.push_back(tmp);
            }
        }
        return vs;
    }
    if (digits.size() == 3)
    {
        string::iterator it = digits.begin();
        string s1 = fun(*it);
        string s2 = fun(*(it + 1));
        string s3 = fun(*(it + 2));
        for (size_t i = 0; i < s1.size(); i++)
        {
            for (size_t j = 0; j < s2.size(); j++)
            {
                for (size_t k = 0; k < s3.size(); k++)
                {
                    string tmp = charadd(s1[i], s2[j],s3[k]);
                    vs.push_back(tmp);
                }
            }
        }
        return vs;
    }
    if (digits.size() == 4)
    {
        string::iterator it = digits.begin();
        string s1 = fun(*it);
        string s2 = fun(*(it + 1));
        string s3 = fun(*(it + 2));
        string s4 = fun(*(it + 3));

        for (size_t i = 0; i < s1.size(); i++)
        {
            for (size_t j = 0; j < s2.size(); j++)
            {
                for (size_t k = 0; k < s3.size(); k++)
                {
                    for (size_t m = 0; m < s4.size(); m++)
                    {
                        string tmp = charadd(s1[i], s2[j], s3[k],s4[m]);
                        vs.push_back(tmp);
                    }
                }
            }
        }
    }
    return vs;
}
};