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 «2» es 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! 😉