Problemas no código

[arestides]

Boas, gostava de saber qual o problema que se encontra nos seguintes códigos e quais as respectivas soluções para estes...alguem me consegue ajudar?

1.

#include <iostream>
using namespace std;

class B{
public:
void Display (){cout<< "Are you going to learn c++?"<<endl;}
};
class D : public B{
public :
void Display () {cout <<"I am also learning c++."<<endl;}
};

int main(){
B b;
D d;
D *dptr = &(D) d;
dptr ->Display ();
dptr = & b;
dptr ->Display ();
return 0;
}

2-

//...
class Racional {
friend const Racional& operator*(const Racional& oe, const Racional& od);

private:
int n, d; //numerador e denominador

public:
Racional (int numerador = 0, int denominador = 1);
//...
};

const racional& operator* (const Racional& oe, const Racional& od){
Racional *resultado = new Racional(oe.n * od.n, oe.d * od.d);
return *resultado;
};

int main(int argc, char** argv){

Racional w,x,y,z;
w = x*y*z;
//...
}

3-

//...
class Racional {

public:
Racional (int numerador = 0, int denominador = 1);

int numerador () const;
int denominador () const;

const Racional operator* (const Racional& rhs) const;

private:
//...
};

int main (int argc, char** argv){
Racional umOitavo(1, 8);
Racional umMeio(1, 2);

Racional resultado = umMeio * umOitavo;
resultado = resultado * umOitavo;

resultado = umMeio * 2;
resultado = 2* umMeio;
//...
};

4-

#include <iostream>

using namespace std;


class Pessoa {
private:
	std::string nome;
	std::string morada;
public:
	Pessoa();
	virtual ~Pessoa();
	//..
};

class Aluno: public Pessoa {
private:
	std::string nomeEscola;
	std::string moradaEscola;
public:
	Aluno();
	~Aluno();
	//...	
};

int main (int argc, char** argv)
{
//...
bool validaAluno (Aluno s);

Aluno fourrier;
bool fourrierIsOK = validaAluno(fourrier);

//...
}

Aguardo pelas vossas sogestoes.

Obrigado.

[mogers]

Assim numa olhadela rápida, penso que é o seguinte:

1) Só há lugar a dynamic lookup em funções virtuais. Como a função display não é virtual, o código executa sempre a função definida na classe B. (por causa de ser chamada a partir de um apontador)

Isto estava errado. Não deparei que o apontador era D* e não B*. O erro é que um apontador para um determinado tipo não pode apontar para um objecto de uma superclasse (e.g. porque não é garantido que a superclasse possua a mesma interface de funções que a subclasse e isto leva a erros).

2) Assim de repente não detectei nenhum erro. Já experimentaste o código?

3) Não está definido o operador *  para inteiros*Racional e Racional*inteiros (fim do main)

4) C++ não permite a definição de funções dentro de funções devido a perdas de eficiência e complexidade da implementação dessa funcionalidade. (validaAluno)

Tenho exame amanhã. Não posso ver mais disto 😕

[arestides]

Estes são alguns exemplos de exames antigos, e so é mostrado este código e pedido os erros e soluções.

1-O problema neste é a violação da hierarquia de classes em "dptr = & b", esta a aceder a um objecto da superclasse. Mas como poderia resolver isto?

2- As accessor functions (const) ao devolverem um ponteiro para atributos privados violam o encapsulamento, a solução seria colocar const antes do ponteiro devolvido???não sei se sera bem isto.

3- Podes dar uma solução no código para entender melhor? Tenho de definir int*Racional ; Racional *int?onde?

4- O problema esta em "bool validaAluno (Aluno s)" é isso? a solução seria definir na classe?

Mogers mais uma vez muito obrigado pela ajuda e boa sorte para o exame. 😕

[mogers]

1) Para isto funcionar, o dptr teria de ser do tipo B* em vez de D*. Neste caso, acontecia aquilo que expliquei no texto rasurado, por isso, para o programa funcionar correctamente, a função display tinha de ser virtual.

2) Devolverem um ponteiro para atributos privados? Mas eles estão a criar um objecto e devolvem uma referencia para o objecto criado (e não um apontador). Btw, eu assumo que na definição do operador "const racional& operator*", a escrita de "racional" em vez de "Racional" seja apenas um typo e não seja este o erro (uma coisa destas seria parvo num exame).

3) Senão me engano, os operadores definidos na classe têm sempre o *this como lhs. Por isso só podias definir o Racional*int na classe e o int*Racional teria de ser à parte. Um exemplo funcional onde ambos são definidos fora da classe:

class Racional {	
public:
        Racional (int numerador = 0, int denominador = 1) {
	n = numerador , d = denominador;
}

        int numerador () const 	{	return n; }	
        int denominador () const{	return d; }

        const Racional operator* (const Racional& rhs) const {
	Racional *novo = new Racional(n*rhs.n , d*rhs.d);
	return *novo;
}

private:
        int n , d;
};

const Racional& operator*(int lhs , const Racional & rhs) {
Racional *novo = new Racional(lhs* rhs.numerador() , rhs.denominador());
return *novo;
}
const Racional& operator*(const Racional & lhs, int rhs) {
Racional *novo = new Racional(rhs* lhs.numerador() , lhs.denominador());
return *novo;
}

int main (int argc, char** argv){
        Racional umOitavo(1, 8);
        Racional umMeio(1, 2);

        Racional resultado = umMeio * umOitavo;
        resultado = resultado * umOitavo;

        resultado = umMeio * 2;
        resultado = 2* umMeio;
        
return 0;
};

4) Sim, o problema está nessa função. Parece-me que definir a função na classe Aluno seria melhor do que uma função global.