当前位置：网站首页>Chapter VIII vector of STL

Chapter VIII vector of STL

2022-07-19 09:32:00 【qq_ forty-three million two hundred and five thousand two hundr】

1 vector Basic concepts

function ：

vector Data structure and Arrays are very similar , Also known as Single ended array

vector Different from ordinary array ：

The difference is that arrays are static spaces , and vector Sure Dynamic expansion

Dynamic expansion ：

It's not a new space after the original space , It's about finding more memory , Then copy the original data to a new space , Release the original space

vector Container iterators are iterators that support random access

2 vector Constructors

Function description ：

establish vector Containers

The function prototype ：

1. vector<T> v; // No arguments structure

2. vector v(v.begin(), v.end()); // Interval construction

3. vector(n, elem); // The constructor will n individual elem Copy to yourself .

4. vector(const vector &vec); // copy constructor .

Example ：

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

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

void test01() 
{ 
	//1. No arguments structure 
	vector<int> v1;
	for (int i = 0; i < 10; i++)
	{
		v1.push_back(i); 
	}
	printVector(v1); 
	
	//2. Interval construction 
	vector<int> v2(v1.begin(), v1.end()); 
	printVector(v2); 
	
	//3. Structure has 10 individual 100 Array of 
	vector<int> v3(10, 100); 
	printVector(v3); 
	
	//4. Copy structure 
	vector<int> v4(v3); 
	printVector(v4); 
}

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

summary ：vector There is no comparability between the various construction methods of , It can be used flexibly .

3 vector Assignment operation

Function description ：

to vector Container to assign values

The function prototype ：

vector& operator=(const vector &vec); // Overload the equal sign operator

assign(beg, end); // take [beg, end) The copy of the data in the interval is assigned to itself

assign(n, elem); // take n individual elem Copy assignment to itself

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

// Assignment operation  
void test01() 
{ 
	//1. Loop assignment  
	vector<int> v1; 
	for (int i = 0; i < 10; i++)
	{ 
		v1.push_back(i); 
	}
	printVector(v1);
	
	//2. Equal sign assignment 
	vector<int>v2; 
	v2 = v1; 
	printVector(v2); 
	
	//3. Interval assignment 
	vector<int>v3; 
	v3.assign(v1.begin(), v1.end()); 
	printVector(v3); 
	
	//4. take 10 individual 100 copy assignment 
	vector<int>v4; 
	v4.assign(10, 100); 
	printVector(v4); 
}

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

summary ： vector The assignment method is relatively simple , Use operator=, perhaps assign Fine .

4 vector Capacity and size

Function description ：

Yes vector The capacity and size of the container

The function prototype

empty(); // Judge whether the container is empty

capacity(); // Capacity of container

size(); // Returns the number of elements in the container

resize(int num); // Reassign the length of the container to num, If the container becomes longer , Then fill in the new location with the default value .

// If the container gets shorter , Then the element beyond the length of the container at the end is deleted .

resize(int num, elem); // Reassign the length of the container to num, If the container becomes longer , with elem Fill new bits with values // Set up . If the container gets shorter , Then the element beyond the length of the container at the end is deleted

Example ：

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

void test01() 
{
	vector<int> v1;
	for (int i = 0; i < 10; i++) 
	{ 
		v1.push_back(i); 
	}
	printVector(v1); 
	
	if (v1.empty()) 
	{ 
		cout << "v1 It's empty " << endl; 
	}
	else 
	{
		cout << "v1 Not empty " << endl; 
		cout << "v1 The capacity of  = " << v1.capacity() << endl;
		cout << "v1 Size  = " << v1.size() << endl; 
	}

	//resize  Re size  , If specified larger , The default with 0 Fill in new location , You can replace the default padding with an overloaded version  
	v1.resize(15,10); 
	printVector(v1); 
	
	//resize  Re size  , If specified smaller , Excess elements are deleted  
	v1.resize(5); 
	printVector(v1); 
}

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

summary ：

Determine whether it is null --- empty

Number of return elements --- size

Return container capacity --- capacity

Re size --- resize

5 vector Insert and delete

Function description ：

Yes vector The container is inserted 、 Delete operation

The function prototype ：

push_back(ele); // Tail-insert element ele

pop_back(); // Delete the last element

insert(const_iterator pos, ele); // The iterator points to position pos Insert elements ele

insert(const_iterator pos, int count,ele); // The iterator points to position pos Insert count Elements ele

erase(const_iterator pos); // Delete the element that the iterator points to

erase(const_iterator start, const_iterator end); // Delete iterators from start To end Between the elements

clear(); // Delete all elements in the container

Example ：

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

// Insert and delete  
void test01() 
{ 
	vector<int> v1;
	
	// Tail insertion  
	v1.push_back(10);
	v1.push_back(20); 
	v1.push_back(30); 
	v1.push_back(40); 
	v1.push_back(50); 
	printVector(v1); 
	
	// Deletion at the end  
	v1.pop_back();
	printVector(v1); 
	
	// Insert  
	v1.insert(v1.begin(), 100); 
	printVector(v1);
	v1.insert(v1.begin(), 2, 1000); 
	printVector(v1); 
	
	// Delete 
	v1.erase(v1.begin()); 
	printVector(v1);
	
	// Empty 
	v1.erase(v1.begin(), v1.end());     // Method 1 
	v1.clear();                         // Method 2 
	printVector(v1); 
}

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

summary ：

Tail insertion --- push_back

Deletion at the end --- pop_back

Insert --- insert ( Position iterator )

Delete --- erase （ Position iterator ）

Empty --- clear

6 vector Data access

Function description ：

Yes vector Access operation of data in

The function prototype ：

at(int idx); // Returns the index idx The data

operator[]; // Returns the index idx The data

front(); // Returns the first data element in the container

back(); // Returns the last data element in the container

Example

void test01() 
{
	vector<int>v1; 
	for (int i = 0; i < 10; i++) 
	{ 
		v1.push_back(i); 
	}
	
	//1. Use [] visit 
	for (int i = 0; i < v1.size(); i++) 
	{ 
		cout << v1[i] << " "; 
	}
	cout << endl; 
	
	//2. Use at visit 
	for (int i = 0; i < v1.size(); i++)
	{
		cout << v1.at(i) << " "; 
	}
	cout << endl;


	cout << "v1 The first element of is ： " << v1.front() << endl; 
	cout << "v1 The last element of is ： " << v1.back() << endl;
}

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

summary ：

Except for iterators vector Elements in the container ,[ ] and at It's fine too

front Returns the first element of the container

back Returns the last element of the container

7 vector Exchange containers

Function description ：

Realize the exchange of elements in two containers

The function prototype ：

swap(vec); // take vec Swapping with its own elements

Example ：

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

void test01() 
{
	vector<int>v1;
	for (int i = 0; i < 10; i++) 
	{
		v1.push_back(i); 
	}
	printVector(v1);
	
	vector<int>v2; 
	for (int i = 10; i > 0; i--) 
	{ 
		v2.push_back(i); 
	}
	printVector(v2);
	
	// Exchange containers  
	cout << " After exchange " << endl; 
	v1.swap(v2); 
	printVector(v1);
	printVector(v2); 
}


void test02() 
{ 
	vector<int> v; 
	for (int i = 0; i < 100000; i++) 
	{ 
		v.push_back(i); 
	}
	cout << "v The capacity of is ：" << v.capacity() << endl; 
	cout << "v The size is ：" << v.size() << endl; 
	v.resize(3);
	cout << "v The capacity of is ：" << v.capacity() << endl;
	cout << "v The size is ：" << v.size() << endl; 
	


	// Shrink memory 
	vector<int>(v).swap(v); 
	// Anonymous object 
	cout << "v The capacity of is ：" << v.capacity() << endl;
	cout << "v The size is ：" << v.size() << endl;
}

int main() 
{
	test01(); 
	test02(); 
	return 0;
}

summary ：swap Two containers can be interchanged , It can achieve the practical effect of shrinking memory

8 vector Reserve space

Function description ：

Reduce vector The number of expansions when dynamically expanding capacity

The function prototype ：

reserve(int len); // Container reservation len Element length , Reserved position is not initialized , The element is not accessible .

Example ：

void test01() 
{
	vector<int> v; 
	
	// Reserve space  
	v.reserve(100000); 
	
	int num = 0;
	int* p = NULL; 
	for (int i = 0; i < 100000; i++) 
	{
		v.push_back(i); 
		if (p != &v[0]) 
		{ 
			p = &v[0]; num++; 
		} 
	}
	cout << "num:" << num << endl;
}

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

summary ： If the amount of data is large , You can start with reserve Reserve space

原网站

版权声明
本文为[qq_ forty-three million two hundred and five thousand two hundr]所创，转载请带上原文链接，感谢
https://yzsam.com/2022/200/202207171023057086.html