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;
}
Tags : , , , ,

0 thoughts on “excepções e vários”

Leave a Reply

Your email address will not be published.

This site uses Akismet to reduce spam. Learn how your comment data is processed.