Programacion en C++ : Flujo de control en funciones

Programacion en C++En este artículo quiero que aprendas cómo el compilador de c++ realiza el flujo de control de las funciones con respecto al programa principal.

Afianzarás conocimientos ya dados anteriormente y realizarás un ejercicio que si eres capaz de solucionar darás un paso importante para la programación estructurada y modular. Lee dos veces el artículo lee los artículos sobre funcionesanteriores y realiza un análisis del problema antes de resolverlo.

Cuando se ejecuta la llamada resultado = Cuadrado(valor); el flujo de control salta a la definición de la función.

  • Se realiza la correspondencia entre los parámetros. El correspondiente parámetro formal recibe una copia del parámetro actual, es decir, se realiza la siguiente asignación en tiempo de ejecución:

parámetro formal = parámetro actual

Esta forma de pasar parámetros se conoce como paso de parámetros
por valor (pass-by-value).

  • Empiezan a ejecutarse las sentencias de la función y, cuando se llega a alguna sentencia return  <expresion>, termina la ejecución de la función y devuelve el resultado de evaluar <expresion> al lugar donde se realizó la invocación.
  • A continuación, el flujo de control prosigue por donde se detuvo al realizar la invocación de la función:

 

double Cuadrado(double entrada){ // entrada = valor
return entrada*entrada;
}
int main(){
double resultado, valor;
valor = 4;
resultado = Cuadrado(valor); // resultado = 16
cout<<"El cuadrado de "<< valor <<" es "
<< resultado;
}

Espero que hayas comprendido todo lo dado hasta ahora con respecto las funciones. Para ello te voy a proponer un ejercicio que no puedes dejarlo para mañana.

¿que tal si?

¿realizas este ejercicio y dejas una de las partes fundamentales de la programación casi completada?, para ello dado este código que te voy a dar a continuación, deberás de definir la función hipotenusa.

#include
#include
using namespace std;
double Hipotenusa( ){
}
int main(){
double lado1_A, lado2_A, lado1_B, lado2_B,
hipotenusa_A, hipotenusa_B;

hipotenusa_A = Hipotenusa(lado1_A, lado2_A);
hipotenusa_B = Hipotenusa(lado1_B, lado2_B);
.............
}

Realiza este ejercicio y si tienes dudas, inquietudes o aportaciones ponme un comentario. Es importante saber cuales son las cosas que no entiendes para poder pulir al 100% tus necesidades.

Un saludo,

Javi Pizarro.

Acerca de Javi Pizarro

Ingeniero informático dedicado a la docencia, con experiencia en creación de programas de gestión y desarrollo de aplicaciones web.
Esta entrada fue publicada en Programacion y etiquetada , , , . Guarda el enlace permanente.

3 respuestas a Programacion en C++ : Flujo de control en funciones

  1. Alan dijo:

    Hola hace unos días que vengo siguiendo este curso, gracias por compartir tu conocimiento. Tu manera de enseñar es excelente y no deja cabos sueltos.
    Pude resolver este ejercicio usando la librería cmath. Me salió casi a la primera pero me olvide de la palabrita return, me di cuenta que a veces los errores están en las cosas más triviales y básicas. Aunque ya lo habías dicho vos jajaja.
    No se si alguien va a leer esto pero lo posteo para la posteridad….

    //Ejercicio Crear función de la hipotenusa
    #include
    #include
    #include

    using namespace std;

    //Parámetros formales
    double hipotenusa(double a,double b){
    return sqrt((a*a)+(b*b));
    }

    int main(){

    //Parámetros actuales
    double lado1_A, lado2_A, lado1_B, lado2_B,
    hipotenusa_A, hipotenusa_B;

    //Cuerpo
    cout<>lado1_A;
    cout<>lado2_A;
    cout<>lado1_B;
    cout<>lado2_B;

    hipotenusa_A=hipotenusa(lado1_A, lado2_A);
    hipotenusa_B=hipotenusa(lado1_B, lado2_B);

    //Resultados
    cout<<"La hipotenusa A es: "<<hipotenusa_A;
    cout<<"\nLa hipotenusa B es: "<<hipotenusa_B;

    getch();
    }

  2. leonardo plaza dijo:

    esto es lo que logre realizar de este ejercicio. me funciona excelente, solo que tuve que realizar dos funciones en vez de la unica que tienes tu ahi. yo realize una funcion individual para cada hipotenusa.

    #include <iostream>
    #include <conio.h>
    #include <cmath>
    using namespace std;
      
        double hipotenusa_a(double a1 , double b1){
               return sqrt((a1*a1)+(b1*b1));
               }
        double hipotenusa_b(double a2,double b2){
               return sqrt((a2*a2)+(b2*b2));
               }
             int main(){
                   double a1,a2,b1,b2,hipotenusa1,hipotenusa2;
                   
                          cout<<"ingrese el cateto a1: ";
                          cin>>a1;
                          cout<<"ingrese el cateto b1: ";
                          cin>>b1;
                          cout<<"ingrese el cateto a2: ";
                          cin>>a2;
                          cout<<"ingrese el cateto b2: ";
                          cin>>b2;
                          
               hipotenusa1=hipotenusa_a(a1,b1);
               hipotenusa2=hipotenusa_a(a2,b2);
               
               cout<<"\nLa hipotenusa 1 es:"<<hipotenusa1<<endl;
               cout<<"\nLa hipotenusa 2 es:"<<hipotenusa2<<endl;
               getch();
    }
    

    no se si era lo que esperabas. pero fue lo que logre hacer. lo que no me gusto fue no poder utilizar la funcion “pow” para las potencias, pero como la hipotenusa es una formula constante que nunca cambia no hay problema.

  3. leonardo plaza dijo:

    Quede con la intriga por la pobreza del codigo anterior, asi que vi el tema siguiente y tome prestado tu modelo mas simple y saque esto.:

    #include <iostream>
    #include <conio.h>
    #include <cmath>
    using namespace std;
      
        double cuadrado_a(double a){
               return a*a;
               }
        double cuadrado_b(double b){
               return b*b;
               }
        double hipotenusa_a(double a , double b){
               return sqrt(cuadrado_a (a) + cuadrado_b (b));
               }
             int main(){
                   double a,a2,b,b2,hipotenusa1,hipotenusa2;
                   
                          cout<<"ingrese el cateto a1: ";
                          cin>>a;
                          cout<<"ingrese el cateto b1: ";
                          cin>>b;
                          cout<<"ingrese el cateto a2: ";
                          cin>>a2;
                          cout<<"ingrese el cateto b2: ";
                          cin>>b2;
                          
               hipotenusa1=hipotenusa_a(a,b);
               hipotenusa2=hipotenusa_a(a2,b2);
               
               cout<<"\nLa hipotenusa 1 es:"<<hipotenusa1<<endl;
               cout<<"\nLa hipotenusa 2 es:"<<hipotenusa2<<endl;
               getch();
    }
    

    el cambio mas sustancial es que logre el mismo resultado pero realize una sola funcion para la hipotenusa pero no logre realizar los dos numeros al cuadrado en una sola funcion lineal asi que hice una funcion para cada numero que iba a ser elevado al cuadrado.

Responder

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s