mylab

POO, conceitos (cap 4)

as Classes:

#estruturas com funções membros
as funções que são declaradas como membros de uma estrutura são as funções membro
uma função membro sabe sempre para que objecto foi invocada
os membros privados só podem ser “trancados” se estes forem declarados como private, e desta forma apenas as funções membro conseguem aceder a eles
por omissão os membros de uma classe são privados, já se fosse os membros de uma estrutura são públicos.
qualquer função membro (nao estática) consegue aceder aos membros da classe sem referência explicita do objecto

acessibilidade:
se as funções membros forem as únicas a ter acesso directo à informação, então essas informações são membros privados
mantendo as funções membros como publicas, dentro da estrutura ou classe
as funções membros podem aceder a membros públicos ou privados, dentro da estrutura ou classe

para a aceder a um método de uma classe faz-se uso do operador ::

#construtores
serve para inicializar os objectos de uma classe
um construtor de uma classe pode ter parâmetros que podem representar os valores iniciais

#construtores overloaded
podemos ter vários construtores para especificar várias maneiras de inicializar objetos.
a escolha do construtor depende do dos argumentos que forem especificados
pode existir o construtor por omissão, será aquele que não tem especificado qualquer argumento

#construtores com parâmetros com valores por omissão
este tipo de construtor é também um construtor por omissão , pois pode ser chamado sem a especificação de argumentos

#destrutor
quando o objeto deixa de existir, os recursos devem ser libertados, usando destrutores, que são automaticamente invocados
a destruição dos objectos é feita da seguinte forma:
_objectos locais não estáticos são destruídos quando a execução do programa sai do bloco onde foram declarados
_objectos globais, são destruídos quando o programa termina
_objectos dinâmicos são destruídos recorrendo ao operador delete

#funções inline
são todas as funções que são funções membro de uma classe e que estejam definidas na classe
normalmente são funções pequenas e que são muitas vezes utilizadas

#membros variáveis estáticos (static)
é partilhado para todos os objectos de uma classe
existe apenas uma única existência de um e um só membro estático pelos objectos da classe
os não estáticos existe apenas uma existência por objectos
são definidos fora da classe, e pode ser inicializado

#funções estáticas (static)
têm acesso apenas aos membros estáticos (variáveis ou funções)
funções não estáticas tem acesso a todos os membros (estáticos ou não estáticos)
o acesso a um membro estático publico:
a.membro ou a.funçãoMembro()

o acesso a um membro estático publico sem referencia de objeto:
Disciplina::membro
Disciplina::funçãoMembro()

#funções membros constantes
o uso de const no fim do prototipo das funções indica que estas nao alteram os membros
se uma função membro tem const no final do prototipo também tem que aparecer const
as funções membros constantes podem ser invocadas para objectos constantes e nao constantes
as funções membros não constantes só podem ser invocadas para objectos não constantes

#funções friend
uma função friend relacionada com uma classe tem acesso aos seus membros privados não sendo mesmo membro dessa classe
a palavra friend surge antes do prototipo

#construtores com lista de inicialização
Disciplina():x(i), y(i){…
..
}

existem situações em que não é possivel inicializar membros variáveis dentro do construtor, tendo que se usar uma lista de inicialização
se forem membros constantes, têm que ser inicializados na lista de inicialização
se forem membros referencia, têm que ser inicializados na lista de inicialização

#Membros variáveis inicializados na declaração
é possivel inicializar os membros variáveis da classe aquando da declaração

#Membros default e delete
o uso da especificação default serve para indicar qual o construtor a ser utilizado (por omissão)
o uso da especificação delete serve para tornar indisponível a sua implementação

POO, conceitos (cap 3)

#funções overloaded, são funções com o mesmo nome se:
tiverem diferentes tipos de argumentos
tiverem diferentes números de argumentos
tiverem diferentes tipos e números de argumentos

#funções com argumentos por omissão:
deve ser feito na declaração da função usando o =

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