mylab

excepções e vários

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

void funcao()
{
	double dX = -23.99;
	cout << "se funcao : antes excepcao " << endl;
	//se não houver excepções corre tudo bem
	//throw - 1; //sai aqui em estado de erro, lançada a execpção que não é tratata
	//ou
	//throw "um texto que e erro..";//sai aqui em estado de erro, lançada a execpção que não é tratata
	//ou
	//throw dX; //sai aqui em estado de erro, lançada a execpção que não é tratata
	cout << "se funcao : depois excepcao " << endl;
}

int main()
{
	cout << "\n inicio do main" << endl;
	funcao();
	cout << "\n fim do main" << endl;
	return 0;
}

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class minhaExcepcao
{
	const char* const descricao;
public:
	minhaExcepcao(const char * const msg =0):descricao(msg){}
};


void funcao2()
{
	double dX = -23.99;
	cout << "se funcao : antes excepcao " << endl;
	//esta versão também não adianta..
	throw minhaExcepcao("algo aconteceu");
		
	cout << "se funcao : depois excepcao " << endl;
}

int main()
{
	cout << "\n inicio do main" << endl;
	funcao2();
	cout << "\n fim do main" << endl;
	return 0;
}

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class Erro
{
	
};

void funcao3()
{
	cout << "se funcao : antes excepcao " << endl;
	try
	{
		//criação artifical de um erro de uma excepção com o uso do throw
		//ou
		//sendo executado o primeiro thorw e interrompe este try
		throw -1;
		//ou
		throw "primeira linha de comentario";
		//ou
		throw Erro(); //esta excepção não é tratada num catch, logo termina em erro, mesmo com a class estabelecida
		//ou
		//se nao for lançada nenhuma excepção então tbm não vai ser executado nenhum catch, e é porque está tudo bem
	}
	catch (int x)
	{
		//e é sempre executado no máximo um catch
		cerr << "apanho o valor int da excepcao: " << x << endl;
	}catch(const char * s)
	{
		cerr << "apanho o valor char da excepcao: " << s << endl;
	}
	cout << "se funcao : depois excepcao " << endl;
}

int main()
{
	cout << "\n inicio do main" << endl;
	funcao3();
	cout << "\n fim do main" << endl;
	return 0;
}

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;


int main()
{
	cout << "\n inicio do main" << endl;
	try
	{
		throw - 1;
	}
	catch (int x)
	{
		//e é sempre executado no máximo um catch
		cerr << "apanho o valor int da excepcao: " << x << endl;
	}
	catch (double)
	{
		cerr << "apanho o valor double da excepcao: "<< endl;
	}
	catch (const string & str)
	{
		cerr << "apanho o valor string da excepcao: " << str << endl;
	}
	cout << "\n fim do main" << endl;
	return 0;
}

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;
class denominadorNull
{
public:
	string sobre()
	{
		return string("denominador nulo\n");
	}
};

class foraDosLimites
{
public:
	string sobre()
	{
		return string("fora dos limites\n");
	}
};

double divisao(int numerador, int denominador)
{
	if(!denominador)
	{
		throw denominadorNull();
	}
	return static_cast<double>(numerador) / denominador;
}

int main()
{
	cout << "\n inicio do main" << endl;
	int a[4] = { 10,11,12,13 };
	int index = 1, d;
	while(index >=0)
	{
		cout << "qual o index: ";
		cin >> index;
		cout << "qual o denominador: ";
		cin >> d;
		try
		{
			//ou
			//throw "aaa";
			//ou
			if (index < 0 || index >= 4) throw foraDosLimites(); //e interrompe, não foi resolvido nao existe um catch
			//se correr bem continuo
			cout << "resultado: " << divisao(a[index], d) << endl;
		}
		catch (denominadorNull & dn)
		{
			cerr << dn.sobre(); //depois disto considera-se resolvido
		}
		catch(foraDosLimites & fl)
		{
			cerr << fl.sobre(); //depois disto considera-se resolvido
		}
		catch (...) //apanha todos os outros erros
		{
			cerr << "qualquer outro erro\n"; //depois disto considera-se resolvido
		}
	}
	return 0;
}

………..varios, exercicios excepções (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class baseErro
{
public:
	virtual void oque()
	{
		cout << "baseErro" << endl;
	}
};


class derivadaErro : public baseErro
{
public:
	virtual void oque()
	{
		cout << "derivadaErro" << endl;
	}
};

void funcao6()
{
	throw derivadaErro();
}

int main()
{
	try
	{
		funcao6();
	}
	catch (baseErro b) //não é usada a derivada mas sim a base, 
		//não existe neste caso o polimorfismo
	{
		b.oque();
	}
	try {
		funcao6();
	}
	catch (baseErro & b) //convem passar por referencia para existir o polimorfismo
		//porque é passado por referencia, surgre assim o erro da derivada
		//e para que não se faça mais uma copia da excepção que foi lançada
	{
		b.oque();
	}
	return 0;
}

………..varios, exame1920_epocanormal (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class Bilhete
{
	string passageiro;
	int passaporte;
	string & companhia; //obrigatoria ser na lista de inicialização, se for & e const
	vector<int> id_malas;

	//Acrescentar bagagens ao bilhete (representadas pelos seus ID e sem repetir):
	int pesquisa(int id)const;
	
public:
	//ou 1
	//Bilhete(string passageiro0, int passaporte0, string & companhia0, vector<int> id_malas0);
	//ou 2
	Bilhete(string passageiro0, int passaporte0, string& companhia0, initializer_list<int> id_malas0);


	//lidar com a atribuir objectos b1=b2
	Bilhete& operator=(const Bilhete& ob);

	//Acrescentar bagagens ao bilhete (representadas pelos seus ID e sem repetir):
	//operador que pode ser membro
	Bilhete& operator <<(int id); //por estar em cadeia
	//ou
	//void operator <<(int id); //se não estivesse em cadeia

	//Remover todas as bagagens com id superior a um indicado): 
	Bilhete& operator -=(int id); //por estar em cadeia
	
	//extra
	string getAsAstring()const;
};
//Mostrar o conteúdo no ecrã da forma (bilhete1 e bilhete2 são objetos da classe Bilhete): 
ostream& operator<<(ostream& saida, const Bilhete & ob);


//Acrescentar bagagens ao bilhete (representadas pelos seus ID e sem repetir):
int Bilhete::pesquisa(int id) const
{
	for(unsigned int i = 0; i< id_malas.size(); i++)
	{
		if(id == id_malas[i])
		{
			return i;
		}
	}
	return -1;
}

//Acrescentar bagagens ao bilhete (representadas pelos seus ID e sem repetir):
Bilhete& Bilhete::operator<<(int id)
{
	int pos = pesquisa(id);
	if(pos == -1)
	{
		//não está lá o id
		id_malas.push_back(id);
	}
	//senão não faço nada
	return  *this; // pedido em cadeia, o retorno é *this
}

//Remover todas as bagagens com id superior a um indicado): 
Bilhete& Bilhete::operator-=(int id)
{
	for(auto it= id_malas.begin(); it != id_malas.end(); )
	{
		if(*it >id)
		{
			it = id_malas.erase(it);
		}else
		{
			++it;
		}
	}
	return *this;
}

//ou
//void Bilhete::operator<<(int id) //se não estivesse em cadeia

//ou 1
//Bilhete::Bilhete(string passageiro0, int passaporte0, string& companhia0, vector<int> id_malas0) : passageiro(passageiro),
//passaporte(passaporte),
//companhia(companhia),
//id_malas(id_malas)
//{
//}
//ou 2, versão "mais complicada"
Bilhete::Bilhete(string passageiro0, int passaporte0, string& companhia0, initializer_list<int> id_malas0) : passageiro(passageiro0),
passaporte(passaporte0),
companhia(companhia0)
{
	//para lidar com o initializer_list
	for(auto & m : id_malas0)
	{
		id_malas.push_back(m);
	}
}

//lidar com a atribuir objectos
Bilhete& Bilhete::operator=(const Bilhete& ob)
{
	//evitar autoatribuição
	if(this == &ob)
	{
		return  *this;
	}
	//pode-se atribuir tudo menos a companhia, i.e. referencias e const
	passageiro = ob.passageiro;
	passaporte = ob.passaporte;
	id_malas = ob.id_malas;
	return *this;
}



//extra
string Bilhete::getAsAstring() const
{
	ostringstream oss;

	oss << "Passageiro: " << passageiro << " Passaporte: " << passaporte << " Companinha: " << companhia << "mala:" << endl;
	for (int i : id_malas)
	{
		oss << " " << i;
	}
	oss << endl;
	return oss.str();
}

//Mostrar o conteúdo no ecrã da forma (bilhete1 e bilhete2 são objetos da classe Bilhete): 
ostream& operator<<(ostream& saida, const Bilhete& ob)
{
	saida << ob.getAsAstring();
	return saida;
}


int main()
{
	//alinea 6.
	//string & companhia;  exige uma variavel
	string aux_nome("tap");
	//ou 1 ou 2
	Bilhete b1("nome Passageiro", 123, aux_nome, {1,2,3,4}); //{1,2,3,4} com initializer_list
	cout <<b1.getAsAstring(); 
	//para atribuir objectos
	string aux_nome2("fly");
	Bilhete b2("outro Passageiro",456, aux_nome2, {5,6,7,8}); 
	cout << b2.getAsAstring();

	//atribuir objectos b1 = b2
	//não é possivel por existe objectos com membros objectos com referencia (&) ou const
	//assim b1=b2 dá erro, é a atribuição default
	//solução: operador atribuição e operator
	b1 = b2;
	cout << b1.getAsAstring();

	//Mostrar o conteúdo no ecrã da forma (bilhete1 e bilhete2 são objetos da classe Bilhete): 
	cout << "\nPassageiro 1 : " << b1 << "\nPassageiro 2" << b2;

	//Acrescentar bagagens ao bilhete (representadas pelos seus ID e sem repetir):
	b1 << 123 << 789 << 123;
	cout << "\nPassageiro 1 acrescentou: " << b1;

	//Remover todas as bagagens com id superior a um indicado):
	(b1 -= 40) -= 35;
	cout << "\nPassageiro 1 removeu: " << b1;
	
	cout << "\nfim do main" << endl;
	return 0;
}

………..varios, exame1920_epocanormal (a25)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;
//antes
/*
class Doutor {
	string nome;
public:
	Doutor(const string& n) :nome(n) {}
	string getNome()const { return nome; }
};
class Engenheiro {
	string nome;
public:
	Engenheiro(const string& n) :nome(n) {}
	string getNome()const { return nome; }
};

class Empresa {
	vector<Doutor> doutores;
	vector<Engenheiro> engenheiros;
public:
	Empresa() {
		doutores.push_back(Doutor("D1"));
		doutores.push_back(Doutor("D2"));
		engenheiros.push_back(Engenheiro("E1"));
		engenheiros.push_back(Engenheiro("E2"));
	}
	void cumprimentar() {
		for (auto& d : doutores) {
			cout << "Bom dia Doutor " << d.getNome() << endl;
		}

		for (auto& e : engenheiros) {
			cout << "Bom dia Engenheiro " << e.getNome() << endl;
		}
	}
	void removeDoutor(string nome) {
		// remove o doutor com esse nome do seu vector
	}
	void removeEngenheiro(string nome) {
		// remove o engenheiro com esse nome do seu vector
	}
};
*/
//depois corrigido
//class abstracta
class Funcionario
{
	string nome;
public:
	Funcionario(string nome0) :nome(nome0){}
	virtual void cumprimentar() const = 0;
	string getNome()const
	{
		return nome;
	}
	//para funionar o destutor, construtor por copia e operador atribuição
	virtual Funcionario* duplica()const = 0;
};

class Doutor: public Funcionario
{
public:
	Doutor(const string& nome0)
		: Funcionario(nome0)
	{
	}

	void cumprimentar() const override
	{
		cout << "Bom dia Doutor " << getNome() << endl;
	}

	Funcionario* duplica() const override
	{
		return new Doutor(*this);
	}
};

class Engenheiro : public Funcionario
{
public:
	Engenheiro(const string& nome0)
		: Funcionario(nome0)
	{
	}

	void cumprimentar() const override
	{
		cout << "Bom dia Engenheiro " << getNome() << endl;
	}

	Funcionario* duplica() const override
	{
		return new Engenheiro(*this);
	}
};

class Empresa {
	vector<Funcionario*> funcionarios;
	int pesquisa(string nome) const
	{
		for (unsigned int i = 0; i < funcionarios.size(); i++)
		{
			if (nome == funcionarios[i]->getNome())
			{
				return i;
			}
		}
		return -1;
	}
public:
	Empresa() {
		funcionarios.push_back(new Doutor("D1"));
		funcionarios.push_back(new Doutor("D2"));
		funcionarios.push_back(new Engenheiro("E1"));
		funcionarios.push_back(new Engenheiro("E2"));
	}
	void cumprimentar() {
		for (auto& d : funcionarios) {
			d->cumprimentar();
		}
	}

	void removerNome(string nome0)
	{
		int pos = pesquisa(nome0);
		if(pos == -1)
		{
			return;
		}
		//existe posso exclucivsa, eliminar o objecto de mem dinamica
		delete funcionarios[pos];
		//remover o ponteiro
		funcionarios.erase(funcionarios.begin() + pos);
	}
	//e existe propriedade exclusiva da empresa
	//fazer destrutor, construtor por copia e operador atribuição e duplica (esta em funcionarions)
	~Empresa()
	{
		for(auto f: funcionarios)
		{
			delete f;
		}
	}
	//construtor por copia
	Empresa(const Empresa& ob)
	{
		*this = ob; //apenas, porque não existem ponteiros primitivos
	}
	//operador atribuição
	Empresa &operator=(const Empresa &ob)
	{
		if(this ==&ob)
		{
			return *this;
		}
		for(auto f: funcionarios)
		{
			delete f;
		}
		funcionarios.clear();
		for(auto f: ob.funcionarios)
		{
			//depois de feitos os duplicas
			funcionarios.push_back(f->duplica());
		}
		return *this;
	}
};

int main() {
	Empresa empresa;
	empresa.cumprimentar();

	Empresa empresa2 = empresa;
	empresa2.removerNome("E1");
	empresa2.removerNome("D2");
	empresa2.cumprimentar();

	cout << "\nfim do main" << endl;
	return 1;
}

herança e polimorfismo

………..ficha7, exercicio1 (a19)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;


class Imovel
{
	float preco;
	float area;
	string codigo;
	static int ordem; //para formar o codigo
//para ser usado por classes derivadas
protected: //nao deixamos o codigo exterior alterar, mas apenas as classes derivadas
	void setCodigo(const string& c);
public:
	Imovel(float p, float a);
	virtual ~Imovel();

	float getPreco() const;
	void setPreco(const float preco);
	float getArea() const;
	string getCodigo() const;
	
	static int getOrdem();

	virtual string getAsString()const;
};

ostream& operator << (ostream& saida, const Imovel& i); //operador do cout

int Imovel::ordem = 0;


void Imovel::setCodigo(const string& c)
{
	codigo = c;
}

Imovel::Imovel(float p, float a):preco(p), area(a)
{
	//ou
	//ostringstream oss;
	//oss << (++ordem);
	//codigo = oss.str();
	//ou
	codigo = to_string(++ordem);
}

Imovel::~Imovel()
{
	
}

float Imovel::getPreco() const
{
	return preco;
}

void Imovel::setPreco(const float preco)
{
	this->preco = preco;
}

float Imovel::getArea() const
{
	return area;
}


string Imovel::getCodigo() const
{
	return codigo;
}

int Imovel::getOrdem()
{
	return ordem;
}

string Imovel::getAsString() const
{
	ostringstream oss;
	oss << "  codigo: " << codigo << "\n   preco: " << preco << "\n   area " << area << endl;
	return oss.str();
}

ostream& operator<<(ostream& saida, const Imovel& i)
{
	saida << i.getAsString();
	return saida;
}

//apartamento deriva de imovel, : public .. e recebe por herança
class Apartamento : public Imovel
{

	int numeroAssoalhadas;
	int andar;

public:
	Apartamento(float area0, int andar0, int numeroAssoalhadas0);
	//getAstring é por herança
	//precisa de ser redifinida com o override
	string getAsString()const override;

};

//o construtor d euma classe derivada já manda executar o construtor da calsse base: Imovel
Apartamento::Apartamento(float area0, int andar0, int numeroAssoalhadas0):Imovel(10* area0, area0), andar(andar0),numeroAssoalhadas(numeroAssoalhadas0)
{
	setCodigo("apartamento-" + getAsString());
}

string Apartamento::getAsString() const
{
	ostringstream oss;
	//preco area -Imovel::getAsString()
	oss << "apartamento \n" << Imovel::getAsString() << " andar: " << andar << "\n n. assoalhadas: " << numeroAssoalhadas << endl;
	
	return oss.str();
}
class LojaComercial : public Imovel
{
	//nao tem membros privados
public:
	LojaComercial(float area);

	string getAsString()const override;

};

LojaComercial::LojaComercial(float area):Imovel(15*area, area) 
{
	setCodigo("lojaComercial-" + getAsString());
}

string LojaComercial::getAsString() const
{
	ostringstream oss;
	//preco area -Imovel::getAsString()
	oss << "lojaComercial \n" << Imovel::getAsString() << "   andar: R/C" << endl;

	return oss.str();
}


class Imobiliaria
{

//"não deve utilizar uma estrutura de dados para cada tipo diferente de bem imobiliário"
//não usar multiplos vectores, um para cada tipo, mas um para todos
//assim:
	vector<Imovel*> imoveis; //coleção de vários tipos de imoveis
	//um ponteiro de uma classe derivada pode apontar para a classe base, upcasting
	//relação entre imobiliaria e imoveis : agregação
	
	string nome;

	int pesquisa(string codigo)const;
public:
	Imobiliaria(string nome);


	void acrescentaImovel(Imovel* imovel); //recebemos um imovel qualquer
	//ponteiro para a base

	bool setPreco(string codigo, float preco);
	float getPreco(string codigo)const;
	bool remover(string codigo);
	
	string getAsString()const;
	string getAsString(string codgio0)const;
};

ostream& operator << (ostream& saida, const Imobiliaria& i); //operador do cout

int Imobiliaria::pesquisa(string codigo) const
{
	for(unsigned int i = 0; 0 < imoveis.size() ; i++)
	{
		if(codigo == imoveis[i]->getCodigo())
		{
			return i;
		}
	}
	return -1;
}

Imobiliaria::Imobiliaria(string nome):nome(nome)
{
}

void Imobiliaria::acrescentaImovel(Imovel* imovel)
{
	if(imovel != nullptr)
	{
		//pode surigr uma loja ou apartamento
		imoveis.push_back(imovel);
	}
}

bool Imobiliaria::setPreco(string codigo, float preco)
{
	if (preco < 0){
		return false;
	}
	int qual = pesquisa(codigo);
	if (qual == -1)
	{
		return false;
	}
	imoveis[qual]->setPreco(preco);
	return true;
}

float Imobiliaria::getPreco(string codigo) const
{
	int qual = pesquisa(codigo);
	if(qual == -1)
	{
		return 0;
	}
	return imoveis[qual]->getPreco();
}

bool Imobiliaria::remover(string codigo)
{
	int qual = pesquisa(codigo);
	if(qual == -1)
	{
		return false;
	}
	//relação de agregação faz-se apenas o erase
	imoveis.erase(imoveis.begin() + qual);
	return true;
}

string Imobiliaria::getAsString() const
{
	ostringstream oss;
	oss << "Imobiliaria " << nome << endl;
	for(unsigned int i = 0; i < imoveis.size(); i++)
	{
		oss << imoveis[i]->getAsString() << endl;
	}
	return oss.str();
}

string Imobiliaria::getAsString(string codgio0) const
{
	int qual = pesquisa(codgio0);
	if(qual == -1)
	{
		return "codigo nao existe";
	}
	return imoveis[qual]->getAsString();
}

ostream& operator<<(ostream& saida, const Imobiliaria& i)
{
	saida << i.getAsString();
	return saida;
}

//extra Interaccao
class Interaccao {
	Imobiliaria* imobiliaria; //classe que envolve toda a lógica
public:
	Interaccao(Imobiliaria* imobiliaria0);
	int escolheOpcao(vector<string> opcoes);
	int lerInt(string msg);
	float lerFloat(string msg);
	void opcaoAcrescentarApartamento();
	void opcaoAcrescentarLoja();
	void opcaoPesquisarImovelPorCodigo();
	void opcaoPesquisarPrecoDeImovelPorCodigo();
	void opcaoActualizarPrecoDeImovelPorCodigo();
	void opcaoRemoverImovelPorCodigo();
	void corre();
};

Interaccao::Interaccao(Imobiliaria* imobiliaria0) {
	imobiliaria = imobiliaria0;
}

int Interaccao::escolheOpcao(vector<string> opcoes) {
	for (unsigned int i = 0; i < opcoes.size(); i++)
		cout << endl << i << " - " << opcoes[i];

	int opcao = -1;
	do {
		opcao = lerInt("\n\nopcao > ");
	} while (opcao < 0 || opcao > opcoes.size());
	return opcao;
}
int Interaccao::lerInt(string msg) {
	int valor;
	bool leu = false;
	do {
		cout << msg;
		string s;
		cin >> s;
		istringstream iss(s);
		if (iss >> valor) // se correu bem a leitura
			leu = true;
	} while (!leu);
	return valor;
}
float Interaccao::lerFloat(string msg) {
	float valor;
	bool leu = false;
	do {
		cout << msg;
		string s;
		cin >> s;
		istringstream iss(s);
		if (iss >> valor) // se correu bem a leitura
			leu = true;
	} while (!leu);
	return valor;
}
void Interaccao::opcaoAcrescentarApartamento() {
	float area;
	int andar;
	int nAss;
	cout << "\nAcrescentar apartamento";
	area = lerFloat("   area: ");
	andar = lerInt("   andar: ");
	nAss = lerInt("   n. de assoalhadas: ");
	imobiliaria->acrescentaImovel(new Apartamento(area, andar, nAss));
}
void Interaccao::opcaoAcrescentarLoja() {
	float area;
	cout << "\nAcrescentar loja: ";
	area = lerFloat("   area: ");
	imobiliaria->acrescentaImovel(new LojaComercial(area));
}

void Interaccao::opcaoPesquisarImovelPorCodigo() {
	string codigo;
	cout << "\nPesquisar imovel por codigo\n   codigo: ";
	cin >> codigo;
	cout << imobiliaria->getAsString(codigo) << endl;
}
void Interaccao::opcaoPesquisarPrecoDeImovelPorCodigo() {
	string codigo;
	cout << "\nPesquisar preco de imovel por codigo\n   codigo: ";
	cin >> codigo;
	cout << imobiliaria->getPreco(codigo) << endl;
}
void Interaccao::opcaoActualizarPrecoDeImovelPorCodigo() {
	string codigo;
	float preco;
	cout << "\nActualizar preco de imovel por codigo\n   codigo: ";
	cin >> codigo;
	cout << imobiliaria->getAsString(codigo) << endl;
	preco = lerFloat("\n   preco: ");
	imobiliaria->setPreco(codigo, preco);
}
void Interaccao::opcaoRemoverImovelPorCodigo() {
	string codigo;
	cout << "\nRemover imovel por codigo\n   codigo: ";
	cin >> codigo;
	cout << imobiliaria->getAsString(codigo) << endl;
	cout << "\n   Remover ";
	if (imobiliaria->remover(codigo))
		cout << " removeu ";
	else cout << " nao removeu ";
}

void Interaccao::corre() {
	vector<string> opcoes;
	opcoes.push_back("Sair");
	opcoes.push_back("Listar");
	opcoes.push_back("Acrescentar apartamento");
	opcoes.push_back("Acrescentar loja");
	opcoes.push_back("Pesquisar imovel por codigo");
	opcoes.push_back("Pesquisar preco de imovel dado o codigo");
	opcoes.push_back("Actualizar o preco de um imovel dado o codigo");
	opcoes.push_back("Remover imovel dado o codigo");

	int opcao = 0;
	do {
		opcao = escolheOpcao(opcoes);
		switch (opcao) {
		case 0: cout << "\nSair\n";
			break;
		case 1: cout << *imobiliaria << endl;
			break;
		case 2:	opcaoAcrescentarApartamento();
			break;
		case 3: opcaoAcrescentarLoja();
			break;
		case 4: opcaoPesquisarImovelPorCodigo();
			break;
		case 5: opcaoPesquisarPrecoDeImovelPorCodigo();
			break;
		case 6: opcaoActualizarPrecoDeImovelPorCodigo();
			break;
		case 7:	opcaoRemoverImovelPorCodigo();
			break;
		}

	} while (opcao != 0);

}


int main()
{

	Imobiliaria* imobiliaria = new Imobiliaria("Imobiliaria");
	Interaccao interaccao(imobiliaria);
	interaccao.corre();
	delete imobiliaria;
	cout << "\nfim do main.." << endl;
	return 1;
}

………..ficha7, exercicio3 (a19,a20)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

/*
+---------------------------------------- + -------------------------- - +
| operador		| membro / não membro |
+---------------------------------------- + -------------------------- - +
| todos os operadores unários p.e: ++a, a++   | membro                    |
| = () -> ->*				  | têm sempre que ser membro |
| += -= /= *= &= |= %= >>= <<=	      | membro                    |
| todos os restantes operadores binários, ==,<<...     | globais |
+---
*/


//relação de agregaçao, memoria dinâmica
class Livro
{
	string titulo;
	string autor;
	long isbn;
	
public:
	Livro(const string& titulo0, const string& autor0, const long isbn0);
	virtual ~Livro(); //classe de hierarquia, boa pratica

	string getTitulo() const;
	void setTitulo(const string& titulo);
	string getAutor() const;
	void setAutor(const string& autor);
	long getIsbn() const;
	void setIsbn(const long isbn);
	
	virtual string getAsString()const; //para adaptar aos objectos das classes derivadas
	
	virtual Livro* duplica() const;  
};
//comparação de dois livros
bool operator==(const Livro& ob1, const Livro& ob2);
// cout objecto-de-livro
ostream& operator<<(ostream& saida, const Livro& lv);

Livro::Livro(const string& titulo0, const string& autor0, const long isbn0):titulo(titulo0), autor(autor0), isbn(isbn0)
{
}

Livro::~Livro()
{
}

string Livro::getTitulo() const
{
	return titulo;
}

void Livro::setTitulo(const string& titulo)
{
	this->titulo = titulo;
}

string Livro::getAutor() const
{
	return autor;
}

void Livro::setAutor(const string& autor)
{
	this->autor = autor;
}

long Livro::getIsbn() const
{
	return isbn;
}

void Livro::setIsbn(const long isbn)
{
	this->isbn = isbn;
}

string Livro::getAsString() const
{
	ostringstream oss;
	cout << "\ntitulo: " << titulo << " autor: " << autor << " isbn " << isbn << endl;
	
	return oss.str();
}

//criar um clone
Livro* Livro::duplica() const
{
	//ou
	//return new Livro(*this);
	//ou
	Livro* lv = new Livro(*this);
	return lv;
	
}

bool operator==(const Livro& ob1, const Livro& ob2)
{
	return ob1.getIsbn() == ob2.getIsbn();
}

ostream& operator<<(ostream& saida, const Livro& lv)
{
	saida << lv.getAsString();
	return saida;
}


class LivroFiccao : public Livro
{
	string nomePlaneta;
	int anoAccao;
	bool realidadeAccao; //0 realista, 1 fatansiosa
public:
	LivroFiccao(const string& titulo0, const string& autor0, const long isbn0, const string& nome_planeta, const int ano_accao, const bool realidade_accao);

	string getNomePlaneta() const;
	int getAnoAccao() const;
	bool getRealidadeAccao() const;
	string getAsString() const override;
	Livro * duplica() const override;
};

LivroFiccao::LivroFiccao(const string& titulo0, const string& autor0, const long isbn0, const string& nome_planeta, 
	const int ano_accao, const bool realidade_accao) : Livro(titulo0, autor0, isbn0), nomePlaneta(nome_planeta),
	anoAccao(ano_accao),realidadeAccao(realidade_accao){
	}

string LivroFiccao::getNomePlaneta() const
{
	return nomePlaneta;
}

int LivroFiccao::getAnoAccao() const
{
	return anoAccao;
}

bool LivroFiccao::getRealidadeAccao() const
{
	return realidadeAccao;
}

string LivroFiccao::getAsString() const
{
	ostringstream oss;
	oss << endl << Livro::getAsString() << " planeta " << nomePlaneta << " ano " << anoAccao << endl;
	if(realidadeAccao)
	{
		oss << " realista \n";
	}else
	{
		oss << " fantasiosa \n";
	}
	
	return oss.str();
}

Livro* LivroFiccao::duplica() const
{
	return new LivroFiccao(*this);
}


class LivroPolicial: public Livro
{
	string nomeDetective;
	int numeroTiros;
public:
	LivroPolicial(const string& titulo0, const string& autor0, const long isbn0, const string& nomeDetective0, int numeroTiros = 0);

	string getNomeDetective() const;
	int getNumeroTiros() const;
	string getAsString()const override;

	Livro* duplica()const override;
};


LivroPolicial::LivroPolicial(const string& titulo0, const string& autor0, const long isbn0,
                             const string& nomeDetective0, int numeroTiros0):Livro(titulo0, autor0, isbn0),
nomeDetective(nomeDetective0),numeroTiros(numeroTiros0)
{
}

string LivroPolicial::getNomeDetective() const
{
	return nomeDetective;
}

int LivroPolicial::getNumeroTiros() const
{
	return numeroTiros;
}

string LivroPolicial::getAsString() const
{
	ostringstream oss;
	oss << endl << Livro::getAsString() << " detective: " << nomeDetective << endl;
	if(numeroTiros > 10)
	{
		oss << " nao aconcelhado a criancas \n";
	}else
	{
		oss << " n. de tiros " << numeroTiros << endl;
	}
	return oss.str();
}

//nas classes concretas tem que haver um duplica
Livro* LivroPolicial::duplica() const
{
	//ou
	//return new LivroPolicial(*this);
	//ou
	LivroPolicial* lvp = new LivroPolicial(*this);
	return lvp;
}

//bibliteca tem relação de composição com o livro
//posse exclusiva, implementar: destrutor, construtor por copia, operador atribuição
class Biblioteca
{
	string morada;
	//qualquer tipo de livros: ponteiros para a classe base, que depois tem acesso às derivadas
	vector<Livro *> livros; //vector polimorfico, <Livro *>
	
	int pesquisaLivro(long isbn0) const; //indice, int
public:
	Biblioteca(const string& morada);
	

	bool acrescentarLivro(Livro * livro);
	bool removerLivro(long isbn0);

	//por haver relação de composição, os livros não sobrevivem à destruição da biblioteca
	//e destrutor
	virtual ~Biblioteca();
	//e construtor por copia
	Biblioteca(const Biblioteca& ob);
	//e operador atribuição
	Biblioteca& operator=(const Biblioteca & ob);
	
	string getAsString()const;
};

ostream& operator<<(ostream& saida, const Biblioteca& bibl);

int Biblioteca::pesquisaLivro(long isbn0) const
{
	for(unsigned int i=0; i<livros.size(); i++)
	{
		if(isbn0 == livros[i]->getIsbn())
		{
			return i;
		}
	}
	return -1;
}

Biblioteca::Biblioteca(const string& morada)
{
}

bool Biblioteca::acrescentarLivro(Livro* livro)
{
	if(livro == nullptr || pesquisaLivro(livro->getIsbn())!=-1)
	{
		return false;
	}
	Livro* lv = livro->duplica(); //é duplicado com o livro->duplica();, não aceito o que me dão
	livros.push_back(lv);
	return true;
}

bool Biblioteca::removerLivro(long isbn0)
{
	int qual = pesquisaLivro(isbn0);
	if(qual == -1)
	{
		return false;
	}
	//liberta o obejcto apontado por livro[i]
	delete livros[qual]; //só por ser relação de composição
	//retirar o vector o pionteito que aponta para memoria já libertada
	livros.erase(livros.begin() + qual);
	return true;
}

Biblioteca::~Biblioteca()
{
	for(Livro * l: livros)
	{
		delete l;
	}
}

Biblioteca::Biblioteca(const Biblioteca& ob)
{
	//nao ha ponteiros com valores lixo para limpar
	//funcionou o construtor por omissão do vector que criou
	//um vector vazio (sem ponteiros)
	//e do membro do tipo string
	
	//se houvesse ponteiros com valores lixo punha-se a nullptr
	//porque precisamos de preparar o objecto que esta aser criado
	//para invocar o operador de atribuição que limpa a memoria velha
	//do objecto que o invoca, o primeiro membro da atribuição
	*this = ob; //chama o operador atribuicao e copia os dados
	//de acordo com o que tem implementado: duplicando
	//a memoria dinmica que o destrutor liberta
}

Biblioteca& Biblioteca::operator=(const Biblioteca& ob)
{
	//prevenção de auto atribuição
	if(this == & ob)
	{
		return *this;
	}
	//limpesa da memoria velha do primeiro membro de atribuicao
	for(Livro * lv: livros)
	{
		delete lv;
	}
	//esvaziar o vector que agora só aponta para memoria ja nao reservada
	livros.clear();
	//duplicar os objectos dinamicos, copiar a informacao de ob
	for(Livro * lv: livros)
	{
		Livro* p = lv->duplica();
		livros.push_back(lv);
	}
	//e nao esquecer os restantes membros
	morada = ob.morada;
	return *this;
}

string Biblioteca::getAsString() const
{
	ostringstream oss;
	oss << "\nmorada: " << morada << endl;
	for(unsigned int i=0; i<livros.size(); i++)
	{
		oss << livros[i]->getAsString();
	}
	return oss.str();
}

// cout objecto-de-livro
ostream& operator<<(ostream& saida, const Biblioteca & bibl)
{
	saida << bibl.getAsString();
	return saida;
}


int main()
{
	Biblioteca* b = new Biblioteca("aldeia de coimbra");

	Livro* p = new LivroPolicial("coimbra", "coimbra", 12345,"coimbra", 1);
	b->acrescentarLivro(p);
	cout << b->getAsString();

	cout << "\nfim do main" << endl;
	return 1;
}

………..ficha?, exercicio? (a21), aquario polimorfico

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class Pargo;
class Pescada;
class Aquario;
class Peixe;

//peixe é uma classe abstracta, não se podem criar objectos deste tipo
class Peixe
{
	string nomeEspecie;
	string cor;
	int peso;
	int numSerie;

	static int sequencia;
	//constantes iguais para todos:
	static const int INICIAL_PESO = 10;

	bool vivo = true; //importante, subs estadio

protected:
	void aumentaPeso(int quant0);
public:
	Peixe(string nomeEspecie0, string cor0 = "cinzento");
	//nao existe aqui construtor default
	//assim a classe derivada precisa de um construtor que alimente a classe base
	Peixe(const Peixe& orig); //existe porque precisamos que os peixes tenham um num de seq diferente
	//tudo é copiado mas o num de série é diferente.
	///se fosse o natrual copiaava tudo
	
	int getNumSerie() const;
	int getPeso() const;
	
	bool isVivo()const;

	virtual string getAsString()const;

	//funcao abstracta nao se podem criar objectos desta classe
	//pode haver "Peixe *" e "Peixe &"
	virtual void alimentar(int quant, Aquario* aquario) = 0; 
	virtual Peixe* duplica()const = 0;
	//serve para criar diferentes tipos de peixes: pargo e pescada
	static Peixe* fabrica(string tipo0, string cor0="cinzento");
	virtual ~Peixe();
	bool setVivo(bool v);
	
};

ostream& operator<<(ostream& saida, const Peixe& p);

void Peixe::aumentaPeso(int quant0)
{
	peso +=quant0;
}

Peixe::Peixe(string nomeEspecie0, string cor0) :nomeEspecie(nomeEspecie0), cor(cor0), peso(INICIAL_PESO), numSerie(sequencia++)
{
}

Peixe::Peixe(const Peixe& orig):nomeEspecie(orig.nomeEspecie), cor(orig.cor), peso(orig.peso), numSerie(sequencia++)
{
	//o peixe construido por copia tem outro numero de série
}


int Peixe::getPeso() const
{
	return peso;
} 


int Peixe::getNumSerie() const
{
	return numSerie;
}


bool Peixe::isVivo() const
{
	return vivo;
}

Peixe* Peixe::fabrica(string tipo0, string cor0)
{
	if(tipo0 == "pargo")
	{
		return new Pargo(cor0);
	}else if(tipo0 == "pescada")
	{
		return new Pescada;
	}
	return nullptr;
}

bool Peixe::setVivo(bool v)
{
	vivo = v;
}

ostream& operator<<(ostream& saida, const Peixe& p)
{
	saida << p.getAsString();
	return saida;
}

string Peixe::getAsString() const
{
	ostringstream oss;

	oss << "\nPeixe: " << nomeEspecie << "\ncor: " << cor << "\npeso: " << peso << "\nnumSerie: " << numSerie << endl;
	return oss.str();
}

int Peixe::sequencia = 499; //num. para cada peixe

//NOVO: surgem duas espécies de peixes

class Pargo: public Peixe
{
	static const int LIMITE_PESO = 50;
public:
	Pargo(string cor0 = "cinzento");

	void alimentar(int quant0, Aquario* aquario) override;
	Peixe* duplica()const override;
};

Pargo::Pargo(string cor0):Peixe("pargo",cor0)
{
	//importante pargo precisa de passar o que o construtor da base precisa, o Peixe
	//porque a base não é default
}

void Pargo::alimentar(int quant0, Aquario* aquario)
{
	if(quant0<=0 || aquario==nullptr)
	{
		return;
	}
	aumentaPeso(quant0);
	if(getPeso()>LIMITE_PESO)
	{
		//aquario->eliminaPeixe(getNumSerie()); //perigo
		setVivo(false);
	}
}

Peixe* Pargo::duplica() const
{
	//duplicação polimórfica
	return new Pargo(*this);
}

class Pescada : public Peixe
{
	static const int LIMITE_SOLIDAO = 1;
	static const int LIMITE_MULTIDAO = 10;
public:
	Pescada();
	
	void alimentar(int quant0, Aquario* aquario0) override;
	Peixe* duplica()const override;
	
};

Pescada::Pescada():Peixe("pescada")
{
}

void Pescada::alimentar(int quant0, Aquario* aquario0)
{
	if(quant0<=0 || aquario0 == nullptr)
	{
		return;
	}
	int num = aquario0->getQuantosPeixes(); //uma estragégia para aceder ao aquario
	//ou colocar na classe peixe um ponteiro para aquario
	//assim as derivadas teriam sempre acesso
	
	if(num> LIMITE_SOLIDAO && num < LIMITE_MULTIDAO)
	{
		aumentaPeso(quant0);
	}else
	{
		aumentaPeso(quant0 / 2);
	}
}

Peixe* Pescada::duplica() const
{
	return new Pescada(*this);
}

//aquario é uma classe abstracta
class Aquario
{
	vector<Peixe*> peixes; //vector de ponteiros

	int pesquisaPeixe(int numSerie0)const;
	void eliminarMortos();
public:
	Aquario() = default;  //qd criado é um vector vazio

	//quando um peixe e posto no aquario, este assume a
	//sua posse e controlo total
	Aquario(const Aquario& orig); //construtor por cópia
	Aquario& operator=(const Aquario& orig); //operador atribuição

	virtual ~Aquario();

	bool addPeixe(string tipo0, string cor0 = "cinzento");
	const Peixe* getPeixe(int numSerie) const;
	void alimentar(int quantidade0);
	void removePeixe(int numSerie);
	bool eliminaPeixe(int numSerie0);

		string getAsString()const;

	unsigned int getQuantosPeixes()const;
};

void Aquario::alimentar(int quantidade0)
{
	//for (Peixe* p : peixes)
	//{
	//	p->alimentar(quantidade0, this); //mt cuidado com isto, usa o vector<Peixe*> novos;
	//}
	//v2
	for(int i = 0; i < peixes.size(); i++)
	{
		peixes[i]->alimentar(quantidade0, this); //percorrer o vector 
	}
	eliminarMortos(); //vou verificar o boolenao vivo dos peixes
}

string Aquario::getAsString() const
{
	ostringstream oss;
	oss << "\nAquario; " << endl;
	//neste caso vai ser contatenada a informação
	//para o objecto que estiver a ser apontado
	//não interessa qual
	for (Peixe* p : peixes)
	{
		oss << p->getAsString();
	}
	return oss.str();
}

unsigned Aquario::getQuantosPeixes() const
{
	return peixes.size();
}

bool Aquario::addPeixe(string tipo0, string cor0) {
	Peixe* peixe = Peixe::fabrica(tipo0, cor0); //fabrica é static por isso ::
	if(peixe==nullptr)
	{
		return false;
	}
	peixes.push_back(peixe);
	return true;
}

const Peixe* Aquario::getPeixe(int numSerie) const
{
	int qual = pesquisaPeixe(numSerie);
	if(qual == -1)
	{
		return nullptr;
	}
	return  peixes[qual];
};

int Aquario::pesquisaPeixe(int numSerie0)const
{
	for (int i = 0; i < peixes.size(); i++)
	{
		if (peixes[i]->getNumSerie() == numSerie0)
		{
			return i;
		}
	}
	return -1;
}

void Aquario::eliminarMortos()
{
	//formula
	//ou
	//for(vector<Peixe*>::iterator it = peixes.begin() ; it != peixes.end(); )
	//ou
	for (auto it = peixes.begin(); it != peixes.end();)
	{
		if (!(*it)->isVivo())
		{
			delete (*it);
			it = peixes.erase(it);
		}
		else
		{
			++it;
		}
	}
}


Aquario::~Aquario()
{
	for (Peixe* p : peixes)
	{
		delete p;
	}
	cout << "\n~Aquario()" << endl;
}

Aquario::Aquario(const Aquario& orig)
{
	//funcionou o constru por defeito do vector
	//o vector está vazio
	//não há ponteiros com lixo
	*this = orig;
}

Aquario& Aquario::operator=(const Aquario& orig)
{
	//prevenção da auto atribuição
	if (this == &orig)
	{
		return  *this;
	}
	//libtertar mem dina velha
	for (Peixe* p : peixes)
	{
		delete p;
	}
	//esvaziar o vector
	peixes.clear();
	//copiar a informacao de orig, duplicando os objectos dinamicos
	for (Peixe * peixe : orig.peixes) {
		Peixe * p = peixe->duplica();
		peixes.push_back(p);
	}
	return *this;
}

void Aquario::removePeixe(int numSerie)
{
	int qual = pesquisaPeixe(numSerie);
	if (qual == -1)
	{
		return;
	}
	delete peixes[qual];
	peixes.erase(peixes.begin() + qual);
}

bool Aquario::eliminaPeixe(int numSerie0)
{
	int qual = pesquisaPeixe(numSerie0);
	if(qual == -1)
	{
		return false;
	}
	//remove o peixe do aquario, é destruido
	delete peixes[qual];
	//depois de feito o dele (libertada a memoria)
	//precisamos de retirar do vector
	//o ponteio para memoria ja nao reservada
	peixes.erase(peixes.begin() + qual);
	return true;
}

int main()
{
	

	cout << "\nfim do main" << endl;
	return 1;
}

#include <string>
#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

class Caderno
{
private:
	//membros variáveis
	string marca;
	string cor;
	int numFolhas;
	string tamanho;
public:

	Caderno(const string& marca, const string& cor, const int num_folhas, const string& tamanho)
	//const não consigo alterar o argumento que vem da main, assim fica mais eficiente/seguro,
	//e tambem assim posso fazer uso de uma const, usando por exemplo "marca"
	//o int pode ter const ou não e referencia, e porque é uma coisa pequena
		: marca(marca),
		  cor(cor),
		  numFolhas(num_folhas),
		  tamanho(tamanho)
	{
	}

	//membros funções
	//funções get
	//os consts sigificam que não podem alterar nada, é uma função de consulta
	string getMarca() const
	{
		return marca;
	}
	string getCor() const
	{
		return cor;
	}
	int getNumfolhas() const
	{
		return numFolhas;
	}
	string getTamanho() const
	{
		return tamanho;
	}
	
	//funções set
	void setMarca(const string & marca)
	{
		this->marca = marca;
	}
	void setCor(const string & cor)
	{
		this->cor = cor;
	}
	void setNumfolhas(int num_folhas)
	{
		if(num_folhas>0){
			numFolhas = num_folhas;
		}else
		{
			numFolhas = 0;
		}
	}
	void setTamanho(const string& tamanho)
	{
		this->tamanho = tamanho;
	}

	string getAsString()const;
};

string Caderno::getAsString()const
{
	ostringstream oss;
	oss << "\nmarca: " << marca
		<< "\ncor: " << cor
		<< "\nnum folhas: " << numFolhas
		<< "n\ntamanho: " << tamanho;
	return oss.str();
}


int main()
{
	const Caderno Cad1("bic","branca",2,"a4"); //const não posso alterar
	cout << Cad1.getAsString();

	cout << "\nfim do main" << endl;

	return 0;
}

………..ficha?, exercicio? (a21, a22), aquario polimorfico v2

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class Aquario;
class Pargo;
class Pescada;

//peixe é uma classe abstracta, não se podem criar objectos deste tipo
class Peixe
{
	string nomeEspecie;
	string cor;
	int peso;
	int numSerie;

	static int sequencia;
	//constantes iguais para todos:
	static const int INICIAL_PESO = 10;

	bool vivo = true; //importante, subs estadio

	//v2
	Aquario* aquario = nullptr;

protected:
	void aumentaPeso(int quant0);
	Aquario* getAquario(); //v2
public:
	Peixe(Aquario* aq0, string nomeEspecie0, string cor0 = "cinzento"); //v2
	//nao existe aqui construtor default
	//assim a classe derivada precisa de um construtor que alimente a classe base
	Peixe(const Peixe& orig); //existe porque precisamos que os peixes tenham um num de seq diferente
	//tudo é copiado mas o num de série é diferente.
	///se fosse o natrual copiaava tudo
	
	int getNumSerie() const;
	int getPeso() const;
	
	bool isVivo()const;

	virtual string getAsString()const;

	//funcao abstracta nao se podem criar objectos desta classe
	//pode haver "Peixe *" e "Peixe &"
	//virtual void alimentar(int quant, Aquario* aquario) = 0;
	virtual void alimentar(int quant) = 0; //v2 
	virtual Peixe* duplica()const = 0;
	//serve para criar diferentes tipos de peixes: pargo e pescada
	static Peixe* fabrica(string tipo0, Aquario * aq0, string cor0="cinzento");
	virtual ~Peixe();
	bool setVivo(bool v);

	//v3
	void setAquario(Aquario* aqua0);
}; 

ostream& operator<<(ostream& saida, const Peixe& p);

void Peixe::aumentaPeso(int quant0)
{
	peso +=quant0;
}

Aquario* Peixe::getAquario()
{
	return aquario;
}

Peixe::Peixe(Aquario * aq0, string nomeEspecie0, string cor0) :aquario(aq0),nomeEspecie(nomeEspecie0), cor(cor0), peso(INICIAL_PESO), numSerie(sequencia++)
{
}

Peixe::Peixe(const Peixe& orig):nomeEspecie(orig.nomeEspecie), cor(orig.cor), peso(orig.peso), numSerie(sequencia++)
{
	//o peixe construido por copia tem outro numero de série
}


int Peixe::getPeso() const
{
	return peso;
} 


int Peixe::getNumSerie() const
{
	return numSerie;
}


bool Peixe::isVivo() const
{
	return vivo;
}

Peixe* Peixe::fabrica(string tipo0, Aquario * aqu0, string cor0)
{
	if(tipo0 == "pargo")
	{
		return new Pargo(aqu0, cor0);
	}else if(tipo0 == "pescada")
	{
		return new Pescada(aqu0);
	}
	return nullptr;
}

bool Peixe::setVivo(bool v)
{
	vivo = v;
}

void Peixe::setAquario(Aquario* aqua0)
{
	this->aquario = aqua0;
}

ostream& operator<<(ostream& saida, const Peixe& p)
{
	saida << p.getAsString();
	return saida;
}

string Peixe::getAsString() const
{
	ostringstream oss;

	oss << "\nPeixe: " << nomeEspecie << "\ncor: " << cor << "\npeso: " << peso << "\nnumSerie: " << numSerie << endl;
	return oss.str();
}

int Peixe::sequencia = 499; //num. para cada peixe

//NOVO: surgem duas espécies de peixes

class Pargo: public Peixe
{
	static const int LIMITE_PESO = 50;
public:
	Pargo(Aquario * aqua0, string cor0 = "cinzento");

	void alimentar(int quant0) override;
	Peixe* duplica()const override;
};

Pargo::Pargo(Aquario* aqua0, string cor0):Peixe(aqua0, "pargo",cor0)
{
	//importante pargo precisa de passar o que o construtor da base precisa, o Peixe
	//porque a base não é default
}

void Pargo::alimentar(int quant0)
{
	if(quant0<=0 || getAquario()==nullptr)
	{
		return;
	}
	aumentaPeso(quant0);
	if(getPeso()>LIMITE_PESO)
	{
		//aquario->eliminaPeixe(getNumSerie()); //perigo
		setVivo(false);
	}
}

Peixe* Pargo::duplica() const
{
	//duplicação polimórfica
	return new Pargo(*this);
}

class Pescada : public Peixe
{
	static const int LIMITE_SOLIDAO = 1;
	static const int LIMITE_MULTIDAO = 10;
public:
	Pescada(Aquario * aqu0);
	
	void alimentar(int quant0) override;
	Peixe* duplica()const override;
	
};

Pescada::Pescada(Aquario* aqu0):Peixe(aqu0, "pescada")
{
}

void Pescada::alimentar(int quant0)
{
	if(quant0<=0 || getAquario() == nullptr) //v2
	{
		return;
	}
	int num = getAquario()->getQuantosPeixes(); //uma estragégia para aceder ao aquario, v2
	//ou colocar na classe peixe um ponteiro para aquario
	//assim as derivadas teriam sempre acesso
	
	if(num> LIMITE_SOLIDAO && num < LIMITE_MULTIDAO)
	{
		aumentaPeso(quant0);
	}else
	{
		aumentaPeso(quant0 / 2);
	}
}

Peixe* Pescada::duplica() const
{
	return new Pescada(*this);
}

//aquario é uma classe abstracta
class Aquario
{
	vector<Peixe*> peixes; //vector de ponteiros

	int pesquisaPeixe(int numSerie0)const;
	void eliminarMortos();
public:
	Aquario() = default;  //qd criado é um vector vazio

	//quando um peixe e posto no aquario, este assume a
	//sua posse e controlo total
	Aquario(const Aquario& orig); //construtor por cópia
	Aquario& operator=(const Aquario& orig); //operador atribuição

	virtual ~Aquario();

	bool addPeixe(string tipo0, string cor0 = "cinzento");
	const Peixe* getPeixe(int numSerie) const;
	void alimentar(int quantidade0);
	void removePeixe(int numSerie);
	bool eliminaPeixe(int numSerie0);

	string getAsString()const;

	unsigned int getQuantosPeixes()const;
};

void Aquario::alimentar(int quantidade0)
{
	//for (Peixe* p : peixes)
	//{
	//	p->alimentar(quantidade0, this); //mt cuidado com isto, usa o vector<Peixe*> novos;
	//}
	//v2
	for(int i = 0; i < peixes.size(); i++)
	{
		peixes[i]->alimentar(quantidade0); //percorrer o vector, v2
	}
	eliminarMortos(); //vou verificar o boolenao vivo dos peixes
}


string Aquario::getAsString() const
{
	ostringstream oss;
	oss << "\nAquario; " << endl;
	//neste caso vai ser contatenada a informação
	//para o objecto que estiver a ser apontado
	//não interessa qual
	for (Peixe* p : peixes)
	{
		oss << p->getAsString();
	}
	return oss.str();
}

unsigned Aquario::getQuantosPeixes() const
{
	return peixes.size();
}



bool Aquario::addPeixe(string tipo0, string cor0) {
	Peixe* peixe = Peixe::fabrica(tipo0, this, cor0); //fabrica é static por isso ::, v2
	if(peixe==nullptr)
	{
		return false;
	}
	peixes.push_back(peixe);
	return true;
}

const Peixe* Aquario::getPeixe(int numSerie) const
{
	int qual = pesquisaPeixe(numSerie);
	if(qual == -1)
	{
		return nullptr;
	}
	return  peixes[qual];
};

int Aquario::pesquisaPeixe(int numSerie0)const
{
	for (int i = 0; i < peixes.size(); i++)
	{
		if (peixes[i]->getNumSerie() == numSerie0)
		{
			return i;
		}
	}
	return -1;
}

void Aquario::eliminarMortos()
{
	//formula
	//ou
	//for(vector<Peixe*>::iterator it = peixes.begin() ; it != peixes.end(); )
	//ou
	for (auto it = peixes.begin(); it != peixes.end();)
	{
		if (!(*it)->isVivo())
		{
			delete (*it);
			it = peixes.erase(it);
		}
		else
		{
			++it;
		}
	}
}


Aquario::~Aquario()
{
	for (Peixe* p : peixes)
	{
		delete p;
	}
	cout << "\n~Aquario()" << endl;
}

Aquario::Aquario(const Aquario& orig)
{
	//funcionou o constru por defeito do vector
	//o vector está vazio
	//não há ponteiros com lixo
	*this = orig;
}

Aquario& Aquario::operator=(const Aquario& orig)
{
	//prevenção da auto atribuição
	if (this == &orig)
	{
		return  *this;
	}
	//libtertar mem dina velha
	for (Peixe* p : peixes)
	{
		delete p;
	}
	//esvaziar o vector
	peixes.clear();
	//copiar a informacao de orig, duplicando os objectos dinamicos
	for (Peixe * peixe : orig.peixes) {
		Peixe * p = peixe->duplica();
		p->setAquario(this); //para aponter para o aquario novo, v3
		peixes.push_back(p);
	}
	return *this;
}

void Aquario::removePeixe(int numSerie)
{
	int qual = pesquisaPeixe(numSerie);
	if (qual == -1)
	{
		return;
	}
	delete peixes[qual];
	peixes.erase(peixes.begin() + qual);
}

bool Aquario::eliminaPeixe(int numSerie0)
{
	int qual = pesquisaPeixe(numSerie0);
	if(qual == -1)
	{
		return false;
	}
	//remove o peixe do aquario, é destruido
	delete peixes[qual];
	//depois de feito o dele (libertada a memoria)
	//precisamos de retirar do vector
	//o ponteio para memoria ja nao reservada
	peixes.erase(peixes.begin() + qual);
	return true;
}

int main()
{
	Aquario* aq1 = new Aquario;
	aq1->addPeixe("pescada");
	aq1->addPeixe("pargo", "laranja");
	cout << aq1->getAsString() << endl;

	Aquario* aq2 = new Aquario;
	aq2->addPeixe("pargo", "azul");
	cout << aq2->getAsString() << endl;

	*aq2 = *aq1;
	cout << aq2->getAsString() << endl;
	aq2->alimentar(10);
	cout << aq2->getAsString() << endl;

	
	cout << "\nfim do main" << endl;
	return 1;
}

………..ficha7, exercicio4 (a22, a23) exercicio global

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

class Ginasio;

using namespace std;

class Tarifario
{
	//sem usar contentores da STL
	//(vector, lista, maps.. )
	//e implica: memoria dinamica, destrutor, operador atribuição, construtor por cópia
	//deve ser usado um array dinamico de inteiros
	unsigned int* treinos; //ponteiro para o array dinamico
	unsigned int quantos; //quantidade de elementos, pois não podemos usar o size(), serve para controlar qts
	//vai ser implementada pelas derivadas
	//esta função apenas se destina a calcular o pagamento
	//a função calculaPagamentoEApagaTreinos invoca esta e apaga os treinos
	virtual unsigned int calculaPagamento()const = 0; //abstracta

public:
	void acrescentaTreino(unsigned int at);
	unsigned int calculaPagamentoEApagaTreinos();

	//é preciso o construtor para inicializar o ponteiro e a variavel quantos
	Tarifario(); //este é um construtor por omissão
	//vai ser preciso ter o destrutor para devolver a memoria ocupada pela matriz dinamica
	virtual ~Tarifario(); //existem derivas esta é virtual
	//justificação de:
	//a matriz dinamica de inteiros(treinos) pertence exclusivamente a cada objeto
	//de tarifario mas nao e automaticamente copiada quando se copiam ou atribuem estes
	//objectos (apenas o ponteiro e copiado lvando a partilha de matriz entre objectos
	//e mais tarde a deletes repetidos da mesma matriz, entre outras incoerencias)
	// => é preciso fazer o operador de atribuição e o construtor por cópia
	Tarifario(const Tarifario& orig);
	Tarifario& operator=(const Tarifario& orig);

	unsigned int getNumTreinos()const;
	unsigned int getTreino(unsigned int i)const;
	
	virtual string getAsString() const;

	//tem que ser abstracta tb. nao se pode construir
	//um tarifario ainda porque é classe abstracta
	virtual Tarifario* duplica()const = 0;  //duplicação polimorfica, por causa do operador atribuição do cliente
	
};

void Tarifario::acrescentaTreino(unsigned at)
{
	//ao inves do push back
	unsigned int* aux = new unsigned int[quantos + 1];
	for(unsigned int i=0; i< quantos; i++)
	{
		aux[i] = treinos[i];
	}
	aux[quantos] = at;
	quantos++;
	delete[] treinos;
	treinos = aux;
}

unsigned Tarifario::calculaPagamentoEApagaTreinos()
{
	//vai chamar a função correspondente a classe do objeto que invoca
	unsigned int conta = calculaPagamento(); //definido nas classes concretas calculaPagamento();
	delete[] treinos;
	treinos = nullptr;
	quantos = 0;
	return conta;
}

Tarifario::Tarifario()
{
	treinos = nullptr; //inicialmente nao existem treinos
	quantos = 0;
}

Tarifario::~Tarifario()
{
	delete[] treinos; //libertar a memoria dinamica
}

Tarifario::Tarifario(const Tarifario& orig)
{
	//pre inicialização para que o operador de atribuição
	//consiga trabalhar bem ( precisa de ter o objecto num estado
	//coerente dai a inicialização previa
	//para acontecer o delete apenas a um valor de um ponteiro
	//nulo ou com um valor dado por new
	treinos = nullptr; //treinos é um vector ponteiro que nasce com lixo, por isso é impts isto!
	quantos = 0;
	//usar o operador de atribuição
	*this = orig;
}

Tarifario& Tarifario::operator=(const Tarifario& orig) //a= b
{
	//testa auto-aribuição para evitar trabalho desnecssário e possivel incorencia
	//e libertação dos treinos da orgem da copia (que coincide com o destino)
	//na memoria diamica se nao o mesmo -> ja sao iguaos = concluido
	if(this == &orig)
	{
		return *this;
	}
	//devolve os recursos ocupados pelo objecto alvo da atribuição
	delete[] treinos; //treinos é um vector ponteiro que nasce com lixo
	treinos = nullptr; 
	quantos = 0;
	//se o outro objecto tambem tem 0 treinos ja estamos iguais. concluido.
	if(orig.treinos == nullptr)
	{
		return * this;
	}
	//senão:
	//criar recursos iguais (copiar) aos do outro objecto
	//alocar matriz dnamica para tantos treinos como os do outro objecto
	//copiar dos dados: o conteudo da matriz e restantes membros
	treinos = new unsigned int[orig.quantos];
	quantos = orig.quantos;
	for(unsigned int i = 0 ; i < quantos; i++)
	{
		treinos[i] = orig.treinos[i]; //copiar todos
	}
	return *this;
}

unsigned Tarifario::getNumTreinos() const
{
	return  quantos;
}

unsigned Tarifario::getTreino(unsigned i) const
{
	if(i<= 0|| (i>=quantos))
	{
		return 0;
	}
	return treinos[i];
}

string Tarifario::getAsString() const
{
	ostringstream oss;
	oss << " tarifario: " << endl;
	return oss.str();
}

//relação com tarifario é de composição, sento Apressado uma sub-classe
//apressado é uma classe derivada concreta e tem que existir:
//tem que se concretirar tdoas as funções abstractas
//tem que haver um construtor que alimenta a classe base, se tiver argumentos o construtor da base
//mas neste caso é um construtor por omissão
class Apressado :public Tarifario
{
	unsigned int calculaPagamento() const override; //é abstracta na classe tarifario (virtual)
public:
	Tarifario * duplica() const override; //é abstracta na classe tarifario (virtual)

	string getAsString() const override;
};

unsigned Apressado::calculaPagamento() const
{
	unsigned int custo = 0;
	unsigned int numTreinos = getNumTreinos();

	for(unsigned int i = 0 ; i< numTreinos; i++)
	{
		unsigned int treino = getTreino(i);
		if(treino <=10)
		{
			custo += 10;
		}else if(treino > 10 && treino < 20)
		{
			custo += 15;
		}else
		{
			custo += 25;
		}
	}
	return  custo;
}

Tarifario* Apressado::duplica() const
{
	return new Apressado(*this);
}

string Apressado::getAsString() const
{
	ostringstream oss;
	oss << " apressado " << endl;
	return oss.str();
}

//cliente genérico, significa que é uma classe base de uma hierarquia
class Cliente
{
	string nome;
	unsigned int bi; //ou string
	Tarifario* tarifario;  //aponta para um qualquer tipo de tarifario que exista
	int horarioInicio;

	//para impedir a copia e a atribuição de objectos
	//se for solicitado era:
	//Cliente(const Cliente& cli) = delete;
	//Cliente& operator=(const Cliente& cli) = delete;
	
public:
	//nao podem existir clientes sem tarifario, é necessário o construtor
	Cliente(const string& nome, unsigned long bi, Tarifario* const tarifario);

	//destrutor para apagar tarifario
	virtual ~Cliente();

	void iniciaTreino(int hora);
	void terminaTreino(int hora);
	unsigned int paga();

	//pergunta exame
	//um método generico que não pode ser já implementado, é uma função abstracta, virtual e =0
	//e vao ter codigo nas classes derivadas
	virtual void reageEntrada(Ginasio* g) = 0; 
	virtual void reageSaida(Ginasio* g) = 0;

	void mudaTarifario(Tarifario* tarifario);

	unsigned int getBi()const;
	bool estarATreinar()const;

	//a c.5)
	Cliente(const Cliente& cli);
	Cliente& operator=(const Cliente& cli);

	virtual string getAsString()const;

	//tem que ser virtual pura (cliente é abstracta)
	virtual Cliente* duplica()const = 0;
	
};

Cliente::Cliente(const string& nome, unsigned long bi, Tarifario* const tarifario) : nome(nome), bi(bi), tarifario(tarifario)
{
	horarioInicio = -1; //nao esta a treinar quando é criado
}

Cliente::~Cliente()
{
	delete tarifario;
	cout << "~Cliente" << endl;
}

void Cliente::iniciaTreino(int hora)
{
	if(horarioInicio==-1)
	{
		horarioInicio = hora;
	}
}

void Cliente::terminaTreino(int hora)
{
	if(horarioInicio != -1)
	{
		tarifario->acrescentaTreino(hora - horarioInicio);
		horarioInicio = -1;
	}
}

unsigned Cliente::paga()
{
	//quem calcula é o tarifario, e o cliente tem
	return tarifario->calculaPagamentoEApagaTreinos();
}

void Cliente::mudaTarifario(Tarifario* tarifario)
{
	if(this->tarifario != nullptr)
	{
		//so muda se o novo tarifario existir mesmo
		//apaga tarifario anterior (deixa de servir)
		//(obs: os treinos do antigo tarifario ficaram
		//por pagar deixa-se pagar antes de mudar de tarifario
		delete this->tarifario;
		this->tarifario = tarifario;
		
	}
}

bool Cliente::estarATreinar() const
{
	return horarioInicio != -1;
}

Cliente::Cliente(const Cliente& cli)
{
	//efectua pre inicilização para compatibilizar com o operador
	//neste caso basta colocar o ponteiro tarifario num estacio inciial coerente
	tarifario = nullptr;
	//usa operador atribuicao
	*this = cli;
}

Cliente& Cliente::operator=(const Cliente& cli)
{
	//testa a auto atribuição para evitar trabalho desnecessario
	//e libertacao do tarifario da origem da copia (que coincide com o destino)
	if(this == &cli)
	{
		return *this;
	}
	//liberta recursos atuais do objecto da atribuicao
	//neste caso so o objeto tarifario
	delete tarifario;
	//cria/copia recursos (iguais ao) do outro objeto
	//no caso do tarifario, pode ser de qualquer tipo
	//usar o new nao e viavel ( nao se sabe o tipo )
	//o tarifario que se duplique
	//tem que ser pela via do "duplica" (implementar no tarifario e derivadas)
	nome = cli.nome;
	bi = cli.bi;
	horarioInicio = cli.horarioInicio;
	tarifario = cli.tarifario->duplica();

	return *this;
}

string Cliente::getAsString() const
{
	ostringstream oss;
	oss << nome << " - bi: " << bi;
	return oss.str();
}

//classe concreta
//e)
class Sociavel: public Cliente
{
	
public:
	Sociavel(const string& nome, const unsigned long bi, Tarifario* const tarifario);

	void reageEntrada(Ginasio* g) override;
	void reageSaida(Ginasio* g) override;
	
	Cliente* duplica() const override;

	string getAsString() const override;
	
};

Sociavel::Sociavel(const string& nome, const unsigned long bi, Tarifario* const tarifario) : Cliente(nome, bi, tarifario)
{
}

void Sociavel::reageEntrada(Ginasio* g)
{
	//nao faz nada
}

void Sociavel::reageSaida(Ginasio* g)
{
	if(g->getNumClientesATreinar()==1) //se for só ele
	{
		g->saiClienteDoTreino(getBi());
	}
}

Cliente* Sociavel::duplica() const
{
	return  new Sociavel(*this);
}

string Sociavel::getAsString() const
{
	ostringstream oss;
	oss << "sociavel - " << Cliente::getAsString();
	return oss.str();
}

//os clientes pertencem ao ginasio
//qd se destroi o ginasio o cliente tambem serão
class Ginasio
{
	//clientes de diversos tipos
	//vector de ponteiros para a classe base
	//* para validar o polimorfismo
	vector<Cliente*>  clientes;

	unsigned int relogio;
	unsigned int pesquisaClienteDadoBi(unsigned int bi);
public:
	void avancaRelogio(int tempo);
	bool acrescentaCliente(Cliente* c);
	unsigned int paga(unsigned int bi);

	void entraClienteNoTreino(unsigned int bi);
	void saiClienteDoTreino(unsigned int bi);
	void removeCliente(unsigned int bi);
	
	Ginasio();
	~Ginasio();
	
	unsigned int getNumClientesATreinar()const;
	bool saiClienteDoTreino(int s);

	Ginasio& operator=(const Ginasio& orig);
	Ginasio(const Ginasio& orig);
	string getAsString() const;
};

unsigned Ginasio::pesquisaClienteDadoBi(unsigned bi)
{
	for(unsigned int i = 0; i<clientes.size(); i++)
	{
		if(bi == clientes[i]->getBi())
		{
			return i;
		}
	}
	return -1;
}

void Ginasio::avancaRelogio(int tempo)
{
	relogio += tempo;
}

bool Ginasio::acrescentaCliente(Cliente* c)
{
	if(c == nullptr)
	{
		return false;
	}
	//se existem clientes com o mesmo bi
	if(pesquisaClienteDadoBi(c->getBi()) != -1)
	{
		return false;
	}
	clientes.push_back(c->duplica());
	return true;
}

unsigned Ginasio::paga(unsigned bi)
{
	//procura cliente. sera devolvida a posicao no vector
	unsigned int indice = pesquisaClienteDadoBi(bi);
	if(indice != -1)
	{
		//se encontrou..
		return clientes[indice]->paga();
	}
	return 0;
}

void Ginasio::entraClienteNoTreino(unsigned bi)
{
	unsigned int indice = pesquisaClienteDadoBi(bi);

	if(indice == -1)
	{
		return;
	}
	//verificar se o cliente ainda não estava a treinar
	if(clientes[indice]->estarATreinar() == true)
	{
		return;
	}
	//avisa os outros clientes a treinar que entrou na sala
	for(unsigned int i=0; i< clientes.size(); i++)
	{
		if(clientes[i]->estarATreinar()){
			clientes[i]->reageEntrada(this);
		}
	}
	//o cliente inicia o treino
	clientes[indice]->iniciaTreino(relogio);
}

void Ginasio::saiClienteDoTreino(unsigned bi)
{
	unsigned int indice = pesquisaClienteDadoBi(bi);
	if(indice == -1)
	{
		return;
	}
	//cliente pode nao estar a treinar
	if(clientes[indice]->estarATreinar() == false)
	{
		return;
	}
	//primeiro tira da sala de treino e so depois avisa os que ficaram que saiu um
	clientes[indice]->terminaTreino(relogio);
	//avisa os outros clientes a treinar que saiu um da sala
	for(unsigned int i = 0; i< clientes.size(); i++)
	{
		if(clientes[i]->estarATreinar())
		{
			clientes[i]->reageSaida(this);
		}
	}
}

void Ginasio::removeCliente(unsigned bi)
{
	//procura o cliente na base de dados de clientes
	unsigned int indice = pesquisaClienteDadoBi(bi);
	if(indice == -1)
	{
		return;
	}
	//encontrou manda sair do treino
	saiClienteDoTreino(bi);

	//antes de ir embora pagar a conta
	clientes[indice]->paga();

	//apaga, os clientes pertencem ao ginasio
	delete clientes[indice];
	//retira do vector o ponteiro para memoria já libertada
	clientes.erase(clientes.begin() + indice);
}

Ginasio::Ginasio():relogio(0)
{
}

Ginasio::~Ginasio()
{
	//apaga as fichas
	for(unsigned int i = 0; i< clientes.size(); i++)
	{
		delete clientes[i]; //os clientes pertencem ao ginasio
	}
}

unsigned Ginasio::getNumClientesATreinar() const
{
	unsigned int n = 0;
	for(unsigned int i = 0; i<clientes.size();i++)
	{
		if(clientes[i]->estarATreinar())
		{
			n++;
		}
	}
	return n;
}

Ginasio& Ginasio::operator=(const Ginasio& orig)
{
	//testar a auto atribuição se sao o mesmo objecto, "ja nao sao iguais"
	//nao se libertam recursos dos destino da atribuição porque coincide com a origem
	if(this == &orig)
	{
		return *this;
	}
	//apaga o conceudo ja existente no "alvo" da atribuicao (*this)
	for(unsigned int i = 0; i< clientes.size(); i++)
	{
		delete clientes[i]; //apaga mesmo os clientes (eram do ginasio)
	}
	//os clientes foram apagados, mas os ponteiros
	clientes.clear(); //ainda estão no vector, o qual deve ser esvaziado

	for(unsigned int i = 0; i<clientes.size(); i++)
	{
		//independentemente do tipo do cliente, duplica
		clientes.push_back(orig.clientes[i]->duplica());
	}
	//copiar o valor do relgio
	relogio = orig.relogio;
	return *this;
	
}

Ginasio::Ginasio(const Ginasio& orig)
{
	//nao é preciso pre inicialização explicita porque o vector e
	//inicializado automaticamente com o seu construtor por omissao
	//um avez que nao foi usado nenhum outro na lista de inicializaca deste construtor
	//e que o deixa  vazio e pronto a usar. noutros casos poderia ser necessario algo aqui
	*this = orig;
}

string Ginasio::getAsString() const
{
	ostringstream oss;

	oss << "\n ginasio" << "(tempo " << relogio << ")" << "clientes: " << endl;
	for(unsigned int i = 0 ; i < clientes.size(); i++)
	{
		oss << clientes[i]->getAsString() << endl;
	}
	oss << "\na treinar " << endl;
	for(unsigned int i = 0; i< clientes.size(); i++)
	{
		if(clientes[i]->estarATreinar())
		{
			oss << clientes[i]->getAsString() << endl;
		}
	}
	return oss.str();
}

int main()
{


	cout << "\nfim do main" << endl;
	return 1;
}

}

………..ficha7, exercicio5 (a24)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;


class Tagarela;
class FalaPouco;

//classe base, abstracta, relação de 
class Tarifario
{
	//nao existem dados, quem tem é o Cartao
	//nao tem informação
public:
	//só tem funções
	Tarifario() = default;

	virtual float calculaCustoChamada(int s) const = 0; //virtual e =0
	virtual float fazCarregamento(float quantia) const = 0;
	virtual bool autorizaChamada(int saldo) const = 0;

	virtual string getNome()const = 0;
	virtual Tarifario* duplica() const = 0; //por causa do operador atribuição na classe rede

	static Tarifario* fabrica(string tipo); //fabrica de tarifarios, para os arrumar

	virtual string getAsString() const;
};

Tarifario* Tarifario::fabrica(string tipo)
{
	if(tipo=="Tagarela")
	{
		return new Tagarela;
	}else if(tipo == "FalaPouco")
	{
		return new FalaPouco;
	}else
	{
		return nullptr;
	}
}

string Tarifario::getAsString() const
{
	ostringstream oss;
	oss << "tarifario: " << endl;
	return oss.str();
}

//classe derivada
class Tagarela : public Tarifario
{
	//existem constantes desta classe
	static const float PRIMEIRO_MINUTO;
	static const float MINUTOS_SEGUINTES;
	static const float BONUS;
	static const float BASE;
public:
	float calculaCustoChamada(int s) const override;
	float fazCarregamento(float quantia) const override;
	bool autorizaChamada(int saldo) const override;
	string getNome() const override;
	Tarifario* duplica() const override;
	string getAsString() const override;
};
//concretizar as constantes
const float Tagarela::PRIMEIRO_MINUTO = 0.02f;
const float Tagarela::BONUS = 5.0f;
const float Tagarela::BASE = 25.0f;
const float Tagarela::MINUTOS_SEGUINTES = 0.02f;


float Tagarela::calculaCustoChamada(int s) const
{
	if(s<=0) //saldo
	{
		return 0;
	}
	float aux_custo = PRIMEIRO_MINUTO;
	if(s>60)
	{
		aux_custo += MINUTOS_SEGUINTES * (s - 60) / 60.0;
	}
	return aux_custo;
}

float Tagarela::fazCarregamento(float quantia) const
{
	if(quantia<BASE)
	{
		return 0;
	}else if(quantia>=2*BASE)
	{
		quantia += BONUS;
	}
	return quantia;
}

bool Tagarela::autorizaChamada(int saldo) const
{
	return saldo >= -PRIMEIRO_MINUTO;
}

string Tagarela::getNome() const
{
	return  "Tagarela";
}

Tarifario* Tagarela::duplica() const
{
	return  new Tagarela(*this);
}

string Tagarela::getAsString() const
{
	ostringstream oss;
	oss << "tagarela: " << endl;
	return oss.str();
}

//classe derivada
class FalaPouco : public Tarifario
{
	static const float TODOS_MINUTOS;
	static const float CARREGAMENTOS;
	static const float BONUS_CARREGAMENTOS;
public:
	float calculaCustoChamada(int s) const override;
	float fazCarregamento(float quantia) const override;
	bool autorizaChamada(int saldo) const override;
	string getNome() const override;
	Tarifario* duplica() const override;
	string getAsString() const override;
};
//concretizar as constantes
const float FalaPouco::TODOS_MINUTOS = 0.25f;
const float FalaPouco::CARREGAMENTOS = 10.0f;
const float FalaPouco::BONUS_CARREGAMENTOS = 0.2f;

float FalaPouco::calculaCustoChamada(int s) const
{
	if(s<0)
	{
		return 0;
	}
	return TODOS_MINUTOS * s / 60.0;
}

float FalaPouco::fazCarregamento(float quantia) const
{
	if(quantia<CARREGAMENTOS)
	{
		return 0;
	}
	int n = rand() % 10; //de 0 a 9
	if(n<2) //<2 é 20%
	{
		quantia *= 2;
	}
	return quantia;
}

bool FalaPouco::autorizaChamada(int saldo) const
{
	//ou talvez meu
	if(saldo<=(TODOS_MINUTOS*10))
	{
		return false;
	}
	return true;
	//ou
	//return saldo >= - TODOS_MINUTOS * 10;
}

string FalaPouco::getNome() const
{
	return "FalaPouco";
}

Tarifario* FalaPouco::duplica() const
{
	return new FalaPouco(*this);
}

string FalaPouco::getAsString() const
{
	ostringstream oss;
	oss << "falapouco" << endl;
	return oss.str();
}

class Cartao
{
	long numero;
	float saldo;
	Tarifario* tarifario;
public:
	Cartao(const long numero, Tarifario* const tarifario);
	virtual ~Cartao();


	long getNumero() const;
	float getSaldo() const;
	string getNomeTarifario() const;

	void setTarifario(Tarifario* const tarifario0);

	bool autorizaChamada()const;
	void registaChamada(int saldo);
	bool fazCarregamento(float quantia);

	string getAsString()const;

};
bool operator==(const Cartao& orig1, const Cartao& orig2); //para dois tarifários iguais!!

Cartao::Cartao(const long numero0, Tarifario* const tarifario0):numero(numero0), tarifario(tarifario0), saldo(0){}

long Cartao::getNumero() const
{
	return numero;
}

float Cartao::getSaldo() const
{
	return saldo;
}

string Cartao::getNomeTarifario() const
{
	return tarifario->getNome();
}

void Cartao::setTarifario(Tarifario* const tarifario0)
{
	this->tarifario = tarifario0;
}

bool Cartao::autorizaChamada() const
{
	//função polimorfica, conforme o tarifario
	return tarifario->autorizaChamada(saldo);
}

void Cartao::registaChamada(int saldo0)
{
	//função polimorfica, conforme o tarifario
	float aux_custo = tarifario->calculaCustoChamada(saldo0);
	saldo = -aux_custo;
}

bool Cartao::fazCarregamento(float quantia0)
{
	//função polimorfica, conforme o tarifario
	float aux_carregamento = tarifario->fazCarregamento(quantia0);
	saldo += aux_carregamento;
	return aux_carregamento > 0;
}

string Cartao::getAsString() const
{
	ostringstream oss;
	oss << "(numero " << numero << " saldo: " << saldo << " tarifario " << tarifario->getNome() << ")";
	return oss.str();
}

bool operator==(const Cartao& orig1, const Cartao& orig2)
{
	return orig1.getNumero() == orig2.getNumero();
}


class Rede
{
	string nome;
	//tarifarios é uma classe abstracta
	//logo não pode haver objectos de uma classe abstracta
	//vector <Tarifario> tarifarios;
	//e queremos ponteiros para a classe base, e uma coleção polimorfica
	vector <Tarifario*> tarifarios;
	//cartoes não tem derivadas
	//e podia ser vector <Cartao> cartoes;
	vector <Cartao*> cartoes;

	Tarifario* procuraTarifario(const string& nome) const;
public:
	Rede(const string& nome0);

	//rede composição: qd a rede deixar de existir os tarifários tb deixam
	Rede(const Rede& ob);
	Rede & operator=(const Rede& ob); //tem uma dificuldade
	~Rede();

	void setNome(const string& nome0);

	bool acrescentaTarifario(const string& nomeTarifario);
	bool acrescentaCartao(long num, const string& nomeTarifa);

	int procuraCartao(long i)const;
	bool removeCartao(long i);

	bool registaChamada(long numero, int duracao);
	bool fazCarregamento(long numero, float quantia);
	bool autorizaChamada(long n)const;

	string getAsString() const;
	
};
ostream& operator<<(ostream& saida, const Rede& rede);

Tarifario* Rede::procuraTarifario(const string& nome) const
{
	for(Tarifario *t : tarifarios)
	{
		if(t->getNome() == nome)
		{
			return t;
		}
	}
	return nullptr;
}

Rede::Rede(const string& nome0):nome(nome0)
{
}

Rede::Rede(const Rede& ob)
{
	*this = ob;
}

Rede& Rede::operator=(const Rede& ob) //immportante, complicado
{
	//prevenção da auto atribuicao
	if(this == &ob)
	{
		return  *this;
	}
	//libertar mem. dinamica apontada pelo primeiro membro da atribuicao
	//e esvaziar os vectores
	for(Tarifario *t: tarifarios)
	{
		delete t;
	}
	tarifarios.clear();
	for(Cartao *c: cartoes)
	{
		delete c;
	}
	cartoes.clear();
	//copiar os dados do segundo membro da atribuição
	nome = ob.nome;
	for(Tarifario * t: ob.tarifarios)
	{
		tarifarios.push_back(t->duplica());
	}
	//depois de todos os tarifários do primeiro membro da atribuição copiados
	for(Cartao *c: ob.cartoes)
	{
		Cartao* novo = new Cartao(*c);
		//cópia do cartao
		//que aponta para um tarifario do segundo membro da atribuicao
		string nomeTarifario = c->getNomeTarifario();

		//identifica do seu tarifario
		//procura tarifario com nomeTarifario no vector do primeiro membro da atribuicao 
		Tarifario* t = procuraTarifario(nomeTarifario);
		novo->setTarifario(t);
		
		cartoes.push_back(novo);
	}
}

Rede::~Rede()
{
	//porque sao vectres de ponteiros para objectos dinamicos
	for(Tarifario *t: tarifarios)
	{
		delete t;
	}
	for(Cartao *c: cartoes)
	{
		delete c;
	}
	//e o que o destrutor libetra
	//o construtor por copia e o operador atribuicao tem que duplicar
	cout << "destr da rede " << nome << endl;
}

void Rede::setNome(const string& nome0)
{
	this->nome = nome0;
}

bool Rede::acrescentaTarifario(const string& nomeTarifario)
{
	Tarifario* tarifario0 = procuraTarifario(nomeTarifario);
	if(tarifario0 != nullptr)
	{
		return  false;
	}
	Tarifario* novoTarifario = Tarifario::fabrica(nomeTarifario);
	if(novoTarifario == nullptr)
	{
		return false;
	}
	tarifarios.push_back(novoTarifario);
	return true;
}

bool Rede::acrescentaCartao(long num, const string& nomeTarifa)
{
	if(procuraCartao(num) != -1)
	{
		return false;
	}
	Tarifario* tf = procuraTarifario(nomeTarifa);
	if(tf == nullptr)
	{
		return false;
	}
	cartoes.push_back(new Cartao(num, tf));
	return true;
}

int Rede::procuraCartao(long i) const
{
	for(unsigned int indice = 0; indice < cartoes.size(); indice++)
	{
		if(cartoes[indice]->getNumero() == i)
		{
			return indice;
		}
	}
	return -1;
}

bool Rede::removeCartao(long i)
{
	int aux = procuraCartao(i);
	if(aux == -1)
	{
		return false;
	}
	//relação de composição
	delete cartoes[aux]; //libetra o objecto
	cartoes.erase(cartoes.begin() + aux);//tira o ponteiro do vector
	return true;
}

bool Rede::registaChamada(long numero, int duracao)
{
	int aux = procuraCartao(numero);
	if(numero == -1)
	{
		return  false;
	}
	cartoes[aux]->registaChamada(duracao);
	return true;
}

bool Rede::fazCarregamento(long numero, float quantia)
{
	int aux = procuraCartao(numero);
	if(aux== -1)
	{
		return false;
	}
	return cartoes[aux]->fazCarregamento(quantia);
}

bool Rede::autorizaChamada(long n) const
{
	int aux = procuraCartao(n);
	if(aux == -1)
	{
		return false;
	}
	return cartoes[aux]->autorizaChamada();
}
string Rede::getAsString() const
{
	ostringstream oss;
	oss << "\nRede: " << nome << endl << " tarifarios: ";
	for(Tarifario *t : tarifarios)
	{
		oss << t->getNome() << "\t";
	}
	oss << "\nCartoes: " << endl;
	for(Cartao *c : cartoes)
	{
		oss << c->getAsString() << endl;
	}
	return oss.str();
}

ostream& operator<<(ostream& saida, const Rede& rede)
{
	saida << rede.getAsString();
	return saida;
}


int main(){
	
	Rede* rede = new Rede("meo");
	rede->acrescentaTarifario("Tagarela");
	rede->acrescentaTarifario("FalaPouco");
	rede->acrescentaCartao(10, "Tagarela");
	rede->acrescentaCartao(20, "FalaPouco");
	cout << rede->getAsString();
	rede->removeCartao(10);
	cout << rede->getAsString();
	
	delete rede;
	

	cout << "\nfim do main" << endl;
	return 0;
}

classes cujos objectos interagem de forma bidirecional

………..ficha6, exercicio1 (a18)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class Aquario;

class Peixe
{
	string nomeEspecie;
	string cor;
	int peso;
	int numSerie;
	int estadio; //0, normal, 1, emagrece, 2,3,4,5 nao come, 6 morre

	static int sequencia;
	//constantes iguais para todos:
	static const int LIMITE_PESO = 50;
	static const int INICIAL_PESO = 10;
	
public:
	Peixe(string nomeEspecie0, string cor0="cinzento");
	//posso e controlo total:
	//composição: destrutor a lierbtar os peixes, construtor pro copia e operador atribuição a duplicar aquilo que o destrutor destroi

	string getNomeEspecie() const;
	void setNomeEspecie(const string& nome_especie);
	string getCor() const;
	void setCor(const string& cor);
	int getPeso() const;
	void setPeso(const int peso);
	int getNumSerie() const;
	void setNumSerie(const int num_serie);
	int getEstadio() const;
	void setEstadio(const int estadio);

	bool isVivo()const;
	void alimentar(int quant, Aquario* aquario);
	
	string getAsString()const;
};

Peixe::Peixe(string nomeEspecie0, string cor0):nomeEspecie(nomeEspecie0), cor(cor0), peso(INICIAL_PESO), numSerie(++sequencia), estadio(0)
{
}

string Peixe::getNomeEspecie() const
{
	return nomeEspecie;
}

void Peixe::setNomeEspecie(const string& nome_especie)
{
	nomeEspecie = nome_especie;
}

string Peixe::getCor() const
{
	return cor;
}

void Peixe::setCor(const string& cor)
{
	this->cor = cor;
}

int Peixe::getPeso() const
{
	return peso;
}

void Peixe::setPeso(const int peso)
{
	this->peso = peso;
}

int Peixe::getNumSerie() const
{
	return numSerie;
}

void Peixe::setNumSerie(const int num_serie)
{
	numSerie = num_serie;
}

int Peixe::getEstadio() const
{
	return estadio;
}

void Peixe::setEstadio(const int estadio)
{
	this->estadio = estadio;
}

bool Peixe::isVivo() const
{
	return getEstadio() <= 5;
}

void Peixe::alimentar(int quant, Aquario* aquario)
{
	if(quant <= 0|| aquario == nullptr)
	{
		return;
	}
	if(estadio >0 && estadio<=5)
	{
		++estadio;
		return;
	}
	if(estadio>5)
	{
		return;
	}
	peso += quant;
	if(peso> LIMITE_PESO)
	{
		int probabilidade = rand() % 100;
		if(probabilidade < 50)
		{
			peso = LIMITE_PESO - INICIAL_PESO;
			aquario->nasceNovoPeixe(nomeEspecie, cor);
		}else
		{
			peso /= 2; //reduzido a metade
			estadio = 1;
		}
	}
	
}

string Peixe::getAsString() const
{
	ostringstream oss;

	oss << "\nPeixe: " << nomeEspecie << "\ncor: " << cor << "\npeso: " << peso << "\nnumSerie: " << numSerie << (estadio <= 5 ? " vivo" : " morto") << " estadio " << estadio << endl;
	return oss.str();
}

int Peixe::sequencia = 499; //num. para cada peixe


//relação bidirecional entre o Peixe e o Aquario
//include no CPP e declaração da classe no h

class Aquario
{
	//tem uma colecção de peixes
	vector<Peixe*> peixes;
	vector<Peixe*> novos; //o peixe usa para colocar os novos

	void eliminarMortos();
	void deslocaNovoParaAquario();
	int pesquisaPeixe(int numSerie0)const;
	
public:

	Aquario() = default; //os dois vectores são construidos por omissão, isto é ficam vazios na construção
	//e porque não existe nenhum ponteirp primitivo na classe
	//e no construtor por copia fica mais simples
	
	virtual ~Aquario();

	//quando um peixei e colocado no aquario, este assume
	//a sua posse e controlo total:
	Aquario(const Aquario& orig); //construtor por copia
	Aquario& operator=(const Aquario & orig); //operador atribuição
	
	void removePeixe(int numSerie);
	void alimentar(int quantidade0);
	void nasceNovoPeixe(string especie0, string cor0);

	bool acrescentaPeixeDoExterior(Peixe* peixe);

	string getAsString()const;
};



void Aquario::alimentar(int quantidade0)
{
	for(Peixe * p : peixes)
	{
		p->alimentar(quantidade0, this); //mt cuidado com isto, usa o vector<Peixe*> novos;
	}
	eliminarMortos();
	deslocaNovoParaAquario(); //sair do novo para o aquario normal
}

void Aquario::nasceNovoPeixe(string especie0, string cor0)
{
	novos.push_back(new Peixe(especie0, cor0));
}

bool Aquario::acrescentaPeixeDoExterior(Peixe* peixe)
{
	if (peixe == nullptr){
		return false;
	}
	//se o peixe estiver no aquario
	if(pesquisaPeixe(peixe->getNumSerie())!= -1)
	{
		return false;
	}
	//se ainda nao esta no aquario
	//criar um novo em mem dinamica, com new
	Peixe* p = new Peixe(*peixe); //faço copia local
	peixes.push_back(p);
	return true;
}

string Aquario::getAsString() const
{
	ostringstream oss;
	oss << "\nAquario; " << endl;
	for(Peixe * p: peixes)
	{
		oss << p->getAsString();
	}
	return oss.str();
}

int Aquario::pesquisaPeixe(int numSerie0)const
{
	for(int i=0; i < peixes.size(); i++)
	{
		if(peixes[i]->getNumSerie() == numSerie0)
		{
			return i;
		}
	}
	return -1;
}

void Aquario::eliminarMortos()
{
	//formula
	//ou
	//for(vector<Peixe*>::iterator it = peixes.begin() ; it != peixes.end(); )
	//ou
	for(auto it = peixes.begin(); it != peixes.end();)
	{
		if(!(*it)->isVivo())
		{
			delete (*it);
			it = peixes.erase(it);
		}else
		{
			++it;
		}
	}
}

void Aquario::deslocaNovoParaAquario()
{
	for(Peixe * p: peixes)
	{
		peixes.push_back(p);
	}
	novos.clear();
}

Aquario::~Aquario()
{
	for(Peixe * p: peixes)
	{
		delete p;
	}
	for(Peixe * p: novos)
	{
		delete p;
	}
	cout << "\n~Aquario()" << endl;
}

Aquario::Aquario(const Aquario& orig)
{
	*this = orig;
}

Aquario& Aquario::operator=(const Aquario& orig)
{
	//prevenção da auto atribuição
	if(this  == &orig)
	{
		return  *this;
	}
	//libtertar mem dina velha
	for(Peixe * p : peixes)
	{
		delete p;
	}
	peixes.clear();
	//copiar a infor de orig, duplicando os objectos dinamicos Peixe
	for(Peixe * p: orig.peixes){
		peixes.push_back(new Peixe(*p));
	}
	for(Peixe * p: orig.peixes)
	{
		novos.push_back(new Peixe(*p));
	}
	return *this;
}

void Aquario::removePeixe(int numSerie)
{
	int qual = pesquisaPeixe(numSerie);
	if(qual == -1)
	{
		return;
	}
	delete peixes[qual];
	peixes.erase(peixes.begin() + qual);
}

int main()
{
	Peixe a("Robalo", "branco");
	Peixe b("Pescada");
	Peixe c("Salmao");

	Aquario* aq1 = new Aquario;

	aq1->acrescentaPeixeDoExterior(&a);
	aq1->acrescentaPeixeDoExterior(&b);
	aq1->acrescentaPeixeDoExterior(&c);

	cout << aq1->getAsString() << endl; // peso 10

	aq1->alimentar(20);

	cout << aq1->getAsString() << endl;  // peso 30
	aq1->alimentar(30);
	cout << aq1->getAsString() << endl;  // peso 60 e consequencias

	for (int i = 0; i < 6; ++i) {
		aq1->alimentar(1);
		cout << aq1->getAsString() << endl;
	}
	aq1->removePeixe(500);
	aq1->removePeixe(500);
	cout << aq1->getAsString() << endl;


	/// testa mem din
	Aquario* aq2 = new Aquario;
	aq2->acrescentaPeixeDoExterior(&a);
	aq2->acrescentaPeixeDoExterior(&a);
	aq2->acrescentaPeixeDoExterior(&a);

	cout << aq2->getAsString() << endl;

	*aq2 = *aq1;

	delete aq1;
	cout << " aq1:\n";
	cout << " aq2:\n";
	cout << aq2->getAsString() << endl;

	Aquario* aq3 = new Aquario(*aq2);
	delete aq2;
	cout << aq3->getAsString() << endl;
	delete aq3;

	cout << "\nfim do main" << endl;
	return 1;
}

objetos dinâmicos, matrizes dinâmicas, classes com construtores por cópia, operador de atribuição e destrutor

………..ficha5, exercicio1 (a15)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

class MSG
{
	string mensagem;
public:
	//	MSG(const string & s);
	MSG(const string& s="por omissao"); //d)
	~MSG();
};

MSG::MSG(const string& s):mensagem(s)
{
	cout << "ola " << mensagem << "\n";
}

MSG::~MSG()
{
	cout << "adeus " << mensagem << endl;
}

MSG * func(string s)
{
	MSG* p = new MSG(s);
	cout << "\n func: criado um objecto " << s << endl;
	return p; //retornamos uma copia, que é o valor do endereço
}

int main()
{
	//a) 
	//MSG * a = new MSG("AAAA");
	//MSG * b = new MSG("BBBB");
	////para destruir o new só aplicando o delete
	//cout << "\ndestruir..";
	//delete a; //destroi apenas o objecto dinamico, não o ponteiro
	//cout << "\ndestruir..";
	//delete b;
	//
	////um objecto que nao é dinamico
	//MSG c("CCCC");

	//a = new MSG("outro"); //o ponteiro a continua disponivel!
	//delete a;

	//c usar a func(a,b)
	//MSG* a = func("AAAA");
	//MSG* b = func("BBBB");
	//delete a;
	//delete b;
	
	//d)
	MSG* v = new MSG[3]; // com este construtor MSG(const string & s); nao funciona
	//só funciona com construtor por omissão
	MSG* v0 = new MSG[2]{ {"primeiro"}, {"segundo"} };

	//e)
	delete [] v;
	delete [] v0;

	//não se pode libertar espaço do MSG* v = new MSG[3];
	//quando se liberta é todos de uma vez
	
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha5, exercicio2 (a15, a16)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

/*
+---------------------------------------- + -------------------------- - +
| operador					| membro / não membro |
+---------------------------------------- + -------------------------- - +
| todos os operadores unários p.e: ++a, a++   | membro                    |
| = () -> ->*				  | têm sempre que ser membro |
| += -= /= *= &= |= %= >>= <<=	      | membro                    |
| todos os restantes operadores binários, ==,<<...           | globais |
+---
*/

class ABC
{
	char* p;
public:
	ABC(const char* s);
	~ABC();

	//c
	const char* getConteudo() const;
	//c) construtor por copia
	ABC(const ABC& ob);
	//c) operador atribuição
	ABC& operator=(const ABC & ob);
};

ABC::ABC(const char* s)
{
	p = new char[strlen(s) + 1];
	//construtor cria, composição
	strcpy(p, s);
	cout << "\nconstruindo .." << p << endl;
}

ABC::~ABC()
{
	cout << "\ndestruindo .." << p << endl;
	delete[] p;
}

const char* ABC::getConteudo() const
{
	return p;
}

//ABC::ABC(const ABC& ob) //c) versão um
//{
//	p = nullptr;
//	//ver se estamos a copiar uma string vazia
//	if(ob.p == nullptr || strlen(ob.p)==0)
//	{
//		return;
//	}
//	//alocar espaco para copiar a string da origem da copia
//	p = new char[strlen(ob.p) + 1];
//	//copiar para o proprio espaco
//	strcpy(p,ob.p);
//
//	cout << "\nconstrutor por copia: " << p << endl;
//}

ABC& ABC::operator=(const ABC& ob) //c)
{
	//operador atribuição tem:
	//prevenção da auto atribuição
	if (this == &ob) {
		return *this;
	}
	//libertacao de memoria apontada pelo prim membro de atribuição
	delete[]p; //ponteiro que tem lixo
	//limpar objecto
	p = nullptr;
	//se estamos a copiar uma string vazia
	if(ob.p == nullptr || strlen(ob.p)==0)
	{
		return *this;
	}
	//alocar espaco para copiar a string do segundo membro
	p = new char[strlen(ob.p) + 1];
	//copiar a string do seg membro para um espaco proprio
	strcpy(this->p, ob.p);
	cout << "\nOperador atribuicao ";
	
	return *this;
}

//c) alternativa versao dois
//construtor por copia à custa do operador atribuição
ABC::ABC(const ABC& ob)
{
	p = nullptr;
	*this = ob; //ao fazer esta atribuição chama.se o operator=
	cout << "\n CCop " << (p != nullptr ? p : nullptr) << " - " << ob.p << endl;
}


//b
void gastaMemoria()
{
	ABC temp("\nTexto temporario que ocupa espaco");
}

//c)
void func(ABC a)
{
	//o a é passado por valor
	//o a é criado pro copia de y, com o construtor por cópia
	//o construtor automatico, faz copia de membro a membro
}

void func()
{
	ABC a("aaa");
	ABC b("bbb");
	a = b;
}

int main()
{
	//b
	//for(unsigned int i = 0; i<10 ; i++)
	//{
	//	gastaMemoria();
	//}
	
	//c
	//a classe não tem construtor por cópia
	//a classe não tem operador de atribuição
	//apos o construtor por copia
	ABC y("ola y");
	cout << "conteudo do y: " << y.getConteudo() << endl;
	func(y);
	cout << "conteudo do y: " << y.getConteudo() << endl;
	//apos o operador de atribuição e a versao dois
	func();
		
	cout << "\nfim do main" << endl;
}

………..ficha5, exercicio5 (a16)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;
//versão matriz dinamica
class Pessoa {
	string nome;
	long bi;
	long nif;

	void setBi(long b);
public:
	Pessoa() = delete;
	Pessoa(const string& s, long b, long n);
	string getNome()const;
	void setNome(const string& n);
	long getBi()const;
	long getNif()const;
	void setNif(long t);
	string getAsString()const;

};

Pessoa::Pessoa(const string& s, long b, long n)
	: nome(s), bi(b), nif(n) {
}

string Pessoa::getNome()const {
	return nome;
}

void Pessoa::setNome(const string& n) {
	nome = n;
}

long Pessoa::getBi()const {
	return bi;
}

void Pessoa::setBi(long b) {
	bi = b;
}

long Pessoa::getNif()const {
	return nif;
}

void Pessoa::setNif(long t) {
	nif = t;
}

string Pessoa::getAsString()const {
	ostringstream oss;
	oss << "\nNome: " << nome
		<< "\nBi: " << bi
		<< "\nNif: " << nif << endl;
	return oss.str();
}

	
class Clube {
	Pessoa** socios; //vector <Pessoa *> socios;
	int tam;
public:
	Clube(int t);
	~Clube();
	void setMembroDoclube(Pessoa* p, int pos);

	//construtor por copia
	Clube(const Clube& ob);
	//operador atribuição
	Clube & operator=(const Clube & ob);

	string getAsString() const;
};


Clube::Clube(int t)
{
	tam = t > 0 ? t : 0;
	if(tam == 0)
	{
		socios = nullptr;
		return;
	}
	socios = new Pessoa * [tam]; //tam, é um array tam, de tam Pessoa *.
	if (socios == nullptr) {
		tam = 0;
		return;
	}
	for (unsigned int i = 0; i < tam; i++)
		socios[i] = nullptr; //tudo igual a nulltpr
}

Clube::~Clube()
{
	delete[]socios; //liberta o array dinamico dos ponteiros
	//nao existe o ciclo for para deletar as pessoas
	//ninguem toca nas pessoas
}

//v1
//void Clube::setMembroDoclube(Pessoa* p, int pos)
//{
//	socios[pos] = p; //socios 0 = endereço de p
//}

//v2
void Clube::setMembroDoclube(Pessoa* p, int pos)
{
	if(pos >= 0 && pos < tam && socios[pos] == nullptr)
	{
		socios[pos] = p;
	}
}

Clube::Clube(const Clube& ob)
{
	//limpar os ponteiros aos quais o operador atribuicao vai fazer delete
	socios = nullptr;
	tam = 0;
	//aplicar o operador atribuição
	*this = ob;
}

Clube & Clube::operator=(const Clube& ob)
{
	//prevenção da auto atribuição
	if(this == &ob)
	{
		return *this;
	}
	//limpar memoria velha
	delete[] socios; //a seguir é necessário o nullptr
	socios = nullptr;
	tam = 0;

	//se a origem da copia for um clube sem socios
	if(ob.socios == nullptr || ob.tam ==0 )
	{
		return * this;
	}
	//se a origem da copia for um clube com socios
	socios = new Pessoa * [ob.tam];
	//copiar o tam
	tam = ob.tam;
	//copiar os ponteiros
	for(unsigned int i = 0; i < tam; i++)
	{
		//nao se duplicam os cosios porque a relacao entre clube e socios e de agregacao
		//o destrutor tambem nao os destroi
		socios[i] = ob.socios[i];
	}
	return *this;
}

string Clube::getAsString() const
{
	ostringstream oss;
	oss << "\nTam: " << tam << endl;
	for (unsigned int i = 0; i < tam; i++) {
		if (socios[i] != nullptr) {
			oss << socios[i]->getAsString() << endl;
		}
	}
	
	return oss.str();
}


int main()
{
	//agregacao entre o clube e as pessoas
	//relação entre o clube e o array de ponteiros é de composição
	
	Pessoa a("aaa",1,111), b("bbb", 2, 222);
	Clube* clube1 = new Clube(50);
	clube1->setMembroDoclube(&a, 0);
	clube1->setMembroDoclube(&b, 1);

	cout << "Clube1: " << clube1->getAsString();
	
	Pessoa c("ccc", 3, 333), d("ddd", 4, 444);
	Clube* clube2 = new Clube(10);
	clube2->setMembroDoclube(&a, 0);
	clube2->setMembroDoclube(&b, 1);
	clube2->setMembroDoclube(&c, 2);
	clube2->setMembroDoclube(&d, 3);

	cout << "Clube2: " << clube2->getAsString();

	*clube1 = *clube2; //atribuir os apontados
	delete clube2;
	cout << "Clube2 depois: " << clube1->getAsString();

	//copia do apontado
	Clube clube3(*clube1);
	cout << "Clube3 depois: " << clube3.getAsString();
	
	cout << "\nfim do main" << endl;
}

………..ficha5, exercicio5 (a16,)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;
//versão vector 
class Pessoa {
	string nome;
	long bi;
	long nif;

	void setBi(long b);
public:
	Pessoa() = delete;
	Pessoa(const string& s, long b, long n);
	string getNome()const;
	void setNome(const string& n);
	long getBi()const;
	long getNif()const;
	void setNif(long t);
	string getAsString()const;

};

Pessoa::Pessoa(const string& s, long b, long n)
	: nome(s), bi(b), nif(n) {
}

string Pessoa::getNome()const {
	return nome;
}

void Pessoa::setNome(const string& n) {
	nome = n;
}

long Pessoa::getBi()const {
	return bi;
}

void Pessoa::setBi(long b) {
	bi = b;
}

long Pessoa::getNif()const {
	return nif;
}

void Pessoa::setNif(long t) {
	nif = t;
}

string Pessoa::getAsString()const {
	ostringstream oss;
	oss << "\nNome: " << nome
		<< "\nBi: " << bi
		<< "\nNif: " << nif << endl;
	return oss.str();
}

class Clube {
	//Pessoa** socios;
	vector <Pessoa *> socios;
	
	int tam;
public:
	Clube(int t);
	//~Clube();
	void setMembroDoclube(Pessoa* p, int pos);

	//construtor por copia
	//Clube(const Clube& ob);
	//operador atribuição
	//Clube& operator=(const Clube& ob);
	//Nesta versao não é preciso construtor por copia, atribuição e destrutor
	//Por nesta classe so usarmos ponteiros, e não ciramos nenhuma memoria dinamica, logo não existe necessidade de cópiar nada
	string getAsString() const;
};

//Clube::Clube(int t)
//{
//	tam = t > 0 ? t : 0;
//	if (tam == 0)
//	{
//		socios = nullptr;
//		return;
//	}
//	socios = new Pessoa * [tam]; //tam, é um array tam, de tam Pessoa *.
//	if (socios == nullptr) {
//		tam = 0;
//		return;
//	}
//	for (unsigned int i = 0; i < tam; i++)
//		socios[i] = nullptr; //tudo igual a nulltpr
//}

Clube::Clube(int t)
{
	for (unsigned int i = 0; i < t; i++) {
		socios.push_back(NULL);
	}
}

//v1
//Clube::~Clube()
//{
//	delete[]socios; //liberta o array dinamico dos ponteiros
//	//nao existe o ciclo for para deletar as pessoas
//	//ninguem toca nas pessoas
//}

//v1
//void Clube::setMembroDoclube(Pessoa* p, int pos)
//{
//	socios[pos] = p; //socios 0 = endereço de p
//}

//v2
//void Clube::setMembroDoclube(Pessoa* p, int pos)
//{
//	if (pos >= 0 && pos < tam && socios[pos] == nullptr)
//	{
//		socios[pos] = p;
//	}
//}

//v3 vestores
void Clube::setMembroDoclube(Pessoa* p, int pos)
{
	if (pos >= 0 && pos < socios.size() && socios[pos] == NULL) {
		socios[pos] = p; // Notar que o obj. Pessoa e visto pelo Clube
	}
}

//Clube::Clube(const Clube& ob)
//{
//	//limpar os ponteiros aos quais o operador atribuicao vai fazer delete
//	socios = nullptr;
//	tam = 0;
//	//aplicar o operador atribuição
//	*this = ob;
//}
//
//Clube& Clube::operator=(const Clube& ob)
//{
//	//prevenção da auto atribuição
//	if (this == &ob)
//	{
//		return *this;
//	}
//	//limpar memoria velha
//	delete[] socios; //a seguir é necessário o nullptr
//	socios = nullptr;
//	tam = 0;
//
//	//se a origem da copia for um clube sem socios
//	if (ob.socios == nullptr || ob.tam == 0)
//	{
//		return *this;
//	}
//	//se a origem da copia for um clube com socios
//	socios = new Pessoa * [ob.tam];
//	//copiar o tam
//	tam = ob.tam;
//	//copiar os ponteiros
//	for (unsigned int i = 0; i < tam; i++)
//	{
//		//nao se duplicam os cosios porque a relacao entre clube e socios e de agregacao
//		//o destrutor tambem nao os destroi
//		socios[i] = ob.socios[i];
//	}
//	return *this;
//}

//v1
//string Clube::getAsString() const
//{
//	ostringstream oss;
//	oss << "\nTam: " << tam << endl;
//	for (unsigned int i = 0; i < tam; i++) {
//		if (socios[i] != nullptr) {
//			oss << socios[i]->getAsString() << endl;
//		}
//	}
//
//	return oss.str();
//}
//v2 vectores
string Clube::getAsString()const {
	ostringstream oss;
	oss << "\nTam: " << socios.size() << endl;
	for (unsigned int i = 0; i < socios.size(); i++) {
		if (socios[i] != nullptr) {
			oss << socios[i]->getAsString() << endl; // tem de uusar ->
		}
	}
	return oss.str();
}
int main()
{
	//agregacao entre o clube e as pessoas
	//relação entre o clube e o array de ponteiros é de composição

	Pessoa a("aaa", 1, 111), b("bbb", 2, 222);
	Clube* clube1 = new Clube(50);
	clube1->setMembroDoclube(&a, 0);
	clube1->setMembroDoclube(&b, 1);

	cout << "Clube1: " << clube1->getAsString();

	Pessoa c("ccc", 3, 333), d("ddd", 4, 444);
	Clube* clube2 = new Clube(10);
	clube2->setMembroDoclube(&a, 0);
	clube2->setMembroDoclube(&b, 1);
	clube2->setMembroDoclube(&c, 2);
	clube2->setMembroDoclube(&d, 3);

	cout << "Clube2: " << clube2->getAsString();

	*clube1 = *clube2; //atribuir os apontados
	delete clube2;
	cout << "Clube2 depois: " << clube1->getAsString();

	//copia do apontado
	Clube clube3(*clube1);
	cout << "Clube3 depois: " << clube3.getAsString();

	cout << "\nfim do main" << endl;
}

………..ficha5, exercicio7 (a17)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

//relação da agenda com contacto é de composição
//qd a agenda for destruida os contactos tb são
//contactos: objecto em memória dinamica
//usar vectores, sem necessidade de indicar quantidades
//matriz dinamics de ponteiros


class Contacto
{
	string nome;
	unsigned int tel;
public:
	Contacto() = delete;
	Contacto(const string& s, unsigned int t);
	string getNome()const;
	void setNome(const string& n);
	unsigned int getTel()const;
	void setTel(unsigned int t);
	string getAsString()const;
};

Contacto::Contacto(const string& s, unsigned t):nome(s), tel(t)
{
}

string Contacto::getNome() const
{
	return  nome;
}

void Contacto::setNome(const string& n)
{
	this->nome = n;
}

unsigned Contacto::getTel() const
{
	return tel;
}

void Contacto::setTel(unsigned t)
{
	this->tel = t;
}

string Contacto::getAsString() const
{
	ostringstream oss;
	oss << "Contacto " << " Nome: " << nome << "\tTel: " << tel;
	return oss.str();
}


class Agenda
{
	string nome;
	vector<Contacto*> contactos; //vector de ponteiros
	//o objecto composto vai destruir a string e o vector de ponteiros
	//mas não os apontados, tem que haver um destrutor que faça a libertação dos apontados
	//pois não existe mais nada no programa que conheça os apontados (ver destrutor da Agenda)
	int pesquisa(const string& s)const;
public:
	Agenda(const string& nome0);
	Agenda(const Agenda& ob); //construtor por copia
	Agenda& operator=(const Agenda& ob); //operador =
	~Agenda();
	string getNome()const;
	void setNome(const string& nome0);
	bool acrescentaContacto(const string& n, unsigned int i);
	bool removeContacto(const string& n);
	string getAsString()const;
	const Contacto * getContacto(const string& s);

	bool gravaContactosEmFicheiroDeTexto();
	bool lerContactosDeFicheiroDeTexto();
	
};


int Agenda::pesquisa(const string& s) const
{
	for(unsigned int i = 0 ; i < contactos.size(); i++)
	{
		if(contactos[i]->getNome() == s)
		{
			return i;
		}
	}
	return -1;
}

Agenda::Agenda(const string& nome0):nome(nome0)
{
}

Agenda::Agenda(const Agenda& ob)
{
	//existem dois membros da classe: nome e vector
	*this = ob;
	cout << "\n CCop " << ob.getAsString() << endl;
}

Agenda& Agenda::operator=(const Agenda& ob)
//a.operator(b), a apontado por this ou *this,
//b é recebido pela ref. ob
{
	//testar a auto atribuição 
	if(this == &ob)
	{
		return *this;
	}
	//destruir os objectos apontados pelo primeiro membro de atribuição
	for(Contacto * c: contactos)
	{
		delete c;
	}
	//esvaziar o vector contactos
	contactos.clear();
	//copiar o segundo membro da atribuição
	for(Contacto * c : ob.contactos)
	{
		Contacto* dupplicado = new Contacto(*c);
		contactos.push_back(dupplicado);
	}
	return *this;
}

Agenda::~Agenda()
{
	//obrigatório por ser relação de composição
	//e existe uma estrutura de vectores de ponteiros
	for(Contacto * c: contactos)
	{
		delete c;
	}
}

string Agenda::getNome() const
{
	return nome;
}

void Agenda::setNome(const string& nome0)
{
	this->nome = nome0;
}

bool Agenda::acrescentaContacto(const string& n, unsigned int t)
{
	int qual = pesquisa(n);
	if(qual != -1)
	{
		return false;
	}
	contactos.push_back(new Contacto(n, t));
	return true;
}

bool Agenda::removeContacto(const string& n)
{
	int qual = pesquisa(n);
	if(qual == -1)
	{
		return false;
	}
	delete contactos[qual]; //nunca sera erase, e primeiro faz-se sempre o erase e depois o delete
	//relação da classe é de composição: 1º deçete, 2º depois erase.
	//se a relação for de agregação é só o erase
	//sendo composição:
	//o delete: liberta a memoria dinamica apontada
	//o erase: tira a posição do vector, tira o ponteiro, erase será do vector
	//se fizer o delete e nao fizer o erase, o ponteiro fica apontar para lixo, e o destrutor vai fazer duplo delete, erro de execução
	//erase e depois o delete: erase da pos zero, e depois o delete de contactos zero.. não faz sentido
	contactos.erase(contactos.begin() + qual);
	return true;
}

string Agenda::getAsString() const
{
	ostringstream oss;
	
	oss << nome << endl;
	for(Contacto * p: contactos)
	{
		oss << endl << p->getAsString();
	}
	
	return oss.str();
}

const Contacto* Agenda::getContacto(const string& s)
{
	int qual = pesquisa(s);
	if(qual == -1)
	{
		return nullptr;
	}else
	{
		return contactos[qual];
	}
}

bool Agenda::gravaContactosEmFicheiroDeTexto()
{
	ofstream dados("dados.txt");
	if (!dados.is_open()) {
		return false;
	}

	for (unsigned int i = 0; i < contactos.size(); i++) {
		dados << contactos[i]->getTel()
			<< " " << contactos[i]->getNome() << endl;
	}

	dados.close();
	if (dados) {
		return true;
	}
	else return false;
}

bool Agenda::lerContactosDeFicheiroDeTexto()
{
	ifstream dados("dados.txt");
	string nome;
	unsigned int tel;
	string s;
	if (!dados.is_open()) {
		return false;
	}
	// ler dados de todas as pessoas
	// uma por linha
	while (!dados.eof()) {
		// ler string com os dados da pessoa
		getline(dados, s);

		istringstream iss(s);
		// ler dados da pessoa
		iss >> tel >> std::ws;
		getline(iss, nome);

		// se correu bem a leitura ...
		if (iss) {
			acrescentaContacto(nome, tel);
		}
	}
	dados.close();
	return true;
}

int main()
{
	Agenda* a1 = new Agenda("a minha agenda 2021");
	a1->acrescentaContacto("pedro", 1234);
	a1->acrescentaContacto("maria", 5678);
	cout << "\nAgenda: " << a1->getAsString() << endl;
	a1->gravaContactosEmFicheiroDeTexto();

	Agenda* a2 = new Agenda("a minha agenda 2022");
	a2->lerContactosDeFicheiroDeTexto();
	cout << "\nAgenda: " << a2->getAsString() << endl;

	Agenda* a3 = new Agenda("a minha agenda especial");
	*a3 = *a2; 
	delete a2;
	a3->removeContacto("maria");
	cout << "\nAgenda: " << a3->getAsString() << endl;
	
	cout << "\nsair do main" << endl;
	return 1;
}

operadores

………..ficha4, exercicio1 (a13, a14)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

//os operadores
//uso de operados de atribuiçao em situações de composição envolvendo memória dinâmica
//aumentar a clareza do código por exemplo a.multiplica(b) po a * b
//operadores podem ser globais ou membros
//p.e.: globaL operator++(a,b)
//p.e.: membro a.operator++(b)
/*
+---------------------------------------- + -------------------------- - +
| operador					 membro / não membro |
+---------------------------------------- + -------------------------- - +
| todos os operadores unários p.e: ++a, a++   | membro                    |
| = () -> ->*			| têm sempre que ser membro |
| += -= /= *= &= |= %= >>= <<=		 | membro                    |
| todos os restantes operadores binários, ==,<<...     | globais |
+---------------------------------------- + -------------------------- - +
*/
//o retorno de um operador pode ser um valor ou uma cópia de algo
//se o objectivo é usar o resultado de um operador, então este deve ser uma referência para algo, não constante e que pode ser modificado 


class Fraccao
{
	int numerador;
	int denominador;
public:
	//explicit //se usado trancamos o construtor, fazendo com que tenhamos que usar implicitamente Fracca(a) , na main
	//explicit, indicar ao construtor que só trabalhar quando o mandarmos trabalhar
	Fraccao();
	Fraccao(int num);
	Fraccao(int num, int denom);

	int getNumerador() const;
	void setNumerador(const int numerador);
	int getDenominador() const;
	void setDenominador(const int denominador);
	
	string getAsString() const;

	//b v3
	Fraccao operator*(const Fraccao& f); //operador * membro

	//j)
	Fraccao & operator*=(const Fraccao& f); //operador *= membro, não pode ser void

	//m) membro, operador unário
	Fraccao & operator++(); //++a
	Fraccao  operator++(int n); //a++, int n, serve para poderem funcionar as duas, mesmo que nao faça nada

	//n) passamos uma fraccao mas a f recebe apenas um inteiro
	//operador de conversao
	operator int()const { return denominador/numerador; };

};

Fraccao::Fraccao()
{
	numerador = 0;
	denominador = 1;
}

Fraccao::Fraccao(int num) :numerador(num)
{
	denominador = 1;
}

Fraccao::Fraccao(int num, int denom):numerador(num)
{
	setDenominador(denom);
}

int Fraccao::getNumerador() const
{
	return numerador;
}

void Fraccao::setNumerador(const int numerador)
{
	this->numerador = numerador;
}

int Fraccao::getDenominador() const
{
	return denominador;
}

void Fraccao::setDenominador(const int denominador)
{
	if(denominador >0)
	{
		this->denominador = denominador;
	}else if(denominador ==0)
	{
		this->denominador = 1;
	}else
	{
		this->numerador = -this->numerador;
		this->denominador = -denominador;
	}
}

string Fraccao::getAsString() const
{
	ostringstream oss;

	oss << " ( " << numerador << " / " << denominador << " ) " << endl;
	
	return oss.str();
}

//b, v3
Fraccao Fraccao::operator*(const Fraccao& f)
{
	cout << "operator*(const Fraccao& f)\n";
	Fraccao prod(getNumerador() * f.getNumerador(), getDenominador() * f.getDenominador());
	return prod;
}

Fraccao & Fraccao::operator*=(const Fraccao & f)
{
	cout << "operator*=(const Fraccao & f)\n";
	numerador *= f.getNumerador();
	denominador *= f.getDenominador();
	return *this; 
}

Fraccao& Fraccao::operator++()
{
	numerador += denominador; //a fracao aumenta uma unidade
	return *this; //retorna objecto depois de incremento
}

Fraccao Fraccao::operator++(int n)
{
	Fraccao aux = *this; //grava para esta varavel auxiliar o objecto antes de incrementar
	numerador += denominador; //a fracção aumenta uma unidade
	return aux; //não pode ser por referencia, retorna-se a variavel local
}


//b, v1
Fraccao produto(const Fraccao& x, const Fraccao& y) //função global
{
	Fraccao prod(x.getNumerador() * y.getNumerador(), x.getDenominador() * y.getDenominador());
	return prod;
}
//b, v2
Fraccao operator*(const Fraccao& x, const Fraccao& y) //função global
{
	cout << "operator*(const Fraccao& x, const Fraccao& y)\n";
	Fraccao prod(x.getNumerador() * y.getNumerador(), x.getDenominador() * y.getDenominador());
	return prod;
}

//g
ostream & operator<<(ostream & saida, const Fraccao & ob)
{
	saida << ob.getAsString();
	return saida;
}

//extra
istream& operator>>(istream& entrada,  Fraccao& ob)
{
	int num, denom;
	entrada >> num, denom;
	if(entrada)
	{
		ob.setNumerador(num);
		ob.setDenominador(num);
	}
	return entrada;
}

//n)
void func(int n) {
	cout << n;  // aparece 2
}

//o) (a==b)
bool operator==(const Fraccao& op1, const Fraccao& op2);
bool operator==(const Fraccao& op1, const Fraccao& op2)
{
	return (op1.getNumerador() * op2.getDenominador() == op1.getDenominador() * op2.getNumerador());
}

int main()
{
	//a)
	/*Fraccao a(1, 2);
	Fraccao b(3);
	const Fraccao c(3, 4);

	cout << a.getAsString();
	cout << b.getAsString();
	cout << c.getAsString();*/

	//b) multiplicação de duas fraccoes
	//v1
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//const Fraccao c(3, 4);
	//Fraccao a1;
	//a1 = produto(b,c); 
	//cout << a1.getAsString();
	//v2
	//a = b * c; // a  = operator(b,c); global
	//cout << a.getAsString();
	//v3 (estando as duas opções disponiveis, global ou membro, recai sobre o membro)
	//a = b * c;// a = b.operator*(c); membro
	//cout << a.getAsString();

	//c)
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//const Fraccao c(3, 4);
	//a = a * b * c; //composição das funções, (a*b)*c
	//operator*(operator*(a,b),c)
	//cout << a.getAsString();

	//d e e)
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//a = b * 4; //b.operator*(4)
	//cout << a.getAsString();
	//d e e) v2 construtor explicit
	//a = b * Fraccao(4); //só assim funcionaria
	//d e e) v3
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//a = 4 * b; //funciona apenas o global, se for membro só se usado o explicit, Fraccao(4) * b;
	//cout << a.getAsString();

	//g) v1
	//Fraccao a(1, 2);
	//cout << a; //<<, operador binário, tem que ser operador global
	//cout está a invocar a nossa operação, cout é da classes ostream, não é da nossa classe, logo << tem que ser global
	//g e h) v2
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//const Fraccao c(3, 4);
	//cout << a << b << c; //por ser global e ostream ao inves de void funciona em cadeia

	//i) ao inves de copia usar o valor, ostream & operator<<(ostream saida, const Fraccao & ob)
	//não dá...dá erro

	//extra
	//Fraccao a(1, 2);
	//Fraccao b(3);
	//cin >> a;
	//cout << a.getAsString();
	
	//j) a *= b
	//Fraccao a(1, 2);
	//Fraccao b(2,3);
	////a *= b;
	////operador global: operator*=(a,b)
	////operador membro: a.operator*=(b) //recomendada
	////*= te como retorno 
	//cout << "antes->" << " a: " << a << " b: " << b << endl;
	//a *= b;
	//cout << "depois->" << " a: " << a << " b: " << b << endl;
	//Fraccao a2(1, 2);
	//Fraccao b2(2, 3);
	//Fraccao c2(3, 4);
	//cout << "antes->" << " a2: " << a2 << " b2: " << b2 << " c2: " << c2 << endl;
	//a2 *=  b2 *= c2;
	//cout << "depois->" << " a2: " << a2 << " b2: " << b2 << " c2: " << c2 << endl;
	//Fraccao a3(1, 2);
	//Fraccao b3(2, 3);
	//Fraccao c3(3, 4);
	//cout << "antes->" << " a3: " << a3 << " b3: " << b3 << " c3: " << c3 << endl;
	//(a3 *= b3) *= c3;
	//cout << "depois->" << " a3: " << a3 << " b3: " << b3 << " c3: " << c3 << endl;

	//l) retornar referencia ou valor
	//Fraccao a(1, 2), b(2, 3), c(3, 4);
	//cout << "antes->" << " a: " << a << " b: " << b << " c: " << c << endl;
	//(a *= b) *= c;
	//cout << "depois->" << " a: " << a << " b: " << b << " c: " << c << endl;
	//// é suposto aparecer 6/24
	//cout << a;
	//cout << "expressao ((a *= b) *= c)" << ((a *= b) *= c) << endl;
	//retornar por referência Fraccao & Fraccao::operator*=(const Fraccao & f)
	//retornar por valor (é uma copia) Fraccao Fraccao::operator*=(const Fraccao & f)

	//m) posfixado, a++ e prefixado ++a
	//++a, global, operator++(a)
	//++a, membro, a.operator++() //não recebe nenhum argumento
	//prefixado
	//int n = 2;
	//cout << "++n= " << ((++n)) << endl; //3, e é possivel fazer uma atribuição (++n)=55, vem ++n=55
	//cout << "  n= " << n << endl; //3
	////posfixado
	//int n2 = 2;
	//cout << "n2++= " << ((n2++)) << endl; //2
	//cout << "  n2= " << n2 << endl; //3
	//Fraccao a(1, 2), b(2, 3), c(3, 4);
	//(++a) = c;
	//cout << ++a; //a.operator++() //sem argumento
	//cout << a; 
	//Fraccao a2(1, 2), b2(2, 3), c2(3, 4);
	//cout << a2++; //a.operator++(0) //0 é um argumento
	//cout << a2;

	//n)
	//const Fraccao f(7,3);
	//func(f);  // é passado automaticamente o valor 7/3
	//     	  // arredondado para baixo

	//o) if(a==b)
	//tem que existir o operador== que retorne um bool, e é global
	Fraccao a(1, 2), b(1, 2);
	if(a== b)
	{
		cout << "oi";
	}else
	{
		cout << "noi";
	}
		
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha4, exercicio3 (a14)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

/*
+---------------------------------------- + -------------------------- - +
| operador					| membro / não membro |
+---------------------------------------- + -------------------------- - +
| todos os operadores unários p.e: ++a, a++   | membro                    |
| = () -> ->*			  	  | têm sempre que ser membro |
| += -= /= *= &= |= %= >>= <<=		   | membro                    |
| todos os restantes operadores binários, ==,<<...    | globais |
+---
*/
class Automovel {
	const string matricula; //const para proibir atribuições
	string marca;
	string modelo;
	int ano;

	static int nAutomoveisCriados; //tem que ser inicializada fora da classe

public:
	Automovel(const Automovel& ob);
	Automovel(string matricula, string marca, string modelo, int ano);
	~Automovel();

	string getMatricula()const;
	string getMarca()const;
	string getModelo()const;
	int getAno()const;

	static int getNAutomoveisCriados();

	void setMarca(string marca);
	void setModelo(string modelo);
	void setAno(int ano);

	string getAsString()const;

	Automovel& operator=(const Automovel& ob); //retorna uma referencia para o primeiro membro da atribuição
};

int Automovel::nAutomoveisCriados = 0;

ostream& operator<<(ostream& saida, const Automovel& ob);

Automovel::Automovel(const Automovel& ob):matricula(ob.matricula), marca(ob.marca), modelo(ob.modelo), ano(ob.ano)
{
	cout << "\nConstrutor por copia";
	++nAutomoveisCriados; //tambem por copia, os construidos por cópia tb devem ser contados!
}

Automovel::Automovel(string matricula1, string marca1, string modelo1, int ano1): matricula(matricula1), marca(marca1),	modelo(modelo1), ano(ano1) {
	cout << "\nConstrutor com parametros";
	++nAutomoveisCriados;
}

Automovel::~Automovel() {
	cout << "\nDestruindo " << getAsString();
}

string Automovel::getMatricula()const {
	return matricula;
}
string Automovel::getMarca()const {
	return marca;
}
string Automovel::getModelo()const {
	return modelo;
}
int Automovel::getAno()const {
	return ano;
}

int Automovel::getNAutomoveisCriados()
{
	return nAutomoveisCriados;
}

void Automovel::setMarca(string marca1) {
	marca = marca1;
}
void Automovel::setModelo(string modelo1) {
	modelo = modelo1;
}
void Automovel::setAno(int ano1) {
	ano = ano1;
}

string Automovel::getAsString()const {
	ostringstream oss;
	oss << "\nAutomovel: " << matricula << "   " << marca << "   " << modelo << "   " << ano;
	return oss.str();
}

Automovel& Automovel::operator=(const Automovel& ob) {
	//
	if (this == &ob) {
		return *this;
	}
	cout << "\nOperador atribuicao ";
	//a matricula nao se altera no objecto destino da atribuição
	this->marca = ob.marca;
	this->ano = ob.ano;
	this->modelo = ob.modelo;
	return *this;
}

ostream& operator<<(ostream& saida, const Automovel& ob) {
	saida << ob.getAsString() << endl;
	return saida;
}

void f(Automovel  x) {
	cout << x << endl;
}

int main()
{
	Automovel a1("11-11-AA", "OPEL", "OMEGA", 2010);
	Automovel a2("22-22-BB", "FIAT", "PUNTO", 2011);

	Automovel a3 = a1; //a3 copia de a1, construtor por copia
	a1 = a2; //operador atribuição, mas havendo membros constantes, tem que se fazer o operador operator=
	//a1.operator=(a2)
	f(a1);
	return 1;
}

composição, agregação, vectores, ficheiros

………..ficha3, exercicio1 (a8)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>

using namespace std;

//"nao deve ser possivel construir objectos desta classe sem a indicacação.." não pode haver construtor por omissão
//"sem desrespeitar o encapsulamento.." gets e sets
//"as funções que permitem obter os dados devem poder ser chamadas sobre bjectos constantes" devem conter o const

class Ponto
{
private:
	//encapsulamento
	int x;
	int y;

public:
	//Ponto(int x0, int y0); //necessário introduzir coordenadas
	~Ponto();

	Ponto(int x0 = 0, int y0 = 0); //construtor por omissão, e)

	//extra
	/*Ponto()
	{
		x = rand() % 100;
		y = rand() % 100;
		cout << "\nponto " << getAsString();
	}*/
	
	
	int getX() const
	{
		return x;
	}

	void setX(const int x)
	{
		this->x = x;
	}

	int getY() const
	{
		return y;
	}

	void setY(const int y)
	{
		this->y = y;
	}

	double calculaDistancia(const Ponto & outro)const;
	
	string getAsString()const;
};

Ponto::Ponto(int x0, int y0)
{
	x = x0;
	y = y0;
	cout << "\nPonto(in x0, int y0) " << getAsString();
}

Ponto::~Ponto()
{
	cout << "\n~Ponto() " << getAsString();
}

double Ponto::calculaDistancia(const Ponto& outro) const
{
	//pitágoras, calculo da distância
	double dist = (x - outro.x) * (x - outro.x) + (y - outro.y) * (y - outro.y);
	return sqrt(dist);
}

string Ponto::getAsString() const
{
	ostringstream oss;
	oss << " ( " << x << " , " << y << " ) " << endl;
	return oss.str();
}

int main()
{
	Ponto a(1,1);
	Ponto b(2,2);

	cout << a.getAsString(); //as funções mmebros recebem um ponbteiro para o objectos que as invocou, daí tem acesso a  e b
	cout << a.calculaDistancia(b);

	//c)
	const Ponto c(5, 6); //agora só posso chamar funcções que sejam const
	cout << c.getAsString();
	cout << "c.getY(); " << c.getY();

	//d)
	Ponto tab_d[] = {Ponto(1,3), Ponto(2,4), Ponto(5,7)};
	
	//e) 	Ponto(int x0 = 0, int y0 = 0); //construtor por omissão, e)
	Ponto tab_e[3];

	
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha3, exercicio3 (a8, a9)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>

using namespace std;

//composição de objectos


class Ponto
{
	int x;
	int y;
public:
	//Ponto(); //construtor por omissao
	//Ponto(int x0, int y0);
	Ponto(int x0=0, int y0=0); //construtor por omissão
	Ponto(const Ponto& z);
	~Ponto();

	int getX() const
	{
		return x;
	}

	void setX(const int x)
	{
		this->x = x;
	}

	int getY() const
	{
		return y;
	}

	void setY(const int y)
	{
		this->y = y;
	}

	string getAsString() const;
};

Ponto::Ponto(int x0, int y0)
{
	x = x0;
	y = y0;
	cout << "\nponto(int x0, int y0) " << getAsString();
}

Ponto::Ponto(const Ponto& z)
{
	x = rand() % 100;
	y = rand() % 100;
	cout << "\nponto(const Ponto& z) " << getAsString();
}

Ponto::~Ponto()
{
	cout << "~Ponto()";
}


string Ponto::getAsString() const
{
	ostringstream oss;

	oss << " ponto x" << x << " y " << y << endl;

	return oss.str();
}

class Rectangulo //objecto composto
{
	Ponto canto;
	int largura;
	int altura;
public:
	Rectangulo(int x, int y, int largura0, int altura0);
	Rectangulo(const Ponto& p0, int largura0, int altura0);
	~Rectangulo();


	Ponto getCanto() const
	{
		return canto;
	}

	int getX()const
	{
		return canto.getX();
	}
	int getY()const
	{
		return canto.getY();
	}

	int getLargura() const
	{
		return largura;
	}

	int getAltura() const
	{
		return altura;
	}

	bool setLargura(int larg0);
	bool setAltura(int alt0);

	void setCanto(const Ponto& c);

	string getAsString() const;

	int calculaArea()const;
};

Rectangulo::Rectangulo(int x, int y, int largura0, int altura0):canto(x,y) //canto(x,y) membro objecto
{
	if(!setLargura(largura0))
	{
		largura = 1;
	}
	if (!setAltura(altura0))
	{
		altura = 1;
	}
	cout << "\nrectangulo int x, int y.." << getAsString();
}
 
Rectangulo::Rectangulo(const Ponto& p0, int largura0, int altura0):canto(p0)
{
	cout << "\nrectangulo const Ponto& p0.." << getAsString();
}

Rectangulo::~Rectangulo()
{
	cout << "~Rectangulo()" << getAsString();
}

bool Rectangulo::setLargura(int larg0)
{
	if(larg0<0) 
	{
		return false;
	}
	largura = larg0;
	return true;
}

bool Rectangulo::setAltura(int alt0)
{
	if(alt0<0)
	{
		return false;
	}
	altura = alt0;
	return true;
}

void Rectangulo::setCanto(const Ponto& c)
{
	canto = c;
}

string Rectangulo::getAsString() const
{
	ostringstream oss;

	oss << " rectangulo " << canto.getAsString() << " larg: " << largura << " alt: " << altura << endl;

	return oss.str();
}

int Rectangulo::calculaArea() const
{
	return largura * altura;
}

int main()
{
	//a) relação de composição

	//b)
	//Rectangulo a(1, 2, 4, 2);
	//cout << "\na:" << a.getAsString() << endl;
	//Rectangulo b(1, 2, 44, 22);
	//cout << "\nb:" << a.getAsString() << endl;
	//os cantos são iguais, mas estão localizados em sitios diferentes de memória..
	//cada rectangulo tem a posso exclusiva do seu canto. mas são diferentes
	
	const Rectangulo c(1, 2, 4, 2);
	c.getLargura();
	
	
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha3, exercicio4 (a9, a10)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>

using namespace std;

class Ponto
{
	int x;
	int y;
public:
	//Ponto(); //construtor por omissao
	//Ponto(int x0, int y0);
	Ponto(int x0 = 0, int y0 = 0); //construtor por omissão
	Ponto(const Ponto& z);
	~Ponto();

	int getX() const
	{
		return x;
	}

	void setX(const int x)
	{
		this->x = x;
	}

	int getY() const
	{
		return y;
	}

	void setY(const int y)
	{
		this->y = y;
	}

	string getAsString() const;

	//calcular a distancia entre dois pontos
	double calculaDistancia(const Ponto& outro)const;
	bool isIgual(const Ponto& outro)const;
	
};

Ponto::Ponto(int x0, int y0)
{
	x = x0;
	y = y0;
	//cout << "\nponto(int x0, int y0) " << getAsString();
}

Ponto::Ponto(const Ponto& z)
{
	x = rand() % 100;
	y = rand() % 100;
	//cout << "\nponto(const Ponto& z) " << getAsString();
}

Ponto::~Ponto()
{
	cout << "~Ponto()";
}


string Ponto::getAsString() const
{
	ostringstream oss;

	oss << " ponto x " << x << " y " << y << endl;

	return oss.str();
}

double Ponto::calculaDistancia(const Ponto& outro) const
{
	//pitágoras, calculo da distância
	double dist = (x - outro.x) * (x - outro.x) + (y - outro.y) * (y - outro.y);
	return sqrt(dist);
}

bool Ponto::isIgual(const Ponto& outro) const
{
	return x == outro.x && y == outro.y;
}

class Rectangulo //objecto composto
{
	Ponto canto;
	int largura;
	int altura;
public:
	Rectangulo(int x, int y, int largura0, int altura0);
	//Rectangulo(const Ponto& p0, int largura0, int altura0);
	//Rectangulo(const Rectangulo& r); //construtor por cópia
	~Rectangulo();


	Ponto getCanto() const
	{
		return canto;
	}

	int getX()const
	{
		return canto.getX();
	}
	int getY()const
	{
		return canto.getY();
	}

	int getLargura() const
	{
		return largura;
	}

	int getAltura() const
	{
		return altura;
	}

	bool setLargura(int larg0);
	bool setAltura(int alt0);

	void setCanto(const Ponto& c);

	string getAsString() const;

	int calculaArea()const;
};

Rectangulo::Rectangulo(int x, int y, int largura0, int altura0) :canto(x, y) //canto(x,y) membro objecto
{
	if (!setLargura(largura0))
	{
		largura = 1;
	}
	if (!setAltura(altura0))
	{
		altura = 1;
	}
	//cout << "\nrectangulo int x, int y.." << getAsString();
}

//Rectangulo::Rectangulo(const Rectangulo& r)
//{
//	*this = r;
//	cout << "\nRectangulo(const Rectangulo& r) " << getAsString() << endl;
//}

//Rectangulo::Rectangulo(const Ponto& p0, int largura0, int altura0) :canto(p0)
//{
//	cout << "\nrectangulo const Ponto& p0.." << getAsString();
//}

Rectangulo::~Rectangulo()
{
	cout << "~Rectangulo()" << getAsString();
}

bool Rectangulo::setLargura(int larg0)
{
	if (larg0 < 0)
	{
		return false;
	}
	largura = larg0;
	return true;
}

bool Rectangulo::setAltura(int alt0)
{
	if (alt0 < 0)
	{
		return false;
	}
	altura = alt0;
	return true;
}

void Rectangulo::setCanto(const Ponto& c)
{
	canto = c;
}

string Rectangulo::getAsString() const
{
	ostringstream oss;

	oss << " rectangulo " << canto.getAsString() << " larg: " << largura << " alt: " << altura << endl;

	return oss.str();
}

int Rectangulo::calculaArea() const
{
	return largura * altura;
}

class Desenho
{
	string nome;
	vector<Rectangulo> rectangulos; //coleccão de rectangulos
	//ao ser destruido o vector são destruidos os seus elementos,
	//são destruidos os rectangulos
	//existe assim uma relação de composição
	//relação de posse exclusiva
public:
	Desenho(string nome0);
	~Desenho();

	void acrescentar(int x, int y, int alt, int larg); //um rectangulo
	int calculaAreda()const;
	vector<Rectangulo> pesquisarRectMesmoCanto(const Ponto& p)const; //const, função de consulta, e retorna o conjunto dos rect que satifazem a condição
	int somaDasAreas()const;
	int calculaArea()const;

	string getAsString() const;

	bool eliminarUm(unsigned int qual);
	int eliminarRectAreaSup(int areaLimite);
};

Desenho::Desenho(string nome0)//:nome(nome0)
{
	//ou
	nome = nome0;
	//ou
	//se nada for indicado, ele vem construido na mesma sendo usada o construtor por omissão
}

Desenho::~Desenho()
{
	cout << "\n~Desenho" << getAsString();
}

void Desenho::acrescentar(int x, int y, int larg , int alt)
{
	Rectangulo rect(x, y, larg, alt);
	rectangulos.push_back(rect); //é feito uma cópia do rect para o vector, pelo construtor por cópia
	//ou
	//rectangulos.push_back(Rectangulo(x, y, larg, alt));
}

int Desenho::calculaAreda() const
{
	return 1;
}

vector<Rectangulo> Desenho::pesquisarRectMesmoCanto(const Ponto& p) const
{
	vector<Rectangulo> v;

	for(const auto & rect : rectangulos)
	{
		//ou
		if(rect.getCanto().isIgual(p))
		{
			v.push_back(rect);
		}
		//ou, mas falha o encapsulamento
		//pois é a classe do ponto que sabe se dois pontos são iguais
		//pois quem deve ter a funcionalidade é a classe que tem a informação correspondente
		//assim não deve ser a classe desenho a faze-lo
		//if(rect.getCanto().getX() == p.getX() && rect.getCanto().getY() == p.getY())
		//{
		//	v.push_back(rect);
		//}
	}
	return v;
}

int Desenho::somaDasAreas() const
{
	int soma = 0;
	//ou
	for(vector<Rectangulo>::const_iterator it = rectangulos.begin(); it != rectangulos.end(); ++it)
	{
		soma += it->calculaArea();
	}
	//ou
	for(auto it = rectangulos.begin(); it != rectangulos.end(); ++it)
	{
		soma += it->calculaArea();
	}
	//ou
	for(unsigned int i= 0; i< rectangulos.size(); i++)
	{
		soma += rectangulos[i].calculaArea();
	}
	
	//ou
	for(const auto & elem:rectangulos)
	{
		soma += elem.calculaArea();
	}
	

	return soma;
}

int Desenho::calculaArea() const
{
	int area = 0;
	return area;
}

string Desenho::getAsString() const
{
	ostringstream oss;

	oss << " nome " << nome << " tem " << rectangulos.size() << " rectangulos \n ";

	//ou
	for(unsigned int i = 0; i< rectangulos.size(); i++){
		oss << rectangulos[i].getAsString() << endl;
	}
	//ou
	//for( auto & rect : rectangulos)
	//{
	//	oss << rect.getAsString() << endl;;
	//}
	//ou iteradores
	//for(vector<Rectangulo>::const_iterator it =rectangulos.begin(); it != rectangulos.end(); ++it)
	//{
	//	oss << it->getAsString() << endl;
	//}
	return oss.str();
}

bool Desenho::eliminarUm(unsigned qual) //qual: indice
{
	{
		if (qual < 0 || qual >= rectangulos.size())
		{
			return false;
		}
		rectangulos.erase(rectangulos.begin() + qual); //o vector auto-reorganiza-se
		//é um iterator: rectangulos.begin() + qual
		return true;
	}
}

int Desenho::eliminarRectAreaSup(int areaLimite)
{
	//serve para coleções
	//https://www.cplusplus.com/reference/vector/vector/erase/
	int nEliminar = 0;
	for(vector<Rectangulo>::iterator it = rectangulos.begin(); it != rectangulos.end();)
	{
		if(it->calculaArea() > areaLimite)
		{
			it = rectangulos.erase(it);
			++nEliminar;
		}else
		{
			++it;
		}
	}
	return nEliminar; //não era necessaria esta informação
}

int main()
{
	Desenho a1("janela");
	cout << "\na1";
	a1.acrescentar(1, 2, 3, 4);
	a1.acrescentar(5, 6, 7, 8);
	a1.getAsString();
	
	cout << "\nfim do main.." << endl;
	return 0;
}

………..ficha3, exercicio7 (a11, a12)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>
#include <fstream>

using namespace std;

//relação entre banco, conta, pessoa e arquivo de identificacao:
//relação entre banco e conta: composição (banco cria a conta)
//quando o banco for destruído as contas tambem o são
//relação entre conta e pessoa: agregação
//relação entre arquivo de identificacao e pessoa: composição (arquivo cria a pessoa)

class Pessoa
{
	//objecto dinamico, que não muda.
	string nome;
	long bi;
	long nif;

	void setBi(long bi); //alteração é privado
public:
	Pessoa(const string& s, long b, long n);
	Pessoa() = delete; //não disponbilizamos construtor por omissão, fica proibido
	~Pessoa();

	string getNome() const;
	void setNome(const string& nome);

	long getBi() const;
	
	long getNif() const;
	void setNif(const long nif);
	
	string getAsString()const;
	string getDados()const;
};

Pessoa::~Pessoa()
{
	cout << "~Pessoa()" << endl;
}

string Pessoa::getNome() const
{
	return nome;
}

void Pessoa::setNome(const string& nome)
{
	this->nome = nome;
}

long Pessoa::getBi() const
{
	return bi;
}

void Pessoa::setBi(const long bi)
{
	this->bi = bi;
}

Pessoa::Pessoa(const string& s, long b, long n):nome(s), bi(b),nif(n)
{
}

long Pessoa::getNif() const
{
	return nif;
}

void Pessoa::setNif(const long nif)
{
	this->nif = nif;
}

string Pessoa::getAsString() const
{
	ostringstream oss;
	oss << "nome: " << nome << " bi: " << bi << " nif: " << nif << endl;
	
	return oss.str();
}

string Pessoa::getDados() const
{
	//ficheiro de dados, linha
	ostringstream oss;
	oss << bi << " " << nif << nome << endl;

	return oss.str();
}

class ArquivoDeIdentificacao
{
	//vector de ponteiros para pessoas
	//ou vector de pessoas/objectos (não ia funcionar bem, porque na conta existe um ponteiro para pessoa, e se for eliminado no arquivo o ponteiro fica como?)
	//o destrutor tem que destruir primeiro as pessoas, libertar a memória com delete
	string nome;
	vector<Pessoa* > pessoas;
	int pesquisa(long bi)const;
public:
	ArquivoDeIdentificacao(string nome0);
	ArquivoDeIdentificacao(const ArquivoDeIdentificacao& ob) = delete; //proibir a construção por cópia
	ArquivoDeIdentificacao& operator=(const ArquivoDeIdentificacao& ob) = delete; //proibir o operador atribuição, proibir a atribuição
	//esta dupla proibição tem a ver com evitar erros de execuação
	~ArquivoDeIdentificacao();

	string getNome() const;
	void setNome(const string& nome);
	bool acrescentaPessoa(string n, long b, long nif); //relação de posse o arquivo.
	string getDados()const; //para lidar com ficheiros
	const Pessoa * getPessoa(long bi);
	
	string getAstring()const;

	bool gravarPessoasEmFicheiroDeTexto(const ArquivoDeIdentificacao &arquivo);
	bool lerPessoasDeFicheiroDeTexto(ArquivoDeIdentificacao &arquivo);
};


int ArquivoDeIdentificacao::pesquisa(long bi) const
{
	//porque existe uma coleção
	for(unsigned int i = 0; i< pessoas.size(); i++)
	{
		if(pessoas[i]->getBi()==bi)
		{
			return i;
		}
	}
	return -1;
}

ArquivoDeIdentificacao::ArquivoDeIdentificacao(string nome0):nome(nome0)
{
}

ArquivoDeIdentificacao::~ArquivoDeIdentificacao()
{
	//o arquivo tem uma relação de composição: cria e destoi a pessoa
	for(Pessoa * p: pessoas)
	{
		cout << p->getAsString();
		delete p;
	}
	//ou
	//for (int i = 0; i < pessoas.size(); i++)
	//	delete pessoas[i];
}

string ArquivoDeIdentificacao::getNome() const
{
	return nome;
}

void ArquivoDeIdentificacao::setNome(const string& nome)
{
	this->nome = nome;
}

bool ArquivoDeIdentificacao::acrescentaPessoa(string n, long b, long nif)
{
	int qual = pesquisa(b);
	if(qual != -1)
	{
		return false; //já existe uma pessoa com este bi
	}
	pessoas.push_back(new Pessoa(n, b, nif));
	//o arquivo tem uma relação de composição: cria e destoi a pessoa
	//new Pessoa(n, b, nif)  //criar a pessoa em memória dinamica, e retorna o endereço
	//pessoas.push_back //acrescenta mais um elemento com o endereço da nova pessoa
	return true; 
}

string ArquivoDeIdentificacao::getDados() const
{
	//para lidar com ficheiros
	ostringstream oss;
	for(Pessoa * p: pessoas)
	{
		oss << p->getDados() << endl;
	}

	return oss.str();
}

const Pessoa* ArquivoDeIdentificacao::getPessoa(long bi)
//primeiro const: para nao alterar o ponteiro, damos acesso apenas aos dados para onde aponta (read only)
{
	int qual = pesquisa(bi);
	if(qual == -1)
	{
		return nullptr;
	}else
	{
		return pessoas[qual];
	}
}

string ArquivoDeIdentificacao::getAstring() const
{

	ostringstream oss;
	for(Pessoa * p : pessoas)
	{
		oss << p->getAsString();
	}
	return oss.str();
}

bool ArquivoDeIdentificacao::gravarPessoasEmFicheiroDeTexto(const ArquivoDeIdentificacao & arquivo)
{
	ofstream dados("dados.txt");
	if (!dados.is_open()) {
		return false;
	}

	dados << arquivo.getDados();

	dados.close();
	if (dados) {
		return true;
	}
	else return false;
}

bool ArquivoDeIdentificacao::lerPessoasDeFicheiroDeTexto(ArquivoDeIdentificacao& arquivo)
{
	ifstream dados("dados.txt");
	string nome;
	long bi;
	long nif;
	string s;

	if (!dados.is_open()) {
		return false;
	}

	// ler dados de todas as pessoas
	// uma por linha

	while (!dados.eof()) {
		// ler strig com os dados da pessoa
		getline(dados, s);

		istringstream iss(s);
		// ler dados da pessoa
		iss >> bi >> nif;
		getline(iss, nome);

		// se correu bem a leitura ...
		if (iss) {
			acrescentaPessoa(nome, bi, nif);
		}
	}
	dados.close();
	return true;
}

class Conta
{
	//ponteiro para pessoa
	const Pessoa* titular; //const, para não alterar 
	int saldo;
public:
	Conta(const Pessoa* const titular); //posso usar um ponteiro para const ou sem const
	//ou
	//Conta(Pessoa* const titular); //pode alterar o apontado desta forma
	~Conta();

	const Pessoa* getTitular()const; //não altera, damos o conhecimento

	int getSaldo()const;
	bool depositar(int quantia);
	bool levantar(int quantida);

	long getBi()const;

	string getAsString()const;

};

Conta::Conta(const Pessoa* const titular):titular(titular), saldo(0)
{
}

Conta::~Conta()
{
	cout << "~Conta()" << endl;
}

const Pessoa* Conta::getTitular() const
{
	return titular;
}

int Conta::getSaldo() const
{
	return saldo;
}

bool Conta::depositar(int quantia)
{
	if (quantia <= 0)
		return false;
	saldo += quantia;
	return true;
}

bool Conta::levantar(int quantia)
{
	if (quantia <= 0 || quantia > saldo)
		return false;
	saldo -= quantia;
	return true;
}

long Conta::getBi() const
{
	return titular->getBi();
}

string Conta::getAsString() const
{
	ostringstream oss;
	oss << "\ntitular " << titular->getAsString() << "\nsaldo " << saldo << endl;
	return oss.str();
}

class Banco
{
	string nome;
	//vector de objectos contas
	vector <Conta> contas;
	//a destruição deste obejcto vai destruir os membros de outras classes: vector e nome

	int pesquisar(long bi)const;
public:
	Banco(string n);
	//~Banco(); //não é preciso, porque as contas não sobrevivem ao fim do banco

	string getNome() const;
	void setNome(const string& nome);
	bool acrescentar(const Pessoa* const pessoa);
	bool eliminar(long bi);
	int somaDosSaldos()const;
	bool depositar(long bi, int quantia);
	bool levantar(long bi, int quantia);

	void eliminarTodasAsContas(long bi);

	
	string getAsString()const;
	
};

int Banco::pesquisar(long bi) const
{
	for(unsigned int i=0; i< contas.size(); i++)
	{
		if(bi == contas[i].getBi())
		{
			return i;
		}
	}
	return -1;
}

Banco::Banco(string n):nome(n) //vai funcionar o construtor por omissão, e fica vazio, sem lixo/elementos
{
}

//Banco::~Banco()
//{
//	cout << "\n~Banco" << endl;
//}

string Banco::getNome() const
{
	return nome;
}

void Banco::setNome(const string& nome)
{
	this->nome = nome;
}

bool Banco::acrescentar(const Pessoa* const pessoa)
{
	if (pessoa == nullptr){
		return false;
	}
	contas.push_back(Conta(pessoa)); //criar contas, é o banco que o faz
	return true;
}

bool Banco::eliminar(long bi)
{
	int qual = pesquisar(bi);
	if(qual == -1)
	{
		return false;
	}
	contas.erase(contas.begin() + qual);
	return true;
}

int Banco::somaDosSaldos() const
{
	int soma = 0;
	for(const Conta &c : contas)
	{
		soma += c.getSaldo();
	}
	return soma;
}

bool Banco::depositar(long bi, int quantia)
{
	int qual = pesquisar(bi);
	if(qual == -1)
	{
		return false;
	}
	return contas[qual].depositar(quantia);
}

bool Banco::levantar(long bi, int quantia)
{
	int qual = pesquisar(bi);
	if(qual == -1)
	{
		return  false;
	}
	return contas[qual].levantar(quantia);
}

void Banco::eliminarTodasAsContas(long bi) //vector
{
	{
		for (auto it = contas.begin(); it != contas.end();)
		{
			if (it->getBi() == bi)
			{
				it = contas.erase(it);
			}
			else
			{
				++it;
			}
		}
	}
}

string Banco::getAsString() const
{
	ostringstream oss;
	oss << "\n== Banco : " << nome << "\t n.contas " << contas.size() << endl;

	for (unsigned int i = 0; i < contas.size(); i++)
	{
		oss << contas[i].getAsString();
	}
	
	return oss.str();
}

int main()
{
	//Pessoa p("coimbra", 123, 321);
	//cout << p.getAsString();

	//Pessoa* ap=nullptr;
	//ou
	//Pessoa* const ap = nullptr; //preciso que Conta(const Pessoa* const titular); 
	//ou
	//const Pessoa* const ap=nullptr; //preciso que Conta(const Pessoa* const titular); 
	//Conta c1(ap);

	/*Pessoa p1("AAA", 123, 321);
	Pessoa p2("BBB", 928, 890);
	Banco b("o banco b");
	b.acrescentar(&p1);
	b.acrescentar(&p2);

	cout << "Banco \n" << b.getAsString() << endl;

	b.depositar(123, 40);
	b.depositar(928, 240);

	cout << "Bancos depositos\n" << b.getAsString() << endl;*/

	//ArquivoDeIdentificacao arquivo("coimbra");
	//ArquivoDeIdentificacao arquivo2("porto");
	//ArquivoDeIdentificacao arquivo3(arquivo2); //dá erro, proibida a cópia de arquivo2, construção por cópia
	//arquivo1 = arquivo2; //dá erro, poribida a atribuição , atribuição

	//arquivo.acrescentaPessoa("pedro", 123, 456);
	//arquivo.acrescentaPessoa("ines", 888, 999);
	//	
	//cout << "arquivo de identificacao\n" << arquivo.getAstring();
	

	//ArquivoDeIdentificacao arquivo("coimbra final");
	//arquivo.acrescentaPessoa("pedro", 123, 456);
	//arquivo.acrescentaPessoa("ines", 888, 999);

	//cout << "arquivo de identificacao\n" << arquivo.getAstring();
	//
	//Banco banco("filial coimbra");
	//banco.acrescentar(arquivo.getPessoa(123));
	//banco.acrescentar(arquivo.getPessoa(888));
	//banco.acrescentar(arquivo.getPessoa(88));
	//banco.acrescentar(arquivo.getPessoa(123));

	//cout << "banco" << banco.getAsString() << endl;

	
	//operação grava ficheiro
	//ArquivoDeIdentificacao arquivo("coimbra");
	//arquivo.acrescentaPessoa("pedro", 123, 456);
	//arquivo.acrescentaPessoa("ines", 888, 999);
	//cout << "arquivo de identificacao\n" << arquivo.getAstring();
	//Banco banco("filial coimbra");
	//banco.acrescentar(arquivo.getPessoa(123));
	//banco.acrescentar(arquivo.getPessoa(888));
	//banco.acrescentar(arquivo.getPessoa(88));
	//banco.acrescentar(arquivo.getPessoa(123));

	//cout << "banco" << banco.getAsString() << endl;
	//arquivo.gravarPessoasEmFicheiroDeTexto(arquivo);

	
	//operação ler ficheiro
	//ArquivoDeIdentificacao arquivo2("porto final");
	//arquivo2.lerPessoasDeFicheiroDeTexto(arquivo2);
	//
	//cout << "arquivo de identificacao\n" << arquivo2.getAstring();
	//Banco banco("filial coimbra");
	//banco.acrescentar(arquivo2.getPessoa(123));
	//banco.acrescentar(arquivo2.getPessoa(888));
	//banco.acrescentar(arquivo2.getPessoa(88));
	//banco.acrescentar(arquivo2.getPessoa(123));

	//cout << "banco" << banco.getAsString() << endl;

	
	cout << "\nfim do main" << endl;
	return 0;
}

Encapsulamento, classes, construtores, destrutores

………..ficha2, exercicio3e4 (a4,a5)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>

using namespace std;

class Caderno
{
private:
	//membros variáveis
	string marca;
	string cor;
	int numFolhas;
	string tamanho;
public:

	Caderno(const string& marca, const string& cor, const int num_folhas, const string& tamanho)
	//const não consigo alterar o argumento que vem da main, assim fica mais eficiente/seguro,
	//e tambem assim posso fazer uso de uma const, usando por exemplo "marca"
	//o int pode ter const ou não e referencia, e porque é uma coisa pequena
		: marca(marca),
		  cor(cor),
		  numFolhas(num_folhas),
		  tamanho(tamanho)
	{
	}

	//membros funções
	//funções get
	//os consts sigificam que não podem alterar nada, é uma função de consulta
	string getMarca() const
	{
		return marca;
	}
	string getCor() const
	{
		return cor;
	}
	int getNumfolhas() const
	{
		return numFolhas;
	}
	string getTamanho() const
	{
		return tamanho;
	}
	
	//funções set
	void setMarca(const string & marca)
	{
		this->marca = marca;
	}
	void setCor(const string & cor)
	{
		this->cor = cor;
	}
	void setNumfolhas(int num_folhas)
	{
		if(num_folhas>0){
			numFolhas = num_folhas;
		}else
		{
			numFolhas = 0;
		}
	}
	void setTamanho(const string& tamanho)
	{
		this->tamanho = tamanho;
	}

	string getAsString()const;
};

string Caderno::getAsString()const
{
	ostringstream oss;
	oss << "\nmarca: " << marca
		<< "\ncor: " << cor
		<< "\nnum folhas: " << numFolhas
		<< "n\ntamanho: " << tamanho;
	return oss.str();
}


int main()
{
	const Caderno Cad1("bic","branca",2,"a4"); //const não posso alterar
	cout << Cad1.getAsString();

	cout << "\nfim do main" << endl;

	return 0;
}

………..ficha2, exercicio5 (a5)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>

using namespace std;

class Automovel
{
private:
	string matricula;
	string combustivel;
	string marca;
	string modelo;
	int ano;
	static int conta; //não surge nos objectos, surge fora dos objectos, membro estático
	//e vai precisar de ser inicializado, no inicio e surge int Automovel::conta = 0;

	//validar a matricula do automovel
	bool validaMatricula(const string & s) const ;

public:
	Automovel(const string& matricula, const string& combustivel, const string& marca, const string& modelo,
		const int ano)
		: combustivel(combustivel),
		  marca(marca),
		  modelo(modelo) //o ano nao surge aqui fica com lixo
	{
		setMatricula(matricula); //construida por omissão
		setAno(ano); //construida por omissão 
		++conta;
	}

	string getMatricula() const
	{
		return matricula;
	}
	string getCombustivel() const
	{
		return combustivel;
	}
	string getMarca() const
	{
		return marca;
	}
	string getModelo() const
	{
		return modelo;
	}
	int getAno() const
	{
		return ano;
	}
	static int getConta();

	
	void setMatricula(const string & matricula)
	{
		if(validaMatricula(matricula)){
			this->matricula = matricula;
		}
		//this->matricula = "99-AA-99";
	}
	void setCombustivel(const string& combustivel)
	{
		this->combustivel = combustivel;
	}
	void setMarca(const string& marca)
	{
		this->marca = marca;
	}
	void setModelo(const string& modelo)
	{
		this->modelo = modelo;
	}
	void setAno(const int ano)
	{
		if (ano > 2000 && ano < 2021) {
			this->ano = ano;
		}
		else {
			this->ano = 0;
		}
	}
	string getAsString()const;
};

int Automovel::conta = 0; //vai ser criado logo no inicio do main

int Automovel::getConta()
{
	return  conta;
}

string Automovel::getAsString()const
{
	ostringstream oss;
	oss << "\nmatricula: " << matricula
		<< "\ncombustivel: " << combustivel
		<< "\nmarca: " << marca
		<< "n\\nmodelo: " << modelo
		<< "\nano: " << ano;
	return oss.str();
}
bool Automovel::validaMatricula(const string & s) const
{
	//v1
	//if (s.length() != 8)
	//{
	//	return false;
	//}
	//return true;
	//v2 expressões regulares
	string patern = "((\d{2}-\d{2}-[A-Z]{2}) | (\d{2}-[A-Z]{2}-\d{2}) | (\[A-Z]{2}-\d{2}-\d{2}))";
	//string patern = R"((\d{2}-\d{2}-[A-Z]{2}) | (\d{2}-[A-Z]{2}-\d{2}) | (\[A-Z]{2}-\d{2}-\d{2}))";
	//string patern = R"(([A-Z]{2}-\d{2}-(\d{2}|[A-Z]{2}))|(\d{2}-(\d{2}-[A-Z]{2}|[A-Z]{2}-\d{2})))";
	regex reg(patern);
	if(regex_match(s, reg))
	{
		return true;
	}
	return false;
}
int main()
{
	cout << "\nconta: " << Automovel::getConta() << endl;
	
	Automovel A1("11-22-CD", "gasolina", "opel", "corsa", 2020);
	
	cout << A1.getAsString();
	cout << "\nconta: " << Automovel::getConta() << endl;
	
	cout << "\nfim da main";
	return 0;
}

………..ficha2, exercicio7 (a6,a7)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>

using namespace std;

class MSG
{
private:
	char letra;
	int numero;
	static int contador;

	//MSG(const MSG& ob); //i)
	
public:
	MSG(char letra = 'X'); //por valor por omissão, um constutor por omissão
	//MSG(char letra); //alternativa que tb funcionar a aliena e)
	~MSG();
	//construtor por cópia
	MSG(const MSG& ob);

	char getLetra() const
	{
		return letra;
	}

	void setLetra(const char letra)
	{
		this->letra = letra;
	}
	int getNumero() const
	{
		return numero;
	}

	void setNumero(const int numero)
	{
		this->numero = contador;
	}
	string getAsString() const;
};

int MSG::contador = 0;

MSG::MSG(char letra)
{
	this->letra = letra;
	this->numero = ++contador;
	cout << "\ncriado: " << getAsString() << endl;
}

MSG::~MSG()
{
	cout << "\nterminado: "<< getAsString() << endl;
}

//construtor por cópia c)
MSG::MSG(const MSG& ob)
{
	//anular o construtor por cópia por defeito que é fornecido pelo compilador
	letra = ob.letra;
	numero = -ob.numero; //para fazer uma coisa diferente (numero simétrico)
	cout << "\nCriado por copia " << getAsString();
}

string MSG::getAsString() const
{
	ostringstream oss;
	oss << "\nletra " << getLetra() << " numero " << getNumero() << endl;
	
	return oss.str();
}

void teste_g()
{
	MSG aux('y');
}

void teste_h(MSG z)
{
	//h)
	//a passagem de um objecto como parametro por valor (funcionou o construtor por cópia)
	//(z é copia de b, e funciona o construtor por cópia)
}

void teste_l(MSG & z) //passar o objecto por referencia
{
	//l)
	//uma referencia não tem o seu lugar proprpio, vai ser apenas outro nome para b,
	//z coincide em memoria com b, não surge outro objecto, é apenas outro nome
	//constutor e destrutor são os mesmos
}

MSG  teste_m()
{
	MSG m; //é criado localemnte um objecto m
	return m; //retornar o m por valor
}

MSG & teste_n() //retorno por referencia, para uma variavel que já existe
{
	MSG m; //é criado localemnte um objecto m
	return m; //retornar o m com estatuto de referencia ( não existe uma cópia )
}

int main()
{
	//objectos não dinamicos, que vai ser destruido no fim do main
	//MSG m1('a');
	//MSG m2; //para fazer uso do default

	//objectos dinâmicos
	//MSG* p = new MSG('D');
	//cout << "\n vou construir D";
	//delete p; //destruo o objecto apontado por p, destruido expressamente
	//cout << "\n vou destruir D";

	//MSG & m3 = m2; //alinea b)
	//m3 é uma referência que se vai "colar" a m2, m3 é um outro nome para m2
	//não vai ser criado mais nenhum objecto

	//c)
	//MSG m4 = m2;
	//não existe nenhum construtor por cópia implementado
	//mas funionou um
	//todas as classe que não tenham um construtor por cópia, o compilador fornece um
	//a nossa construção do construtor por cópia
	//MSG m4 = m2; //criado por cópia

	//d) atribuição
	//MSG m4 = m2; //criado por cópia
	//m1 = m2; //atribuição

	//e) matriz (array) de objectos
	//MSG mat1[] = {'M', 'N'};

	//f) matriz (array) de objectos
	//MSG mat2[2]; //criado se e só existir um constutor por omissão
	//ou
	//MSG m1('a');
	//MSG m2; //para fazer uso do default
	//MSG mat[] = { m1, m2 };
	//ou
	//MSG mat[4] = { MSG('A') , MSG('B') };
	//ou
	//MSG mat[4] = { MSG() , MSG() };

	//g)
	/*cout << "\n alinea g)" << endl;
	teste_g();
	cout << "\n alinea g)" << endl;
	teste_g();*/

	//h)
	//MSG b;
	//cout << "\n alinea h)" << endl;
	//teste_h(b);
	//cout << "\n alinea h)" << endl;
	//teste_h(MSG('c'));
	//a passagem de um objecto como parametro por valor (funcionou o construtor por cópia)
	//(z é copia de b, e funciona o construtor por cópia)

	//i) e j)
	//em privado o  construtor po cópia MSG(const MSG & ob);
	//mas sendo privado a cópia não vai funcionar, teste_h(b);

	//k)
	//objecto é criado com lixo, e é bloqueada a construção por cópia do compilador
	
	
	//l)
	/*MSG b;
	teste_l(b);*/

	//m)
	//MSG b = teste_m(); //o valor m chegou aqui
	//, mas m perde a validade no primeiro }, morre aqui, é terminado
	//vai ser feita uma copia de m e é este que vai representar a informação a seguir ao = do teste_m()
	//quem actua é o construtor por cópia, o return é uma cópia

	//n) retorno por referência
	MSG b = teste_n(); //
	
	
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha2, exercicio9 (a7, a8)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>

using namespace std;

class Televisao
{
	vector<string> canais; //estes endereços podem mudar de sítio
	//acrescentar elementos ao canais.push_back("rtp1");
	//string s = "sic";
	//canais.push_back(s);
	//percorrer:
	//for(int i = 0; i< canais.size(); i++){
	// cout << canais[i];
	//}
	//esvaziar tudo:
	//canais.clear(); //size a zero
	//alternativa será uso de vectores de ponteiros para objectos dinâmicos (dinâmicos vão estar no seu lugar)
	
	bool ligada;
	int volume;
	int canal; //indice do vector de canais +1
	string nomeCanal;

	//o conjunto de canais definido na construção não se altera a partir do exterior da classe
	void setCanais(string canais0[], unsigned int n);

public:
	Televisao(string canais0[], int n);

	bool isLigada()const; //is por ser booleana
	void ligar();
	void desligar();

	void aumentaVolume();
	void diminuiVolume();

	void mudaCanal(int c);
				
	int getCanal() const
	{
		return canal;
	}

	//para experimentar
	Televisao(initializer_list<string> canais0); //lista de constantes, separadas por virgulas e chavetas
	void setCanais(initializer_list<string> canais0);
	void setCanais2(vector<string> canais0); 
		
	string getAsString()const;
		
};

void Televisao::setCanais(string canais0[], unsigned int n)
{
	//validação
	if(n< 0)
	{
		n = 0;
	}
	//se já tiver previamente preecnhido
	canais.clear();
	for(unsigned int i = 0; i < n; ++i)
	{
		canais.push_back(canais0[i]); //copiar os elementos para o vector de strings
	}
}

Televisao::Televisao(string canais0[], int n)
{
	setCanais(canais0, n);
	ligada = false;
	volume = 0;
	canal = 1;
	cout << "\nNormal" << endl;
}

bool Televisao::isLigada() const
{
	return ligada;
}

void Televisao::ligar()
{
	ligada = true;
}

void Televisao::desligar()
{
	ligada = false;
}

void Televisao::aumentaVolume()
{
	if (ligada != true)
		return;
	if (volume <= 10)
		volume++;
}

void Televisao::diminuiVolume()
{
	if (ligada != true) 
		return;
	if (volume >= 10)
		volume--;
}

void Televisao::mudaCanal(int c)
{
	if (ligada != true)
		return;
	unsigned cc = c;
	if (cc > 0 && cc <= canais.size())
		canal = c;
}

Televisao::Televisao(initializer_list<string> canais0)
{
	setCanais(canais0);
	ligada = false;
	volume = 0;
	canal = 1;
	cout << "\nInitializer" << endl;
}

void Televisao::setCanais(initializer_list<string> canais0)
{
	canais.clear();
	//ou
	//for (const auto& c : canais)
	//{
	//	canais.push_back(c);
	//}
	//ou
	//for (initializer_list<string>::iterator it = canais0.begin(); it != canais0.end(); ++it){
	//	canais.push_back(*it);
	//}
	//ou
	for(auto it = canais0.begin(); it != canais0.end(); ++it)
	{
		canais.push_back(*it);
	}
}

void Televisao::setCanais2(vector<string> canais0)
{
	canais.clear();
	for (auto it = canais0.begin(); it != canais0.end(); ++it)
	{
		canais.push_back(*it);
	}
}

string Televisao::getAsString() const
{
	ostringstream oss;
	
	//for(unsigned int i = 0; i < canais.size() ; ++i)
	//{
	//	//oss << canais[i] << " ";
	//	oss << canais.at(i) << " ";
	//}

	//for (const string& c : canais) //c é um outro nome para cada um dos elementos da coleção
	//	oss << c << " ";

	//for (string c : canais) //c é uma copia dos elementos da coleção
	//	oss << c << " ";

	//for (const auto & c : canais)
	//	oss << c << " ";

	//iterador aponta para os elementos do objecto e desta forma conseguimos percorrer
	//for (vector<string>::const_iterator it = canais.begin(); it != canais.end(); ++it)
	//	oss << *it << " ";

	for( auto it = canais.begin() ; it != canais.end(); ++it)
	{
		oss << *it << " ";
	}

	if(!ligada)
	{
		oss << "desligada\n";
		return oss.str();
	}
	if(canais.empty())
	{
		oss << "sem canais ";
		return oss.str();
	}
	
	oss << "\nCanal"  << canais[canal-1] << " " << canal << "\nvolume: " << volume << endl;

	return oss.str();
}

int main()
{
	//exemplos dos inicializer lists
	Televisao tv = { "um","dois","tres","quatro" };
	Televisao tv2{ "um", "dois" };
	Televisao tv3({ "um","dois" });
	//outro exemplo e se for construtor e fizer uso dos ()
	tv.setCanais2({ "um","dois","tres" });

	//uniform inicialization
	//usar estes construtor Televisao(string canais0[], int n);
	string canais[] = { "um","dois" };
	Televisao tv4(canais, 2);
	Televisao tv5{ canais, 2 };
	Televisao tv6 = { canais, 2 };
	
	cout << "\nfim do main" << endl;
	return 0;
}

………..ficha2, exercicio5 (a10, a11)

#include <string>
#include <iostream>
#include <sstream>
#include <vector>
#include <regex>
#include <initializer_list>

using namespace std;

class Prego {
	int x, y;
public:
	Prego(int a, int b);
	~Prego();
	void mudaDeSitio(int a, int b);

	string getAsString() const;

	int getX()const { return x; }
	int getY()const { return y; }
};

Prego::Prego(int a, int b):x(a), y(b)
{
	//x = a; y = b;
	cout << "construindo prego em " << x << "," << y << "\n";
}

Prego::~Prego()
{
	cout << "~Prego em " << x << "," << y << "\n";
}

void Prego::mudaDeSitio(int a, int b)
{
	x = a; y = b;
}

string Prego::getAsString() const
{
	ostringstream oss;

	oss << "Prego: ( " << x << " , " << y << " ) ";
	
	return oss.str();
}

class Aviso
{
	string texto;
	//Prego prego; //relação de composição.
	//Prego * prego;
	//usamos um ponteiro, já não é uma posse exclusiva
	//aviso é destruído, o prego fica lá..
	//com ponteiro pode haver posse excluiva ou não
	//Prego * const prego;
	//não é possivel mudar o endereço do prego
	//recebe um valor e não pode mudar, usa-se o const
	const Prego * const prego;
	//O aviso nao te direito a fazer alterações ao Prego... const Prego
	//a relação entre aviso e prego é de agregação (tem o conhecimento)
	//porque se o aviso for destruido o prego não é
	//o prego pode ser partilhado por mais de um aviso
	//o prego já existe antes do aviso
	//o aviso tem o conhecimento do prego
public:
	Aviso(const string & t, const Prego * const p);
	~Aviso();
	int getX() const;
	int getY() const;
	string getAsString() const;
	Aviso(const Aviso& ob); //construtor por cópia
};

Aviso::Aviso(const string& t, const Prego * const p):texto(t), prego(p)
{
	//prego = p
	//nao é possivel usar porque o Prego é um membro constante de Aviso (ou até podia ser uma referencia)
	//logo tem que ser usada a outra opção
	//os membros const e os membros referencias é obrigatório inicializar na lista de inicialização do construtor
	cout << " construido Aviso " << texto << endl;
}

Aviso::~Aviso()
{
	cout << " ~Aviso() " << texto << endl;
}

int Aviso::getX() const
{
	return prego->getX();
}

int Aviso::getY() const
{
	return prego->getY();
}

string Aviso::getAsString() const
{
	ostringstream oss;
	oss << "Aviso: " << texto << " " << prego->getAsString();
	
	return oss.str();
}

Aviso::Aviso(const Aviso& ob):prego(ob.prego)
{
	texto = ob.texto+"Copia";
	cout << "CCopia de aviso " << texto << endl;
}


int main()
{
	Prego p(1, 2);
	Aviso a("quadro 1", &p);
	Aviso b("quadro 2", &p);

	cout << " A " << a.getAsString() << endl;
	cout << " B " << b.getAsString() << endl;

	p.mudaDeSitio(99, 99);

	cout << " A " << a.getAsString() << endl;
	cout << " B " << b.getAsString() << endl;

	//a=b; //erro
	//a atribuição entre dois objectos é feita membro a membro
	//o texto consegue atribuir, mas o prego pk tem const não consegue
	//assim a atribuição default dá erro, podemos é usar uma atribuição que funcione
	//usando o operador atribuição

	Aviso c = a;
	cout << " C " << c.getAsString() << endl;

	vector<Aviso> avisos;
	cout << "-pushback-\n";
	
	avisos.push_back(a);
	Aviso* pa = &avisos[0]; //ponteiro para o primeiro elemento do vector
	cout << pa->getAsString() << endl;

	avisos.push_back(b);
	Aviso* pb = &avisos[0];
	cout << pb->getAsString() << endl;

	if(pa==pb)
	{
		cout << " == \n";
	}else
	{
		cout << " != \n";
	}
	cout << avisos[0].getAsString() << endl;

	//avisos.erase(avisos.begin() + 1);
	//dá erro, pk os objectos do vector têm um membro constante
	//a atribuição dá erro, e o erase precisa de atribuições internamente
		
	cout << "\nfim do main" << endl;
	return 0;
}