c++编程之标准库和STL

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>

using namespace std;


void print(const vector<int> &v) {
	for (int i = 0; i < v.size(); ++i) {
		cout << v[i] << " ";
	}
	cout << endl;
}

int main(int argc, char *argv[]) {
	const int SIZE = 10;
	vector<int> numbers(SIZE);

	cout << "size = " << numbers.size() << endl;
	cout << "capacity = " << numbers.capacity() << endl;
	print(numbers);

	srand(time(0));

	for (size_t i = 0; i < numbers.size(); ++i) {
		numbers.at(i) = rand() % 100;
	}

	print(numbers);

	// no error compile and run
	cout << "First element is " << numbers.front() << endl;
	// runtime out_of_range exception
	cout << "Last element is " << numbers.back() << endl;

	cout << numbers[55] << endl;
	// cout << numbers.at(55) << endl;

	return 0;
}

#include <iostream>
#include <cstdlib>
#include <ctime>
#include <vector>

using namespace std;

void print(const vector<int> &v) {
	for (int i = 0; i < v.size(); ++i) {
		cout << v[i] << " ";
	}
	cout << endl;
}

int main(int argc, char *argv[]) {
	vector<int> numbers;
	cout << "size = " << numbers.size() << endl;
	cout << "capacity = " << numbers.capacity() << endl;

	srand(time(0));
	for (int i = 0; i < 5; ++i) {
		numbers.push_back(rand() % 100);
	}
	print(numbers);
	cout << "size = " << numbers.size() << endl;
	cout << "capacity = " << numbers.capacity() << endl;

	numbers.pop_back();
	numbers.pop_back();
	print(numbers);
	cout << "size = " << numbers.size() << endl;
	cout << "capacity = " << numbers.capacity() << endl;
	numbers.clear();
	cout << "size = " << numbers.size() << endl;
	cout << "capacity = " << numbers.capacity() << endl;
	return 0;
}

#include <iostream>
#include <string>
#include <cstdlib>
#include <vector>

using namespace std;

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

int main(int argc, char *argv[]) {
	vector<string> strs;
	strs.push_back("apple");
	strs.push_back("orange");
	strs.push_back("banana");
	print(strs);
	cout << "size = " << strs.size() << endl;

	// Test insert()
	strs.insert(strs.begin() + 2, "b4-banana");
	strs.insert(strs.begin() + 1, 2, "b4-orange");
	print(strs);

	// Test arase()
	strs.erase(strs.begin() + 1, strs.begin() + 4);
	print(strs);
	cout << "size + " << strs.size() << endl;

	// insert() from another vector
	vector<string> newStrs;
	newStrs.push_back("1");
	newStrs.push_back("2");
	newStrs.push_back("3");
	strs.insert(strs.begin() + 1, newStrs.begin(), newStrs.end());
	print(strs);
	cout << "size = " << strs.size() << endl;
	return 0;
}

for (auto iter = strs.begin(); iter != strs.end(); ++iter) {
	cout << *iter << " ";
}

for (auto item:strs) {
	cout << item << " ";
}

vector (const allocator_type & alloc = allocator_type());
   // Default Constructor: construct a vector object
vector (size_type n, const value_type & val = value_type(),
        const allocator_type & alloc = allocator_type());
   // Fill Constructor: construct a vector object with n-element filled with val
vector (const vector & v);
   // Copy Constructor
template <class InputIterator>
vector (InputIterator first, InputIterator last,
        const allocator_type & alloc = allocator_type());
   // Range Copy Constructor

size_type size () const;      // Return the size (number of elements)
size_type capacity () const;  // Return the storage allocated (in term of element)
bool empty () const;          // Return true if size is 0
void reserve (size_type n);   // Request for storage to hold n elements
void resize (size_type n, value_type val = value_type());
      // resize to n, remove extra element or fill with val
size_type max_size () const;  // Return the maximum number of element
void shrink_to_fit ();        // (C++11) Request to shrink storage

value_type & operator[] (size_type n);  // [n] operator (without index-bound check)
value_type & at (size_type n);          // Return a reference to n-th element with index-bound check
value_type & front ();    // Return a reference to the first element
value_type & back ();     // Return a reference to the last element

void push_back (const value_type & val); // Append val at the end
void pop_back ();                        // Remove the last element
void clear ();                           // Remove all elements

==, !=, <, >, <=, >=    // Comparison Operators
// E.g.
template <class T, class Alloc>
bool operator== (const vector<T,Alloc> & left, const vector<T, Alloc> & right);
   // Compare two vectors
   // For == and !=, first compare the size, then each element with equal algorithm.
   //   Stop at the first mismatch.
   // For <, >, <=, >=, use lexicographical_compare algorithm. Stop at first mismatch.

template <class T, class Alloc>
void swap (vector<T,Alloc> & v1, vector<T,Alloc> v2);
   // Swap the contents of containers v1 and v2.
   // Both shall has the same type, but can have different sizes.

iterator begin();  // Return an iterator pointing to the first element
iterator end();    // Return an iterator pointing to the pass-the-end element

reverse_iterator rbegin(); // Return a reverse iterator pointing to the reverse beginning (last element)
                           // increasing a reverse iterator to transverse in reverse order
reverse_iterator rend();   // Return a reverse iterator pointing to the reverse past-the-end

iterator insert (iterator pos, const value_type & val);  // Single-Element: insert element val before iterator pos
void     insert (iterator pos, size_type n, const value_type & val);  // Fill: insert n copies of val before pos
template <class InputIterator>
void     insert (iterator pos, InputIterator first, InputIterator last)
    // Range-copy: copy the range [first, last) and insert before pos.

iterator erase (iterator pos);  // Single-element: remove element pointed to by iterator pos
iterator erase (iterator first, iterator last);  // Range: remove elements between [first,last)

void assign (size_type n, const value_type & val);  // Fill: clear old contents and assign n copies of val
template <class InputIterator>
void assign (InputIterator first, InputIterator last);  // Range: assign [first, last)