Standard library type

Key types: string, vector, bitset, companion type

string s1;

string s2(s1);

string s3("value");

string s4(n,'c');

string line;

while(getline(cin, line))

cout<<line<<endl;

string s;

s.empty()

s.size()

s[n]

S1+s2

S1=s2

V1==v2

!=, <, <=,

>, >=

string::size_type

for(string::size_type ix=0;ix!=str.size();++ix)

str[ix]='*';

isalnum(c)

isalpha(c)

iscntrl(c)

isdigit(c)

isgraph(c)

islower(c)

isprint(c)

ispunct(c)

isspace(c)

isupper(c)

isxdigit(c)

tolower(c)

toupper(c)

Vector

Class template

#include <vector>

using std::vector;

vector<T> v1;

vector<T> v2(v1);

vector<T> v3(n, i);

vector<T> v4(n);

v.empty()

v.size()

v.push_back(t)

v[n]

v1=v2

V1==v2

!=, <, <=, >, >=

-------------------------------------------------------------------------------------------------

#include "stdafx.h"

#include <vector>

using std::vector;

#include <iostream>

using std::cin;

using std::cout;

int _tmain(int argc, _TCHAR* argv[])

{

vector<int> ivec;

for(vector<int>::size_type i=0;i<=10;++i)

ivec.push_back(i);

for(vector<int>::size_type ix=0;ix<=10;++ix)

cout<<ivec[ix];

cout<<"/r/n";

for(vector<int>::iterator iter=ivec.begin();

iter != ivec.end();

++iter)

cout<<*iter;

cout<<"/r/n";

vector<int>::iterator mid=ivec.begin()+ivec.size()/2;

cout<<*mid;

int x;

cin>>x;

return 0;

}

------------------------------------------------------------------------------------------------

#include <bitset>

using std::bitset;

bitset<n> b;

bitset<n> b(unsigned_long_variable);

bitset<n> b(string_object);

bitset<n> b(string_object, pos, n);

b.any()

b.none()

b.count()

b.size()

b(pos)

b.test(pos)

b.set()

b.set(pos)

b.reset()

b.reset(pos)

b.flip()

b.flip(pos)

b.to_ulong()

os<<b

bitset<32> bitvec2(0xffff);

cout<<"bitvec2:"<<bitvec2<<endl;

Terminology:

abstract data type

bitset

cctype header

class template

container

difference_type

empty

getline

high-order

index

iterator

iterator arithmetic

low-order

off-the-end iterator

push_back

sentinel

size

size_t

size_type

using declaration

value initialization

++operator

::operator

[]operator

*operator

<<operator

>>operator