Test Foro de elhacker.net SMF 2.1

La duda es la siguiente digamos que en una clase padre yo poseo el siguiente esquema:
ahora bien en una clase hijo que pose la siguiente estructura:

la cuestión es que al momento de implementar necesito el resultado del método Funcion() y el getEjemplo() en el método Funcion_h().
asi:


Tipo hijo::Funcion_h ( ) {
return Funcion()+getEjemplo(); //es solo un ejemplo
}

La pregunta es como hago ya he intentado las siguientes sintaxis:
padre::getEjemplo()
padre.getEjemplo()
Tipo hijo::Funcion_h ( ) : getEjemplo() {
return Funcion()+getEjemplo(); //es solo un ejemplo
}
se que no es asi pero aja uno nunca sabe  ;D
Les agradeceria me ayudaran urgentemente es un proyecto  :silbar:
Gracias de antemano...

Igual es que no has heredado bien la clase , si no es lo que quieres vuelve a postear y detalla más lo que quieres  :)
class padre
{
   public:
   int funcion();
   int getEjemplo();
   int setEjemplo();
};
class hijo : public padre//Aquí es donde se hereda la clase padre
{
   public:
   int funcion_h()
   {
       return funcion()+getEjemplo();
   }
};
¡Un saludo!

Gracias por responder, sin embargo esto que has planteado lo tengo claro y aun asi no se por que no funciona mira, pues que te digo publicare la secuencia de los archivos a ver si vez donde esta el inconveniente:

padre.h
#ifndef PADRE_H
#define PADRE_H

class padre {
Tipo Ejemplo;
private:
protected:
public:
padre();
~padre();
void setEjemplo(Tipo E);
Tipo getEjemplo();
Tipo Funcion();
};

#endif

padre.cpp
#include "padre.h"

padre::padre() {

}

padre::~padre() {

}


void padre::setEjemplo (Tipo E) {
Ejemplo=E;
}

Tipo padre::getEjemplo ( ) {
return Ejemplo;
}

Tipo padre::Funcion ( ) {
return operacion_que_emplea(Ejemplo);
}

hijo.h
#ifndef HIJO_H
#define HIJO_H
#include "padre.h"

class hijo : public padre {
private:
protected:
public:
hijo();
~hijo();
Tipo Funcion_h();
};

#endif

hijo.cpp
#include "hijo.h"

hijo::hijo() {

}

hijo::~hijo() {

}


Tipo hijo::Funcion_h ( ) {
return Funcion()+getEjemplo(); //es solo un ejemplo
}

main.cpp
#include<iostream>
#include "hijo.h"
#include "padre.h"
using namespace std;

int main () {
hijo h;
padre p;//tengo entendido que no hay necesidad de declarar la clase padre si sus funciones estan incluidas en hijo sin embargo en el original yo lo nombro
Tipo x; //declaracion de parametros
cout << "Digite el parametro: ";
cin >> x;
p.setEjemplo(x);
cout << p.getEjemplo(); //escribe perfecto
cout << h.getEjemplo(); //se supone que deberia ser el mismo resultado cosas que he intentado:
//cout << h::p.getEjemplo();
//cout << h->padre.getEjemplo();
//y varias mas que se qui ni al caso...
cout << h.Funcion_h(); // ademas tambien necesito calcular esto y depende de padre
return 0;
}

Realmente necesito ayuda urgente el proyecto en pasado mañana y estoy quedado solo en ese pedacito se que es algo que estoy omitiendo y quizas sencillo de solucionar, del resto no poseo muchas dudas :huh:

Es que los tipos clase padre y clase hijo son diferentes , es decir:
padre p;
hijo h;//Desde h no puedes acceder a p. h es un tipo con herencia de la clase de p , pero no puede acceder a él.
Digamos que la clase hijo , es una extensión a la clase padre , pero una clase hijo no puede controlar a una clase padre que sean objetos distintos

Gracias ahora empiezo a entender puedo usar las ecuaciones que poseo en la clase padre pero debe introducir yo los parámetros no puedo usar los últimos parámetros empleados en la clase padre  :-(

empece haciendo pruebas donde llamada de esta manera a un método de la clase padre para ello inicie en el constructor de la clase padre un valor cualquiera y este era la respuesta

padre.cpp
padre::padre() {
Ejemplo=parametro;
}


main.cpp
p.setEjemplo(x); //usando esta asignación, no se imprimía el valor deseado
h.padre::setEjemplo(x); // esta resulto perfecta
cout << h.padre::getEjemplo();

pero esto significa que si tuviese varios metodos tendria entonces que hacer:
padre.cpp
padre::padre() {
Ejemplo=parametro; // esto generalmente sera inicializado en cero
        Ejemplo2=parametro;
}


main.cpp
p.setEjemplo(x); //usando esta asignación, no se imprimía el valor deseado
h.padre::setEjemplo(x); // esta resulto perfecta
h.padre::setEjemplo2(x); // para luego poder llamarlo por medio de hijo
cout << h.padre::getEjemplo();
cout << h.padre::getEjemplo2();