Instituto Tecnológico Superior de Coatzacoalcos

Ingeniería en Mecatrónica

Integrantes:
• Alonso Pineda Jorge Ángel
• Acosta Leetch José Carlos
• Puig Pérez Carlos Sebastián
• Ramón Alegría Jonathan
• Torres Reyes Alberto
• Uscanga Mateos Luis Ángel

Actividad 1: Guía de consulta para C++

Nombre de la Asignatura: Periodo:

Programación Avanzada AGOSTO-DICIEMBRE 2019

Semestre: 7° Grupo: “C”

Nombre del Docente: Gómez Bernal Eugenio

Apellido Paterno Apellido Materno Nombre(s)

Coatzacoalcos, Ver. A. 08 de septiembre del 2019

 Instrucciones declarativas

Sirven para declarar librerías, variables, constantes, arreglos, punteros, estructuras…

Por ejemplo:

1.) Para librerias:

las librerias 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 algun 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 unicas 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” o 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.
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, asi:

#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 triángulo 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 método anterior, éste si lleva el delimitador “;” al final de la línea.
A continuación, se meuestra 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 triángulo es: “<< area <<endl;
system(“pause”);
}

4) Para arreglos:
los arreglos son un conjunto de variables del mismo tipo y nombre, pero indexadas por una
posición 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, asi:
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 asignación

Sirven para dar valores a las variables, y llevan este 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
opción 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 esta 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

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
REPORT THIS AD
{
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.

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

LOS TIPOS ELEMENTALES DEFINIDOS EN C++ SON:

char, short, int, long, que representan enteros de distintos tamaños (caracteres enteros
de 8 bits).

float, double y long double, que representan números reales (en coma flotante).

Para declarar variables de un tipo determinado se escribe el nombre del tipo, seguido de
la variable. Por ejemplo:

int i;
double d;
char c;

Sobre los tipos elementales se pueden emplear los siguientes operadores aritméticos:
+ Más
- Menos
* Multiplicación.
/ División.
& Resto.
Y los operadores relacionales:
== Igual.
!= Distinto.
< Menor que.
> Mayor que.
<= Menor o igual que.
>= Mayor o igual que.

El operador de asignación se representa por =.

También, se suelen considerar como tipos derivados los construidos mediante la

aplicación de un operador a un tipo elemental o compuesto en su declaración. Estos
operadores son:

* Puntero.
& Referencia.
[] Vector (Array).
() Función.

Los tipos compuestos son las estructuras (struct), las uniones y las clases (class).

ESTRUCTURA DE CONTROL.

Como estructuras de control el C++ incluye:

Condiciones:

if Instrucción de selección simple.

switch Instrucción de selección múltiple.

Bucles:
do-while Instrucción de iteración con condición final.

while Instrucción de iteración con condición inicial.

for Instrucción de iteración especial (similar a las de repetición con contador).

De salto:
break Instrucción de ruptura de secuencia (sale del bloque de un bucle o instrucción
condicional).

continue Instrucción de salto a la siguiente iteración (se emplea en bucles para saltar a
la posición donde se comprueban las condiciones).

goto Instrucción de salto incondicional (salta a una etiqueta).

return Instrucción de retorno de un valor (se emplea en las funciones)

Sintaxis del Condicional If en C++:
La sintaxis de un condicional if, es bastante simple e incluso creo que intuitiva. Vamos entonces
a ver rápidamente como es la estructura para ir luego a unos ejemplos y quedar bien claros.
Sintaxis del Condicional Switch en C++:
La sintaxis de un condicional Switch es bastante distinta a la de un condicional típico, sin embargo
es bastante intuitiva y fácil de comprender, es solo cuestión de acostumbrarse. Veamos a
continuación la estructura general de un condicional Switch y luego unos cuantos ejemplos.

Sintaxis del Ciclo For en C++:

La sintaxis de un ciclo for es simple en C++, en realidad en la mayoría de los lenguajes de alto
nivel es incluso muy similar, de hecho, con tan solo tener bien claros los 3 componentes del ciclo
for (inicio, final y tamaño de paso) tenemos prácticamente todo hecho
Sintaxis del Ciclo While en C++:
La sintaxis de un ciclo while es incluso más simple y "legible" que la del ciclo for en C++, pues
simplemente requerimos tener clara una condición de parada. En realidad, en la mayoría de los
lenguajes de alto nivel la manera de escribir un ciclo while (la sintaxis) es incluso muy similar, así
que con tan solo tener bien clara una condición de finalización para el ciclo tendremos
prácticamente todo hecho.

Sintaxis del Ciclo Do-While en C++:

La sintaxis de un ciclo do-while es un tanto más largo que la del ciclo while en C++, sin embargo
no se hace más complicado, de hecho con tan solo tener bien clara una condición de finalización
para el ciclo tendremos prácticamente todo terminado.