mylab

POO, conceitos (cap 2)

Operadores de saída e entrada:
Operador de saída: << Operador de entrada: >>

podemos usar o namespace para organizar ou evitar conflitos, inclusive podemos criar o nosso próprio exemplo:
namespace exemplo {
// definições de funções, variáveis,
// classes, etc.
}

e para evitar o uso dos operadores :: aquando da biblitoeca iostream
std::cout
faz-se:
using namespace std;

Bibliotecas a usar:
#include <iostream>
#include <string>

Cast: conversão explícita de tipo:
static_cast, de ponteiros do tipo void* para ponteiros de outros tipos
exemplo:
double d = 0.0;
int x = d;
x = static_cast(d);

const_cast,
reinterpret_cast,
dynamic_cast, Converte um ponteiro para um uma classe, num ponteiro para uma classe derivada, derivada da derivada
auto, o compilador determina automaticamente o tipo de uma variável
exemplo:
double val1 = 1;
double val2 = 2;
auto x = val1 + val2;

Ciclo for range-based, para quando todos os elementos de uma colecção (array, vector, …) devem ser processados
for(auto & elemento: tabela)
exemplo:
int a[10];
for(auto & elemento: a){
elemento = 4;
}

A constante nullptr em C++11, A constante nullptr pode ser usada para inicializar ponteiros nulos.

Referências,pode:
ser passada a uma função
ser retornada por uma função
ser criada de forma independente.

Ponteiro como parâmetro de uma função
exemplo:
void f(int *n);

int main() {
int i = 0;
f(&i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}

void f(int *n) {
*n = 100;
}

Referência como parâmetro de uma função
exemplo:
void f(int & n);

int main() {
int i = 0;
f(i);
cout << “\nNovo valor de i:” << i << endl;
return 0;
}
void f(int & n) {
n = 100;
}

Referência como retorno de uma função
exemplo:
int & f( );
int x = 0; //tem que ser global
int main( ){
f( ) = 100;
cout << x << endl;
return 0;
}
int & f( ){
return x;
}

Constantes, uma constante deve ser inicializada, já que não é possível fazer-lhe atribuições.
A palavra const antes do * impede qualquer alteração ao objecto apontado através do ponteiro em causa
A palavra const depois do * torna constante o ponteiro.
A palavra const antes e depois do * torna impossivel alterar o objeto apontado

Quando usar: quando uma função nao deve alterar uma variavel

Parâmetros do tipo referência para constante
_ganhar eficiencia de passar a referência ao invés do valor

exemplo conclusão

#include <iostream>

void t(int*) {}

void u(const int* cip) {
//*cip = 2; // ERRO: modifica valor
int i = *cip; // OK: copia valor
//int* ip2 = cip; // ERRO: ip2 nao é pont. para const
}

const char* v() {
// Retorna o endereço de uma string: 
return "result of function v()";
}


void main()
{
int x = 0;
int* ip = &x;
const int* cip = &x;
t(ip);
//t(cip);//Erro:t() nao pode receber ponteiro para constante
u(ip);  // OK u() pode receber ponteiro sem restricoes
u(cip); // OK u() pode receber ponteiro para constante 
//char* cp = v(); // Erro: nao deve ser possivel alterar 
// a string retornada por v() 
const char* ccp = v(); // OK 
system("pause");
}

faltou:
referências a lvalue e rvalue