Duda sobre herencia en C++

[NekoOs]

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:

Código (cpp) [Seleccionar] Expandir


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

La pregunta es como hago ya he intentado las siguientes sintaxis:

Código (cpp) [Seleccionar] Expandir

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 
Les agradeceria me ayudaran urgentemente es un proyecto 
Gracias de antemano...

[avesudra]

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  

Código (cpp) [Seleccionar] Expandir

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!

[NekoOs]

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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

#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

Código (cpp) [Seleccionar] Expandir

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

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

#endif

hijo.cpp

Código (cpp) [Seleccionar] Expandir

#include "hijo.h"

hijo::hijo() {

}

hijo::~hijo() {

}


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

main.cpp

Código (cpp) [Seleccionar] Expandir

#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

[avesudra]

Es que los tipos clase padre y clase hijo son diferentes , es decir:

Código (cpp) [Seleccionar] Expandir

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

[NekoOs]

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

Código (cpp) [Seleccionar] Expandir

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


main.cpp

Código (cpp) [Seleccionar] Expandir

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

Código (cpp) [Seleccionar] Expandir

padre::padre() {
Ejemplo=parametro; // esto generalmente sera inicializado en cero
        Ejemplo2=parametro;
}


main.cpp

Código (cpp) [Seleccionar] Expandir

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