Questões de C++ (parte3)


#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 1
//construir o construtor por cópia

class Funcionario{ /* ... */ };
class Reuniao
{
	//só faz uso das fichas funcionarios, convocados
	vector <Funcionario*> convocados;
	//é da posse exclusiva da Reuniao, ordemDeTrabalhos
	vector <string*> ordemDeTrabalhos;
public:
	//..
	~Reuniao()
	{
		for(string * s: ordemDeTrabalhos)
		{
			delete s;
		}
	}
	//do construtor por cópia
	Reuniao(const Reuniao & ob)
	{
		convocados = ob.convocados; //copiar vector Funcionario
		//porque é posse exclusiva, podes querer modificar
		for(string * o : ordemDeTrabalhos) //copiar as strings
		{
			ordemDeTrabalhos.push_back(new string(*o));
		}
	}
};

int main()
{
}

//regra dos três:
//destrutor
//construtor por cópia
//operador de cópia
//https://pt.wikipedia.org/wiki/Regra_dos_tr%C3%AAs_(C%2B%2B)#Regra_dos_Tr%C3%AAs
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 2
class Num
{
	int n;
	public:
		Num()
		{
			n = 0;
		}
	void setN(int nn)
		{
		n = nn;
		}
	int getN()const
		{
		return n;
		}
};

void f(const Num * p)
{
	p->setN(5); //<- erro
	//é const o Num
	//logo não são do mesmo tipo
	p = new Num();
}

void g(Num * const p)
{
	p->setN(5);
	p = new Num(); //<- erro
	//é const o p
	//logo não pode ser modificado
}

int main()
{
	Num ob;
	ob.setN(4);
	f(&ob);
	g(&ob);
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 3

class Erro {
	string msg;
public:
	Erro(const string & s = "") :msg(s)
	{
	}
	string what()
	{
		return msg;
	}
};

void calculaArea(int lado)
{
	try
	{
		if(lado < 0)
		{
			throw Erro("lado negativo");
		}else if(lado >10)
		{
			throw new string("lado superior ao limite");
		}
	}catch(Erro & e)
	{
		lado = 0;
	}catch(string & e)
	{
		lado = 10;
	}
	cout << "area = " << lado * lado << ";";
}
int main()
{
	try
	{
		calculaArea(-2);
		cout << "depois; ";
	}catch (Erro & e)
	{
		cout << "catch main; \n";
	}catch(string & e)
	{
		cout << "catch main; \n";
		
	}
	cout << "fim main;\n";
}

ouput:
area = 0
depois;
fim main
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 4

class Canideo
{
	int peso;
	string dieta;
public:
	Canideo(int a, string b = "Carne"): peso(a), dieta(b)
	{
	}
	Canideo() = default;
	virtual	~Canideo()
	{
	};
	virtual double dose() const
	{
		return peso * 0.1;
	};
	int getPeso() const
	{
		return peso;
	}
	string getDieta() const
	{
		return dieta;
	}
};

class Cao: public Canideo
{
	string nome;
public:
	Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05;
	}
};
class Lobo: public Canideo
{
	string habitat;
public:
	Lobo(int a, string b = "galinha", string c = "floresta") : Canideo(a), habitat(c)
	{
	}
};
int main()
{
	Lobo a(120);
	Canideo* c = new Cao(20);

	cout << a.getDieta() << " " << c->getDieta() << " ";
	cout << a.dose() << c->dose() << endl;
}

output
carne racao 12 1

//A especificação = default após a declaração do construtor por omissão,
//indica ao compilador para disponibilizar o construtor por omissão, trivial
//O construtor por omissão, trivial faz as seguintes ações:
//É aplicada a inicialização dos membros variáveis, feita na declaração
//Relativamente aos restantes membros variáveis:
//Os membros variáveis de tipo primitivo não são inicializados
//Os membros que são objetos de classes são inicializados pelos seus
//construtores por omissão
//Se a classe for derivada de uma classe base, o subobjeto da classe base
//é inicializado pelo construtor por omissão desta classe base
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 5

//acrescentar um novo tipo de cao, o Galgo
//que tem um determinada velocidade, indicada na criação deste objecto
//a velocidade tem impacto na sua dose diaria
//qual a solução?
//a) criar uma classe derivada de Canideo com atributo velocidade. esta classe deve
//ter um construtor e tem que redefinir o método virtual dose()
//b) criar uma classe derivada de Cao com atributo velocidade. esta classe
//deve ter um construtor e tem que redefinir o método virtual dose();
//c) criar uma classe derivada de Cao com atributo velocidade. esta classe
//deve ter um construtor, mas pode utilizar o método virtual dose() da classe
//base
//d) acrescentar um atributo booleano tipo à classe Cão, indicando se os
//objectos são Galgos. adpatar o método dose() desta classe, para calcular
//a dose diária correta se os cães em questão forem galgos.

class Canideo
{
	int peso;
	string dieta;
public:
	Canideo(int a, string b = "Carne"): peso(a), dieta(b)
	{
	}
	Canideo() = default;
	virtual	~Canideo()
	{
	};
	virtual double dose() const
	{
		return peso * 0.1;
	};
	int getPeso() const
	{
		return peso;
	}
	string getDieta() const
	{
		return dieta;
	}
};

class Cao: public Canideo
{
	string nome;
public:
	Cao(int a, string b = "Racao", string c = "Bobi") : Canideo(a,b), nome(c)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05;
	}
};

class Galgo : public Cao
{
	int velocidade;
public:
	Galgo(int a, int v, string b = "Racao") : Cao(a,b), velocidade(v)
	{
	}
	virtual double dose() const override
	{
		return getPeso() * 0.05 / velocidade;
	}
};

resposta:
b) criar uma classe derivada de Cao com atributo velocidade.esta classe
deve ter um construtor e tem que redefinir o método virtual dose();
//porque é um tipo Cao, e a velocidade afecta paenas o tipo Galgo
Tags : , , ,