std::string Común a todos los contenedores

string() contenedor()
string(size_type cant, char ch) contenedor(const contenedor& otro)
string(const string& otra)
string(const string& otra, size_type pos) bool empty()
string(const string& otra, size_type pos, size_type cant) size_type size()
string(const char* s)
string(const char* s, size_type cant) void swap(contenedor& otro)
string(iterator primero, iterator ultimo)

string& operator=(const string& otra) Común a vector, list, set y map

string& operator=(const char* s) contenedor(iterator primero, iterator ultimo)
string& operator=(char ch)
iterador begin()
string& operator+=(const string& otra) iterador end()
string& operator+=(char ch) iterador_inverso rbegin()
string& operator+=(char* s) iterador_inverso rend()
char& operator[](size_type pos) void clear()
char& at(size_type pos)
iterator erase(iterator pos)
const char* c_str() iterator erase(iterator primero, iterator ultimo)
bool empty()
size_type size() Común a vector<T> y list<T>
void clear()
contenedor(size_type cantidad, const T& valor)
string& insert(size_type
idx, size_type cant, char ch)
T& front()
string& insert(size_type
idx, const char* s)
T& back()
string& insert(size_type
idx, const char* s, size_type cant)
T* data()
string& insert(size_type
idx, string& str)
string& insert(size_type
idx, string& str,
iterator insert(iterator pos, const T& valor)
size_type
str_idx, size_type str_count)
iterator insert(iterator pos, size_type cantidad, T& valor)
iterator insert(iterator pos, iterator primero,
string& erase()
iterator ultimo)
string& erase(size_type idx)
string& erase(size_type idx, size_type cant)
void push_back(const T& valor)
void pop_back()
string substr()
string substr(size_type pos)
string substr(size_type pos, size_type cant) Común a set<K> y map<K,T>
size_type find(const string& str) size_type erase(const K& clave)
size_type find(const string& str, size_type pos)
size_type find(char ch) size_type count(const K& clave)
size_type find(char ch, size_type pos) iterator find(const K& clave)
size_type find(char* ch) iterator lower_bound(const K& clave)
size_type find(char* ch, size_type pos) iterator upper_bound(const K& clave)
size_type find(char* ch, size_type pos, size_type cant )

size_type rfind( /* mismos que find */)

std::vector<T>
T& operator[](size_type pos)
size_type find_first_of(const string&) T& at(size_type pos)
size_type find_first_of(const string&, size_type pos)
size_type find_first_of(const char ch)
size_type find_first_of(const char ch, size_type pos) std::list<T>
size_type find_first_of(const char* s) void remove(const T& valor)
size_type find_first_of(const char* s, size_type pos)
size_type find_first_of(const char* s, size_type pos, void push_front(const T& valor)
size_type cant) void pop_front()
size_type find_first_not_of( /* mismos que find_first_of */ ) void reverse()
size_type find_last_of( /* mismos que find_first_of */ ) void unique()
size_type find_last_not_of( /* mismos que find_first_of */ ) void sort()
void sort(compare cmp)

void merge(list& otra)

void merge(list& otra, compare cmp)
void splice(const_iterator pos, list& otra) fstream& operator<<(short valor)
void splice(const_iterator pos, list& otra, fstream& operator<<(int valor)
const_iterator it) fstream& operator<<(long valor)
void splice(const_iterator pos, list& otra, fstream& operator<<(long long valor)
const_iterator primero, const_iterator ultimo) fstream& operator<<(float valor)
fstream& operator<<(double valor)
fstream& operator<<(long double valor)
std::set<K> fstream& operator<<(bool valor)
std::pair<iterator, bool> insert(const K& valor) fstream& operator<<(const void* valor)
iterator insert(iterator pista, K& valor)
void insert(iterator primero, iterator ultimo) fstream& put(char ch)
fstream& write(const char* s, std::streamsize cant)

std::map<K,T> bool good()

bool eof()
typedef std::pair<K,T> PAR
bool fail()
bool bad()
T& operator[](const K& clave)
bool operator!()
operator bool()
std:pair<iterator, bool> insert(const PAR& par)
iterador insert(iterador pista, const PAR& par)
void insert(iterador primero, iterador ultimo)

std::stack<T>
T& top()
void push(const T& valor)
void pop()

std::queue<T>
T& front()
T& back()
void push(const T& valor)
void pop()

std::fstream
fstream(const char* ruta, openmode modo)

bool is_open()
void open(const char* ruta, openmode modo)
void close()

/* openmode puede ser: app, binary, in, out, trunc y/o ate */

fstream& operator>>(short& valor)

fstream& operator>>(int& valor)
fstream& operator>>(long& valor)
fstream& operator>>(long long& valor)
fstream& operator>>(float& valor)
fstream& operator>>(double& valor)
fstream& operator>>(long double& valor)
fstream& operator>>(bool& valor)
fstream& operator>>(void* valor)

char peek()
char get()
fstream& unget()
fstream& putback(char ch)

fstream& get(char& ch)

fstream& get(char* s, std::streamsize cant)
fstream& get(char* s, std::streamsize cant, char delim)
fstream& getline(char* s, std::streamsize cant)
fstream& getline(char* s, std::streamsize cant, char delim)

fstream& ignore(std::streamsize cant, char delim)