Dev-C++, Clase19 – Punteros o apuntadores

Hola a todos/as,

Continuando con las clases en c++ en esta ocacion trataremos el tema de los punteros o apuntadores. Aquí les dejo dos videos hechos por mi, espero les sea de ayuda:

IMPORTANTE: para ver los videos en alta resolución, basta con abrirlos en youtube y seleccionar 720 px

– Parte 1 –


– Parte 2 –


El codigo es el siguiente:

25.) Trabajando con punteros

#include <iostream.h>
#include <conio.h>

// Declaramos punteros de cada tipo de dato

char   *caracter;
int    *entero;
float  *flotante;
short  *entero_corto;
long   *entero_largo;
bool   *boleano;

// puntero a funciones

void (*funcion)();
void saluda();

main()
{
    cout<<“\n\n PUNTEROS O APUNTADORES \n\n”;

    int A=10;

    entero = &A;
    cout<<entero<<“\t”;
    cout<<&A<<“\t”;  
    cout<<*entero<<“\t”;  
    cout<<A<<“\n\n”;  

    getch();

    char nombre[]=”Eddy”;

    cout<<nombre<<“\t”;
    cout<<nombre[2]<<“\t”;  
    caracter = nombre;
    cout<<caracter<<“\t”;  
    cout<<caracter[2+1]<<“\n\n”;  

    getch();  

    funcion = saluda;
    saluda();
    funcion();

    getch();
}

void saluda()
{ cout<<“\n Saludos desde Programando – paso A paso con Eddy \n”; }

Anuncios

Dev-C++, Clase18 – ejercicio

Hola a todos/as,

Bien, ya está la clase 18 de Dev-C++, puedes verla AQUI

Ya subí el archivo ( ejercicio ), para que lo puedan ejecutar y comprobar por ustedes mismos, pueden acceder a la descarga desde AQUI

NOTA: por motivos de seguridad le puse contraseña, la contraseña es la clase a la que pertenece el ejercicio, en éste caso “clase18

Saludos ;)

Dev-C++, Clase18 – Funciones (paso por referencia)

Hola a todos/as,

Continuando con las clases en c++, pues trataremos el tema sobra las funciones y su paso por referencia; esta es otra manera de enviar valores a diferentes funciones además de la manera que ya tratamos en la clase17 – funciones (paso por valor).

Aquí les dejo dos videos hechos por mi, espero les sea de ayuda:

IMPORTANTE: para ver los videos en alta resolución, basta con abrirlos en youtube y seleccionar 720 px

– Parte 1 –

– Parte 2 –

El codigo es el siguiente:

24.) Hacer un programa, que reciba en una funcion dos valores enteros
pero un dato que sea pasado por referencia y otro sea pasado por valor

#include <iostream.h>
#include <conio.h>

void referencia ( int&, int );

int A,B;

main()

{

cout<<“\n Ingrese un valor para A: “;
cin>>A;
cout<<“\n Ingrese un valor para B: “;
cin>>B;

cout<<“\n ———————————— “;
cout<<“\n valor inicial de A: “<<A;
cout<<“\n direccion inicial de A: “<<&A;
cout<<“\n valor inicial de B: “<<B;
cout<<“\n direccion inicial de B: “<<&B;
cout<<“\n ———————————— \n\n\n”;

referencia(A,B);

getch();

}

void referencia ( int &vieneA, int vieneB )

{
    cout<<”  [ PRUEBA 1 ]  \n”;

    cout<<“\n\n valor de *vieneA* = “<<vieneA<<“\n”
        <<” direccion de *vieneA* = “<<&vieneA<<“\n”
        <<” valor de *A* = “<<A<<“\n”
        <<” direccion de *A* = “<<&A<<“\n\n”     
        <<“\n\n valor de *vieneB* = “<<vieneB<<“\n”
        <<” direccion de *vieneB* = “<<&vieneB<<“\n”
        <<” valor de *B* = “<<B<<“\n”
        <<” direccion de *B* = “<<&B<<“\n”
        <<” ______________________________________\n”;   
        getch();

    cout<<”  [ PRUEBA 2 ]  \n”;
    vieneA = 10;

    cout<<“\n\n valor de *vieneA* = “<<vieneA<<“\n”
        <<” direccion de *vieneA* = “<<&vieneA<<“\n”
        <<” valor de *A* = “<<A<<“\n”
        <<” direccion de *A* = “<<&A<<“\n\n”
        <<“\n\n valor de *vieneB* = “<<vieneB<<“\n”
        <<” direccion de *vieneB* = “<<&vieneB<<“\n”
        <<” valor de *B* = “<<B<<“\n”
        <<” direccion de *B* = “<<&B<<“\n”
        <<” ______________________________________\n”;   
        getch();

    cout<<”  [ PRUEBA 3 ]  \n”;
    vieneB = 1200;

    cout<<“\n\n valor de *vieneA* = “<<vieneA<<“\n”
        <<” direccion de *vieneA* = “<<&vieneA<<“\n”
        <<” valor de *A* = “<<A<<“\n”
        <<” direccion de *A* = “<<&A<<“\n\n”
        <<“\n\n valor de *vieneB* = “<<vieneB<<“\n”
        <<” direccion de *vieneB* = “<<&vieneB<<“\n”
        <<” valor de *B* = “<<B<<“\n”
        <<” direccion de *B* = “<<&B<<“\n”
        <<” ______________________________________\n”;   
        getch();

    cout<<”  [ PRUEBA 4 ]  \n”;
    A = 44;

    cout<<“\n\n valor de *vieneA* = “<<vieneA<<“\n”
        <<” direccion de *vieneA* = “<<&vieneA<<“\n”
        <<” valor de *A* = “<<A<<“\n”
        <<” direccion de *A* = “<<&A<<“\n\n”
        <<“\n\n valor de *vieneB* = “<<vieneB<<“\n”
        <<” direccion de *vieneB* = “<<&vieneB<<“\n”
        <<” valor de *B* = “<<B<<“\n”
        <<” direccion de *B* = “<<&B<<“\n”;  
        getch();
}

cualquier duda estamos por aquí. Saludos!

Dev-C++, Clase17 – ejercicio

Hola a todos/as,

Bien, ya está la clase 17 de Dev-C++, puedes verla AQUI

Ya subí el archivo ( ejercicio ), para que lo puedan ejecutar y comprobar por ustedes mismos, pueden acceder a la descarga desde AQUI

NOTA: por motivos de seguridad le puse contraseña, la contraseña es la clase a la que pertenece el ejercicio, en éste caso “clase17

Saludos 😉

Dev-C++, Clase17 – Funciones (paso por valor)

Hola a todos/as,

En la clase anterior (clase16), vimos los conceptos e implementaciones de las funciones en si en c++, vimos lo que era la definicion y declaracion de la funcion en el cuerpo del programa, cómo se debia hacer, dónde se debia hacer, su estructura, etc.. Ahora asi mismo, las funciones no solamente son llamadas para que realicen cierta necesidad, si no que en algunas ocaciones para que la funcion desarrolle dicha necesidad necesita que se le envien parametros.

En la clase anterior vimos que eran los parametros y para que servian, ademas de como denotarlos; asi que si no sabes que son parametros de funcion, puedes ir a la clase anterior y revisarlo para no tener confusiones.

Bien ahora esos parametros que se le enviarán a la funcion para que ella pueda cumplir su papel correctamente, pueden ser enviados de dos maneras:

1) Pasar los parametros por valor ( paso por valor )

2) Pasar los parametros por referencia ( paso por referencia )

Aquella manera de pasar los datos mencionada anteriormente es diferente una de la otra, es decir no es lo mismo pasar datos por valor que pasarlos por referencia. En la programacion depende del ejercicio o de la ocacion para implementar o pensar en como seria mejor que pase el parametro. En la clase de hoy vamos a ver el paso por valor y en la siguiente veremos por referencia.

¿ Qué es el paso por valor ?

Es enviarle un parametro ( variable,constante,etc.. ) a otra funcion que para resolver su contenido necesita obligatoriamente recibir ese parametro, es decir la funcion depende de los parametros para funcionar.

¿ Al pasar por valor los parametros que hago en si ?

Estas enviando el contenido de algo ( ya sea una variable, constante, etc.. ) para que la funcion de destino la use y ahi pueda completar con exito su objetivo. Pero se debe tener en cuenta que al pasar por valor; la variable original no se altera, se envia una “copia” de ella a la cual si se le aplican cambios serán alterados unicamente en ella, más no en la original.

¿ Como declaro una funcion que reciba parametros por valor ?

La declaracion de una funcion que recibe parametros es casi igual a la que vimos en la clase anterior en una funcion “en general”, la sintaxis seria la siguiente para una funcion que reciba parametros por valor:

prototipo_de_la_funcion nombre_de_la_funcion ( tipo_de_dato del parametro1 , tipo_de_dato del parametro 2 , … );

Ejemplo:

void suma ( int , int );

Como vemos en el ejemplo anterior, está declarada una funcion “suma” que va a recibir dos parametros que serán enteros porque el tipo de dato lo denota asi. Aquellos parametros son por valor , lo denotamos por el hecho que unicamente va el tipo de dato en los parentesis.

El prototipo de la funcion “suma” es void, es decir que no va a retornar valores, será un procedimiento. Si retornara un entero sería int el prototipo, un numero con decimales seria float el prototipo, etc..

¿ Cómo defino una funcion que recibe parametros por valor ?

La definicion es la misma que la anterior, solo que no lleva punto y coma (;) al final, puesto aqui es un ambiente que se va a programar mas no una declaracion, tendremos algo asi como definicion de la funcion “suma”:

Ejemplo:

void suma ( int n1, int n2 )

{

….

}

Donde n1 y n2 son variables formales.

¿ Qué son variables formales ?

Son aquellas que se declaran en el momento de recibir el parametro en la funcion de destino, tienen el contenido de una variable existente; pero no tiene necesariamente el mismo nombre. Por ejemplo si éste es mi codigo:

// sueldo = 100.

// comision = 20.

main()

{

…………………

………….

…….

suma ( sueldo, comision );

….

……

}

void suma ( int n1, int n2 )

{

….

}

Ahi lo que pueden observar es que en el cuerpo principal ( main ), se hace un llamado a una funcion “suma” que recibe como parametro dos numeros enteros. En éste caso será el sueldo y la comision de un empleado, la funcion “suma” los recibirá y con esos valores hara un proceso interno.. Pero vemos que al momento de llamar a la funcion “suma” le enviamos:

* sueldo ( variable entera )

* comision ( variable entera )

Pero en la definicion de la funcion “suma”, están dos variables en donde llega el contenido de sueldo y comision, aquellas variables son: n1 y n2.

Como pueden ver, no necesariamente la funcion debe tener en su definicion el mismo nombre de la variable que le está pasando el dato, mas bien se suele recomendar cambiar el nombre a las variables formales ( las que se crean / se declaran en la definicion de la funcion que recibe parametros ya sea por valor o por referencia, pero estamos viendo por valor en ésta clase ).

Lo que si nos importa es que aquellas variables cualquiera que sea su nombre ( en nuestro caso n1 y n2 ), reciben el contenido esperado. Es decir que:

Si sueldo valia 100 como estaba previsto, n1 va a tener el valor de 100 en su contenido.

Si comision valia 20 como estaba previsto, n2 va a tener el valor de 20 en su contenido.

Y si a n1 y n2 le sumamos 500 mas, ¿ que pasa ?

Lo que pasa es que quedaria asi:

n1 = 600 ( es decir 100 + 500  )

n2 = 520 ( es decir 20 + 500  )

Pero sueldo y comision quedarian intactos, es decir:

sueldo = 100

comision = 20

NO se alteran las variables originales en los pasos por valor como ya habia indicado al inicio de la clase, pero si pasan su contenido exacto a las variables formales de la funcion destinada que recibe parametros. Como dije se crea una “copia” y esas copias pueden ser alteradas pero no se alterarán las originales.

Bien, ahora que sabemos como declarar y definir una funcion que reciba parametros por valor, ademas de tener claros muchos conceptos base para el manejo de funciones, ya podemos realizar un ejemplo de como usariamos en la practica el paso por valor en un programa que nos lo pida. Veamos:

23.) Hacer un programa que haga las veces de calculadora entre dos números, es decir que el usuario ingresará dos números y luego el programa por medio de funciones recibirá los números y mostrará su resultado en: suma, resta, multiplicacion y division. Luego tambien mostrará cuales fueron los números ingresados.

Por favor antes de ver ésta entrada recomiendo ver la entrada:

” Uso de la aplicacion

ATENCION: en las clases anteriores he explicado las lineas y que hace cada una, entonces les sugiero que vean las entradas anteriores para entender las lineas de las que no voy a hacer mucha enfasis.

Las lineas que ya hayamos visto, les colocaré ” *** “  al final para que sepan que ya lo hemos visto con anterioridad ( entiendase como “anterioridad” a la/las clases anteriores ademas de sus correspondientes entradas en la seccion “General” del mapa de sitio ).

Bien hay diferentes maneras de hacerlo, pero vamos a verlo de manera individual es decir que voy a realizar una funcion para cada caso: suma,resta,multiplicacion y division. De esta manera entenderán mejor como va el paso por valor en funciones, comencemos:

#include <iostream.h>

#include <conio.h>

void suma(float,float);

void resta(float,float);

void multiplicacion(float,float);

void division(float,float);

main()

{

float n1,n2;

cout<<“\n -Operaciones aritmeticas basicas- \n”

<<“\n Ingrese cantidad 1:”;

cin>>n1;

cout<<“\n Ingrese cantidad 2:”;

cin>>n2;

suma(n1,n2);

resta(n1,n2);

multiplicacion(n1,n2);

division(n1,n2);

cout<<“\n\n Los numeros ingresados fueron: “<<n1<<” y “<<n2;

getch();

}

void suma(float x,float y)

{

cout<<“\n La suma = “<<(x+y);

}

void resta(float x,float y)

{

cout<<“\n La resta = “<<(x-y);

}

void multiplicacion(float x,float y)

{

cout<<“\n La multiplicacion = “<<(x*y);

}

void division(float x,float y)

{

cout<<“\n La division = “<<(x/y);

}

– linea 1 – 2: la cabecera y libreria ***

– linea 3 – 6: declaración de funciones que vamos a usar ***

– linea 7: función principal ***

– linea 8 – 21: inicio – fin del programa ***

– linea 9: declaramos variables tipo flotantes ***

– linea 10 – 11: recurso cout ***

– linea 12: recurso cin ***

– linea 13: recurso cout ***

– linea 14: recurso cin ***

– linea 15 – 18: llamamos a las funciones

Aquí lo que estamos haciendo es llamar a cada función: suma,resta,multiplicacion,division. Como la función necesita de los numeros ingresados anteriormente ( n1 y n2 ) para calcular su respectiva suma ó resta ó multiplicacion ó division, entonces debemos enviarle como parametros aquellos datos. Pero debes tener en cuenta lo siguiente:

– La declaración de la función debe ser acorde a la definición de la misma función [ ver declaracion y definicion ( clase16 ) ]

es decir que, no podemos entrar en contradicciones por ejemplo al declarar:

void suma();

y luego al momento de usar la funcion ( ó al definirla ) colocar:

int suma ( x,y,z )

{

}

Eso conyeva a errores de compilacion, porque como ya he dicho el lenguaje es “key sensitive”; osea que no es lo mismo suma que: Suma ó suMA ó summa, etc..

En nuestro caso, como declaramos una función void ( ésto quiere decir que no retorna valores ), mas abajo al momento de realizar la programación debemos definirla de igual manera como void, NO como int ni float ni double, etc..

También con los parametros, si la declaramos como void que no recibe parametros; NO debemos despues definirla como void que si reciba parametros, por más que este bien escrito el nombre y el prototipo, no coincide a la hora de ser llamada la función por el simple hecho de que no es lo mismo:

void resta (); -> declaracion

void resta ( n1,n2 ) -> definicion

{

}

Como pueden ver, el n1 y n2 están de más por así decirlo, en todo caso el programa lo que interpretaría es que esa función resta(n1,n2) es otra función diferente a resta() por el simple hecho de que no coinciden completamente. Así que mucho ojo con eso 😉

– linea 19: recurso cout ***

Lo que hacemos aquí es mostrar los numeros que fueron ingresados, con el fin de reconocer que en el paso por valor NO se alteran las variables originales, ya que mostraremos n1 y n2 con los valores originales a pesar de que hubo acciones aritméticas en su contenido ( sumas, restas, .. ) pero esos cambios NO afectaron a las variables originales sino a las formales; pues esa es una de las caracteristicas de pasar por valor los datos, se pasan copias.

– linea 20: pausamos el programa ***

– linea 22 – 25: funcion suma

Aqui esta la definicion de la funcion suma, que como vemos:

no retorna valores ( void )

recibe dos parametros flotantes ( x,y )

y lo que hace en su ambiente es mostrar mediante el recurso cout: “la suma es” y hacer un calculo matematico (x+y), que lo que hará es mostrar en pantalla la suma de ambas variables.

– linea 22 – 25: funcion resta

Hace lo mismo que la suma, solo que el calculo matematico cambia (x-y)

– linea 26 – 29: funcion multiplicacion

Hace lo mismo que las anteriores, solo que el calculo matematico cambia (x*y)

– linea 29 – 32: funcion division

Hace lo mismo que las anteriores, solo que el calculo matematico cambia (x/y)

Y eso es todo, podemos ver que mostramos los valores calculados y el contenido de las variables orginales, con ésto podemos tener una buena nocion de como son y para que sirven las funciones con paso por valor.

Saludos!, cualquier duda o sugerencia comenten serán bienvenidos! (:

Dev-C++, Clase16 – ejercicio

Hola a todos/as,

Bien, ya está la clase 16 de Dev-C++, puedes verla AQUI

Ya subí el archivo ( ejercicio ), para que lo puedan ejecutar y comprobar por ustedes mismos, pueden acceder a la descarga desde AQUI

NOTA: por motivos de seguridad le puse contraseña, la contraseña es la clase a la que pertenece el ejercicio, en éste caso “clase16

Saludos 😉

Dev-C++, Clase16 – Funciones (en general)

Hola a todos/as,

En ésta clase vamos a tratar sobre las funciones en c++, para ello debemos tener algunos conceptos claros:

¿ Qué es una funcion ?

Una funcion es un conjunto de instrcciones que se la puede llamar desde el programa principal o desde otras funciones.

¿ Para que sirven las funciones ?

Nos sirven para desarrollar algo en especial cuando el programa asi lo necesite.

¿ Como usarlas ?

Para usar funciones, debemos tener en cuenta dos cosas que necesita:

1) La declaracion de la funcion:

Esta nos sirve para que al compilar el programa, el compilador reconozca que esa funcion existe; ya que si la llamamos desde alguna parte del programa sin haberla declarado o habiendola declarado, se la declaró mal eso nos dará error. Entonces es importante antes siquiera de desarrollar la funcion, declararla.

Para declararla se sigue la siguiente sintaxis:

prototipo_de_funcion nombre_de_la_funcion ( parametros opcionales );

¿ Qué es eso de prototipo y parametros ?

Prototipo de la funcion: sirve para indicar que va a retornar la funcion, si va a retornar un entero, un double, un char, o simplemente no retorna nada ( void ). Esto es obligatorio

Parametros: son los datos que le enviamos a la funcion para que con ellos posiblemente desarrolle algo que necesitemos. Esto es opcional.

Entonces, una funcion para ingresar podria ser asi:

void ingresar();

Donde vemos no va a retornar nada, por ello tiene void entonces la funcion hace lo que tiene que hacer y termina, no devuelve nada.

Un ejemplo de devolucion seria en una suma de enteros, ya que se le podria enviar como dato los dos numeros y la funcion haria internamente la suma devolviendonos la suma de dichos numeros ( si son todos enteros, devolveria un int. Si son enteros y flotantes devolveria un float ), asi:

int suma_enteros ( int, int ); // suma unicamente enteros, devuelve un entero

float suma_numeros ( float, float ); // suma enteros o flotantes, devuelve un flotante

2) La definicion de la funcion:

Como vimos la declaracion nos servia para que el compilador sepa que existe dicha funcion, ahora la definicion nos sirve ya para desarrollar la funcion; es decir ya programar dentro de ella para que haga lo que necesitamos. Como consecuencia de que ya está creada podemos usarla, pero si no la hubiesemos declarado y la desarrollamos ( hacemos la definicion ), al compilar nos dará error y dirá que esa funcion no fue declarada, que no existe.

La definicion es muy similar a la declaracion, solo que esta vez lleva un ambiente ( donde vamos a programar es decir las llaves “{ … }” ), asi:

void ingresar()

{

……… // Lo que deba hacer esa funcion

}

Tambien otra diferencia es que la declaracion lleva “;” ( punto y coma ) al final, la definicion ya no lo lleva.

Ahora vamos a ver un ejemplo de como usariamos una funcion en nuestro programa, haremos esa “ingresar” que veniamos poniendo de ejemplo.

22.) Hacer un programa que pida dos datos cualesquiera llamando a una funcion sin retorno y luego confirme si se ingresaron correctamente.

Por favor antes de ver ésta entrada recomiendo ver la entrada:

Uso de la aplicacion

ATENCION: en las clases anteriores he explicado las lineas y que hace cada una, entonces les sugiero que vean las entradas anteriores para entender las lineas de las que no voy a hacer mucha enfasis.

Las lineas que ya hayamos visto, les colocaré ” *** “  al final para que sepan que ya lo hemos visto con anterioridad ( entiendase como “anterioridad” a la/las clases anteriores ademas de sus correspondientes entradas en la seccion “General” del mapa de sitio ).

Bien, como datos tenemos que el programa deberá usar una funcion sin retorno, es decir una void. Tambien que debemos pedir en esa funcion dos valores cualesquiera; en mi caso voy a pedir dos cosas: nombre y numero de la suerte; luego se mostrará el mensaje de que se ingresaron correctamente dichos datos, vamos a ello:

#include <iostream.h>
#include <conio.h>

// declaramos la funcion “ingresar”
void ingresar();

main()
{
cout<<“\n Ingrese los datos: \n”;
ingresar();
cout<<“\n Los datos se ingresaron correctamente! \n”;
getch();
}

 

//definimos la funcion “ingresar”

void ingresar()
{
char nombre[10];
int numero;
cout<<“\n Ingrese su nombre: \n”;
cin>>nombre;
cout<<“\n Ingrese su numero de la suerte: \n”;
cin>>numero;
}

– linea 1 – 2: la cabecera y libreria ***

– linea 3: comentario ***

– linea 4: declaracion de la funcion

La declaracion de una funcion debe estar siempre antes de la definicion, por eso es recomendable que se la coloque al inicio del programa debajo de las librerias para que el programa se vea mejor estructurado y puedan encontrar rapido las funciones que han declarado y si hace falta alguna añadirla rapidamente o editarla en caso de haberla declarado mal, es altamente recomendable que se proceda de dicha forma.

De la declaracion de la funcion ingresar, queda muy poco que decir ya lo vimos arriba en los conceptos.

– linea 5: funcion principal ***

– linea 6 – 11: inicio y fin del programa ***

– linea 7: recurso cout ***

– linea 8: llamamos a una funcion ya declarada

Ya que creamos una funcion llamada “ingresar” con el fin de pedir los datos por medio de ella y no por medio del cuerpo principal main(), debemos llamarla / convocarla para que pueda ejecutar lo que tiene programado en su interior ya que por si sola ( sin ser llamada ), el programa terminaria y ella no realizaria ninguna accion.

Para llamar a una funcion lo unico que se debe hacer es escribirla tal cual fue declarada sin alteraciones ya que las funciones son key sensitive, es decir que no es lo mismo:

void HOLA(); que void HoLa();

Pues distingue mayusculas de minusculas, para el compilador son dos funciones diferentes ( para nosotros son la misma palabra pero escrita diferente ).

Bien, como decia para llamar a la funcion se la coloca tal como fue declarada seguida del punto y coma ( no se le pone el prototipo ), solo el nombre y los posibles parametros que lleve, por lo tanto nuestra declaracion seria:

ingresar();

Como vemos no se le colocó el prototipo ( void ) y no lleva parametros por lo que los parentesis no tienen nada dentro. Esa linea hará que el compilador vaya a donde se encuentra definida dicha funcion y realize lo que ella tenga programado y eso es lo que queremos, pues la funcion “ingresar” es la que le va a pedir los datos al usuario.

– linea 9: recurso cout ***

Esta linea está a continuacion de la llamada a la funcion “ingresar“, pero ésta linea no será ejecutada hasta que termine de ejecutarse lo que contiene la funcion “ingresar” porque los programas van en orden logico no necesariamente en orden lineal, por lo que estando en la linea 8 y llamamos a una funcion cuyo desarrollo está en la linea 15, el compilador saltá a dicha posicion ejecuta todo lo que tiene en ése ambiente ( entre las llaves “{…}” ) y de ahi regresa y continua con la linea 9.

Visto de una manera grafica, así es como funciona la llamada a funciones:

Ampliar imagen

– linea 10: pausamos el programa ***

– linea 12: comentario ***

– linea 13: Definicion de la funcion

Lo mismo, queda poco que decir ya vimos al inicio de la clase como se definian las funciones una vez declaradas, aqui va a ir codigo normal ( codigo que tranquilamente podria ir en la funcion principal main(), pero el enunciado indica que debemos desarrollar una funcion que lo haga ).

Como podemos ver, aqui dentro de la definicion:

– declaramos variables

– mostramos contenido

– pedimos contenido

Son procedimientos normales solo que aplicados de una manera nueva, que estamos viendo en esta clase; “las funciones”.

– linea 14 – 21: Inicio y fin de la funcion ingresar();

Hasta el momento habiamos visto en clases anteriores “inicio y fin del programa”, éste inicio y fin está delimitado por las llaves ( tambien llamado ambiente: “{…}” ), entonces las funciones tambien tienen su ambiente, por lo tanto el inicio y fin de una funcion será desde donde comienza la llave y se cierra.

– linea 15 – 16: Declaramos variables ***

– linea 16: Recurso cout ***

– linea 17: Recurso cin ***

– linea 19: Recurso cout ***

– linea 20: Recurso cin ***

Bien, una vez que se haya ejecutado la linea 20, el compilador irá hacia la linea 9 para continuar con el correcto funcionamiento del programa ahi lo que hará es mostrar un mensaje “Los datos se ingresaron correctamente!” y luego con el getch(); se pausará la aplicacion para ver los resultados.

Eso es todo por ahora, cualquier duda / comentario / sugerencia, haganla con confianza. Saludos! 😉