Tipos de instrucciones

Hola a todos/as,
Aquí 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 instrucción es lo que le ordenamos a la máquina para que ejecute, por eso se dice que un
programa es un conjunto de instrucciones; ya que cuando ejecutamos un programa, se
ejecutan así mismo en su interior muchas instrucciones que hacen que la maquina realice algo.

Estos son los tipos de instrucciones:

– instrucciones declarativas
– instrucciones de asignación
– instrucciones selectivas
– instrucciones repetitivas
– instrucciones de entrada y salida de datos
– instrucciones de bifurcación

– Instrucciones declarativas –
Sirven para declarar librerías, variables, constantes, arreglos, punteros, estructuras…
Por ejemplo:

1.) Para librerías:

Las librerías las declaramos porque vamos a usar recursos que contienen ellas.

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

#include <conio.h> ——> función getch()..
#include <string.h> ——> para manipular cadenas
#include <math.h> ——> para operaciones numéricas
#include <time.h> ——> para usar la hora
#include <stdio.h> ——> para usar alternativas de entrada – salida como printf , scanf

2.) Para variables:

Las variables las declaramos con el fin de tener un espacio para almacenar algún dato que va
a cambiar con el tiempo.

char nombre; ——> Declarando variable tipo carácter

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

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

– los contadores
– los acumuladores

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

Acumuladores: se incrementa o decrementa en un valor variable.

Ejemplo: sacar el promedio de un alumno, se suman las notas (que varían) 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 algún dato que
no va a cambiar.

Se las puede declarar de dos formas:

Tomemos como ejemplo la fórmula para hallar el área de un triángulo:

¿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 ahí. Entonces si queremos declarar al “2” como una
constante, podemos hacerlo de dos maneras:

1) Anteponiéndole” #define” al nombre de la constante y luego el valor que le corresponde, así:

#define nomb 2
( lo puse de color para que se entienda mejor )

Nota: al usar éste método no se le pone el delimitador ” ; ” al final de la línea.

A continuación coloco un ejemplo en código, para que tengan una idea de cómo sería:

#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) Anteponiéndole” const ” seguido del tipo de variable que és, después el nombre de la
constante y luego el valor que va a contener, así:

const int nomb = 2;

( lo puse de color para que se entienda mejor )

Nota: a diferencia del método anterior, éste si lleva el delimitador” ; ” al final de la línea.
A continuación coloco un ejemplo en código, para que tengan una idea de cómo sería:
#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 únicamente en su posición, así:

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 posición 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, así:
float * ventas ;

6.) Para estructuras:

las estructuras son una agrupación 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
expresión que estemos evaluando en ese momento y pueden ser:

– Las selectivas simples

– Las selectivas dobles
– Las selectivas múltiples

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 condición if , puede acceder

3.) Múltiples:
Podemos ejecutar diferentes acciones como resultado de una expresión que estemos
evaluando; ejemplo:
switch ( expresión a evaluar ) ——> Esta es la expresión que vamos a evaluar.
{
case 1 : accion 1 ;
case 2 : accion 2 ;
case 3 : accion 3 ;
}
– Instrucciones repetitivas –
Sirven para repetir una condición N veces, siempre y cuando la condición 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

– 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 librerías.

Por ejemplo:
En la libreria <iostream.h> tenemos para la entrada y salida de datos
a cin y coutrespectivamente.
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 printfrespectivamente.
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 tuviéramos 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 ahí acabaría 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!