Tag: agregação

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 : , , , , , ,

Questões de C++ (parte 1)

#include <iostream>
#include <string>
using namespace std;

//----------------------------------pergunta 1 
class Ser
{
public:
	void respirar() { cout << "\n respirar?"; }
	virtual void alimentar() { cout << "\n alimentar?"; }
};

class SerVivo : public Ser {
public:
	void respirar() { cout << "\n ser vivo respira"; }
	virtual void alimentar() { cout << "\n ser vivo alimenta-se "; }
};

class Planta : public SerVivo {
public:
	void respirar() { cout << "\n pelas folhas"; }
	virtual void alimentar() { cout << "\n pelas raizes "; }
};

void alimentarPorObjecto(Ser obj) {
	obj.alimentar();
}

void alimentarPorReferencia(Ser & ob) {
	ob.alimentar();
}

int main() {
	Ser* s1 = new Planta;
	cout << "\n---1---";
	//como respirar não é virtual,
	//vai executar a função do ponteiro ou referência (Ser)
	s1->respirar();
	//como alimentar é virtual,
	//vai executar a funlãi da classe deste objeto (Planta)
	s1->alimentar();

	cout << "\n---2---";
	SerVivo* s2 = new Planta;
	//como respirar não é virtual,
	//vai executar a função do ponteiro ou referência (SerVivo)
	s2->respirar();
	//como alimentar é virtual,
	//vai executar a funlãi da classe deste objeto (Planta)
	s2->alimentar();

	cout << "\n---3---";
	Planta arvore;
	//executa as funções deste objecto (Planta)
	arvore.respirar();
	//executa as funções deste objecto (Planta)
	arvore.alimentar();

	cout << "\n---4---";
	//executa as funções da base (Ser)
	alimentarPorObjecto(arvore);
	//executa as funções deste objecto (Planta)
	alimentarPorReferencia(arvore);
}

#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 2
class Ser
{
	string nome;
	string * local;
public:
	Ser(string s):nome(s)
	{
	}
	string getNome()
	{
		return nome;
	}
	//const antes e depois do *
	//não é possivel qualquer alteração
	const string* getLocal()const
	{
		return local;
	}
};
int main()
{
	//const, o objeto é constante
	const Ser ob("abc");
	//função getNome() tinha que ser depois const
	cout << ob.getNome();
	//p1 não é const, devia ser const string
	string *  p1 = ob.getLocal();
	const string* p2 = ob.getLocal();
	//p3 não é const, devia ser const string
	string * const p3 = ob.getLocal();
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 3
class A
{
	int numA;
	string nome;
public:
	A():numA(0), nome("default1")
	{
	}
	A(int v):numA(v), nome("default2")
	{
	}
	int getNumA() { return numA; }
	string getNome() { return nome; }
};

class B1: public A
{
	int numB;
public:
	B1(int v):A(v+1), numB(v)
	{
	}
	B1(const B1 & orig):numB(orig.numB)
	{
	}
	void imprime()
	{
		cout << getNumA() << " " << getNome() << numB << endl;
	}
};

class B2 : public A
{
	int numB;
public:
	B2(int v):A(v+1), numB(v)
	{
	}
	void imprime()
	{
		cout << getNumA() << " " << getNome() << numB << endl;
	}
};

void f()
{
	//executa o construtor da base (A) com parametros
	//e executa o seu construtor (B) que recebe um parametro
	B1 bx(3);
	//executa o construtor da base (A) sem parametros
	//e executa o seu construtor (B) que recebe objeto do tipo B
	B1 by(bx);

	cout << "\n--funcao f()" << endl;
	//saida-> 4 default2 3
	bx.imprime();
	//saida-> 0 default1 3
	by.imprime();
}

void g()
{
	//executa o construtor da base (A) com parametros
	//e executa o seu construtor (B) que recebe um parametro
	B2 bw(3);
	//nao tem nada de especial para executar
	//o bz faz uma "copia" do que tem o bw
	B2 bz(bw);
	cout << "\n--funcao g()" << endl;
	//saida-> 4 default2 3
	bw.imprime();
	//saida-> 4 default2 3
	bz.imprime();
}

int main()
{
	f();
	g();
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 4


class Produto
{
	string nome;
	int quantidade;
public:
	Produto(string s, int q)
	{
		nome = s;
		quantidade = q;
	}
	// += operador membro: (a += b) += c
	Produto& operator += (const Produto a)
	{
	}
};
// + operador global: c = a + b
Produto operator+(Produto a, Produto b)
{
};

// << operador global: cout << a << b
ostream & operator << (ostream& str, const Produto& k)
{
};

// << operador global: (a << 4) << 5;
int operator<<(const Produto& a, const int& b)
{
};

Produto & operator++(const Produto & produto);

int main()
{
	Produto a("aaa", 10), b("bbb", 20), c("ccc", 30);
	c = a + b; //implementar Global: Produto operator+(Produto a, Produto b)
	cout << a << b;//implementar Global: ostream & operator<<(ostream& str, const Produto& k)
	(a += b) += c;//implementar membro: Produto& operator += (const Produto a)
	(a << 4) << 5;//implementar Global: int operator<<(const Produto& a, const int& b)
	++a;//implementar Global: Produto & operator++(const Produto & produto);
}

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

class Ponto
{
	int x;
	int y;
public:
	Ponto(int x0, int y0)
	{
		x = x0;
		y = y0;
	}
};

class Figura
{
	string nome;
public:
	Figura(string s){
		nome = s;
	}
	string getNome()const
	{
		return nome;
	}
};

class Rectangulo: public Figura
{
	Ponto cantoSupEsq;
	Ponto cantoInfDir;
public:
	//implementar o que falta:
	Rectangulo(int a, int b, int c, int d): Figura("rectangulo"), cantoSupEsq(a, b), cantoInfDir(c, d)
	{
	}
};

int main()
{
	Rectangulo rect(1, 1, 4, 4);
	cout << rect.getNome(); //aparece rectangulo no ecrã
}
#include <iostream>
#include <string>
using namespace std;
//----------------------------------pergunta 6

class A
{
public:
	virtual void f() = 0;
	virtual void g() = 0;
};

class B: public A
{
public:
	virtual void h() = 0;
	virtual void g(){}
};

//definir uma class C, concreta, derivada de B
//func f e a func h são virtuais puras logo têm de ser definidas 
//em C para que esta classe seja concreta
class C : public B
{
	virtual void f();
	virtual void h();
	virtual void g() {}
};

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

class Animal
{
public:
	//completar aqui
	//não deve ser possivel criar objectos da classe Animal
	//função virtual pura
	virtual void Fala() = 0;
};

//a relação entre Jaula e Animal é agregação
//a relação entre Jaula e alimentos é composição
class Jaula
{
	vector <Animal * > animais;
	string ** alimentos; //array dinamico de ponteiros para string
	int nAlimentos; //numero de alimentos do array dinâmico
public:
	Jaula()
	{
		alimentos = new string * [2];
		nAlimentos = 2;
		alimentos[0] = new string("agua");
		alimentos[1] = new string("cereais");
	}
	~Jaula()
	{
		//completar aqui, os destrutores desta classe
		for (Animal* a : animais) {
			delete a;
		}
		delete alimentos;
	}
	//..
	//por ter uma virtual na base
	void Fala(){}
};

//a relação entre Zoo e Animal é composição
//a relação entre Zoo e Jaula é composição
class Zoo
{
	vector <Animal* > animais;
	vector<Jaula* > jaulas;
public:
	~Zoo()
	{
		//completar aqui, os destrutores desta classe
		for(Animal * a: animais) {
			delete a;
		}
		for (Jaula* j : jaulas) {
			delete j;
		}
	}
	//..
	//por ter uma virtual na base
	void Fala() {}
};
Tags : , , , , , , , ,