Day: September 14, 2020

estudar1920 – as heranças simples, em c++

As heranças “simples”, herança única, tem como precipícios que a classe que for derivada herda:
se o acesso for private: herda os membros públicos e protegidos como privados;
se o acesso for protected: herda os membros públicos e protegidos como protegidos;
se o acesso for public: herda exatamente os mesmos níveis de proteção dos membros da classe-base;

exemplo:

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros, velocidade;
public:
	Veiculo();
	~Veiculo();

	int getPassageiros();
	void setPassageiros(int p);
	int getVelocidade();
	void setVelocidade(int v);

	void Imprime();
};
Veiculo::Veiculo()
{
	
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor do veiculo com velocidade " << getVelocidade() << endl;
	passageiros = NULL;
	velocidade = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::setVelocidade(int v)
{
	velocidade = v;
}

int Veiculo::getVelocidade()
{
	return velocidade;
}

void Veiculo::Imprime()
{
	cout << "\nImprime do Veiculo com velocidade " << getVelocidade() << endl;
}

//as heranças
class Automovel : public Veiculo
{
private:
	string tipo;
public:
	Automovel();
	~Automovel();
	void setTipo(string s);
	string getTipo();

	void Imprime();
};

Automovel::Automovel()
{
	
}

Automovel::~Automovel()
{
	cout << "\ndestrutor do automovel com velocidade: " << getVelocidade() <<endl;
	tipo = "";
}

void Automovel::setTipo(string s)
{
	tipo = s;
}

string Automovel::getTipo()
{
	return tipo;
}

void Automovel::Imprime()
{
	cout << "\nImprime do Automovel com velocidade: " << getVelocidade() << endl;
}


class Comboio : public Veiculo
{
private:
	int carruagens;
public:
	Comboio();
	~Comboio();
	void setCarruagens(int c);
	int getCarruagens();
	void Imprime();
};

Comboio::Comboio()
{
	
}

void Comboio::setCarruagens(int c)
{
	carruagens = c;
}

int Comboio::getCarruagens()
{
	return carruagens;
}

Comboio::~Comboio()
{
	cout << "\ndestrutor do comboio com velocidade " << getVelocidade() << endl;
}

void Comboio::Imprime()
{
	cout << "\nImprime do Comboio com velocidade " << getVelocidade() << endl;
}

int main()
{
	Veiculo vei1;
	vei1.Imprime();

	Automovel auto1, auto2;
	auto1.setTipo("renault");
	auto1.setVelocidade(120);
	auto1.setPassageiros(4);
	auto1.Imprime();

	Comboio comb1;
	comb1.setCarruagens(4);
	comb1.setVelocidade(220);
	comb1.Imprime();

	return 0;
}
Tags : , ,

c++, introdução

introdução:
A programação é orientada não pela decomposição de tarefas mas pela identificação das entidades que constituem o problema e como são modelizadas e manipuladas;
Uma entidade é uma coisa do mundo real:
_É descrita por dados
_É manipulada por funções
Vai-se juntar esses dados e essas funções num novo tipo de dados que representa a entidade do mundo real

Uma classe representa a especificação do novo tipo de dados que representa a entidade.
Definida por:
_Dados
_Funções
Essas funções só possam ser aplicadas a esses dados
Esses dados só podem ser manipulados por essas funções
Um objecto é uma variável (instância) de uma classe

Os objectos (classes) assumem o papel principal do planeamento do programa: pensasse o problema em termos de diversos objectos e da forma como se relacionam entre si.
Que classes/objectos vão existir (quais as entidades que existem no problema a resolver ?)
Que dados descrevem esses objectos?
Quais as operações que esses objectos permitem e/ou oferecem?
Quais as relações existentes entre os vários objectos/classes?

A programação orientada a objectos utiliza os mecanismos de:
encapsulamento
herança
polimorfismo

#Encapsulamento
Dados e código que manipula esses dados são reunidos dentro da mesma entidade (classe), formando uma unidade íntegra e indivisível, autónoma em termos de dados e funcionalidade, que vai funcionar como um bloco de construção do programa.
Utilizam-se mecanismos de acesso que regulam quais os dados e funcionalidade que ficam visíveis (acessíveis) ao resto do programa) que protegem os dados de interferência exterior e de má utilização
Cada objecto vai então ser uma entidade autónoma, capaz de cuidar de si própria, com toda a funcionalidade necessária dentro de si e protegida do resto do programa
O resto do programa apenas sabe como se utiliza e não precisa de saber os pormenores internos de implementação
O programa fica mais simples e mais robusto.
Cada objecto age como uma caixa negra: “funciona e pronto” – é só usar.

#Herança
A herança é o processo pelo qual um tipo de dados pode herdar as propriedades de outro e ter ainda as suas propriedades específicas e sem ter que repetir código.
Torna possível uma classificação hierárquica.

#Polimorfismo
O polimorfismo um mecanismo/propriedade que permite manipular dados diferentes por aquilo que têm de comum, sem necessidade de repetir código nem estruturas de dados.
Age através do mecanismo de herança e, sintacticamente, utiliza o nome da classe base.
O mesmo interface (molde) pode usar-se para especificar diversas acções com significado análogo.

Tags : , , , ,

estudar1920 – as heranças múltipla e a superclasse, em c++

Uma classe pode herdar múltiplos membros de várias classes e uma classe derivada por também ser uma superclasse, havendo uma árvore de derivação

exemplo de superclasse (veiculo<-autocarro<-minicoisa):

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros;
public:
	Veiculo();
	~Veiculo();

	void setPassageiros(int p);
	int getPassageiros();
	
	void imprime();
};

Veiculo::Veiculo()
{
	cout << "\nconstrutor de veiculo " << getPassageiros() << endl;
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor de veiculo " << getPassageiros() << endl;
	passageiros = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::imprime()
{
	cout << "\nsou o veiculo " << getPassageiros() << endl;
}

class Autocarro : public Veiculo
{
private:
	int portas;
public:
	Autocarro();
	~Autocarro();
	void setPortas(int p);
	int getPortas();

	void imprime();
};

Autocarro::Autocarro()
{
	cout << "\nconstrutor de autocarro " << getPortas() << endl;
}

Autocarro::~Autocarro()
{
	cout << "\ndestrutor de autocarro " << getPortas() << endl;
	portas = NULL;
}

void Autocarro::setPortas(int p)
{
	portas = p;
}

int Autocarro::getPortas()
{
	return portas;
}

void Autocarro::imprime()
{
	cout << "\sou o autocarro " << getPortas() << endl;
}

class MiniCoisa: public Autocarro
{
private:
	int rodinhas;
public:
	MiniCoisa();
	~MiniCoisa();
	void setRodinhas(int r);
	int getRodinhas();

	void imprimir();
};

MiniCoisa::MiniCoisa()
{
	cout << "\nconstrutor de minicoisa " << getRodinhas() << endl;
}

MiniCoisa::~MiniCoisa()
{
	cout << "\ndestrutor de rodinhas " << getRodinhas() << endl;
	rodinhas = NULL;
}

void MiniCoisa::setRodinhas(int r)
{
	rodinhas = r;
}

int MiniCoisa::getRodinhas()
{
	return rodinhas;
}

void MiniCoisa::imprimir()
{
	cout << "\nsou o rodinhas " << getRodinhas() << endl;
}

int main()
{
	Veiculo vei1;
	vei1.imprime();

	Autocarro auto1;
	auto1.setPortas(3);
	auto1.imprime();

	MiniCoisa min1;
	min1.setRodinhas(5);
	min1.imprimir();

	return 0;
}

exemplo de herdar de multiplas classes (minicoisa de veiculo E minicoisa de autocarro):

#include <iostream>

using namespace std;

class Veiculo
{
private:
	int passageiros;
public:
	Veiculo();
	~Veiculo();

	void setPassageiros(int p);
	int getPassageiros();

	void imprime();
};

Veiculo::Veiculo()
{
	cout << "\nconstrutor de veiculo " << getPassageiros() << endl;
}

Veiculo::~Veiculo()
{
	cout << "\ndestrutor de veiculo " << getPassageiros() << endl;
	passageiros = NULL;
}

void Veiculo::setPassageiros(int p)
{
	passageiros = p;
}

int Veiculo::getPassageiros()
{
	return passageiros;
}

void Veiculo::imprime()
{
	cout << "\nsou o veiculo " << getPassageiros() << endl;
}

class Autocarro
{
private:
	int portas;
public:
	Autocarro();
	~Autocarro();
	void setPortas(int p);
	int getPortas();

	void imprime();
};

Autocarro::Autocarro()
{
	cout << "\nconstrutor de autocarro " << getPortas() << endl;
}

Autocarro::~Autocarro()
{
	cout << "\ndestrutor de autocarro " << getPortas() << endl;
	portas = NULL;
}

void Autocarro::setPortas(int p)
{
	portas = p;
}

int Autocarro::getPortas()
{
	return portas;
}

void Autocarro::imprime()
{
	cout << "\sou o autocarro " << getPortas() << endl;
}

class MiniCoisa : public Autocarro, public Veiculo
{
private:
	int rodinhas;
public:
	MiniCoisa();
	~MiniCoisa();
	void setRodinhas(int r);
	int getRodinhas();

	void imprimir();
};

MiniCoisa::MiniCoisa()
{
	cout << "\nconstrutor de minicoisa " << getRodinhas() << endl;
}

MiniCoisa::~MiniCoisa()
{
	cout << "\ndestrutor de rodinhas " << getRodinhas() << endl;
	rodinhas = NULL;
}

void MiniCoisa::setRodinhas(int r)
{
	rodinhas = r;
}

int MiniCoisa::getRodinhas()
{
	return rodinhas;
}

void MiniCoisa::imprimir()
{
	cout << "\nsou o rodinhas " << getRodinhas() << endl;
}

int main()
{
	MiniCoisa min1;
	min1.setRodinhas(10);
	min1.setPassageiros(4);
	min1.setPortas(2);
	min1.imprimir();

	return 0;
}
Tags : , ,

estudar1920 – o polimorfismo, em c++

O polimorfismo, permite que objectos tenham a capacidade de ter variados comportamentos em função das suas particularidades e ambientes onde estão inseridos. Para isso é necessário usar métodos virtuais e classes abstractas.
Os ponteiros ou apontadores são endereços de memória que permitem armazenar endereços de memória de outras variáveis ou de objectos
Um ponteiro quando declarado faz uso do operador unário de indirecção (*), exemplo: int * curso; // int é o tipo de dados, e curso é o nome do ponteiro para a variável
Para se aceder ao endereço de memória tem que se faz usando o operador de leitura de endereços (&), por exemplo: curso = &casa; // em que curso é o ponteiro que foi previamente declarado, e &casa é o nome do endereço que vai ser assumido de memória variável;

exemplo:

#include <iostream>

using namespace std;

int main()
{
	int comida = 20;
	int * aponta;
	aponta = &comida;
	cout << "vou mostrar: " << *aponta << endl;

	return 0;
}

os ponteiros também podem ser usados para objectos, e neste caso a sua declaração tem que ser feita por exemplo: Corrida *apontar; //Corrida é o nome da classe, e apontar é o nome do ponteiro.
Não esquecer que para se aceder a essa zona da memória é necessário primeiro indicar que o ponteiro está a olhar para a respectiva classe: apontar = &casa; //apontar, é o nome do ponteiro, e casa é a instância da classe
para se aceder aos membros apontados deve fazer-se uso do operador de referência (->) e não o operador (.)
exemplo de ponteiros para objectos:

#include <iostream>

using namespace std;

class Carro
{
private:
	int velocidade;
public:
	Carro();
	~Carro();
	void setVelocidade(int v);
	int getVelocidade();
	void imprimir();
};

Carro::Carro()
{
	cout << "\nconstrutor do carro" << getVelocidade() << endl;
}

Carro::~Carro()
{
	cout << "\ndestrutor do carro " << getVelocidade() << endl;
}

void Carro::setVelocidade(int v)
{
	velocidade = v;
}

int Carro::getVelocidade()
{
	return velocidade;
}

void Carro::imprimir()
{
	cout << "\nacerca do carro " << getVelocidade() << endl; } int main() { Carro car1; car1.setVelocidade(100); Carro * aponta; aponta = &car1; aponta->imprimir();

	aponta->setVelocidade(10);
	car1.imprimir();
	
	return 0;
}

Existe também uma palavra chave que é o this
O this é um atalho que permite apontar para a classe actual, e é útil para se referir a membros dessa classe.
exemplo:

#include <iostream>

using namespace std;

class Carro
{
private:
	int velocidade;
public:
	Carro();
	~Carro();
	void setVelocidade(int v);
	int getVelocidade();
	bool compararVelocidade(Carro car);
	void imprimir();
};

Carro::Carro()
{
	cout << "\nconstrutor do carro" << getVelocidade() << endl;
}

Carro::~Carro()
{
	cout << "\ndestrutor do carro " << getVelocidade() << endl; } void Carro::setVelocidade(int v) { velocidade = v; } int Carro::getVelocidade() { return velocidade; } bool Carro::compararVelocidade(Carro car) { return this->getVelocidade() > car.getVelocidade();
}

void Carro::imprimir()
{
	cout << "\nacerca do carro " << getVelocidade() << endl;
}

int main()
{
	Carro car1, car2;
	car1.setVelocidade(10);
	car2.setVelocidade(20);
	if(car1.compararVelocidade(car2))
	{
		cout << "\ncar1 > car2" << endl;
	}else
	{
		cout << "\ncar1 < car2" << endl;
	}
	
	return 0;
}

Existem também os métodos virtuais. Um método virtual é declarado numa classe base, mas é implementado nas classes que derivam. Esta virtualização vai permitir que as classes derivadas façam uso desse método mas variando o seu comportamento.
Os métodos virtuais têm que ser declarados na secção pública de uma classe base

 

Tags : , ,

c++, Características Gerais de C++

Acerca de:
Operadores de saída e entrada
Um programa em C++
namespace std
Comentários
Funções sem parâmetros
Definição de variáveis locais
Tipos de dados
Enumerações unscoped vs. scoped (C++11)
Cast: conversão explícita de tipo
Dedução de tipo: auto (C++11)
Ciclo for range-based (C++11)
A constante nullptr (C++11)
Referências
Constantes
Ponteiros e constantes
Referências lvalue/rvalue (C++11)

#Namespace
namespace- define uma região declarativa para identificadores (tipos, funções, variáveis, …)
namespaces são usados para:
_Organizar o código em contextos lógicos
_Evitar o conflito de nomes

using namespace std; //disponibiliza os identificadores definidos no namespace std sem o prefixo std

#Tipos de dados
wchar_t:
É uma extensão do tipo básico char para caracteres que exigem uma representação mais ampla, como os caracteres unicode.

#Enumerações

Tags : , , ,