Dev-C++, clase5 – ejercicios de aplicacion I

Hola a todos/as,

Bien, pues con lo que hemos visto hasta ahora, procederé a realizar varios ejercicios ( con lo que hemos visto hasta ahora ), pero antes quisiera que estén al dia de lo que hemos venido haciendo durante éste tiempo, así que les sugiero que revisen la sección «Ayuda«, donde encontrarán detallada de manera ascendente las clases y ejercicios que hemos venido haciendo. Recuerden que en ésta clase veremos ejercicios que contienen todo lo que vimos en las clases anteriores 😉

5.-) Hacer un programa que permita ingresar 3 numeros, entonces que multiplique los dos primeros numeros y luego a ése resultado se le sume el tercer numero que ingresó el usuario/a.

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

” Uso de la aplicacion “

Bien, veamos lo que tenemos:

Nos pide que ingresemos tres numeros, entonces serán tres variables diferentes para nosotros, usaremos n1,n2,n3 para los numeros que ingresará el usuario/a.

Despues nos dice que tenemos que multiplicar los dos primeros numeros, es decir que multiplicaremos n1 y n2 lo cual nos dará un resultado, a ese resultado lo llamaremos «multip» porque es el resultado de la multiplicacion de n1 y n2.

Y por ultimo el programa debe sumarle el valor de n3 a nuestra variable «multip» porque así lo dice el enunciado. esa operacion dará un nuevo resultado el cual lo llamaremos «resp» de respuesta y será lo que mostraremos al final.

Veamos el ejercicio asumiendo datos:

n1 = 10

n2 = 8

n3 = 40

Entonces, ahi toca multiplicar los dos primeros numeros:

n1 * n2 = multip

10 * 8 = 80

Luego a ése valor hallado se le sumará el tercer numero:

multip + n3 = resp

80 + 40 = 120

Al final, se mostrará el resultado que será: 120

Ahora vamos con el codigo fuente del programa 😉

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 ).

#include <iostream.h>
main ()

{

int n1,n2,n3,multip,resp;
cout<<» \t \n Ingrese 3 numeros \n \n»;
cout<<» \t \n los dos primeros se multiplicaran y ese resultado se le sumara al tercer numero\n \n»;
cout<<» \n Primer nuemro: \n»;
cin>>n1;
cout<<» \n Segundo nuemro: \n»;
cin>>n2;
cout<<» \n Tercer nuemro: \n»;
cin>>n3;

multip = n1 * n2;

cout<<» \n La multiplicacion de los dos primeros numeros fue: \n\n»;
cout<<n1<<«x»<<n2<<«=»<<multip<<«\n\n»;

resp = multip + n3;

cout<<» \n Al sumar el tercer nuemro con el resultado anterior tenemos: \n\n»;
cout<<multip<<«+»<<n3<<«=»<<resp<<«\n\n»;

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

– linea 3 – 20 : inicio y fin del programa ***

– linea 4: declaramos variables ***

– linea 5: recurso ” cout ” ***

– linea 6: recurso ” cout ” ***

– linea 7: recurso ” cout ” ***

– linea 8: recurso ” cin ” ***

– linea 9: recurso ” cout ” ***

– linea 10: recurso ” cin ” ***

– linea 11: recurso ” cout ” ***

– linea 12: recurso ” cin ” ***

– linea 13: operaciones con variables ***

NOTA: su explicacion más detallada está en la clase4

– linea 14: recurso ” cout ” ***

– linea 15: recurso ” cout ” ***

NOTA: su explicacion más detallada está en la linea 12 de la clase3

– linea 16: operaciones con variables ***

– linea 17: recurso ” cout ” ***

– linea 18: recurso ” cout ” ***

– linea 19: pausando el programa ***

6.-) Hacer un programa que pida 4 numeros, entonces sumará el primero y el tercero, luego se le restará el segundo y a ese resultado se le multiplicará el cuarto numero.

Bien, veamos lo que tenemos:

Nos pide que ingresemos cuatro numeros, entonces serán cuatro variables diferentes para nosotros, usaremos n1,n2,n3,n4 para los numeros que ingresará el usuario/a.

Despues nos dice que tenemos que sumar el primer numero con el tercer nuemero, es decir sumaremos: n1 y n3 lo cual nos dará un resultado, a ese resultado lo llamaremos «sum» porque es el resultado de la suma de n1 y n3.

Tambien nos pide el programa que a ése resultado se le reste el segundo numero, es decir que a lo que nos dió como resultado «sum» se le restará el valor que tenga la variable n2, así habra un nuevo numero que será llamado «rest» porque es el resultado de la resta entre sum y n2

Y por ultimo el programa debe multiplicar ése resultado hallado ( osea «rest» ) el valor de n4 porque así lo dice el enunciado. esa operacion dará un nuevo resultado el cual lo llamaremos «resp» de respuesta y será lo que mostraremos al final.

Veamos el ejercicio asumiendo datos:

n1 = 50

n2 = 30

n3 = 15

n4 = 6

Entonces, ahi toca multiplicar los dos primeros numeros:

n1 + n3 = sum

50 + 15 = 65

Luego a ése valor hallado se le restará el segundo numero:

sum – n2 = rest

65 – 30 = 35

Y por ultimo tenemos que a ése valor se le debe multiplicar la cantidad que está almacenada en nuestra variable n4

rest * n4 = resp

35 * 6 = 210

Al final, se mostrará el resultado que será: 210

Ahora vamos con el codigo fuente del programa 😉

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 ).

#include <iostream.h>
main ()

{

int n1,n2,n3,n4,sum,rest,resp;
cout<<» \t \n Ingrese 4 numeros \n \n»;
cout<<» \n Primer nuemro: \n»;
cin>>n1;
cout<<» \n Segundo nuemro: \n»;
cin>>n2;
cout<<» \n Tercer nuemro: \n»;
cin>>n3;
cout<<» \n Cuarto nuemro: \n»;
cin>>n4;

sum = n1 + n3;

cout<<» \n La suma del primer y tercer numero fue: \n\n»;
cout<<n1<<«+»<<n3<<«=»<<sum<<«\n\n»;

rest = sum – n2;

cout<<» \n Al restar el segundo nuemro con el resultado anterior tenemos: \n\n»;
cout<<sum<<«-«<<n2<<«=»<<rest<<«\n\n»;

resp = rest * n4;

cout<<» \n Multiplicando el cuarto nuemro con el resultado anterior tenemos: \n\n»;
cout<<rest<<«x»<<n4<<«=»<<resp<<«\n\n»;

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

– linea 3 – 24 : inicio y fin del programa ***

– linea 4: declaramos variables ***

– linea 5: recurso ” cout ” ***

– linea 6: recurso ” cout ” ***

– linea 7: recurso ” cin ” ***

– linea 8: recurso ” cout ” ***

– linea 9: recurso ” cin ” ***

– linea 10: recurso ” cout ” ***

– linea 11: recurso ” cin ” ***

– linea 12: recurso ” cout ” ***

– linea 13: recurso ” cin ” ***

– linea 14: operaciones con variables ***

NOTA: su explicacion más detallada está en la clase4

– linea 15: recurso ” cout ” ***

– linea 16: recurso ” cout ” ***

NOTA: su explicacion más detallada está en la linea 12 de la clase3

– linea 17: operaciones con variables ***

– linea 18: recurso ” cout ” ***

– linea 19: recurso ” cout ” ***

– linea 20: operaciones con variables ***

– linea 21: recurso ” cout ” ***

– linea 22: recurso ” cout ” ***

– linea 19: pausando el programa ***

Saludos, y cualquier duda o comentario con gusto lo atenderé lo más pronto posible 😉

Dev-C++, Clase4 – ejercicio

Hola a todos/as,

Bien, ya está la cuarta clase 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 “clase4“

Saludos 😉

Dev-C++, clase4 – operaciones con variables

Hola a todos/as,

Hasta el momento ya hemos visto lo que son:

Dev-C++, clase1 – mostrar constantes

Dev-C++, clase2 – ingresar variables

Dev-C++, clase3 – mostrar variables

Entonces ya que sabemos mostrar datos variables y constantes y sabemos como ingresar variables. Pues ahora procedemos a aprender como hacer operaciones con dichas variables y así ir sacando resultados diferentes, la forma no cambia mucho, hacer operaciones es aun más facil que ingresar o mostrar datos porque no hace falta de ningun comando 😉

4.-) Hacer un programa que pida 3 numeros y luego los sume y muestre la respuesta en pantalla con el formato: » n1+n2+n3=n4 «

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

” Uso de la aplicacion “

Bien, el ejercicio nos pide 3 numeros ( que son los que ingresará el usuario/a ), y con esos numeros almacenados cada uno en una variable diferente, es decir:

n1 = primer nuemro

n2 = segundo numero

n3 = tercer numero

Esos numeros vamos a sumarlos entre ellos para así sacar un resultado, que será almacenado en una nueva variable que llamaremos n4.

n4 = resultado de la suma de n1+n2+n2

Ahora que sabemos como va a ir planteado nuestro programa, procedemos a realizarlo. Y así como les dije antes, no hay miedos, porque hacer operaciones es super sencillo no entra ningun nuevo comando 😉

Nota: El hecho de usar el simbolo « = «, quiere decir que estás usando un operador de asignacion, puedes ver más detalles [ Aqui ]

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 ).

#include <iostream.h>
main ()

{

int n1,n2,n3,n4;
cout<<» \t \n Ingrese 3 numeros para hallar la suma total de ellos \n \n»;
cout<<» \n Primer nuemro: \n»;
cin>>n1;
cout<<» \n Segundo nuemro: \n»;
cin>>n2;
cout<<» \n Tercer nuemro: \n»;
cin>>n3;

n4 = n1 + n2 + n3;

cout<<» \n La suma total de los numeros es: \n\n»;
cout<<n1<<«+»<<n2<<«+»<<n3<<«=»<<n4<<«\n\n»;

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

– linea 3 – 16 : inicio y fin del programa ***

– linea 4: declaramos variables ***

– linea 5: recurso ” cout ” ***

– linea 6: recurso ” cout ” ***

– linea 7: recurso ” cin ” ***

– linea 8: recurso ” cout ” ***

– linea 9: recurso ” cin ” ***

– linea 10: recurso ” cout ” ***

– linea 11: recurso ” cin ” ***

– linea 12: operacion con las variables

Como podemos ver sin ningun codigo nuevo, le hemos asignado a la variable n4 un nuevo valor ( que equivale a la suma de n1+n2+n3 ). Por eso tenemos la linea de ésta manera:

n4 = n1 + n2 + n3;

Vemos que n4 viene a ser nuestra variable receptora de informacion. Porque a ella se le asigna el valor de: n1+n2+n3

Entonces si tendriamos que:

n1 = 5

n2 = 245

n3 = 10

Equivale a:    n4 = 5 + 245 + 10;

Entonces:      n4 = 260;

Nota: El operador de asignacion » = » tambien es denominado una instrucción de asignacion, para saber más ver [ Tipos de instrucciones ]

– linea 13: recurso ” cout ” ***

– linea 14: recurso ” cout ” ***

NOTA: su explicacion más detallada está en la linea 12 de la clase3

– linea 15: pausando el programa ***

Saludos, cualquier duda con toda confianza me la pueden decir 😉

Dev-C++, Clase3 – ejercicio

Hola a todos/as,

Bien, ya está la tercera clase 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 “clase3“

Saludos 😉

Dev-C++, clase3 – mostrar variables

Hola a todos/as,

Hemos avanzado hasta ahora con los comando que deberiamos ir aprendiendo en orden y lo mas sencillo posible, ahora que sabemos:

mostrar datos constantes ( clase1 )

ingresar variables ( clase2 )

Vamos a procedes con un ejercicio para aprender a mostrar variables. De la misma manera en que usamos el comando « cout<< » dato constante « «, lo usaremos para mostrar variables, la única diferencia es que, como sabemos ya las constantes se las muestra con comillas y las variables no 😉

– Asi como lo vimos en su tiempo con el DFD

Por ése motivo es indispensable primero pasar por los diagramas de flujo y algoritmos antes de comenzar a programas con codigos, porque ayudan al mejor entendimiento. Por el simple hecho de que se compara y se da por hecho que es lo mismo, solo que en vez de simbolos ahora usamos codigos, y lo mismo es en cualquier lenguaje de programacion.

Vamos a continuacion a ver un ejemplo para aplicar el concepto de ésta clase, mostrar variables.

3.-) Hacer un programa que pida 3 numeros y luego los muestre en pantalla.

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

” Uso de la aplicacion “

Tenemos que el ejercicio propuesto pide 3 numeros que van a ser nuestras variables ya que cada vez que se ejecute el programa los datos cambiarán, entonces son datos variables. Por lo tanto estamos pidiendo datos, para pedirlos se le avisa al usuario entonces aplicaremos ( mostrar constantes ) y para que el usuario/a lo ingrese estaremos aplicando ( ingresar variables ), lo nuevo es que ahora vamos a mostrar las variables ingresadas por el usuario/a. 😉

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 ).

#include <iostream.h>

main( )

{

int n1,n2,n3;

cout<< » \n   \n   \t   \t    Ingrese el primer numero:    \n   \n «;

cin>>n1;

cout<< » \n   \n   \t   \t    Ingrese el segundo numero:    \n   \n «;

cin>>n2;

cout<< » \n   \n   \t   \t    Ingrese el tercer numero:    \n   \n «;

cin>>n3;

cout<< » \n   Los numeros ingresados fueron:   \n «;

cout<< » \t   primer numero: «<<n1<<«\n»;

cout<< » \t   segundo numero: «<<n2<<«\n»;

cout<< » \t   tercer numero: «<<n3<<«\n»;

system(«pause»);

}

– Primera linea: la cabecera y libreria ***

– Segunda linea: funcion principal ***

–  linea 3 – 16 : inicio y fin del programa ***

– Cuarta linea: declaramos variables“ ***

Esta funcion ya la vimos en la clase anterior, pero quiero recalcar que las variables que vayamos a declarar en cada programa que hagamos si son más de una pues van separadas con una coma. Así:

– Ejercicio de la clase anterior –

int cantidad;

solo necesitabamos una variable para cumplir con lo que pedia el programa, pero ahora necesitamos tres variables, entonces colocamos en nombre de la variable seguida de una coma ( , ) para separar cada variable. Así:

– Ejercicio de ésta clase –

int n1,n2,n3;

– Quinta linea: recurso ” cout ” ***

– Sexta linea: recurso ” cin “ ***

Esta funcion tambien la vimos en la clase anterior, pero quiero recalcar que por cada » cin » ( por cada vez que pidamos un dato ), éste debe llevar su correspondiente variable, en éste caso tenemos 3 variables, entonces habrá 3 » cin « pidiendo cada una. Así es correcto:

cin>>n1; —–> para el numero 1

cin>>n2; —–> para el numero 2

cin>>n3; —–> para el numero 3

Esta mal que se haga por ejemplo que pidamos los tres numeros y que le coloquemos al » cin » la misma variable ya que eso hará que en vez de que se almacene un valor unico por cada variable, se reemplaze por el más reciente. Asi es incorrecto:

cin>>n1; —–> para el numero 1

cin>>n1; —–> para el numero 2

cin>>n1; —–> para el numero 3

Eso haria que se reemplace el numero anterior por uno nuevo ya que el dato que ingrese el usuario/a se almacenará en la misma variable cada vez, perdiendo asi ésa variable el valor que tenia antes por el ultimo valor que ingreso el usuario/a.

– Septima linea: recurso ” cout ” ***

– Octava linea: recurso ” cin “ ***

– Novena linea: recurso ” cout ” ***

– Decima linea: recurso ” cin “ ***

– linea 11: recurso ” cout ” ***

– linea 12: recurso ” cout ” ***

Ya he explicado como funciona » cout «, pero aqui vamos a mostrar variables ahora. Para ello se usa el mismo comando solo que como decia al comienzo, » para mostrar constantes se usan las comillas, mientras que para mostrar variables no se usan comillas «. Entonces por ése motivo vemos ésto:

cout<< » \t   primer numero: «<<n1<<«\n»;

vemos que estamos mostrando una parte constante: » \t   primer numero: «

seguido de la parte constante que no lleva comillas: n1

y para dar un «enter o salto de linea» colocamos despues el simbolo » \n « como siempre en una manera constante osea entre comillas como siempre lo hemos hecho, ya que es un codigo hecho con ese fin, no es una variable.

Hemos usado » << « en varias situaciones ya que ése es el separador de datos constantes y datos variables. Es como decir ésto:

cout<< » \t   primer numero: «;

cout<< n1;

cout<< » \n «;

Pero simplificado en una sola linea, por eso queda así:

cout<< » \t   primer numero: «<<n1<<«\n»;

Si recordamos en DFD, nuestro separador de partes constantes y partes variables era la coma ( , ) pueden recordarlo ( AQUI ). Acá en el lenguaje c++ en cambio es el simbolo » << «.

– linea 13: recurso ” cout ” ***

– linea 14: recurso ” cout ” ***

– linea 15: pausando el programa ***

Saludos, cualquier inquietud haganmela saber 😉

Dev-C++, Clase2 – ejercicio

Hola a todos/as,

Bien, ya está la segunda clase 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 “clase2“

Saludos 😉

Dev-C++, clase2 – ingresar variables

Hola a todos/as,

Como vimos en la clase anterior ( clase1 – mostrar constantes ), pues ahora que sabemos ya mostrar datos, vamos a aprender a ingresar datos. Para ello usaremos ahora un recurso diferente al de salida de datos que era » cout «, el nuevo recurso es » cin «, pero no hay complicaciones porque la sintaxis es más facil aun que la de mostrar ( cout ).

2.-) Hacer un programa que pida una cantidad y una vez ingresada nos muestre un mensaje de que se ingresó correctamente el dato.

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

» Uso de la aplicacion «

Bien, como vemos ahora trabajaremos no solo con constantes si no con variables también, por lo tanto deben tener en claro lo que son las variables, su uso, la manera de declararlas correctamente, etc.. Para ello les recominedo lean las siguientes entradas ( si han seguido el curso a medida que he ido avanzando, ya han de haber visto éstas entradas 😉 )

Todo sobre: “variables”

Reglas para la declaración de variables

Una vez leidas y comprendidas las dos entradas anteriores, podemos avanzar con el codigo fuente de éste programa que hemos propuesto para realizar.

#include <iostream.h>

main( )

{

int cantidad;

cout<< » \n   \n   \t   \t    Ingrese una cantidad:    \n   \n «;

cin>>cantidad;

cout<< » \n   La cantidad se ingreso correctamente. Gracias   \n «;

system(«pause»);

}

Bien, segun el codigo que está arriba tenemos que:

ATENCION: en la clase anterior expliqué las lineas y que hace cada una, aqui solo cambia que vamos a usar un nuevo codigo «cin«, entonces les sugiero que vean la entrada anterior para entender las lineas de las que no voy a hacer mucha enfasis ( clase1 – mostrar constantes )

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 ).

– Primera linea: la cabecera y libreria ***

– Segunda linea: funcion principal ***

– Tercera/novena linea: inicio y fin del programa ***

– Cuarta linea: declaramos variables

Por lo general despues de la apertura del programa ( la llave » { » ), se coloca las variables que vamos a usar, pero hay que recordar que para usar variables hay que declararlas y saber las reglas de una buena declaracion, para que no tengamos problemas futuros. Ahora a diferencia de los algoritmos/diagramas como veiamos en DFD ( AQUI ), pues en los lenguajes de programacion usamos «codigos» en lugar de «simbolos«. Entonces como veiamos ahi, usabamos el simbolo de «asignacion» ( ver simbolos ) para declarar las variables, acá no vamos a usar un simbolo si no un codigo 😉 . El codigo puede variar dependiendo de lo que queramos hacer con esa variable, las formas de declaracion más comunes son:

int —> para declarar variables que van a contener datos enteros, es decir que no contendrán decimanles. Por ejemplo 453

float —> para declarar variables que van a contener una parte entera y una parte decimal corta. Por ejemplo 8.6

double —> para declarar variables del mismo tipo que las «float» pero éste usa mas precision con los decimales. Por ejemplo 9.453

char —> para asignar un solo caracter. Por ejemplo t

Ahora que hemos visto los » tipos de datos » que sirven para declarar nuestras variables y saber como van a ser almacenadas a medida que se ejecute el programa. Pues en éste caso vamos a pedir un numero entero cualquiera, porque el ejercicio unicamente nos pide: » Hacer un programa que pida una cantidad «, nada más entonces solo lo declararemos como un valor entero seguido del nombre que usará como variable, por eso quedó esa linea asi:

int cantidad;

Porque «int» va a indicar que la variable «cantidad» contendrá datos enteros sin decimales. Asi de sencillo amigos/as.

– Quinta linea: recurso » cout » ***

– Sexta linea: recurso » cin «

Bien ésta es la linea nueva de programación para nosotros, en ésta linea le indicamos al programa que va a pedir un dato y ése dato que ingrese el usuario/a, lo va a almacenar en la variable cantidad ( antes declarada )

¿ Cómo funciona cin ?

como sabemos ya, cin al ser un recurso para la entrada de datos de la libreria <iostream.h> no es una palabra restrigida/reservada, es decir que se puede usar como variable, pero NO es recomendable quizá de problemas al compilar el programa, para saber en C++ cual es o no es una palabra reservada, pues se lo denota por estar en negrita ( ver entrada: reglas para la declaracion de variables ), entonces ahora que lo hemos “recordado”, veremos como es su sintaxis ( forma de escritura para que funcione como debe )

cin>>nombre de la variable ;

esa la sintaxis que lleva para poder pedir datos al usuario/a. Si se omite uno de esos caracteres, al compilar el programa nos dará errores por mala escritura o sintaxis. ( compilar es hacer un barrido a los codigos escritos de arriba a abajo en busca de errores, de escritura/variables/funciones/etc.. ). Y así funciona cin 😉

Nota: El recurso cin tambien es denominado una instrucción de entrada de datos, para saber más ver [ Tipos de instrucciones ]

– Septima linea: recurso » cout » ***

– Octava linea: pausando el programa ***

Saludos, cualquier duda por favor diganmela con toda confianza 😉

Dev-C++, Clase1 – ejercicio

Hola a todos/as,

Pues ya vimos la primera clase en Dev-C++, puedes verla AQUI

El algoritmo realizado fue subido a la biblioteca Programando en un servidor, en éste caso MediaFire, puedes acceder a el ejercicio desde AQUI , para que lo descargues y ejecutes.

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

Saludos 😉

Dev-C++, uso de la aplicacion

Hola a todos/as,

Aqui voy a explicar cual es el proseso para el uso del Dev-C++

– Primero –

Antes de cualquier cosa hay que abrir el programa, con doble click o con click derecho sobre el icono y dar la opcion arbrir en el menú que nos apareció, al abrirlo tendremos una ventana asi:

ampliar imagen

– Segundo –

Una vez abierto el programa, debemos crear un nuevo documento. Para ello vamos a:

Archivo – Nuevo – Codigo fuente ( en español )

File – New – Source file ( en ingles )

Asi como podemos ver en la imagen a continuacion:

ampliar imagen

– Tercero –

Vemos que siempre se nos crea por defecto un nuevo proyecto con el nombre de » untitled1 » porque aun no le colocamos nombre ( está recien creado ), vemos tambien que ya está el espacio donde vamos a colocar la codificacion que iremos haciendo, como vemos en la imagen:

ampliar imagen

– Cuarto –

Programamos en el cuerpo de desarrollo y luego guardamos nuestro documento con el nombre que querramos. Para ello vamos a:

Archivo – Guardar como ( en español )

File – Save as ( en ingles )

Como podemos ver en la imagen de aqui:

ampliar imagen

Es necesario guardar el archivo para poder compilarlo en busca de errores, y ese será nuestro siguiente paso.

– Quinto –

Ahora compilamos el programa en busca de errores, que pueden ser por sintaxis, falta de variables, malas declaraciones, etc..

Para compilar el codigo podemos ir a la siguiente ruta:

Ejecutar – Compilar ( en español )

Execute – Compile ( en ingles )

Asi como muestra la imagen:

ampliar imagen

Y debajo, al final del programa nos indicara si hay errores y en que lineas están los errores, ese es el siguiente paso.

– Sexto –

Nos saldrá una ventanita de confirmacion de que se está compilando el programa, aquella ventana es del » proceso de compilacion «, la cual podemos ver aqui:

ampliar imagen

Una vez compilado nos mostrará los errores que puedan existir en nuestro codigo fuente, en un apartado mas abajo como vemos a contnuacion:

ampliar imagen

Si existen esas tres lineas ya se puede ejecutar sin problemas el programa y ver si está bien programado o hay que cambiar el codigo. Si existen mas lineas se le da doble click a cada una y el programa resaltará en el codigo dónde esta el error.

– Septimo –

Una vez que tengamos ya bien hecho el programa sin errores ( es decir esas tres lineas unicamente ), pues podemos avanzar a ejecutar el programa. Para ello vamos a la siguiente ruta:

Ejecutar – correr aplicacion ( en español )

Execute – run ( en ingles )

Asi como vemos en la siguiente imagen:

ampliar imagen

– Octavo –

Ahora solo nos queda ver si el programa cumplió con lo que esperabamos, es decir que si programamos bien pues funcionará caso contrario, deberemos revisar que podemos agregar / quitar para que muestre los resultados esperados, la pantalla de salida es la siguiente:

ampliar imagen

Y como podemos ver en la imagen cumplió con lo programado, quisimos mostrar ese mensaje ( para más informacion ver la clase1 ).

Saludos 😉

Dev-C++, clase1 – mostrar constantes

Hola a todos/as,

como veniamos viendo en la entrada » codigos » en Dev-C++ he visto necesario hacer una simplificacion linea por linea del codigo usado con la libreria <iostream.h> , asi analizamos las funciones que tiene. Las mas claras asi como veniamos diciendo en las entradas anteriores ( estructura ) y ( codigos ), son las funciones cin ( para ingresar datos ) y cout ( para mostrar datos ). Vamos a ello:

Como ya vimos en la entrada » estructura de un programa en c++ «, tenemos la cabecera, la funcion principal y el cuerpo. Entonces haré a continuacion un programa pequeño donde usemos las funciones principales de la libreria <iostream.h>

MOSTRAR MI NOMBRE

1.) Hacer un programa que muestre tu nombre con el formato: *** tu nombre ***

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

» Uso de la aplicacion «

#include <iostream.h>

main ( )

{

cout<< » \n   \n   \t   \t    * * * Eddy * * *    \n   \n «;

system(«pause»);

}

Analicemos el codigo anterior,

* Primera linea – cabecera y libreria

Al ser <iostream.h> nos permite usar los recursos cin ( entrada ) y cout ( salida ) entre otras muchas otras cosas, pero ahora solo estamos viendo entrada y salida de datos por lo tanto nos enfocamos mas en el cin y cout, tambien ésta libreria contiene una funcion llamada: system(«pause») que pudieron ver en el codigo anterior está una linea antes de que se cierre la ultima llave, mas adelante veremos con detalle para que sirve y por qué está ahi 😉

Como lo que queremos es unicamente » mostrar mi nombre «, pues usamremos solo cout que sirve para mostrar, es decir datos constantes ( ver entrada: Todo sobre constantes ).

* Segunda linea – funcion principal

Siempre colocamos la funcion principal: main ( ) en todo programa para indicar que comenzaremos con el desarrollo del mismo ( ver entrada: estructura de un programa en c++ )

* Tercera / sexta  linea – inicio y fin del programa

Las llaves indican que el cuerpo del programa se desarrollará en su interior, es como decir que son los limites para saber de donde a donde va la codificacion de algun programa.

* Cuarta linea – recurso cout

Bien ésta ya es la primera linea que hemos programado, porque el programa al ejecutarse va a mostrar ésto: * * * Eddy * * *

¿ Cómo funciona cout ?

como sabemos ya, cout es un recurso que usa C++ para la salida de datos de la libreria <iostream.h> no es una palabra restrigida/reservada, es decir que se puede usar como variable, pero NO es recomendable quizá de problemas al compilar el programa, para saber en C++ cual es o no es una palabra reservada, pues se lo denota por estar en negrita ( ver entrada: reglas para la declaracion de variables ), entonces ahora que lo hemos «recordado», veremos como es su sintaxis ( forma de escritura para que funcione como debe )

cout<< » » ;

esa la sintaxis que lleva para poder mostrar datos constantes como texto/numeros/simbolos. Si se omite uno de esos caracteres, al compilar el programa nos dará errores por mala escritura o sintaxis. ( compilar es hacer un barrido a los codigos escritos de arriba a abajo en busca de errores, de escritura/variables/funciones/etc.. ). Y así funciona cout 😉

Nota: El recurso cout tambien es denominado una instrucción de salida de datos, para saber más ver [ Tipos de instrucciones ]

* Quinta linea – pausado del programa

system(«pause»);

Es la funcion que se usa para pausar el programa ya que si tenemos un programa y lo compilamos, despues lo ejecutamos. El programa avanzara como está previsto y programado pero al terminar la codificacion, es decir al llegar a la llave del final se cierra automaticamente porque ha terminado su funcion ( hacer lo que se le programó )

{ <————- aqui comienza a correr el programa

….

…….

} <————- al llegar aquí se cierra automaticamente.

Y así uno no alcanza a ver » el resultado » , en éste caso que nos muestre: * * * Eddy * * *

Entonces por ese motivo se coloca una pausa antes de llegar a la llave final y así no se cierre el programa automaticamente. Si no que nos pedirá: «presione una tecla para continuar«. Así nosotros decidimos cuando queremos cerrar el programa y tenemos tiempo de ver bien los resultados 😉

{ <————- aqui comienza a correr el programa

….

…….

system(«pause»);   <—– pausamos para ver los resultados 😉

} <—— cuando hayamos presionado una tecla ahi si se cierra automaticamente el programa.

Tambien debemos recordar que para usar la funcion system(«pause»); debemos declarar inicialmente la libreria <iostream.h> pues ésta es la que la contiene como contiene tambien al cin y cout del cual hablamos mas arriba.

Saludos 😉