Questões de C++ (parte2)

#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 1

class Jogador
{
public:
	void treinar() { cout << "\n treinar"; }
	virtual void jogar() { cout << "\n jogar"; }
};

class Defesa: public Jogador
{
public:
	void treinar(){ cout << "\n treinar defesa"; }
	void jogar() override { cout << "\n jogar defesa"; }
	//override: redefinição de uma função virtual da classe base
};

class Atacante : public Jogador
{
public:
	void treinar() { cout << "\n treinar ataque"; }
	void jogar() override { cout << "\n jogar ataque"; }
};

class PontaDeLanca : public Atacante
{
};
int main()
{
	vector<Jogador*> jogadores;
	jogadores.push_back(new Defesa);
	jogadores.push_back(new Atacante);
	jogadores.push_back(new PontaDeLanca);
	for(Jogador * j: jogadores)
	{
		j->treinar();
		j->jogar();
	}
}

output:
treinar
jogar defesa
treinar
jogar ataque
treinar
jogar ataque
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 2
class Ponto
{
	int x, y;
public:
	Ponto(int x0 = 0, int y0 = 0)
	{
		x = x0;
		y = y0;
	}
};
class Figura
{
	string nome;
public:
	Figura(const string & n)
	{
		nome = n;
	}
	void setNome(const string &n )
	{
		nome = n;
	}
};
class Circulo : public Figura
{
	Ponto centro;
	const int raio;
public:
	//qual sera o construtor..
	//resposta1:
	Circulo(int x0, int y0, int r) : centro(x0, y0), raio(r), Figura("circulo")
	{
	};
	//resposta2
	Circulo(int r) : raio(r), Figura("circulo")
	{
	};
};

int main()
{
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 3

class SerVivo
{
public:
	virtual void f() = 0;
	virtual void g() = 0;
};
class Animal : public SerVivo
{
public:
	virtual void h() = 0;
	void f() override { /* ... */}
};

class Ave : public Animal
{
public:
	//a classe Ave tem que ser concreta
	//...
	//sabe-se que:
	//Uma classe abstrata é uma classe para a qual um ou mais
	//métodos são declarados, mas não definidos
	//O polimorfismo permite que classes abstratas consigam
	//receber comportamentos através de classes concretas
	//As classes derivadas das classes abstratas são conhecidas
	//como classes concretas
	//f e g são funções virtuais puras logo têm de ser definidas
	//em Ave para que esta classe seja concreta
	virtual void g(){}
	virtual void h() {}
};
int main()
{
}
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 4
class Erro
{
	string msg;
public:
	Erro(const string& s): msg(s){}
	string what()
	{
		return "(1) erro " + msg;
	}
};

void funcao()
{
	try
	{
		cout << "(2) antes; ";
		throw Erro("(3) em funcao ...");
		cout << "(4) depois; ";
	}catch (Erro & e)
	{
		cout << e.what() << "(5) ;";
	}catch(string & e)
	{
		cout << "(6) catch string;";
	}
	cout << "(7) fim funcao; ";
}
int main()
{
	try
	{
		funcao();
	}
	catch (Erro & e)
	{
		cout << "(8) catch erro main;";
	}
	cout << "(9) fim main; \n";
}

output:
(2) antes;
(1) erro (3) em funcao ... (5);
(7) fim funcao;
(9) fim main;
#include <iostream>
#include <string>
#include <vector>
using namespace std;
//----------------------------------pergunta 5

//inicio extra enunciado
class FichaAnimal
{
	FichaAnimal(){}
};
//fim extra enunciado

class Gaiola
{


private:
	vector <FichaAnimal*> animais; //um vector
	string* ocorrencias;
	int nOcorrencias;
public:
	//...
	//inicio extra enunciado
	Gaiola(const vector<FichaAnimal*>& ficha_animals, string* ocorrencias, int ocorrencias1)
		: animais(ficha_animals),
		ocorrencias(ocorrencias),
		nOcorrencias(ocorrencias1)
	{
	}
	//fim extra enunciado
	//resposta:
	~Gaiola()
	{
		delete[] ocorrencias;
	}
};

int main()
{
}
Tags : , , , , , ,