Tipos de instrucciones

Hola a todos/as,

Aqui voy a hablar sobre los tipos de instrucciones con los que por lo general vamos a trabajar al momento de programar en c++

Pero antes, ¿ qué es una instrucción ?

Una instruccion es lo que le ordenamos a la maquina paara que ejecute, por eso se dice que un programa es un conjunto de instrucciones; ya que cuando

ejecutamos un programa, se ejecutan asi mismo en su interior muchas instrucciones que hacen que la maquina realize algo.

Estos son los tipos de instrucciones:

– instrucciones declarativas

– instrucciones de asignacion

– instrucciones selectivas

– instrucciones repetitivas

– instrucciones de entrada y salida de datos

– instrucciones de bifurcacion

– Instrucciones declarativas –

Sirven para declarar librerias, variables, constantes, arreglos , punteros, estructuras…

Por ejemplo:

1.) Para librerias:

las librerias las declaramos porque vamos a usar recursos que contienen ellas.[ más detalles ]

#include <iostream.h> ——> cin , cout..

#include <conio.h> ——> funcion getch()..

#include <string.h> ——> para manipular cadenas

#include <math.h> ——> para operaciones numericas

#include <time.h> ——> para usar la hora

#include <stdio.h> ——> para usar alternativas de entrda – salida como printf , scanf

2.) Para variables:

las variables las declaramos con el fin de tener un espacio para almacenar algun dato que va a cambiar con el tiempo. [ más detalles ]

char nombre;                       ——> Declarando variable tipo caracter

int a,b,c;                                  ——> Declarando variable tipo entero

double sueldo                      ——> Declarando variable tipo decimal

short contador                     ——> Declarando variable tipo entero-corto

Sugerencia: leer cuanto espacio ocupa usar cada tipo de variable [ Aqui ]

Consejo: A las unicas variables que se deben dar valores iniciales son a:

– los contadores

– los acumuladores

Pero, ¿ Cuál es la difencia entre ambos ?

Acumuladores: se incrementa o decrementa en un valor variable.

Ejemplo: sacar el promedio de un alumno, se suman las notas ( que varian ) y se divide para el numero de notas.

Contadores: se incrementa o decrementa en una forma constante.

Ejemplo: va contando de “1 en 1” ó de  “-3 en -3” , etc…

3.) Para constantes:

las constantes las declaramos con el fin de tener un espacio para almacenar algun dato que no va a cambiar. [ más detalles ]

Se las puede declarar de dos formas:

Tomemos como ejemplo la formula para hallar el area de un triangulo:

¿ qué es lo que nunca cambia ?

La base puede variar, la altura puede variar. Pero como vemos el “2es constante, sea cual sea la base o la altura el 2 se queda ahi. Entonces si queremos

declarar al “2” como una constante, podemos hacerlo de dos maneras:

1) anteponiendole ” #define ” al nombre de la constante y luego el valor que le corresponde, asi:

#define nomb 2

( lo puse de color para que se entienda mejor )

Nota: al usar éste metodo no se le pone el delimitador ” ; ” al final de la linea.

A continuación coloco un ejemplo en codigo, para que tengan una idea de como seria:

#include <iostream.h>
main()
{
#define nomb 2
——> Declarada la constante de la forma 1.
int base,altura,area;
cout<<“Ingrese base: \n”;
cin >>base;
cout<<“Ingrese altura: \n”;
cin >>altura;
area = ( base * altura )/nomb;
cout<<“El area del triangulo es: “<< area <<endl;
system(“pause”);
}

2) anteponiendole ” const ” seguido del tipo de variable que és, despues el nombre de la constante y luego el valor que va a contener, asi:

const int nomb = 2;

( lo puse de color para que se entienda mejor )

Nota: a diferencia del metodo anterior, éste si lleva el delimitador ” ; ” al final de la linea.

A continuación coloco un ejemplo en codigo, para que tengan una idea de como seria:

#include <iostream.h>
main()
{
const int nomb = 2;
——> Declarada la constante de la forma 2.
int base,altura,area;
cout<<“Ingrese base: \n”;
cin >>base;
cout<<“Ingrese altura: \n”;
cin >>altura;
area = ( base * altura )/nomb;
cout<<“El area del triangulo es: “<< area <<endl;
system(“pause”);
}

4.) Para arreglos:

los arreglos son un conjunto de variables del mismo tipo y nombre, pero indexadas por una posicion diferente.

float vector [12];         ——> Declarando un arreglo tipo flotante ( decimal )

ése “vector” que se ha declarado arriba, al ser un arreglo quiere decir que hay 12 variables con el mismo nombre

y son del mismo tipo, pero diferenciadas unicamente en su posicion, asi:

vector[0],vector[1],vector[2],vector[3],vector[4],vector[5],vector[6], ………….. ,vector[10],vector[11].

Nota: los arreglos siempre comienzan en la posicion cero ( 0 ) por eso llegan hasta una unidad menos, en éste caso como declaramos

un arreglo de 12 , su tope será de 11; puesto a que desde cero ( 0 ) hasta once ( 11 ) hay doce ( 12 ) variables 😉

5.) Para punteros:

los punteros son variables que almacenan direcciones de memoria y se los reconoce por llevar un “asterisco” ( * ) delante del nombre de la variable, asi:

float * ventas ;

6.) Para estructuras:

las estructuras son una agrupacion de variables que forman un registro, se las denota de ésta manera:

struct alumno

{

int cedula;

char nombre;

short edad;

}

– Instrucciones de asignacion –

Sirven para dar valores a las variables, y llevan éste formato:

nombre_variable = expresión ;

Por ejemplo:

a = 15 ;

x = a + 5 ;

z = x / 2 ;

– Instrucciones selectivas –

Son mediante las cuales podemos ejecutar diferentes acciones, como resultado de una expresion que estemos evaluando en ese momento y pueden ser:

– Las selectivas simples

– Las selectivas dobles

– Las selectivas multiples

1.) Simples:

Las que como resultado de una expresión que se esté evaluando, solo podemos ejecutar una opcion por verdadero; ejemplo:

if ( expresión a evaluar )         ——> Si ésa expresión es verdadera y solo es verdadera, se ejecutarán las acciones.

{

acción_1;

acción_2;

}

2.) Dobles:

Nos permite seleccionar entre dos diferentes acciones:

– Una por verdadero

– Otra por falso

De ésta manera:

if ( expresion a evaluar )         ——> Si ésa expresión es verdadera, se ejecutarán las acciones 1 y 2.

{

accion_1;

accion_2;

}

else ——> Pero si ésa expresión era falsa, se ejecutarán las acciones 3 y 4.

{

accion_3;

accion_4;

}

A profundidad: para ver más sobre el manejo de la condicion if , puede acceder [ Aqui ]

3.) Multiples:

Podemos ejecutar diferentes acciones como resultado de una expresión que estemos evaluando; ejemplo:

switch ( expresion a evaluar )         ——> Esta es la expresion que vamos a evaluar.

{

case 1 :   accion 1 ;

case 2 :   accion 2 ;

case 3 :   accion 3 ;

}

– Instrucciones repetitivas –

Sirven para repetir una condicion N veces, siempre y cuando la condicion sea verdadera.

a) Cuando no sabemos cuántas veces tendrá que ejecutarse una acción para que sea verdadera, se usa el While y el Do – While. Estas dos instrucciones repetitivas son muy parecidas en su función, y llegan al mismo resultado. Solo cambia la sintaxis:

– Para while:

While ( expresión )                    ——> Mientras esa expresión sea verdadera hará las acciones 1 y 2.

{

acción 1;

acción 2;

}

– Para Do – While:

Do

{

acción 1;

acción 2;

} While ( expresión )                  ——> Mientras esa expresión sea verdadera hará las acciones 1 y 2.

b) Cuando sabemos cuántas veces queremos que se realice una acción, pues usamos la instruccion repetitiva ” for “, su sintaxis es la siguiente:

for ( expresión inicial ; expresión final ; incremento / decremento )   

{

acciónes; ——> Hasta que no llegue a la “expresión final“, se ejecurá la acción una y otra vez.

}

Nota: Sobre los operadores de incremento y decremento, puedes ver más información [ Aqui ]

– Instrucciones de entrada y salida de datos –

El lenguaje C++ no tiene palabras reservadas para ingresar o mostrar datos, para ello usan recursos que se encuentran en las librerias.

Por ejemplo:

En la libreria <iostream.h> tenemos para la entrada y salida de datos a cin y cout respectivamente.

Uso:

– Para la entrada de datos ( pedir )

cin >> nombre_del_usuario ;

– Para la salida de datos ( mostrar )

cout << nombre_del_usuario

En la libreria <stdio.h> tenemos para la entrada y salida de datos a scanf y printf respectivamente.

Uso:

– Para la entrada de datos ( pedir )

scanf ( ” %i %s %f ” , &edad apellido &sueldo ) ;

Nota: Los amperson ( & ) van en todo tipo de variable menos en las cadenas de caracteres cuando usamos el scanf.

– Para la salida de datos ( mostrar )

printf ( ” su edad es: %i ” , edad )

– Instrucciones de bifurcación –

Interrumpen el flujo normal de un programa, es decir que evitan que se ejecute alguna instrucción del programa y salta a otra parte del programa.

Por ejemplo: el “ break

Switch ( expresión que estamos evaluando )

{

case 1 : cout << ” Hola! “ ; break ;

case 2 : cout << ” amig@s “ ;

}

En el ejemplo anterior tenemos, que en caso de que haya sido “1” pues mostrará “Hola!” y saldrá del programa dejando a un lado lo demás. Entonces hemos comprobado que interrumpió el flujo normal del programa.

Pero si tuvieramos algo de ésta manera:

Switch ( expresión que estamos evaluando )

{

case 1 : cout << ” Hola! “ ;

case 2 : cout << ” amig@s ” ;

case 3 : cout << ” bienvenidos a “ ;

case 4 : cout << ” Programando: Paso a Paso “ ; break ;

}

Entonces el flujo normal del programa avanza hasta el caso 4 dónde vemos que está el ” break ” y él pues interrumpe el flujo normal del programa y ahi acabaria nuestro programa, como resultado nos hubiera mostrado lo siguiente: ” Hola! amig@s bienvenidos a Programando: Paso a Paso “.

Asi mismo, hay otras que cumplen funciones parecidas como por ejemplo:

continue : éste hace que se salte la instrucción en donde está y pase a la siguiente, por ejemplo:

for ( x=1; x<10; x++ )

{

if ( x == 5 ) continue;

cout << x << endl;

}

Como resultado muestra: 1 – 2 – 3 – 4 – 6 – 7 – 8 – 9

No muestra el número 5, porque ahi se encuentra el continue.

goto : éste nos lleva a una linea que indiquemos por medio de etiquetas. Asi:

A:

………….

………….

………….

if ( x == 100 ) goto A ;

Y otros como ” return ” que devuelve un valor ( usado en funciones por lo general ), otro es ” exit ” que obliga a salir.

Eso es todo sobre los tipos de instrucciones, espero les haya servido; cualquier pregunta no duden en hacerla. Saludos! 😉

Anuncios

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:

12-11-2009 7-37-57Ampliar 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.

12-11-2009 7-37-58Ampliar 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:

imagenAmpliar 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 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:

retorno carroAmpliar 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:

salto lineaAmpliar 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:

retorno espacioAmpliar 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:

retorno espacio 6Ampliar 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:

fin de cadenaAmpliar imagen

Esas son las más usadas secuencias de escape, espero les haya servido y nos estamos leyendo. 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:

IMG0ampliar 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:

IMG1ampliar 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:

IMG2ampliar 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:

IMG3ampliar 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:

IMG4ampliar 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:

IMG5ampliar imagen

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

IMG6ampliar 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:

IMG7ampliar 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:

IMG8ampliar imagen

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

Saludos 😉