Guia Rpido de C++ Classes

Uma classe definida como:

class NomeDaClasse{ lista_de_atributos lista_de_mtodos };

Os atributos e mtodos podem ser declarados como public, private ou protected da seguinte forma:
class NomeDaClasse{ public: lista_de_atributos_public private: lista_de_atributos_private protected: lista_de_atributos_protected public: lista_de_mtodos_public private: lista_de_mtodos_private protected: lista_de_mtodos_protected };

H duas maneiras de especificar mtodos: - declara e define o corpo do mtodo dentro da classe.
class NomeDaClasse{ private: lista_de_atributos public: valorDeRetorno mtodo1( ){ corpo } valorDeRetorno mtodo2( ){ corpo }

};

-Declara os prottipos dentro da classe e define os corpos dos mtodos fora.

class NomeDaClasse{ private: lista_de_atributos public: valorDeRetorno mtodo1( ); valorDeRetorno mtodo2( ); }; valorDeRetorno NomeDaClasse :: mtodo1( ){ corpo } valorDeRetorno NomeDaClasse :: mtodo2( ){ corpo }

O operador de escopo :: indica que o mtodo definido da classe especificada. Construtores e Destrutores O primeiro mtodo de uma classe o construtor e tem o nome da classe. H trs formas de definir o construtor: -Como uma funo normal:
class NomeDaClasse{ private: Tipo atributo1; Tipo atributo2; public: NomeDaClasse( parmetros ){ corpo_do_mtodo } ... };

-Com inicializao dos atributos antes do corpo:

class NomeDaClasse{ private: Tipo atributo1; Tipo atributo2; public: NomeDaClasse( parmetro1, parmetro2 ): atributo1(parmetro1), atributo2( parmetro1) {

corpo_do_mtodo } ... };

Os atributos assumem os valores dos parmetros. Ao invs de parmetros, podem ser colocadas constantes nos atributos. -Com a execuo de um construtor da classe pai, antes do corpo:
class NomeDaClasse : public NomeDaClasseHerdada{ private: Tipo atributo1; Tipo atributo2; public: NomeDaClasse( parmetros ): NomeDaclasseHerdada( parmetros ) { corpo_do_mtodo } ... };

O destrutor o metodo que tem a funo de desalocar da memria um objeto da classe quando seu escopo acaba ou quando usa-se o comando delete. O destrutor tem o mesmo nome da classe precedido por um til (~).
class NomeDaClasse{ private: Tipo atributo1; Tipo atributo2; public: NomeDaClasse( parmetros ){ corpo_do_mtodo } ~NomeDaClasse( parmetros ){ corpo_do_mtodo } ... };

Se no for declarado um construtor para a classe, ser gerado um construtor default, sem parmetros. Basta declarar como:
TipoObjeto objeto;

Se um construtor for criado, e tiver parmetros, esse dever ser invocado na hora da declarao:
TipoObjeto objeto( parmetros );

Com o mecanismo de sobrecarga de funes/mtodos pode existir varias implementaes da funo/mtodo com diferentes parmetros. Atributos e mtodos estticos Atributos estticos podem ser referenciados, usados, por qualquer parte do cdigo fora da classe. So definidos como:
class NomeDaClasse{ private: static Tipo atributo1; Tipo atributo2; ... }; ... NomeDaClasse :: atributo1 = valor; ...

O comando :: indica que a varivel pertence a classe. Geralmente variveis estticas so usadas para definir constantes. Usa-se o comando const para que o valor de uma varivel no possa ser modificada.
class NomeDaClasse{ private: static const Tipo atributo1 = valor; Tipo atributo2; ... };

Um mtodo declarado como const no pode acessar seus atributos. Para indicar ao compilador que um mtodo no altera os atributos usa-se o comando const aps o parnteses dos parmetros.
... metodo( parmetros ) const {...} ...

O ponteiro this

Quando se esta dentro de um mtodo de uma classe, quando um objeto dessa classe instanciado, para acessar um atributo do objeto ou um de seus mtodos, usa-se o ponteiro this, que um ponteiro para o prprio objeto que chamou o mtodo. Exemplo:
class Classe{ int atributo, ...; ... void Metodo1(){ int a; ... a += this->atributo; ... this->Metodo2(a); .. } ... voi Metodo2(int a){...} ... }

Funes e Mtodos
Argumentos Default O programador pode definir valores default para os parmetros dos seus mtodos/funes caso o cdigo que o chame omita alguns ou todos.
TipoDeRetorno Funcao( parametro1 = valorDefault1, parametro2 = valorDefault2, ...) {...}

Exemplo:
int raizQuadrada(int radicando = 1, int radical = 1){...};

Caso se receba um parmetro, o radical ser 1, caso no se receba parmetro os dois parmetros recebero 1. Referencia

No preciso passar um ponteiro como parmetro para salvar valor na varivel. Basta especificar na assinatura da funo/mtodo que o parmetro formal uma referencia ao parmetro real da seguinte forma:
TipoDeRetorno NomeDaFuncao( Tipo & referencia, ... ){...}

O & antes indica que o parmetro formal uma referencia. Da s preciso passar o nome da varivel como parmetro real. Do mesmo modo, uma funo/mtodo pode retornar uma referencia:
TipoDeRetorno & NomeDaFuncao ( Parametros ) {...}

Funo friend Antes vamos definir uma funo friend. Uma funo friend uma funo normal, declarada dentro de uma classe podendo usar as variveis e mtodos privados da classe e ser usada em qualquer parte do cdigo sem especificar a classe.
class NomeDaClasse{ lista_de_atributos lista_de_mtodos friend TipoDeRetorno NomeFuncao( parmetros ){ ... } }; ... NomeFuncao( parmetros); ...

A funo friend no pode acessar o ponteiro this da classe, pois no associada um objeto. O comando explicit Todos os objetos cujos construtores da classe possuem apenas um parmetro podem receber esse parametro com o sinal =. Convencionalmente faramos:
TipoObjeto obj( parametro );

Mas pode-se usar o sinal =:

TipoObjeto obj = parametro;

Para indicar que o construtor no pode ser chamado com =, usa-se o comando explicit.

explicit TipoObjeto( parametro ){...}

Herana
Para herdar uma classe faz-se o seguinte:
class NomeDaClasse : public NomeDaClasseHerdada{ corpo da classe };

O comando : indica que a classe a esquerda vai herdar a classe a direita. O comando public indica que os atributos e mtodos pblicos da classe herdada continuaro pblicos. O default private. O que no herdado: Construtor e destrutor Os membros operator=() (ver Sobrecarga de operadores) Funes friend

Mtodos Virtuais Se o parmetro de uma funo uma referencia a um objeto base,

ValorDeRetorno Funcao( TipoObjeto &objeto ){ ... objeto.metodo( ); ... }

e for enviado um objeto que herda desse, ser aceito em C++. Porm, se o objeto da classe que herda sobreescrever algum mtodo da classe pai e chamar esse mtodo dentro da funo, o mtodo chamado ser o da classe pai e no o sobreescrito. Para que o programa execute sempre o mtodo de um objeto da classe filho, se existir, a classe base deve implementar esse mtodo como virtual.
class TipoObjeto{ ... virtual ValorDeRetorno metodo( ){...} ...

Bibliotecas
As bibliotecas do C++ so invocadas com a diretiva #include, mas no usa-se o .h (header) como no C. Por exemplo, a biblioteca iostream invocada como:
#include <iostream>

e no como
#include <iostream.h>.

Um bloco declarado como namespace, tal como:

namespace bloco{...}

serve para definir um escopo para variaveis, comandos, funes e classes. Para acessar uma varivel, por exemplo, de um namespace deve se usar o comando :: do seguinte modo:
bloco::variavel;

Onde bloco se refere ao namespace. Todas as definies das bibliotecas do c++ esto contidas no namespace std. Para acessar, o comando cout da biblioteca iostream, por exemplo, deve-se fazer:
std::cout

Para no precisar referenciar o namespace std em todo o programa pode-se usar o comando using depois das definies das diretivas:
#include <iostream> ... using namespace std;

Alocao Dinmica
O comando new aloca dinamicamente: - uma varivel especificando o seu tipo:
Tipo *varivel; varivel = new Tipo;

- um vetor ou matriz:
Tipo *vetor;

vetor = new Tipo[TAMANHO_DO_VETOR];

- um objeto:
Tipo *objeto; objeto = new Tipo( parmetros_do_construtor );

- um vetor de objetos:
Tipo *vetorObjetos; vetorObjetos = new Tipo( parmetros_do_construtor ) [ TAMANHO_DO_VETOR];

O comando delete desaloca da memria: - uma varivel ou objeto apontado:

Tipo *variavel = new Tipo; delete variavel;

- um vetor:
delete [ ]vetor;

Operadores de Cast
O comando abaixo indica para uma atribuio ou parametro interpretar a expresso com o tipo especificado entre < >.
reinterpret_cast <tipo> ( expresso );

E/S pelo terminal

Usa-se a biblioteca iostream. O comando cout converte o tipo especificado em uma string para o terminal.
cout << Ola Mundo! << << 123

O comando imprime : Ola Mundo! 123. O comando << concatena os valores. O comando cin converte o texto do terminal em valores para as variveis da direita do comando >>.

No terminal, o usuario digitou: Ola Mundo! 123 O comando,

char texto[20]; int valor; cin >> texto >> valor;

faz com que, texto = Ola Mundo! e valor = 123. Espaos e tabs so ignorados por >>. Dessa forma, para salvar string mais recomendado usar:
getline(cin, string);

E/S de arquivos
http://pt.wikibooks.org/wiki/Programar_em_C%2B%2B/Classes#Declarando_classes Usa-se a biblioteca fstream. Os objetos que manipulam arquivos so das seguintes classes: -ifstream: manipula arquivos de apenas leitura. -ofstream: manipula arquivos de apenas escrita. -fstream: manipula arquivos de leitura e escrita. Alguns mtodos comuns so: open(nome_do_arquivo): abre um arquivo para leitura, se ifstream, escrita, se ofstream, e ambos caso fstream. Geralmente no se usa, pois basta usar o construtor na hora de criar o objeto. close( ): fecha o arquivo associado ao objeto. get( caractere ): l um byte do arquivo, um caractere. No precisa passar o ponteiro, referencia. put( caractere ): escreve um byte no arquivo, um caractere. eof( ): retorna true se final de arquivo. Para arquivos texto, para ler ou escrever pode-se usar os comandos >> e <<, respectivamente. Exemplo:
// l arquivo e coloca contedo em outro ifstream entrada( nome1.txt ); ofstream saida( nome2.txt );

// testa se ocorreu erro if( entrada && sada ){ while( entrada >> c ) sada << c; }

Como o comando >> no l espaos e tabs, caso precise, usa-se o mtodo get( ). Alternativamente, getline( char s[ ], int max ) l uma linha e retorna quando max caracteres forem lidos ou nova linha for encontrada. O mtodo open( ) ou o construtor podem receber alm do nome do arquivo como parmetro, um flag que so constantes.
arquivo.open( nome_arquivo, flag );

Dentre as constantes temos: ios::out : Abre para escrita, se for fstream; ios::in : Abre para leitura, se for fstream; ios::binary : L/escreve em modo binrio; ios::ate: Vai para o final do arquivo ler, mas escreve em qualquer lugar; ios::app : Cria novo arquivo, ou adiciona ao final de um arquivo existente. Quando se manipula arquivos binrios usa-se:
read( char *buffer, int numeroBytes): l numeroBytes de bytes do

arquivo e armazena em buffer;

write( char *buffer, int numeroBytes): escreve numeroBytes de

bytes do buffer no arquivo; Exemplo:

// l valores doubles de arquivo e coloca contedo em outro double temp; ifstream entrada( nome1.bin, ios::binary ); ofstream saida( nome2.bin, ios::binary ); // testa se ocorreu erro if( entrada && sada ){ while(!entrada.eof()){ entrada.read(reinterpret_cast<char*>(temp), sizeof(double)); saida.write(reinterpret_cast<char*>(temp), sizeof(double)); } }

Os mtodos que permitem acesso randomico no arquivo so: seekg( posio_do_byte, flag ): indica em qual byte deve comear a leitura a partir da posio dita por flag; seekp( posio_do_byte, flag ): indica em qual byte deve comear a escrita a partir da posio dita por flag; Os possveis valores do flag so: ios::beg: Comeo do arquivo; ios::cur: Localizao corrente; ios::end: Final do arquivo;

Sobrecarga de Operadores
Os operadores primitivos da linguagem, tais como:
+ - * / % ^ ~ ! , = < > ++ -- << >> += -= /= %= <<= >>= [ ] & | <= >= == != && || ^= & = |= *= ( ) -> ->* new delete

podem ser sobrecarregados com mtodos de uma classe. Um mtodo add da classe List pode ser substitudo pelo operador +, por exemplo. Bom, para sobrecarregar um operador, tal como +, a classe deve definir um mtodo operator da seguinte forma:
TipoRetorno operatorOPERADOR ( operandos ) {...}.

Para o caso do +, teramos

NomeDaClasse operator+ ( NomeDaClasse &operando ){...}

Numa soma usando o operador +, o operando da esquerda chama o mtodo operator+ e o operando da direita colocado como parmetro e o mtodo executa as operaes definidas. Ento, em uma funo principal usariamos
... NomeDaClasse objetoSoma, operando1( ), operando2( ); ... objetoSoma = operando1 + operando2;

Que seria equivalente

objetoSoma = operando1.operator+( operando2 );

Nesse caso, se um valor inteiro for parametro do construtor, ento

objetoSoma = operando1 + 5;

ser vlido, mas

objetoSoma = 5 + operando1;

ser invalido, pois no possvel

5.operator+(operando1);

Caso se queira que o operator+ seja desvinculado do objeto a esquerda pode-se declaralo como uma funo friend.
friend NomeDaClasse operator+( NomeDaClasse &operando1, NomeDaClasse &operando2 );

Ento,
objetoSoma = operando1 + operando2;

seria equivalente :
objetoSoma = operator+( operando1 + operando2 );

Porm, no minimo, um dos operandos deve ser da classe, para o compilador identificar a que classe operator+ pertence; Para sobrecarregar o operando ==, poderamos fazer:
int operator==( NomeDaClasse &operando ){...}

e o cdigo
if( operando1 == operando2 ){...}

seria equivalente

if( operando1.operator==( operando2 ) ){...}.

Excees
Uma exceo um objeto criado quando ocorre algum comportamento inesperado de um programa tal como um erro. O comando try-catch usado da seguinte forma:
try{ ... } catch( TipoDaExcecao &nome ){ ... }

Dentro do bloco try o programa executa normalmente. Se ocorrer uma exceo, um objeto do tipo TipoDaExcecao lanado, o try encerrado e o bloco catch executado recebendo como parametro a exceo. O comando throw usado para lanar a exceo. Uma exceo lanada como:
throw (TipoExcecao(parametro));

Exemplo: tratando diviso por zero com um objeto da TrataDivZero.

#include <iostream> using using using using std::cout; std::cin; std::endl; std::string;

class TrataDivZero { public: TrataDivZero(int n); void Msg(); private: int NLinha; }; TrataDivZero::TrataDivZero(int n) { NLinha = n; } void TrataDivZero::Msg() { cout << "Tratador de erro foi chamado ..." << endl;

cout << "Erro na linha: " << NLinha << endl; } int main() { int n, m; cout << "Numerador: "; cin >> n; cout << "Denominador: "; cin >> m; try // inicio do bloco TRY { if (m==0) { // lana a exceo, criando um objeto da classe TrataDivZero // e passando o nmero da linha onde o erro ocorreu throw (TrataDivZero(__LINE__)); // dentro deste bloco nada executado aps o throw. } cout << "Diviso: " << (double)n/m << endl; } // final do bloco TRY catch (TrataDivZero &T) // pode ter ou no o objeto { // apenas o tipo obrigatrio T.Msg(); } cout << "Fim..." << endl; system("pause"); return 0; }

A macro __LINE__ retorna a linha do cdigo. Se no possvel prever que exceo pode ser lanada, no parametro do catch so colocados trs pontos:
try{ ... } catch(...){ ... }

Se na funo/mtodo for lanada a exceo e esse no trata-la, ento esse funo/mtodo ser encerrado e a exceo ser lanada para o funo/mtodo que o invocou. Se nenhuma funo tratar a exceo ao chegar no main, se esse no tratar, o programa encerrado. Podem haver vrios tratadores de exceo.

try{...} catch(TipoDeExcecao1 &ex1){...} catch(TipoDeExcecao2 &ex2){...} .... catch(TipoDeExcecaoN &exN){...}

Nesse caso o tratador a ser executado ser o que trata o tipo de exceo lanada por try. Excees padronizadas Usa-se a biblioteca exception para a classe exception e stdexcept para as demais. So excees lanadas por comandos ou funes da biblioteca do C++ e que podem ser lanadas por funes criadas por programadores. So todas derivadas da classe exception.

So elas: exception: a me de todas as exceptions. Uma alternativa melhor que o catch (...) pois voc ainda poder obter o erro da exception. O mtodo what( ) retorna uma mensagem definida no construtor do objeto. bad_alloc: Disparada automaticamente pelo comando new quando no h memria suficiente.

bad_cast: Disparada pelo dynamic_cast caso a converso de tipos que voc est tentando for impossvel runtime_error: Excees que denotam erros de programao comuns, que no poderiam ser previstos inicialmente pelo programador. Tal como, no meio da avaliao de uma funo, um clculo ter o limite superior de uma varivel estourada (std::overflow_error). logic_failure: So excees que violam condies no programa, ou que denotam erros de programao. Por exemplo, numa funo de fatorial, passar valores negativos como parmetro. Geralmente, suas excees sero sempre filhas de logic_error. Suas filhas so: o domain_error: Indica que um erro de domnio foi cometido. Ou seja, um valor incorreto foi passado para uma funo matemtica (por exemplo, na funo de raiz quadrada, foi passado um nmero negativo). o invalid_argument: Indica o valor de um dos parmetros recebidos pela funo invlido. Por exemplo, o usurio passou um ponteiro nulo onde deveria passar um objeto. o length_error: Indica que no possvel alterar o tamanho de uma estrutura para o valor indicado. Por exemplo, o usurio tentou dar um resize para um tamanho maior que o mximo, ou negativo. o out_of_range: Indica que um parmetro foi passado fora do intervalo permitido. Por exemplo, valores menores que 10 ou maiores que 100 numa funo que pergunta ao usurio sua idade.

Handlers de excees Usa-se a biblioteca iostream. Alm dos tratadores catch, existem funes de tratamento ou handlers que tratam excees padronizadas. Alguns deles so: set_terminate( FuncaoDeTratamento) : A funo de tratamento invocada quando o main encerrado prematuramente, porque uma exceo no foi tratada. set_new_handler(FuncaoDeTratamento): Quando ocorre falta de memria usando o comando new. set_unexpected(FuncaoDeTratamento): Quando dentro de um mtodo/funo no h tratamento para a funo lanada.

Templates
Pode-se definir um nico mtodo/funo e definir tamplates para ele, que so tipos que sero substitudos pelo tipo do parmetro enviado para o mtodo/funo. Imediatamente, antes da definio da funo, defini-se os templates:

template < class S, class T>.

Cada template declarado como class ou como typename, tanto faz. Logo, os templates so definidos como parametros da funo e/ou tipo de retorno:
T nomeFuncao( T parametro1, S parametro2, T parametro3 ){...}.

Caso seja passado diferentes parmetros para a funo, o compilador ira substituir o tamplate pelo tipo do parametro correspondente:
nomeFuncao( 1, 23, 9 ); nomeFuncao( Ola, 12, Mundo );

Tambm podemos definir classes templates. Os templates usados pela classe tambm devem ser declarados imediatamente antes da definio da classe. Para que os templates sejam substitudos pelos tipos desejados, eles devem ser passados na declarao do objeto da seguinte maneira:
int a; double b; ClasseTemplate< int, double > objeto; objeto.Soma(a, b);

Dessa forma o template correspondente na lista de templates ser substitudo pelo tipo especificado dentro da classe. Note que os mtodos definidos fora da classe, devem especificar os templates usados:
template < class S, class T>. class ClasseTemplate{ ... int MetodoTemplate( ); ... } ... int ClasseTemplate <S,T> :: MetodoTemplate(){...} ...

Biblioteca STL
A STL (Standard Template Library) uma biblioteca padro da linguagem C++, e faz parte de todos os compiladores que seguem o padro ISO C++. uma biblioteca quase que totalmente baseada em templates, buscando simplicidade, produtividade e rapidez. Temos na STL alguns estilos bsicos de templates, chamados concepts. Vamos aos concepts bsicos da STL:

Containers: So objetos usados para guardar conjuntos de outros objetos ou valores. Entre eles temos o vector (um array de acesso sequencial), o list (lista ligada) e o map (mapa associativo de chave e valor). Iterators: uma abstrao criada para unificar a forma de percorrer todos os itens de um container, de forma que o mesmo algoritmo possa ser usado em diversos containers. Algoritmos: Funes templates que manipulam de alguma forma os containers, modificando seu prprios itens ou gerando cpias. So feitos com o mnimo possvel de conhecimento sobre o container que ser utilizado, para que possa ser usado de forma genrica na maior quantidade possvel de situaes e usos.

Iterators Num lao, tal como este:

for(i = 0; i < 10; i++) vetor[i] = VALOR + 1;

a varivel i serve como iterador, para acessar um elemento do vetor. Os iterators da STL so iteradores inteligentes, e servem para varrer qualquer container. A declarao de um iterator :
tipoContainer<tipo> :: iterator iter;

Cada container tem seu iterador especifico. Por isso preciso usar o comando de escopo ::. Para varrer um container faz-se:
for(iter = container.begin(); iter != container.end(); iter++) cout << *iter;

Containers tm mtodos padres para manipular iterators. Os mtodos para manipular iterators so: begin(): retorna inicio do container; end(): retorna a posio depois do ultimo elemento, indicando fim; rbegin(): retorna o ultimo elemento, e ao somar iterador, esse ira referenciar o penltimo elemento, e assim em diante; rend(): retorna iterador para o fim da busca reversa, ou seja, o inicio. O iterador um ponteiro, que dependendo do container, aponta para uma varivel ou para uma struct. Classe de comparao

Como os elementos de um continer podem ser qualquer objeto ou varivel, preciso uma forma de comparao entre os elementos de quem maior que quem. Dessa forma preciso passar para os containers uma classe de comparao que deve implementar:

class Compara{ ... public: bool operator()(tipo a, tipo b){...} ... };

Compara(a, b) ser usada para comparar dois elementos de um conteiner: retorna true se a > b e false caso contrario. Quando uma classe de comparao no for passada, os elementos sero comparados pelo operador >. Containers Alguns containers so: vector: como um array comum, mas cresce dinamicamente. Biblioteca: <vector>. Recebe como parametro tamplate o tipo de seus elementos:
vector<tipo> vetor(int n, tipo valor);

Seu construtor recebe como parmetro o tamanho n do vetor e o valor inicial dos n elementos. Caso no seja passado parmetro, o vetor ter tamanho zero. Alguns de seus mtodos so: empty(): retorna true se o container est vazio; size(): retorna tamanho do container; resize(int): apesar de crescer dinamicamente, melhor redimensionar o container usando resize, quando quiser aumentar seu tamanho; front(): acessa o primeiro elemento; back(): acessa o ultimo elemento; at(n): retorna elemento da posio n; push_back(): insere elemento no fim; pop_back(): deleta elemento do fim; swap(container): deleta contedo do container e copia elemento de outro container do mesmo tipo; clear(): deleta elementos do container; list: implementado como uma lista duplamente encadeada. Biblioteca: <list>. Recebe como parametro tamplate, o tipo dos seus elementos. Alguns de seus mtodos so:

empty(): retorna true se o container est vazio; size(): retorna tamanho do container; front(): acessa o primeiro elemento; back(): acessa o ultimo elemento; push_back(): insere elemento no fim; pop_back(): deleta elemento do fim; swap(container): deleta contedo do container e copia elemento de outro container do mesmo tipo; clear(): deleta elementos do container; insert(iterator, T): insere na posio indicada por iterator, um elemento do tipo especifico do container, trocado pelo template; erase(iterator): deleta um elemento, ou uma sequencia de elemento (erase(begin, end)); remove(v): remove elemento de valor v; unique( ): Exceto o primeiro encontrado, remove todos os elementos repetidos. sort( ): ordena os elementos da lista em tempo NlogN, N tamanho da lista. stack, queue e priority_queue: esses containers usam na verdade outros containers para armazenar seus elementos. Eles usam polticas de remoo e insero. Vejamos abaixo suas definies: stack: so estruturas do tipo LIFO (last in, last out). Biblioteca: <stack>. Sua declarao :
stack<tipo, classeContainer> pilha;

onde tipo o tipo dos elementos e classeContainer ser um dos seguintes containers: vector, list ou dequeue (que ser por default). Suas operaes so: empty(): retorna 0 se no vazio, e no 0 se vazio. size(): retorna o numero de elementos. top(): retorna o ultimo elemento inserido push(x): insere o elemento de valor x pop(): remove o ultimo elemento inserido queue: so estruturas do tipo FIFO (first in, last out). Biblioteca: <queue>.Sua declarao :
queue<tipo, classeContainer> fila;

onde tipo o tipo dos elementos e classeContainer ser um dos seguintes containers: list ou dequeue (que ser por default). Suas operaes so: empty(): retorna 0 se no vazio, e no 0 se vazio. size(): retorna o numero de elementos. front( ): retorna primeiro elemento da fila back( ): retorna ultimo elemento da fila

push(x): insere elemento no final da fila pop(): remove elemento do final da fila priority_queue: so estruturas que implementam filas de prioridade. Ou seja, o maior elemento sempre o primeiro a ser removido. implementado com um heap. Biblioteca: <queue>. Sua declarao :
priority_queue<tipo, classeContainer, Compara> fila;

onde tipo o tipo dos elementos e classeContainer ser um dos seguintes containers: dequeue ou vector (que ser por default). Seus mtodos so: empty(): retorna 0 se no vazio, e no 0 se vazio. size(): retorna o numero de elementos. top(): retorna elemento de maior valor push(x): insere elemento pop(): remove elemento de maior valor set: no permite elementos com mesmo valor. A maneira de verificar se dois elementos so iguais usando uma classe comparadora, assim como no priority_heap. Se
(Compara(a, b) == false && Compara(b, a) == false) == true

Ento, os elementos so iguais. Biblioteca: <set>. A busca de um elemento se d pelo seu valor e no pela sua posio. implementado como uma arvore binria balanceada. Sua declarao :
set<tipo, Compara> arvore;

Algumas de suas operaes: find(x): retorna iterator do elemento de valor x; erase(x): apaga elemento de valor x. O x pode ser tambm o iterador de x. insert(x): insere elemento de valor x. Se valor j existente, no faz nada. multiset: igual ao set, porm permite chaves repitidas. Usa tambm a biblioteca <set>. map: como o set, mas a busca de um elemento se d pela sua chave e no pelo seu valor. Biblioteca <map>. Declarao:
map<tipoChave, tipoElementos, Compara> mapa;

Cada elemento do map uma struct chamada pair<tipoChave, tipoElementos>, com dois campos: first, que o campo da chave e second, que o campo do elemento. Para acessar a chave de uma posio qualquer faz-se:
map<tipoChave, tipoElementos, Compara> :: iterator i; ... (*i).first; ...

Para acessar o elemento:

(*i).second;

Algoritmos Usa-se a biblioteca <algorithm>. Alguns algoritmos para manipular containers so: sort(iterator begin, iterator end, Compara): ordena o container a partir de begin at end. Compara, uma classe de comparao, assim como a usada no priority_queue.

merge(iterator first1, iterator last1, iterator first2, iterator last2, iterator out, Compara): Pega duas sequencias ordenadas: (first1, last1) e (first2, last2) e junta em uma sequencia ordenada cujo iterator para o comeo out. Compara a classe de comparao. Exemplo:
#include <iostream> #include <algorithm> #include <vector> using namespace std; int main () { int first[] = {5,10,15,20,25}; int second[] = {50,40,30,20,10}; vector<int> v(10); vector<int>::iterator it; sort (first,first+5); sort (second,second+5); // usa operador <, ao inves de compara merge (first,first+5,second,second+5,v.begin()); cout << "O vetor resultante contem:";

for (it=v.begin(); it!=v.end(); ++it) cout << " " << *it; cout << endl; } return 0;

SAIDA:
O vetor resultante contem: 5 10 10 15 20 20 25 30 40 50

"Receitas de Bolo" para uso de grafos com STL Grafo direcionado: Declarao: map< int, set<int> > G; Preenchimento - adicionar arco 5 -> 3: G[5].insert(3); Consultar vizinhos do n 33: set<int>::iterator sIt; for ( sIt=G[33].begin() ; sIt!=G[33].end() ; sIt++ ) printf("vertice %d\n", *sIt); Declarao de grafo direcionado com pesos: map< int, map<int, set<int>> > G;

Mais sobre a biblioteca STL pode ser consultado em http://www.cplusplus.com/reference/stl/.

A classe string
Usa-se a classe string para manipular strings de forma mais natural. Sobrecarrega as operaes +, =, ==, <, >, <=, >=, !=. Biblioteca <string>. Seu construtor pode ser: string str(x); Onde x pode ser uma string constante ou outro objeto string, ou string str(i1, i2);

Onde i1 o iterador para o inicio de uma string e i2 para o fim. Alguns de seus mtodos: size(): tamanho da string; resize(n): redimensiona string para o tamanho n; empty(): retorna true se string vazia; assign(s): atribui uma string s a string; insert(p, c): insere a partir da posio p, n caracteres; insert(p, i1, i2): insere a partir da posio p, a substring de iteradores i1 a i2; erase(p): apaga caracteres a partir da posio p; swap(s): troca contedo de strings; c_str(): retorna uma string do estilo C. find(s, p): procura a primeira ocorrncia da substring s, a partir de p, retornando seu tamanho. A classe wstring, biblioteca <wstring>, semelhante a classe string, porm manipula caracteres de 16 bits do tipo wchar_t.

Biblioteca PThreads
A biblioteca pthreads no faz parte da biblioteca C, mas um padro POSIX e por isso se encontra em qualquer sistema UNIX/Linux. Serve para manipular threads. Cabealho: <pthread.h>. Use gcc -o prog1 prog1.c -lpthread para compilar. O tipo pthread_t define uma thread. A funo para inicializar a thread :
int pthread_create(pthread_t * thread, pthread_attr_t *attr, void * (*func)(void *), void *arg);

onde, thread: a thread a ser inicializada; attr: um parmetro do tipo pthread_attr_t que se deve inicializar previamente com os atributos
que queremos que a thread tenha. Entre os atributos esto a prioridade, o algoritmo da thread, etc. Se passarmos como parmetro NULL, a biblioteca atribuir a thread atributos por default.

func: a funo que queremos que a thread axecute; arg: o argumento da funo executada pela thread, que deve ser um ponteiro. Todos os valores executados pela thread so guardados mesmo depois de sua execuo. Para liberar esses valores da memria deve-se usar umas das duas funes:
int pthread_join(pthread_t th, void **thread_return):

a thread que chama pthread_join bloqueado at que a thread th termine sua execuo. return o valor retornado por th.
int pthread_detach(pthread_t th): ao usar essa funo, indicamos que no

queremos que o resultado da thread th seja guardado. Por padro, o resultado da execuo de todas as threads so guardados at que faamos um pthread_join para recuperar o resultado. Uma thread encerra sua execuo quando executa a seguinte funo:
void pthread_exit(void *retval): onde retval

o valor enviado pela thread.

Exemplo:
#include <stdio.h> #include <stdlib.h> #include <pthread.h> #define THREADS_MAX 4 /*funcao que as threads vao executar*/ void *function(void *parametro) { int id = *((int *)(parametro)); printf("thread %d \n", id); pthread_exit(NULL); } int main(void) { /*definindo as threads*/ pthread_t threads[THREADS_MAX]; int thread_args[THREADS_MAX]; int i; printf("pre-execucao\n"); for (i = 0; i < THREADS_MAX; i++) { thread_args[i] = i; pthread_create(&threads[i], NULL, function, (void *) &thread_args[i]); } printf("execucao do meio\n"); for (i = 0; i < THREADS_MAX; i++) { /*vai esperar cada thread*/

pthread_join(threads[i], NULL); } printf("pos-execucao\n"); return EXIT_SUCCESS;

Se uma thread no quer salvar suas variveis depois de sua execuo com pthread_detach(), ela consegue o objeto que contem seus atributos atraves da funo pthread_self(). Ento, faramos:
pthread_detach(pthread_self());

Para matar uma thread faz-se:

int pthread_kill(pthread_t thread, int signo)

onde, signo colocamos a constante SIGKILL. Biblioteca do C As bibliotecas do C podem ser usadas no C++. Nesse caso omiti-se o .h na declarao e coloca-se um c em frente ao nome original. Exemplo, stdio.h fica como cstdio. Algumas funes do C sero relembradas abaixo. Funes matemticas Usa-se a biblioteca cmath. ceil(x): Arredonda x para o menor inteiro maior ou igual a x cos(x): Co-seno de x (x em radianos) exp(x): Funo exponencial (ex) fabs(x): Valor absoluto de x floor(x): Arredonda x para o maior inteiro menor ou igual a x fmod(x, y): Resto de x/y como um nmero de ponto flutuante log(x): Logaritmo natural (base e) de x log10(x): Logaritmo na base 10 de x pow(x, y): x elevado a y sin(x): Seno de x (x em radianos) sqrt(x): Raiz quadrada de x tan(x): Tangente de x (x em radianos)

Funes para manipulao de strings Usa-se a biblioteca cstring.

strcpy(char*s1, const char *s2): copia a string s2 no array de caractere s1. O valor de s1 retornado. strncpy( char *s1, const char *s2, size_t n ): copia at n caracteres da string s2 no array de caractere s1. O valor de s1 retornado. strcat(char*s1, const char *s2): adiciona a string s2 na string s1. O primeiro caractere de s2 sobrescreve o caractere de terminao nulo de s1. O valor de s1 retornado. strncat(char*s1, const char *s2, size_t n): Adiciona at n caracteres da string s2 na string s1. O primeiro caractere de s2 sobrescreve o caractere de terminao nulo de s1. O valor de s1 retornado. int strcmp(const char*s1, const char *s2): compara a string s1 com a string s2. A funo retorna um valor zero, menor que zero ou maior que zero se s1 for igual a, menor que ou maior que s2, respectivamente. strncmp( const char *s1, const char *s2, size_t n ): compara at n caracteres a string s1 com a string s2. A funo retorna zero, menor que zero ou maior que zero se s1 for igual a, maior que ou menor que s2, respectivamente. strtok( char*s1, const char *s2): A sequncia de chamadas a strtok quebra a strings1 em pedaos (pedaos lgicos como palavras em uma linha de texto) delimitados por caracteres contidos na string s2. A primeira chamada contm s1 como primeiro argumento. J as chamadas posteriores para continuar separando a mesma string contm NULL como o primeiro argumento. Um ponteiro para o primeiro pedao retornado a cada chamada. Se no houver mais nenhum pedao quando a palavra for chamada, NULL retornado. char *strlen(const char *s): determina o comprimento da string s. O nmero de caracteres precedendo o caractere de terminao nulo retornado.

Gerando nmeros aleatrios Usam-se as bibliotecas ctime e cstdlib. Primeiro, gera-se um valor chamado semente, atravs da funo srand( ):
srand( time(NULL) );

time( ) retorna a hora atual em segundos desde 1970 e srand( ) usa-a para gerar a semente. Logo aps usa-se a funo rand( ) que usa a semente para gerar e retornar um nmero aleatrio. Para gerar um numero entre uma faixa de 0 a N faz-se:
rand() % N;

Para gerar um numero entre uma faixa de M a N faz-se:

M + ( rand() % N );

Diretiva #pragma http://pt.cppreference.com/w/cpp/preprocessor/pragma