// Como comear um programa em C++11

// /////////////////////////////////
#include <bits/stdc++.h>
using namespace std; // se no for usado, todas os nomes
// do c++ devero comear com std::
// ex: std::vector, std::cin, std::cout
int main(){
// seu cdigo
// o return 0 no mais necessrio
}
///////////////////////////////
// Compilar?
g++ -std=c++11 SEU_CODIGO.cpp /* qlqr outra coisa, assim como em C*/
///////////////////////////////////
// Maravilhas sintticas do C++11
///////////////////////////////////
// for
for(int i = 0; i < n; i++)
// range-for
vector<int> vetor = {1,2,3};
for(int x : vetor){ /* faz algo */} // itera em ordem pelo vetor
[1,2,3]
// auto: deduz automaticamente o tipo de uma varivel, caso no haja
ambiguidade
for(auto x : vetor){/* faz algo */} // deduz que x um int,
automaticamente
auto func(){ return 5; }
retorno

// deduz int func() atravs do tipo de

// caso haja ambiguidade, o compilador

acusar o problema
// swap
swap(a, b);

// troca os valores das variveis a e b

// troca eficientemente variveis complexas
// como vectors, sets, etc

// entrada e sada
int x, y;
cin >> x >> y; // leitura (l at o proximo espao em branco)
cout << x << " " << y; // escrita: "x y"
string s;
cin >> s;
// l uma string para um tipo string do c++
double db = 10.500001;
cout << fixed << setprecision(3); // imprime numeros em ponto
flutuante
// de agora em diante com 11 casas
decimais
cout << db << "\n";
// 10.500
// initializer list
struct Estruquite{
int x, y, z;
};

Estruquite est = {10, 5, 4};

// x=10, y=5, z=4
vector<int> vet = {1, 2, 3, 4}; // inicializa um vetor de tamanho 4
// com elementos [1, 2, 3 ,4]
set<int> vet = {1, 5, 10};
pair<int, int> par = {10, 20}; // inicializa um par (10, 20)
// Orientao a objetos
struct Estruquite{
int x, y, z;
int get_sum(){ return x+y+z; }
int set_xyz(int a, int b, int c){
x = a;
y = b;
z = c;
}
};
est.get_sum(); // retorna 19
est.set_xyz(1, 1, 1);
est.get_sum(); // retorna 3
///////////////////////////////////
// STL: Standard Template Library
// ////////////////////////////////
// Pairs
// pair<TIPO_FIRST, TIPO_SECOND>
pair<int, string> par(5, "lala");
pair<int, string> par = {5, "lala"}; // com initializer-lists
cout << pair.first << " " << pair.second << endl; // imprime "5 lala"
pair<int, pair<int, int>> par; // possvel criar pairs de pairs
// funo auxiliar make_pair
make_pair(25, "str"); // deduz os tipos das variveis e retorna um par
// com a tipagem correta
auto par = make_pair(23, 22); // o tipo deduzido ser pair<int, int>
// comparao: o pair tem tanto operador <, tanto operador > bem
definidos
(x, y) < (a, b) SE E SOMENTE SE x < a OU (x == a E y < b)
(x, y) > (a, b) SE E SOMENTE SE x > a OU (x == a E y > b)
//
pair<int, int> P1 = {10, {12, 5}};
pair<int, int> P2 = {10, {13, 5}};
if(P1 > P2){
cout << "P1 ganha" << "\n";
}else if(P2 > P1){
cout << "P2 ganha" << "\n";
} else{
cout << "EMPATE" << endl;
}
// pode comumente ser usado para facilitar o trabalho em problemas de
ordenauo
// ordenar por medalhas de ouro, prata e bronze, nesta ordem, EX:
vector< pair<int, pair<int, int>> > vetor;
/* ordena vetor */

// caso os nomes dos tipos fiquem grandes, possivel usar o typedef

do C
typedef pair<int, pair<int, pair<int, int>>> Pais;
vector<Pais> vetor;
//////////////////////////////////////////////////////////////////////
//////////
// Containers
cont.clear(); // limpa o container
cont.size(); // retorna o tamanho do container (UNSIGNED INT, TOMAR
CUIDADO)
cont.empty(); // retorna verdadeiro/falso se o container estiver
vazio/nao vazio
//vector<int>::iterator it;
//////////////////////////////////////////////////////////////////////
//////////
// Vectors
// semelhante aos arrays do C, mas com caractersticas dinamicas
// Construtor: vector<TIPO> vetor;
vector<int> vetor;
vector<int> vetor(n); // constroi um vetor com n posicoes
vector<int> vetor(n, 10);
vector<int> vetor = {1, 2, 3};
vetor.push_back(10);
(aumenta o tamanho em
vetor.pop_back();
tamanho em 1)
vetor.back();
vetor.front();
vetor[i];
indexed).

// insere o inteiro 10 no final do vetor

1)
// remove o ultimo elemento do vetor (diminui o
// retorna o ultimo elemento do vetor
// retorna o primeiro elemento do vetor
// acessa o i-simo elemento do vetor (0//

pode ser usado para atribuir um valor

tambm.
vetor.insert(iter, 5);
iter no vetor
vetor.erase(iter);
vetor.erase(iter1, iter2);
iter2

// LENTO! insere 5 *ANTES* do elemento

// LENTO! apaga iter
// LENTO! apaga elementos entre iter1 e

sort(vetor.begin(), vetor.end()); // operador < (menor que)

reverse(vetor.begin(), vetor.end());
//////////////////////////////////////////////////////////////////////
///////////
// Strings
string str; // inicializa uma string vazia
string str = "cpp11"; // inicializa uma string a partir de uma string
constante do C
string str(string_do_C_convencional); // converte uma string do C para
uma string do C++
// e a retorna, sem modific-la
//
func(string(string_do_C));
str += 'x'; // adiciona o caractere x ao fim da string (resultado:
cpp11x)

str += "lalala"; // adiciona lalala ao fim da string (resultado:

cpp11xlalala)
str + outra_str; // concatena duas strings e retorna o resultado (sem
modific-las)
str.c_str();
stoi(str); // equivalente ao atoi do C
to_string(10); // converte um valor numerico para o equivalente em
string
str.find("lala"); // retorna a posio da primeira ocorrncia de
lalala
str.substr(1, 3); // retorna a substring que comea na posio 1 de
str e tem tamanho 3
// (resultado: pp1)
//
//////////////////////////////////////////////////////////////////////
/////
// Sets: mantm conjuntos ordenados de acordo com um operador de
ordenao
// Construtor: set<TIPO, operador_ordenacao> st;
// DEFINICAO: K = custo para comparar dois elementos do tipo TIPO
// DEFINICAO: n = tamanho do conjunto
//
set<int> st;
// por padro, usa o operador less<TIPO>
set<int, less<int>> st2;
set<int, greater<int>> st3;
st.insert(5); //
//
st.erase(5); //
st.count(5); //
st.find(5);
//

insere o elemento 5 no conjunto, em O(logn * K)

nao tem efeito se o elemento ja existir
remove o elemento 5
retorna 1 caso 5 esteja no conjunto, 0 caso contrrio
retorna um iterator pro elemento 5

st.upper_bound(5);
st.lower_bound(5);
*st.begin();

// espcie de busca binria,

// conversaremos mais tarde sobre isso :)
// retorna o primeiro elemento do conjunto
// depende do operador de ordenao

//////////////////////////////////////////////////////////////////////
///
// Maps: semelhante ao set, mas mantm pares (chave, valor)
// Os elementos so ordenados da mesma forma, mas somente com base na
chave
// Construtor: map<TIPO_CHAVE, TIPO_VALOR, operador_ordenacao> mapa;
map<string, int> st;

st["LALA"];

// mapeia strings para inteiros

// os elementos so ordenados alfabeticamente
// de acordo com as chaves

// retorna o valor de LALA

// caso o elemento no exista, ele criado com valor
// padro. 0, no caso de inteiros. o valor retornado

st["LALA"] = 7;
// atribui o valor 7 a chave LALA
st["LALA"]++;
// agora se tornou 8
cout << st["LALA"] << endl; // imprime 8

st["AABB"] = 3;

// note que agora os elementos do mapa so

// [("AABB", 3) , ("LALA", 8)], nesta ordem

st.erase("LALA"); // apaga o elemento de chave LALA

st.count("LALA");
for(pair<string, int> par : st){
cout << par.first << " " << par.second << endl;
// imprime em linhas distintas os pares "CHAVE VALOR" do map
}
///////////////////////////////////////////////////////////////////
// Filas
// ////////////////////////////////////////////////////////////////
queue<int> q;
q.push(10); // adiciona 10 no fundo da fila
q.push(5);
q.front(); // retorna 10 da frente da fila
q.pop();
// remove 10 da frente da fila
///////////////////////////////////////////////////////////////////
// Stacks
// ////////////////////////////////////////////////////////////////
stack<int> st;
st.push(10); // adiciona no topo da pilha
st.top();
// checa o topo da pilha
st.pop();
// remove do topo da pilha