Operadores de incremento

Hola a todos/as,

En ésta ocacion vamos a ver los operadores de incremento, éstos sirven para ir incrementando un valor de alguna variable o algun contador que estemos usando, para ello tenemos dos sintaxis:

A++

éste sirve para que se le incremente en cada «pasada / barrido» una unidad más. Osea que si tenemos que:

la variable vaya de A = 0 hasta A <= 10 de uno en uno , entonces al poner A++ , se va a ir incrementando Asi:

0 , 1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10

Pues va incrementando a A de uno en uno. En cambio, si tenemos:

++A

éste sirve para que se le incremente de inmediato una unidad más. Osea que si tenemos que:

la variable vaya de A = 0 hasta A <= 10 de uno en uno , entonces al poner A++ , se va a ir incrementando Asi:

1 , 2 , 3 , 4 , 5 , 6 , 7 , 8 , 9 , 10 , 11

Esto se debe a que en vez de comenzar con A = 0 , comienza de inmediato con uno ( 1 ), pues al tener ++A significa que primero se le suma un valor y luego hace la siguiente «pasada / barrido».

Pues podemos ver que en el ejercicio anterior comenzaba con:

A=0 [ para A++ , entonces primero vale cero y luego se le incrementa 1 ( ++ ) ]

Y en el de ahora ultimo con:

A = 0 [ para ++A , entonces primero vale uno porque primero está el ( ++ ) y luego se aplica entonces 0 + 1 = 1 . Nuestro primer valor es 1 ]

Y como comenzamos con cero ( 0 ) en la primera, osea A++ vamos en un rango de 0 – 10 porque son 11 numeros que debemos tener. Mientras tanto si hacemos con ++A comenzamos ya no con cero, sino con uno ( 1 ), y por lo tanto si se aumenta una unidad al principio; tambien al final para no desequilibrar por eso va de 1 – 11 porque deben ser 11 numeros.

Acá dejo un ejemplo en codigo para que puedan pegarlo en sus compiladores de c++ y ver como funciona:

#include<iostream.h>
#include<conio.h>
main ()
{

short A = 0,x;
cout<<«\n\n **** Con A++ **** \n\n»<<endl;
for ( x = 0; x<=10; x++ )
{
cout<<«\t»<< A++ <<endl;
}

cout<<«\n\n **** Con ++A **** \n\n»<<endl;
for ( x = 0; x<=10; x++ )
{
cout<<«\t»<< ++A <<endl;
}

getch();

}

Nota: Asi mismo con la misma «tecnica» funciona los de decremento [ A – –  ó – -A , pero de forma decreciente ]

Operadores aritmeticos

Hola a todos/as,

Bien los operadores aritmeticos son aquellos que nos van a servir para hacer las operaciones con numeros, variables, etc.

– Operadores de asignacion –

Estos operadores son comunmente usados para las operaciones mas rutinarias como son:

suma ( entero y decimal ) —> +

resta ( entero y decimal ) —> –

multiplicacion ( entero y decimal ) —> *

dividision ( entero y decimal ) —> /

division para hallar el residuo ( solo para enteros ) —> %

Entonces podesmos ver cuales son los operadores aritmeticos más usados en los medios de codificacion, pues hacen las operaciones mas comunes y necesarias. Ahora veremos un par de ejemplos por cada operador:

Suma:

A = 5 + 30

Podemos ver que tenemos en éste caso dos numeros enteros usando un operador aritmetico ( el más ) y un operador de asignacion para que la suma se le asigne a la variable A.

M = 80.10 + 0.70

Aqui hacemos lo mismo de arriba, pero estamos trabajando con decimales.

Z = X + Y

Aqui en cambio estamos haciendolo directamente con variables, el valor X  y el valor Y pudieron haber sido ingresados por el usuario asi ya no son constantes como arriba el 5 , 30 , 8.10 , 0.70 a diferencia de ellos los valores que tomara X y tambien Y iran cambiando con cada ejecucion del programa pues al ser diferentes usuarios que ingresen datos no ingresaran los mismos que el usuario anterior.

Resta:

M = 800 – 400

Lo que vemos en la expresion de arriba es una resta de numeros enteros que se le asigna a una variable M

M = 40.55 – 20.10

Aqui la unica diferencia es que estamos restando decimales.

C = A – B

Del mismo modo que expliqué en la suma, aqui estamos restando dos variables que pueden ser datos ingresados por el usuario y esa resta se le asignará a C.

Multiplicacion:

AA = 4 * 5

Multiplicacion de dos cantidades enteras.

BB = 12.8 * 6

Multipliacion donde se involucra un valor decimal.

R = U * D

La multiplicacion de las variables U y D se le asignará  a R.

Division:

J = 5 / 2

Como podemos ver, estamos dividiendo dos numeros enteros y el problema que viene a la mente de muchos usuarios es que dividir 5 para 2 no da un valor exacto pues 5 no es un numero par. Entonces muchos piensan que el resultado que dará es 2.5. Pero no es asi, el resultado de la division de enteros en c++ se denota asi:

Ampliar imagen

Y por lo tanto vemos que al dividir 5 para 2, nos queda un valor decimal. Pero cuando usamos la division de enteros nos da como resultado solo la parte entera. Es decir que si tenemos ésto:

5 / 2

La respuesta seria 2.5 , pero como estamos haciendo una division de enteros nos dará unicamente como respuesta la parte entera. Es decir el 2 y el .5 lo dejará sin importancia pues es una division de enteros y nos dará como resultado solo la parte entera.

A diferencia de haber hecho una division de decimales, usando el mismo ejemplo tenemos que pudo haber sido asi:

5.0 / 2

Ahi nos dará como respuesta el valor 2.5 completo, pues se da cuenta que estas haciendo una division de decimales.

Ampliar imagen

Entonces el programa asimila automaticamente que lo que quieres es una respuesta con decimales y no solamente entera, que por algo colocaste 5.0 en vez de 5.

Division para el residuo:

En el caso anterior vimos la » dividion » para enteros y decimales. Pero ahora que vamos a ver la » division para el residuo » solo funciona con numeros enteros. Tanto el dividendo como el divisor deben ser numeros enteros, no pueden llevar decimales, Asi:

A = 10 % 3    —> ¡ correcto !

Asi como les decia, éste simbolo » % » sirve para hallar el residuo de una division de enteros, en el caso de A que es 10 % 3 , pues el resultado será 1. Porque 1 es el residuo ó lo que sobra en la division. De ésta manera para que se entienda mejor:

Ampliar imagen

En la imagen que acabo de exponer, está la diferencia entre cuando dividimos dos cantidades enteras para sacar el residuo ó sacar el cociente. Para el residuo vemos que usamos » % » y vemos que dato es el que almacenará. Mientras que para hallar el cociente de la division, usamos el » / » y asi mismo vimos que dato almacenará.

A = 10.1 % 3.3    —> ¡ incorrecto !

Como les decia al principio, el » % » solo funciona con cantidades enteras no con numeros reales, es decir los que van acompañados de decimales. Por lo tanto si colocan ésa expresion les dará un error.

Bueno eso es todo sobre operadores aritmeticos, cualquier duda puedes comentarmela, saludos 😉

Operadores de asignacion

Hola a todos/as,

Vamos a ver lo que son los operadores de asignacion, como su nombre lo indica son aquellos que sirven para asignar «algo«.

– Operadores de asignacion –

Asi como decia anteriormente, son para asignar algo ( texto – valores – caracteres especiales ) a cualquier variable por ejemplo y se los denota con la forma:

algo1 = algo2

Donde el signo » = » sirve como operador para la asginacion. En éste caso a lo que se encuentre dentro de » algo2 » ya sean numeros o texto, se le asignará o se lo dará a » algo1 » quedando éste osea » algo1 » con el valor o caracteres que le dió » algo2 «.

Para eso principalmente sirve el operador de asignacion » = » para asignar.

Ahora vamos a ver algunos ejemplos para tener más claro el asunto, a continuacion veremos como se le asigna un valor a una variable:

#include <iostream.h>
#include <conio.h>
main ()

{

int A;

A = 100;

cout<<«El valor de A es: «<<A;

getch();

}

Vemos que hemos declarado una variable llamada: » A » como tipo entero ( int ), eso significa que los valores que le asignemos van a tener que ser » redondos – exactos – justos » en otras palabras no podran ser numeros reales ( numeros reales son aquellos enteros que estan acompañados por decimales ).

Para ello vemos que le asignamos a la variable » A » la cantidad de 100. Para ello debimos usar la sintaxis de los operadores de asignacion, osea:

algo1 = algo2

A = 100

Pero ya en la codificacion recuerden que cada instruccion va acompañada del punto y coma ( ; ) para indicar que ahi termina ésa linea. Asi:

A = 100 ;

Pero vemos claramente como es asignarle un valor a una variable con el operador de asignacion » igual ( = ) «.

Ampliar imagen

Ahora veremos como asignar valores de una variable a otra variable:

Asi mismo como el ejemplo anterior pero haciendo unos pequeños cambios, pues ahora no le asignaremos un valor si no el contenido de otra variable, para ello vamos a agregar una variable B. Y darle un valor y asi veremos como funciona la asignacion en dos variables, vamos a ello:

#include <iostream.h>
#include <conio.h>
main ()

{

int A,B;

B = 51;

A = B;

cout<<«El valor de A es: «<<A;

getch();

}

Como vemos a diferencia del ejemplo anterior donde la asignamos un valor directamente a » A «, ahora le asignamos un valor a otra variable osea a » B «. Y el valor de la variable B se le asignará a la variable A, es decir que A deberia valer lo mismo que vale B porque así lo declaramos, al ejecutar el programa nos da como resultado ésto, vemos que funciona:

Ampliar imagen

Ahora veremos con texto, el caso de que se le quiera asignar texto a una variable, es lo mismo solo que cambia el tipo de dato, ya que para texto y caracteres se usa char mientras que para enteros se usa int. Vamos a ello:

#include <iostream.h>
#include <conio.h>
main ()

{

char A,B;

B = ‘ z ‘ ;

A = B;

cout<<«El valor de A es: «<<A;

getch();

}

Aqui vemos que hemos declarado a la variable A y B como tipo caracter, entonces al asignarle un caracter a » A » y despues el contenido de A se lo asignamos a B, entonces B tendrá el valor de A. Entonces si le asignamos a A el caracter ‘ z ‘, B tendrá el contenido de ‘ z ‘ tambien por el operador de asignacion ( = ) y por ser del mismo tipo que A.

Ampliar imagen

Saludos 😉

Operadores logicos

Hola a todos/as,

A continuacion vamos a ver lo que son los operadores logicos, su funcion y como se denota cada uno de ellos.

– Operadores logicos –

Los operadores logicos sirven para hacer diferentes operaciones dependiendo de lo que se proponga, por ese motivo se le califica como que sirven para » admitir / rechazar » propuestas que son expresadas por el programador o algun ejercicio / algoritmo en si.

Entro los operadores logicos tenemos a:

OR ————- > ||

AND ————- > &&

NOT ————- > !

Con respecto a OR [ || ], significa » o «. Podemos decir en lenguaje humano, que funciona de la siguiente manera:

Si 14 es mayor a 10 O 14 es mayor 11 entonces haga lo siguiente…

Ahora en lenguaje de codigo, seria de la siguiente manera:

if ( 14 > 10 || 14 > 11 )

{

. . . . . . . .

}

Con respecto a AND [  && ], significa » y «. Podemos decir en lenguaje humano, que funciona de la siguiente manera:

Si 14 es mayor a 10 Y 14 es mayor 11 entonces haga lo siguiente…

Ahora en lenguaje de codigo, seria de la siguiente manera:

if ( 14 > 10 && 14 > 11 )

{

. . . . . . . .

}

Con respecto a NOT [  ! ], significa » no / diferente que «. Podemos decir en lenguaje humano, que funciona de la siguiente manera:

Si 14 NO es igual a 10 entonces haga lo siguiente…

Ahora en lenguaje de codigo, seria de la siguiente manera:

if ( 14 != 10 )

{

. . . . . . . .

}

Saludos 😉

Espacios de memoria por tipo de variable

Hola a todos/as,

Es importante saber cuanto pueden llegar a almacenar cada tipo de variable. Pues eso se debe tener en cuenta para poder declarar variables, ya que si queremos ingresar un numero entero ¿ para qué necesitamos un espacio de decimales ? , o que si queremos ingresar solo 1 caracter ¿ para que necesitamos un espacio de muchos caracteres con precision ?. Entonces asi aprendemos a declarar adecuadamente las variables, ahorrando espacio y haciendo mas funcional el programa. Vamos a ello:

Para ver el espacio de cada tipo de variable, primero se tipea la palabra reservada sizeof y seguido de ella, entre parentesis colocamos el tipo de variable para saber cuantos bytes ocupa dicha variable.

NOTA: recordar que, 8 bits son equivalentes a 1 byte. Y cada caracter posee 8 bits, es decir que cada caracter tiene un espacio de 1 byte. Por ejemplo el caracter ‘ A ‘ ocuparia 1 byte de memoria.

Ahora vamos con el codigo fuente para ver las medidas:

#include <iostream.h>
#include <conio.h>
main ()
{
cout<<endl;
cout<<«Los tipos de datos enteros: \’int\’ ocupan: «<<sizeof(int)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos enteros cortos: \’short int\’ ocupan: «<<sizeof(short int)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos enteros largos: \’long int\’ ocupan: «<<sizeof(long int)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos flotantes: \’float\’ ocupan: «<<sizeof(float)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos entero con decimales: \’double\’ ocupan: «<<sizeof(double)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos entero con decimales largos: \’long double\’ ocupan: «<<sizeof(long double)<<» bytes de memoria \n\n»;
cout<<«Los tipos de datos caracter: \’char\’ ocupan: «<<sizeof(char)<<» bytes de memoria \n\n»;
getch();
}

Bien como vemos arriba, pedi el » tamaño de » ( es decir el sizeof ) de cada una de los tipos de variables que vamos a usar. Y como resultados tenemos la siguiente tabla:

Ampliar imagen

Ahora con ésos datos ya sabremos como declarar mejor nuestras variables, porque sabremos cuantos caracteres almacenaran cada una, es decir que si queremos que el usuario/a ingrese solo 1 caracter no vamos a declararlo tipo long double, si no como char pues char almacena unicamente 1 caracter. Asi evitamos problemas futuros con los programas. Saludos 😉

Secuencias de escape

Hola a todos/as,

Pues vamos a ver las secuencias de escape en c++ . Las secuencias de escape no son más que «constantes especiales» que se diferencian por llevar una barra inclinada delante, es decir éste simbolo: » \ «

Tenemos algunas, mencionaremos las más usadas:

‘ \r ‘

Es el retorno del carro, se la denomina así porque el cursor se ubica al comienzo de la misma linea al ser ejecutado el programa y llegar al \r , el cursor volverá al comienzo de la misma linea. Asi:

Ejemplo:

#include <iostream.h>
#include <conio.h>
main ()

{

cout<<«Progrmando – paso A paso \r«;
getch();

}

Como podemos ver, he resaltado con rojo a la secuencia de escape de «retorno de carro«, entonces el programa hará lo siguiente:

1) como va a usar «cout» identificará que se esté usando la libreria iostream.h

2) luego mostrará en pantalla lo que esta en comillas tal y cual

3) al final, antes de llegar al cierre de comillas se dará cuenta que está una secuencia de escape llamada retorno del carro, entonces hará que el cursor se regrese al inicio de la misma linea.

4) verá que hay un getch(); que sirve para pausar el programa y poder visualizar lo que hay en la consola ( ventanita negra )

Osea que en vez de quedar el subguion titiliando al final, osea despues de la palabra «paso» Asi:

Programando – paso A paso_

ése guion bajo se ira al inicio, quedando debajo de la primera letra, es decir la letra » P » de Programando. Asi:

Ampliar imagen

‘ \n ‘

Esta secuencia de escape funciona para dar un salto de linea, es decir un  » enter «, Es como en literatura un punto a parte, dice que vaya a la siguiente linea, asi es el \n , funciona para ir al comienzo de la siguiente linea.

Ejemplo:

#include <iostream.h>
#include <conio.h>
main ()

{

cout<<«Progrmando – paso A paso \n«;
getch();

}

Como podemos ver, he resaltado con rojo a la secuencia de escape de «salto de linea«, entonces el programa hará lo siguiente:

1) como va a usar «cout» identificará que se esté usando la libreria iostream.h

2) luego mostrará en pantalla lo que esta en comillas tal y cual

3) al final, antes de llegar al cierre de comillas se dará cuenta que está una secuencia de escape llamada salto de linea, entonces hará que el cursor baje una linea y se ubique al comienzo de ésta nueva linea.

4) verá que hay un getch(); que sirve para pausar el programa y poder visualizar lo que hay en la consola ( ventanita negra )

Osea que en vez de quedar el subguion titiliando al final, osea despues de la palabra «paso» Asi:

Programando – paso A paso_

ése guion bajo se ira al inicio de la siguiente linea, quedando asi:

Ampliar imagen

‘ \a ‘

Esta secuencia de escape funciona para dar pitido o alarma, es decir un  » piiip «, Es como una especie de notificacion, se la usa muy amenudo para cuando se ingresa mal un valor, que ademas de un mensaje de error, se muestre un sonido de error, para eso se usa el \a.

Ejemplo:

#include <iostream.h>
#include <conio.h>
main ()

{

cout<<«Progrmando – paso A paso \a«;
getch();

}

Como podemos ver, he resaltado con rojo a la secuencia de escape de » alarma «, entonces el programa hará lo siguiente:

1) como va a usar «cout» identificará que se esté usando la libreria iostream.h

2) luego mostrará en pantalla lo que esta en comillas tal y cual

3) al final, antes de llegar al cierre de comillas se dará cuenta que está una secuencia de escape llamada alarma, entonces hará un sonido de aviso cuando termine de mostrar el texto, como un » piiip »

4) verá que hay un getch(); que sirve para pausar el programa y poder visualizar lo que hay en la consola ( ventanita negra )

NOTA: como es un sonido no lo puedo colocar aqui, pero vamos pueden probarlo en sus casas y ejecutenlo verán que funciona 😉

‘ \b ‘

Esta secuencia de escape funciona para retroceder un espacio en la linea mostrada, no es como el » retorno del carro « ó » \r «, pues el retorno de carro se regresaba toda la linea, mientras que el » \b « solo retrocede un espacio.

Ejemplo:

#include <iostream.h>
#include <conio.h>
main ()

{

cout<<«Progrmando – paso A paso \b«;
getch();

}

Como podemos ver, he resaltado con rojo a la secuencia de escape de » retorno de espacio «, entonces el programa hará lo siguiente:

1) como va a usar «cout» identificará que se esté usando la libreria iostream.h

2) luego mostrará en pantalla lo que esta en comillas tal y cual

3) al final, antes de llegar al cierre de comillas se dará cuenta que está una secuencia de escape llamada retorno de espacio, entonces regresará un espacio en la misma linea.

4) verá que hay un getch(); que sirve para pausar el programa y poder visualizar lo que hay en la consola ( ventanita negra )

Osea que en vez de quedar el subguion titiliando al final, osea despues de la palabra «paso» Asi:

Programando – paso A paso_

ése guion bajo se ira un espacio antes en la misma linea, quedando asi:

Ampliar imagen

Entonces cada vez que coloquemos un \b irá retrocediendo un espacio mas hacia atras, para dejar un ejemplo hagamos el mismo pero con seis \b , entonces retrocederemos 4 espacios a la izquierda en la misma linea. Asi:

cout<<«Progrmando – paso A paso \b\b\b\b\b\b«;

Entonces quedara debajo de la «A», veamos:

Ampliar imagen

‘ ‘ ( barra inclinada y el cero )

Esta secuencia de escape se llama » caracter nulo » o » fin de cadena «. Se encuentra al final de cada linea, pero son invisibles a la vista del programador o del espectador. Diria que es asi mas o menos como está en el medio, tomando como ejemplo los ejercicios anteriores:

cout<<«Progrmando – paso A paso \r «;

cout<<«Progrmando – paso A paso \n «;

cout<<«Progrmando – paso A paso \a «;

cout<<«Progrmando – paso A paso \b «;

No lo vemos, pero siempre está al final de cada cadena indicando que hasta ahi llega lo que se quizo mostrar. Ahora veremos un ejemplo claro del » fin de cadena «, donde cortaremos una cadena a la mitad con el simple hecho de usar el puesto que siempre está al final ( invisible para nosotros ), si lo usamos podemos cortar cualquier cadena.Asi:

Ejemplo:

#include <iostream.h>
#include <conio.h>
main ()

{

cout<<» \n Progrmando – paso A paso \n «;
getch();

}

Como podemos ver, he resaltado con rojo a la secuencia de escape de » fin de la cadena «, y con color verde a la secuencia de escape » fin de linea » para ver que se pueden usar las que queramos. Entonces el programa hará lo siguiente:

1) como va a usar «cout» identificará que se esté usando la libreria iostream.h

2) luego mostrará en pantalla lo que esta en comillas tal y cual

3) al medio de la cadena, antes de llegar donde dice: » A paso « se dará cuenta que está una secuencia de escape llamada fin de la cadena, entonces cortará la cadena hasta ahi. Dejando olvidado lo demás.

4) verá que hay un getch(); que sirve para pausar el programa y poder visualizar lo que hay en la consola ( ventanita negra )

Osea que en vez de quedar mostrando todo el texto:

Programando – paso A paso

la secucencia de caracter nulo ó fin de cadena, hará que se muestre solamente hasta antes de » A paso «, quedando asi:

Ampliar imagen

Esas son las más usadas secuencias de escape, espero les haya servido y nos estamos leyendo. Saludos 😉

Dev-C++, Clase8 – ejercicio

Hola a todos/as,

Bien, ya está la octava 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 “clase8“

Saludos 😉

Dev-C++, clase8 – ciclo: mientras que..

Hola a todos/as,

En ésta clase veremos un nuevo bucle ( secuencia repetitiva ):

DO – WHILE.

Que en español podria ser traducida como:

hacer ésto – miestras que ésto pase.

Esta nueva » instrucción repetitiva » la usaremos para hacer repeticiones de algo un numero indeterminado de veces. Por ejemplo el caso de que solo se desee ingresar un numero que sea menor a 10 entonces no podemos dejar que el usuario ingrese cualquier digito, para eso esta el ciclo mientras, ya que diriamos nosotros..

mientras que el numero ingresado sea mayor a 10

entonces.. pida de nuevo el numero hasta que ingrese un numero menor a 10

Ese es un caso normal para el uso de la instrucción repetitiva: DO – WHILE

Pero vamos  a profundisar más con un ejemplo sencillo para que quede claro como funciona y como es su sintaxis, vamos a ello:

10.-) Hacer un programa que pida un numero mayor a 100 y lo muestre en pantalla con la forma: *** numero ***

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

” Uso de la aplicacion “

Bien como podemos observar, el ejercicio solo nos pide que ingresemos un numero pero con una condicion, de que el numero ingresado sea mayor a 100, si no cumple esa funcion pues no vale el programa porque la finalidad es que el usuario ingrese un numero unicamente mayor a 100.

Para ésto vamos a poner en practica lo que ya hemos aprendido en las clases anteriores, siendo la más reciente la clase sobre la instrucción selectiva doble: if / else [ clase6 ]

Desglosando un poco lo que vamos a hacer, pues necesitamos unicamente de un numero, por lo tanto vamos a usar una variable unicamente, le asignare el nombre de num porque va a ser el numero que ingrese el usuario/a.

De ésta manera pediremos el numero al usuario, el usuario ingresará un numero y ese numero se almacenara en la variable num

Ahora que la variable num tiene el numero ingresado procederiamos a analizarla a ver si es que el numero que ingresó el usuario/a es mayor a 100, si es asi lo mostramos directamente, pero si no es asi; entonces ahi aplicamos el ciclo mientras..

Diriamos lo siguiente:

Hacer: ingresar un numero ———> DO

Hasta que: el numero ingresado sea mayor a 100 ———> WHILE

Entonces el usuario/a, ingresará una y otra vez un numero hasta que el numero que ingrese sea mayor a 100, si no; el bucle se repetirá infinitamente.

Una vez que haya ingresado el numero mayor a 100, debemos hacer que el programa lo muestre en pantalla con el formato: *** num ***

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 num;
cout<<» \t \n Ingrese un numero mayor a 100 \n \n»;
cin>>num;

if ( num <= 100 )
{

do
{
cout<<» \t \n Ingrese un numero mayor a 100 \n \n»;
cin>>num;
}
while ( num <= 100 );

}

cout<<» \n \n El numero fue: «<<«*** «<<num<<» ***»<<«\n \n»;

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

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

– linea 4: declaramos variables ***

– linea 5: recurso ” cout ” ***

– linea 6: recurso ” cin ” ***

– linea 7 – 15: instrucción selectiva simple: » if » ***

– linea 9 – 14: instrucción repetitiva: ” do – while ”

Como podemos ver aqui estamos aplicando la nueva instrucción repetitiva, osea DO – WHILE, como toda instrucción\función\prototipo\ lleva su forma de escritura, es decir su sintaxis para que funcione debe estar convocada de la manera en que se creó para que funcione bien, asi como hemos visto las sintaxis o formas de escritura para varias instrucciones como la de if – else , recuerdan que era:

if ( algo pasa ) ———> si algo pasa

{

entonces.. hago ésto, muestro ésto,etc..

}

Bien para el caso de DO – WHILE es lo mismo, vamos con la sintaxis de:

do ———> hacer lo que esta en llaves..

{

ésta operacion

}

while ( ésto pase ) ———> mientras pase lo que está en parentesis

Eso es lo que estamos diciendo y aplicando con la sintaxis que mostré arriba, pues supongamos que el usuario ingreso el numero: 60 ( en la linea 6 ).

Bien, claramente vemos que el numero 6 NO es mayor que 100, por lo tanto NO lo deberia mostrar si no más bien pedir de nuevo el numero HASTA que el usuario/a ingrese un numero mayor a 100 por ejemplo 106

Entonces ahi es donde entra en juego el DO – WHILE, vemos que dice:

Hacer lo siguiente

{

Pedimos al usuario que ingrese un numero mayor a 100

}

Mientras que ( el numero que ingrese no sea mayor a 100 )

Perfecto, lo que tenemos es que si en el primer intento el usuario/a ingresó una cantidad menor a 100, se meterá en el ciclo DO – WHILE, obligandolo en cada intento a que ingrese un numero mayor a 100, caso contrario el ciclo no acabará. Pero si en el primer intento ingresó una cantidad mayor a 100, no entrará al ciclo DO – WHILE si no que directamente lo mostrará. Porque vemos que para entrar al ciclo DO – WHILE primero debe cumplir la condicion if que dice:

if ( num <= 100 )

Si el numero es menor o igual a 100 … entre al ciclo DO – WHILE

Entonces asi vemos como funciona el ciclo mientras – que 😉

– linea 16: recurso ” cout ” ***

– linea 17: pausando el programa ***

Saludos, y cualquier duda comenten con toda confianza 😉

Dev-C++, Clase7 – ejercicios

Hola a todos/as,

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

Ya subí los archivos ( ejercicios ), 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 “clase7“

Saludos 😉

Dev-C++, clase7 – ejercicios de aplicacion II

Hola a todos/as,

En la clase anterior vimos la aplicacion de la instrucción selectiva doble: if / else que sirve para las condiciones. Ahora haremos unos ejercicios de aplicacion para terminar de solventar ese conocimiento y aplicarlo bien. Vamos a ello.

8.-) Hacer un programa que pida 3 numeros y al mayor lo muestre en pantalla

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

” Uso de la aplicacion “

Bien, entonces segun el ejercicio propuesto necesitamos tres numeros, para ello vamos a usar tres variables diferentes: n1,n2,n3.

n1 = primer numero

n2 = segundo numero

n3 = tercer numero

Luego habra que analizar cual entre los tres numeros ingresados es el mayor, y al encontrarlo lo mostraremos en pantalla. Funcionará de ésta manera, asumiendo datos:

n1 = 15

n2 = 22

n3 = 9

Expresandolo en manera humana, como apreciamos nosotros el medio:

si 15 es mayor a 22 y tambien es mayor a 9 entonces, Mostramos 15

Expresandolo en  manera de codigo, la primera pregunta seria:

Si 15 > 22 && 15 > 9

si eso fuera cierto mostrariamos el 15 como respuesta. Pero no es cierto por lo tanto vamos con la siguiente pregunta.

Si 22 > 15 && 22 > 9

eso si es cierto, entonces mostrariamos el numero 22 como resultado. Pero si eso tampoco fuera cierto se preguntaria por tercera vez:

Si 9 > 15 && 9 > 22

si eso fuera cierto, se mostraria el 9 como numero mayor, pero no es así. El numero mayor fue el 22. Se hubiera mostrado en la linea anterior cuando preguntamos si 22 era mayor que 15 y 9

Tambien podemos observar que tenemos un codigo nuevo, es el separador » && » que significa » Y «. Asi como vemos he coloreado con café el » Y » en el lenguaje Humano y el » && » en lenguaje codigo para que observen que decir » Y » equivale a poner » && » en codigo fuente en lenguaje C++

NOTA: ver mas informacion sobre el operador logico » && » [ AQUI ]

Ahora que vimos como va el ejercicio. Comenzamos con el codigo fuente 😉

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<<» \t \n Ingrese 2 numeros \n \n»;
cout<<» \n Primer nuemro: \n»;
cin>>n1;
cout<<» \n Segundo nuemro: \n»;
cin>>n2;
cout<<» \n Segundo nuemro: \n»;
cin>>n3;

if ( n1 > n2 && n1 > n3 )
{
cout<<» \n El mayor numero entre: «<<n1<<» , «<<n2<<» , «<<n3<<» fue el numero: «<<n1<<«\n\n»;
}

if ( n2 > n1 && n2 > n3 )
{
cout<<» \n El mayor numero entre: «<<n1<<» , «<<n2<<» , «<<n3<<» fue el numero: «<<n2<<«\n\n»;
}

if ( n3 > n1 && n3 > n2 )
{
cout<<» \n El mayor numero entre: «<<n1<<» , «<<n2<<» , «<<n3<<» fue el numero: «<<n3<<«\n\n»;
}

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

– linea 3 – 25 : 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 – 15: instrucción selectiva simple » if «

Vemos asi como lo explicaba arriba, que el codigo pide al programa que pregunte si el primer numero es mayor que el segundo y el tercero. A continuacion les colocare el modo «lenguaje humano» y el «lenguaje codigo»

Lenguaje humano

Si ( primer numero > segundo numero Y primer numero > tercer numero )

Entonces, haga esto:

{

muestre: » El mayor numero entre: « primer numero,segundo numero,tercer numero. » fue el numero: « primer numero «doble enter»;

}

Lo mismo que vemos escrito en «lenguaje humano», es decir lo que nosotros entendemos y podemos realizarlo a medida de logica. Pues la computadora no lo entendera porque no es su lenguaje, asi que para decirle eso, habrá que hablar en su lenguaje de ésta manera:

( como está en el programa ya expuesto )

Lenguaje codigo

if ( n1 > n2 && n1 > n3 )
{
cout<<» \n El mayor numero entre: «<<n1<<» , «<<n2<<» , «<<n3<<» fue el numero: «<<n1<<«\n\n»;
}

Y asi mismo con cada pregunta, ya que son tres numeros se haran tres preguntas, ya que cada una asumira que ése sera el primero y si no es así pues saltará a la siguiente y siguiente y siguiente asi sucesivamente hasta llegar al numero que cumple la condicion [ que sea mayor a los demas numeros ingresados ]

Nota: Cuando solo se valida a la expresión para saber unicamente si fué positiva, se le denomina una » instrucción selectiva simple » y usa unicamente el » if » porque va a validar solo en caso de que se haya cumplido la condición, en ésta instrucción no entra el » else «, por lo mismo se le denomina simple. Para ver más entrar [ Aqui ]

– linea 16 – 19: instrucción selectiva simple » if » ***

– linea 20 – 23: instrucción selectiva simple » if » ***

– linea 24: pausando el programa ***

9.-) Hacer un programa que pida 5 numeros y muestre los numeros pares hallados

Bien como podemos apreciar, el ejercicio propuesto nos pide que ingresemos cinco numeros, osea que usaremos cinco variables:

n1 = primer numero

n2 = segundo numero

n3 = tercer numero

n4 = cuarto numero

n5 = quinto numero

Y segun el ejercicio, solo se deben mostrar aquellos numeros que fueron pares. Entonces tendremos que validar cada numero para saber si cada uno es par o no. Si es par lo mostramos si no es par pues pasamos al siguiente. De ésta manera:

Si primer numero es par

entonces

{

mostramos el primer numero

}

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,n5;
cout<<» \t \n Ingrese 5 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;
cout<<» \n Quinto nuemro: \n»;
cin>>n5;

if ( n1 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n1<<«\n\n»;
}

if ( n2 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n2<<«\n\n»;
}

if ( n3 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n3<<«\n\n»;
}

if ( n4 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n4<<«\n\n»;
}

if ( n5 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n5<<«\n\n»;
}

system(«pause»);

}

– linea 1: la cabecera y libreria ***

– linea 2: funcion principal ***

– linea 3 – 37 : 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: recurso ” cout ” ***

– linea 15: recurso ” cin ” ***

– linea 16 – 19: instrucción selectiva simple » if » ***

Asi como venia diciendo al comienzo del ejercicio. Teniamos que validar cada numero para saber si era o no un numero par, y en caso de que lo fuese mostrarlo. Pero..

¿ Cómo sabemos si un numero es par ?

Esto ya lo hemos visto cuando vimos DFD, pero de todas maneras lo explicare a continuacion:

Pues un numero es par cuando al dividirlo para dos ( 2 ), su residuo o resto es igual a cero ( 0 ). Dado como la formula:

entonces si tenemos por ejemplo dando datos los siguientes valores:

n1 = 22

n2 = 7

Aplicando la formula de numeros pares ( «numero cualquiera» dividio para «dos» ), entonces tenemos que:

Numero par

22 / 2 = 11 sobrando cero ( 0 ) porque es exacta la division.

Numero impar

7 / 2 = 3 sobrando uno ( 1 ) porque la division no es exacta.

Pero todo lo que vemos es la manera en como la entendemos nosotros, a la computadora se le escribe en codigo para que entienda entre lineas lo que debe realizar y como lo debe realizar. Para ello lo transicribimos del «lenguaje humano» al «lenguaje codigo». De esta manera para que sea más didactico:

Lenguaje humano

Si el residuo del primer numero al dividido para dos es igual a cero

entonces

{

mostrar el primer numero porque es par

}

Lenguaje codigo

if ( n1 % 2 == 0 )
{
cout<<» Numero par hallado: «<<n1<<«\n\n»;
}

Como podemos observar aqui tambien usamos un nuevo codigo que es para hallar el residuo o resto de una division, es el simbolo » % «.

Recordatorio: en DFD usabamos una funcion llamada «mod» para hacer ésta operacion, osea hablamos de sacar el residuo/resto/lo que sobra, en una division de dos numeros. [ ver más sobre mod en DFD, ejercicio8 ]. Acá en el lenguaje C++ usamos a diferencia de DFD, un simbolo que equivale a usar el mod en DFD, es el simbolo que venimos viendo en ésta clase: « % »

He hecho una grafica donde muestro más didacticamente como funciona el » mod » ( en DFD ) y el » % » ( en lenguaje C++ ), como ven a continuacion:

Ampliar imagen

– linea 20 – 23: instrucción selectiva simple » if » ***

– linea 24 – 27: instrucción selectiva simple » if » ***

– linea 28 – 31: instrucción selectiva simple » if » ***

– linea 32 – 35: instrucción selectiva simple » if » ***

– linea 36: pausando el programa ***

Eso fue todo por ésta clase, espero haya sido de ayuda. Cualquier inquietud o sugerencia me la pueden comentar, la atenderé lo más rapido posible. Saludos 😉