C++ 容器（一）：顺序容器简介

vector

list

deque

1.顺序容器的概念

vector

vector

list

deque

vector

list

deque

[code]#include <vector>  // vector
#include <list>    // list
#include <deque>   // deque

[code]vector<string> sVec; // empty vector that can hold strings
list<int> iList;     // empty list that can hold ints
deque<float> fDeque; // empty deque that can holds floats

C<T> c

c

C

vector

T

int

string

C c(c2)

c2

c

c2

c

C c(n)

n

c

C c(n, t)

n

t

c

t

C

C c(b, e)

c

b

e

[code]vector<int> iVec;
vector<int> iVec2(iVec);   // ok
vector<double> dVec(iVec); // error, iVec holds int not double
list<int> iList(iVec);     // error, iVec is not list<int>

[code]vector<string> sVec;
// initialize sList with copy of each element of sVec
list<string> sList(sVec.begin(), sVec.end());
// calculate the midpoint in the vector
vector<string>::iterator mid = sVec.begin() + sVec.size() / 2;
// initialize front with first half of sVec: the elements up to but not including *mid
vector<string> front(sVec.begin(), mid);

// also can initialize with a pointer
char* words[] = {"first", "second", "third", "forth"};
int sizeOfWords = sizeof(words) / (sizeof(char*));
vector<string> word2(words, words + sizeOfWords);

// cout
for ( int idx=0; idx<sizeOfWords; idx ++ )
    cout << word2[idx] << endl;

[code]const list<int>::size_type listSize = 64; // also can be: int listSize = 64
list<std::string> lstr(listSize, "str");  // 64 strings, each is str

vector<int> iVec(listSize); // 64 ints, each initialized to 0

[code]vector<vector<int> > myVec;  // the space required between close >

[code]vector<vector<int> > myVec; // ok
vector<vector<int>> myVec;  // ok

2.顺序容器的操作

size_type

iterator

const_iterator

reverse_iterator

const_reverse_iterator

difference_type

value_type

reference

value_type&

const_value_type

const value_type&

[code]// iter is the iterator type defined by vector<string>
vector<string>::iterator iter;

// cnt is the difference_type type defined by vector<int> 
vector<int>::difference_type cnt;

begin

end

c.begin()

c

c.end()

c

c.rbegin()

c

c.rend()

c

[code]// includes the first and each element up to but not including last
[first, lase)

end

vector

deque

[code]vector<int> v(42);
// cache begin and end iterator
vector<int>::iterator first = v.begin(), last = v.end();

while( first!= last ) // disaster: this loop is undefined
{
    // insert new value and reassign first, which otherwise would be invalid
    first = v.insert(++first, 2);
    ++ first; // advance first just past the element we added
}

c.push_back(t)

c

t

void

c.push_front(t)

c

t

void

list

deque

c.insert(p, t)

p

t

c.insert(p, n, t)

p

n

t

void

c.insert(p, b, e)

p

b

c

void

[code]// add elements at the end of vector
vector<int> iVec;
for ( int idx=0; idx<4; ++ idx )
{
    iVec.push_back( idx );
}

// insert an element
vector<string> sVec;
string str("Insert");
// warning: inserting anywhere but at the end of a vector is an expensive operation
sVec.insert(sVec.begin(), str);

// insert some elements
sVec.insert(sVec.begin(), 10, "Anna");
string array[4] =  {"first", "second", "third", "forth"};
sVec.insert(sVec.end(), array, array+4);

c.size()

c

c::size_type

c.max_size()

c

c::size_type

c.empty()

c.resize(n)

c

n

n<c.size()

c.resize(n, t)

c

n

t

[code]vector<int> iVec(10, 1); // 10 ints, each has value 1
iVec.resize(15);     // adds 5 elements of value 0 to back of iVec
iVec.resize(25, -1); // adds 10 elements of value -1 to back of iVec
iVec.resize(5);      // erases 20 elements from the back of iVec

resize

vector

deque

resize

resize

c.back()

c

c

c.front()

c

c

c

n

n<0

n>c.size()

vector

deque

c.at(n)

n

vector

deque

front

back

c.erase(p)

p

p

p

c.erase(b, e)

b

e

e

c.clear()

c

void

c.pop_back()

c

void

c

c.pop_font()

c

void

c

pop_front

front

[code]while ( !vec.empty() )
{
    // do something with the current top of vec    process(vec.front()); 
    // remove first element
    vec.pop_front();
}

erase

erase

find

#include <algorithm>

find

[code]string searchValue("find");
vector<std::string> vec(1, "find");
vector<string>::iterator iter = std::find(vec.begin(), vec.end(), searchValue);
if ( iter!= vec.end() )
    cout << *iter << endl;

clear

begin

end

erase

[code]vec.clear(); // delete all the elements within the container
vec.erase(vec.begin(), vec.end()); // equivalent

swap

[code]vec1 = vec2; // replace contents of vec1 with a copy of elements in vec2
// equivalent operation using erase and insert
vec1.erase(vec1.begin(), vec1.end()); // delete all elements in vec1
vec1.insert(vec2.begin(), vec2.end()); // insert vec2

c1=c2

c1

c2

c1

c1

c2

c1.swap(c2)

c1

c2

c2

c1

c1

c2

c2

c1

c.assign(b, e)

c

b

c

c

b

e

c

c.assign(n, t)

c

n

t

swap

vector

size

capacity

size

capacity

capacity >= size

clear

c1 = c2

assign

capacity

swap

size

capacity

[code]vector<int> vec(100); // size: 100, capacity: 100;
vec.clear();          // size: 0, capacity: 100

vector<int> vec2(50);
vec = vec2;           // size: 50, capacity: 100

vector<int> vec3(30);
vec.assign(vec3.begin(), vec.end()); // size: 30, capacity: 100

vec.swap(vec3); // error!

vector<int> v1(30), v2(50);
v1.swap(v2); // v1: size 50, capacity 50; v2: size 30, capacity 30

clear

swap

[code]vector<int> vec(100);      // size 100, capacity 100
vector<int>().swap( vec ); // size 0, capacity 0

vector

reserve

[code]vector<int> vec(24);  // size 24, capacity 24
vec.reserve(50);      // size 24, capacity 50
cout<< "size" << vec.size() << endl << 
    "capacity" << vec.capacity() << endl;

3.结束语

vector

vector

vector

vector

n

vector

list

vector

vector

vector

list

deque