mylab

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() {}
};