Está en la página 1de 23

Lenguaje de programación C++.

23/11/2020.
Equipo 3.

Contenido
Introducción.......................................................................................................................................3
1. Características del lenguaje de programación............................................................................3

Tecnológico
 Nacional de México Campus Cerro Azul.
Variables y Vectores...............................................................................................................3
 Condicionantes.......................................................................................................................4

Carrera:
Bucles.....................................................................................................................................4
 Ingeniería Civil.
Funciones...............................................................................................................................4
 Sintaxis...................................................................................................................................4
Materia:
2. Estructura básica de un programa..............................................................................................4
1. Software Civil ea11
Estructura secuencial.............................................................................................................5
2. Estructura selectiva o de selección.........................................................................................5
Actividad:
3. Estructura de control cíclica o repetitiva................................................................................5
Investigación sobre Lenguaje de programación C++.
3. Traducción de un programa: compilación, enlace de un programa, errores en tiempo de
compilación........................................................................................................................................6
Docente:
1. COMPILACIÓN........................................................................................................................6
2. Claudia E. Blanco Villanueva
ENLACE DE UN PROGRAMA....................................................................................................6
4. Ejecución de un programa..........................................................................................................7
Integrantes del equipo 3:
Proceso de ejecución de un programa...........................................................................................7
5.
1. Luis Enrique del Ángel Cruz.
Tipos de datos............................................................................................................................7
N° de control: 20500025.
1. Tamaños asociados................................................................................................................8
2. Cindy Ruiz Sampayo.
2. Wchar_t..................................................................................................................................8
N° de control: 20500780.
3. La palabra reservada "void"...................................................................................................9
3. Luis Francisco Landeta Pérez.
4. La palabra "NULL"...................................................................................................................9
N° de control: 20500043.
6. Bifurcaciones............................................................................................................................10
4. Dipna Melissa Huerta del Ángel.
1. Bifurcación simple:...............................................................................................................10
N° de control: 20500786.
2. Bifurcación completa............................................................................................................11
3. Bifurcación múltiple.............................................................................................................12
Fecha: 23/11/2020.
7. INSTRUCIONES DE INTERACCIONES (CICLOS) BUCLES, REPETITIVAS........................................14
1. El Inicio del Ciclo...................................................................................................................14
Cuando se recorre un arreglo, es necesario mover el índice que indica la posición en la que
estamos en un momento dado (índice++). En algún punto (en el avance o en el cuerpo) debe
haber una instrucción que cambie el valor de la condición para que finalmente ésta sea falsa y

1
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
se detenga así la ejecución de la instrucción iterativa. Si esto no sucede, el programa se quedará
en un ciclo infinito........................................................................................................................14
2. Bucle.....................................................................................................................................15
3. Componentes de una Instrucción Repetitiva........................................................................16
8. Entrada y Salida estándar en C++.............................................................................................17
1. Salidas con cout....................................................................................................................17
2. Formateo de salidas con funciones de flujos........................................................................18
3. Entrada con cin.....................................................................................................................20
4. Entrada y Salida de caracteres..............................................................................................20
Bibliografía.......................................................................................................................................21

2
Lenguaje de programación C++.
23/11/2020.
Equipo 3.

Introducción.
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención de su
creación fue extender al lenguaje de programación C mecanismos que permiten la manipulación
de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, C++ es
un lenguaje híbrido.

Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los


paradigmas de programación estructurada y programación orientada a objetos. Por esto se suele
decir que el C++ es un lenguaje de programación multiparadigma.

Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los
fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como
ROOT.

El nombre "C++" fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado
por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases".
En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de
C.

1. Características del lenguaje de programación


Un lenguaje de programación es un idioma artificial diseñado para expresar procesos que pueden
ser llevadas a cabo por máquinas como las computadoras. Está formado por un conjunto de
símbolos y reglas sintácticas y semánticas que definen su estructura y el significado de sus
elementos y expresiones. Al proceso por el cual se escribe, se prueba, se depura, se compila y se
mantiene el Código fuente de un programa informático se le llama programación.

Los elementos que caracterizan el lenguaje de programación son:

Variables y Vectores
Podrían calificarse como contenedores de datos y por ello se diferencian según el tipo de dato que
son capaces de almacenar. En la mayoría de los lenguajes de programación se requiere especificar
un tipo de variable concreto para guardar un dato concreto. Los más comunes son:

 Variables tipo Char: Estas variables contienen un único carácter, es decir, una letra, un
signo o un número.
 Variables tipo Int: Contienen un número entero.
 Variables tipo float: Contienen un número decimal.
 Variables tipo String: Contienen cadenas de texto, o lo que es lo mismo, es un vector con
varias variables del tipo Char.

3
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
 Variables del tipo Boolean: Solo pueden contener un 0 o un 1. El cero es considerado para
muchos lenguajes como la variable del tipo String "False" mientras que el 1 se considera
"True".

Condicionantes
Son estructuras de código que indican que para que cierta parte del programa se ejecute, deben
cumplirse ciertas premisas, como, por ejemplo, que dos valores sean iguales, que un valor exista,
que un valor sea mayor que otro y similares. Estos condicionantes por lo general solo se ejecutan
una vez a lo largo del programa. Los condicionantes más conocidos y empleados en programación
son:

 If: Indica una condición para que se ejecute una parte del programa.
 Else If: Siempre va precedido de un "If" e indica una condición para que se ejecute una
parte del programa siempre que no cumpla la condición del if previo y si se cumpla con la
que el "Else If" especifique.
 Else: Siempre precedido de "If" y en ocasiones de "Else If". Indica que debe ejecutarse
cuando no se cumplan las condiciones previas.

Bucles
Los bucles son parientes cercanos de los condicionantes, pero ejecutan constantemente un código
mientras se cumpla una determinada condición. Los más frecuentes son:

 For: Ejecuta un código mientras una variable se encuentre entre 2 determinados


parámetros.
 While: Ejecuta un código mientras se cumpla la condición que solicita.

Funciones
Se crearon para evitar tener que repetir constantemente fragmentos de código. Una función
podría considerarse como una variable que encierra código dentro de sí.

Sintaxis
La sintaxis de un lenguaje de programación describe las combinaciones posibles de los símbolos
que forman un programa sintácticamente correcto. El significado que se le da a una combinación
de símbolos es manejado por su semántica (ya sea formal o como parte del código duro de la
referencia de implementación). Dado que la mayoría de los lenguajes son textuales, este artículo
trata de la sintaxis textual.

4
Lenguaje de programación C++.
23/11/2020.
Equipo 3.

2. Estructura básica de un programa.

Las partes principales de un programa están relacionadas con dos bloques: declaraciones e
instrucciones.

En las instrucciones podemos diferenciar tres partes fundamentales

Entrada de Datos:
La constituyen todas las instrucciones que toman los datos de entrada desde un dispositivo
externo y los almacena en la memoria principal para que puedan ser procesados.

Proceso o algoritmo:
Está formado por las instrucciones que modifican los objetos a partir de su estado inicial (datos de
entrada) hasta el estado final (resultados) dejando los objetos que lo contiene disponibles en la
memoria principal.

Salida de resultados:
Conjunto de instrucciones que toman los datos finales (resultado) de la memoria principal y los
envían a los dispositivos externos.

El teorema de Böhm y Jacopini (1966) dice que un programa propio puede ser escrito utilizando
sólo tres tipos de estructuras de control:

1. Estructura secuencial
Una estructura de programa es secuencial si las instrucciones se ejecutan una tras otra, a modo de
secuencia lineal, es decir que una instrucción no se ejecuta hasta que finaliza la anterior, ni se
bifurca el flujo del programa.

2. Estructura selectiva o de selección


La estructura selectiva permite que la ejecución del programa se bifurque a una instrucción (o
conjunto) u otra/s, según un criterio o condición lógica establecida, sólo uno de los caminos en la
bifurcación será el tomado para ejecutarse.

Estructura de control selectiva simple


Estructura de control selectiva doble
Estructura de control selectiva múltiple

5
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
3. Estructura de control cíclica o repetitiva
 Estructura de control desde
 Estructura de control mientras

para estas estructuras son necesarios los operadores lógicos y de relación.


Operadores de relación. Operadores lógicos
Mayor a > Y (and) &
Menor a < O (or) |
Mayor igual a >= No (not) ~
Menor igual a <=
Exclusivo o xor
Diferente a ~= (or)

Con el uso de los operadores de relación se construyen las condiciones simples y con el uso de los
operadores de relación y lógicos se construyen las condiciones compuestas.

Anidamiento
El cuerpo de cualquier estructura puede ser instrucciones simples u otras estructuras, que a su vez
pueden contener a otras.

3. Traducción de un programa: compilación, enlace de un


programa, errores en tiempo de compilación.

1. COMPILACIÓN
Un compilador es un programa informático que traduce un programa escrito en un lenguaje de
programación a otro lenguaje de programación, generando un programa equivalente que la
máquina será capaz de interpretar. Usualmente el segundo lenguaje es lenguaje de la máquina,
pero también puede ser un código intermedio, o simplemente texto. Este proceso de traducción
se conoce como compilación.

Un programador puede diseñar un programa en un lenguaje mucho más cercano a cómo piensa
un ser humano, para luego compilarlo a un programa más manejable por una computadora.

2. ENLACE DE UN PROGRAMA
la creación de un programa ejecutable conlleva dos pasos. El primer paso se llama compilación
(propiamente dicho) y traduce el código fuente escrito en un lenguaje de programación
almacenado en un archivo a código en bajo nivel (normalmente en código objeto, no directamente
a lenguaje máquina). El segundo paso se llama enlazado en el cual se enlaza el código de bajo nivel

6
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
generado de todos los ficheros y subprogramas que se han mandado compilar y se añade el código
de las funciones que hay en las bibliotecas del compilador para que el ejecutable pueda
comunicarse directamente con el sistema operativo, traduciendo así finalmente el código objeto a
código máquina, y generando un módulo ejecutable.

4. Ejecución de un programa.
A un programa en ejecución se le suele llamar también proceso.

El proceso de ejecución de un programa escrito en un lenguaje de programación y mediante un


compilador tiene los siguientes pasos:

 Escritura del programa fuente con un editor (programa que permite a una computadora
actuar de modo similar a una máquina de escribir electrónica) y guardarlo en un
dispositivo de almacenamiento.
 Introducir el programa fuente en memoria.
 Compilar el programa con el compilador.
 Verificar y corregir errores de compilación.
 Obtención del programa objeto
 El enlazador (linker) obtiene el programa ejecutable.
 Se ejecuta el programa y, si no existen errores, se tendrá la salida del programa.

Y, el proceso de ejecución se ilustra en la siguiente imagen:

Proceso de ejecución de un programa


Se denomina tiempo de ejecución (run time en inglés) al intervalo de tiempo en el que un
programa de computadora se ejecuta en un sistema operativo. Este tiempo se inicia con la puesta
en memoria principal del programa, por lo que el sistema operativo comienza a ejecutar sus
instrucciones. El intervalo finaliza en el momento en que éste envía al sistema operativo la señal
de terminación, sea ésta una terminación normal, en que el programa tuvo la posibilidad de
concluir sus instrucciones satisfactoriamente, o una terminación anormal, en el que el programa
produjo algún error y el sistema debió forzar su finalización.

Este término suele emplearse, en oposición a tiempo de compilación, para indicar si una acción o
hecho sucede en uno u otro tiempo.

7
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
5. Tipos de datos
C++ tiene los siguientes tipos fundamentales:

 Caracteres: Char (también es un entero), wchar_t

 Enteros: short, Int, Long, Long

 Números en coma flotante: float, double, Long double

 Booleanos: bool

 Vacío: void

El modificador unsigned se puede aplicar a


enteros para obtener números sin signo (por
omisión los enteros contienen signo), con lo que Tamaños de tipos primitivos bajo i386
se consigue un rango mayor de números (GCC)
naturales.
Tipo Número de bits
1. Tamaños asociados
Según la máquina y el compilador que se utilice Char 8
los tipos primitivos pueden ocupar un
determinado tamaño en memoria. La siguiente short 16
lista ilustra el número de bits que ocupan los
Int 32
distintos tipos primitivos en la arquitectura x86.

Otras arquitecturas pueden requerir distintos float 32


tamaños de tipos de datos primitivos. C++ no dice
nada acerca de cuál es el número de bits en un double 64
byte, ni del tamaño de estos tipos; más bien,
ofrece solamente las siguientes "garantías de
tipos":

 De acuerdo con el estándar c99, un tipo Char debe ocupar exactamente


un byte compuesto de un mínimo de 8 bits independientemente de la arquitectura de la
máquina.

 El tamaño reconocido de Char es de 1. Es decir, sizeof (Char) siempre devuelve 1.

 Un tipo short tiene al menos el mismo tamaño que un tipo Char.

 Un tipo Long tiene al menos el doble tamaño en bytes que un tipo short.

 Un tipo Int tiene un tamaño entre el de short y el de Long, ambos inclusive,


preferentemente el tamaño de un apuntador de memoria de la máquina. Su valor máximo
es 2147483647, usando 32 bits.

 Un tipo unsigned tiene el mismo tamaño que su versión signed.

8
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
2. Wchar_t.
Para la versión del estándar que se publicó en 1998, se decidió añadir el tipo de dato wchar_t, que
permite el uso de caracteres UNICODE, a diferencia del tradicional Char, que contempla
simplemente al código de caracteres ASCII extendido. A su vez, se ha definido para la mayoría de
las funciones y clases, tanto de C como de C++, una versión para trabajar con wchar_t, donde
usualmente se prefija el carácter w al nombre de la función (en ocasiones el carácter es un infijo).
Por ejemplo:

 strcpy - strcpy

 STD: String - STD: wstring

 STD: cout - STD: wcout

Cabe resaltar que en C se define wchar_t como:

typedef unsigned short wchar_t;

Mientras que en C++ es en sí mismo un tipo de dato.

3. La palabra reservada "void"


La palabra reservada void define en C++ el concepto de no existencia o no atribución de un tipo en
una variable o declaración. Es decir, una función declarada como void no devolverá ningún valor.
Esta palabra reservada también puede usarse para indicar que una función no recibe parámetros,
como en la siguiente declaración:

 Int función (void);

Aunque la tendencia actual es la de no colocar la palabra "void".

Además, se utiliza para determinar que una función no retorna un valor, como en:

 void función (Int parámetro);

Cabe destacar que void no es un tipo. Una función como la declarada anteriormente no puede
retornar un valor por medio de return: la palabra clave va sola. No es posible una declaración del
tipo:

 void t; //Está mal

En este sentido, void se comporta de forma ligeramente diferente a como lo hace en C,


especialmente en cuanto a su significado en declaraciones y prototipos de funciones.

Sin embargo, la forma especial void * indica que el tipo de datos es un puntero. Por ejemplo:

 void *memoria;

Indica que memoria es un puntero a alguna parte, donde se guarda información de algún tipo.
El programador es responsable de definir estos "algún", eliminando toda ambigüedad. Una ventaja
de la declaración "void *" es que puede representar a la vez varios tipos de datos, dependiendo de
la operación de “cast” escogida. La memoria que hemos apuntado en alguna parte, en el ejemplo

9
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
anterior, bien podría almacenar un entero, un flotante, una cadena de texto o un programa, o
combinaciones de estos. Es responsabilidad del programador recordar qué tipo de datos hay y
garantizar el acceso adecuado.

4. La palabra "NULL"
Además de los valores que pueden tomar los tipos anteriormente mencionados, existe un valor
llamado NULL, sea el caso numérico para los enteros, carácter para el tipo Char, cadena de texto
para el tipo String, etc. El valor NULL, expresa, por lo regular, la representación de una Macro,
asignada al valor "0".

Tenemos entonces que:

 void* puntero = NULL;


 Int entero = NULL;
 bool boleana = NULL;
 Char caracter = NULL;

El valor de las variables anteriores nos daría 0. A diferencia de la variable "caracter", que nos daría
el equivalente a NULL, '\0', para caracteres.

6. Bifurcaciones
Llega un momento en que necesitamos hacer una bifurcación condicional: si se cumple una
condición hacer una cosa, si no se cumple hacer otra. Para ello colocaremos las llamadas
"bifurcaciones", que las hay de tres tipos:

1. Bifurcación simple: Se trata de ejecutar unos comandos en caso de que se cumpla una
condición o nada en caso contrario. Lo cual viene expresado mediante el llamado
"diagrama de flujo" así:

10
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
Es decir, el orden de ejecución del programa que viene de arriba hacia abajo, al llegar a condición,
la evalúa y si la condición resulta verdadera pasa a ejecutar comandos, mientras que si resulta
falsa se salta ese conjunto de comandos y sigue ejecutando los demás hacia abajo.

La estructura del Matlab para la bifurcación condicional simple es la siguiente:

If,
end;

Un ejemplo muy simple es el siguiente:

Si x > y queremos imprimir en pantalla el valor de x, pero en caso de no ser x > y no nos
interesa sacarlo en pantalla sino continuar con el programa normalmente.

Esto lo podríamos hacer con una bifurcación simple así:

El "If" abre la bifurcación y el "end" la finaliza, en su interior se hallan encerradas uno o varios
comandos que sólo se ejecutarán si la condición es verdadera.

2. Bifurcación completa: Otro caso es ejecutar unos comandos en caso de que se cumpla
una condición u otros comandos en caso contrario. Lo cual viene expresado por "diagrama
de flujo" así:

11
Lenguaje de programación C++.
23/11/2020.
Equipo 3.

Es decir, el orden de ejecución del programa que viene de arriba hacia abajo, al llegar a condición,
la evalúa y si la condición resulta verdadera pasa a ejecutar comandos (1), mientras que si resulta
falsa ejecuta el bloque de comandos(2), a continuación continúa el programa en orden
descendente.

La estructura del Matlab para la bifurcación completa es la siguiente:

 If (condición)
 Else comandos (1);
 end comandos (2);

Un ejemplo muy simple es el siguiente:

Si x > y queremos imprimir en pantalla el valor de x e imprimir una frase que lo indique,
pero en caso de no ser x > y (entonces y será mayor o igual a x) queremos sacar en
pantalla el valor de y e indicarlo con un mensaje.

Esto lo podríamos hacer con una bifurcación simple así:

Entre el "If" que abre la bifurcación y el "end" que la cierra, tenemos la condición (que viene tras el
"If"), el bloque de sentencias a ejecutarse si se cumple la condición, a continuación, el "Else", y tras
él viene el bloque de sentencias a ejecutarse en caso de no cumplirse la condición.

3. Bifurcación múltiple: Un tercer caso es el de ejecutar unos comandos en caso de que


se cumpla una condición (1) o ejecutar otros en caso de cumplir una condición2 ... etc.
finalmente ejecutar otros en caso de fallar las dos (o más) condiciones anteriores. Lo cual
viene expresado mediante el "diagrama de flujo" así:

12
Lenguaje de programación C++.
23/11/2020.
Equipo 3.

En este caso se pueden poner no sólo dos condiciones, sino más de dos (aunque con más de tres
el código de programa se oscurece demasiado). Fijarse cómo el bloque de comandos (3) se ejecuta
cuando fallan todas las condiciones, que por cierto podrían ser más de dos.

La estructura del Matlab para la bifurcación condicional múltiple es la siguiente:

If (condición1) comandos (1);


ElseIf (condición2) comandos (2);
Else comandos (3);
end;

Un ejemplo muy simple es el siguiente:

 Si x > y queremos imprimir en pantalla el valor de x e imprimir una frase que lo indique; en
caso de ser y > x queremos sacar en pantalla el valor de y e indicarlo con un mensaje;
finalmente si no se dan ninguna de las dos condiciones entonces sacaremos en pantalla
que "x es igual a y". Esto lo podríamos hacer con una bifurcación simple así:

13
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
Operadores relacionales

Para expresar la condición de arriba deben ser unidas dos expresiones con un operador
relacional en medio, de tal manera que el resultado sea verdadero o falso. Los operadores
relacionales que utiliza Matlab son los siguientes:

* > "mayor que"

* >= "mayor o igual que"

* < "menor que"

* <= "menor o igual que"

* = = “igual que” (Atención: se trata del doble =)

* >= "mayor o igual que"

* ~= "distinto que"

Operadores lógicos

Por otra parte, para expresar la condición de arriba, además de los operadores relacionales
indicados, utilizamos también operadores lógicos tales como el "and", "or" y "not", los cuales en
Matlab se expresan así:

* & equivale a "and".

* | equivale a "or".

* ~ equivale a "not".

De esta manera pueden ser expresadas condiciones complicadas tales como:

A >= B & B ~= C ("A mayor que B y B distinto de C")

(A+B) <= (C-D) | (E+F) >= (G/H) ("A+B menor o igual que C-D y E+F mayor o igual que G/H").

7. INSTRUCIONES DE INTERACCIONES (CICLOS)


BUCLES, REPETITIVAS.

1. El Inicio del Ciclo


El objetivo de las instrucciones de inicio o preparación del ciclo es asegurarnos de que vamos a
empezar el proceso repetitivo con las variables de trabajo en los valores correctos. En nuestro

14
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
caso, una variable de trabajo la utilizamos como índice para movernos por el arreglo y la otra para
acumular la suma de las notas:

La suma antes de empezar el ciclo debe ser cero: double suma = 0.0;

El índice a partir del cual vamos a iterar debe ser cero:int índice = 0;

El cuerpo del ciclo contiene las instrucciones que se van a repetir en cada iteración. Estas
instrucciones indican:

La manera de modificar algunas de las variables de trabajo para ir acercándose a la solución del
problema. Por ejemplo, si el problema es encontrar la suma de las notas de todos los estudiantes
del curso, con la instrucción suma += notas [índice] agregamos un nuevo valor al acumulado.

La manera de modificar los elementos del arreglo, a medida que el índice pasa por cada casilla. Por
ejemplo, si queremos sumar una décima a todas las notas, lo hacemos con la instrucción notas
[índice] += 0.1.

Cuando se recorre un arreglo, es necesario mover el índice que indica la posición en la que
estamos en un momento dado (índice++). En algún punto (en el avance o en el cuerpo) debe
haber una instrucción que cambie el valor de la condición para que finalmente ésta sea falsa y se
detenga así la ejecución de la instrucción iterativa. Si esto no sucede, el programa se quedará en
un ciclo infinito.

2. Bucle
Un bucle es una estructura de programación que permite la repetición controlada de un conjunto
de instrucciones. Este tipo de estructuras, y en particular las instrucciones For y While, son
utilizadas de forma generalizada en la inmensa mayoría de lenguajes de programación, lo cual
hace interesante su estudio. Sin embargo, en muchos casos los bucles pueden (y deben) evitarse
en Octave, ya que hay estructuras típicas de este lenguaje más eficaces que los propios bucles. No
obstante, s ́ı que existen ocasiones en las que es necesario el uso de bucles, por lo que
estudiaremos estas instrucciones con detalle en esta unidad.

Los bucles For se utilizan cuando nos interesa repetir un bloque de instrucciones un numero
predeterminado de veces. La estructura general del bucle For es la siguiente1: fori=vector
instrucciones en del conjunto de instrucciones se repite para cada elemento de vector,
denominándose iteración cada una de estas repeticiones. En cada iteración, toma ordenadamente
el valor de cada elemento de vector. Al igual que ocurra con las instrucciones, resulta conveniente
realizar un sangrado de línea en las instrucciones del interior del bucle. Veamos un ejemplo
sencillo:

For i = [1:5]j = 2*i; disp.(j)end246810


En este ejemplo, observamos como el valor de i toma en cada iteración, y de forma ordenada, los
valores del vector [1 2 3 4 5], y dichos valores se utilizan para realizar cálculos en el interior del

15
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
bucle. El operador’:’ para la creación ́ de listas es ampliamente utilizado en los bucles For. En este
caso, los bucles tendrán la siguiente forma particular: fork= [inicial: incremento: final]
instrucciones en da un que los corchetes no son realmente necesarios. Por ejemplo, supongamos
que queremos calcular los cuadrados de los primeros 5 números impares. Podríamos hacerlo
utilizando una instrucción F́ or.

3. Componentes de una Instrucción Repetitiva


La manera en que se ejecuta una instrucción repetitiva. Primero, y por una sola vez, se ejecutan las
instrucciones que vamos a llamar de inicio o preparación del ciclo. Allí se le da el valor inicial al
índice y a las variables en las que queremos acumular los valores durante el recorrido. Luego, se
evalúa la condición del ciclo. Si es falsa, se ejecutan las instrucciones que se encuentran después
del ciclo. Si es verdadera, se ejecutan las instrucciones del cuerpo del ciclo para finalmente repetir
el mismo proceso. Cada repetición, que incluye la evaluación de la condición y la ejecución del
cuerpo del ciclo, recibe el nombre de iteración o bucle.

Una instrucción repetitiva con la instrucción While se escribe de la siguiente manera:

<inicio>
While(<condición>)
{<cuerpo>
<avance>}

 Las instrucciones de preparación del ciclo van antes de la instrucción repetitiva.

16
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
 La condición que establece si se debe repetir de nuevo el ciclo va siempre entre
paréntesis.
 El avance del ciclo es una parte opcional, en la cual se modifican los valores de algunos de
los elementos que controlan la salida del ciclo (avanzar el índice con el que se recorre un
arreglo sería parte de esta sección).

Una instrucción repetitiva con la instrucción For escribe de la siguiente manera: se

<inicio1>
For(<inicio2>; <condición>; <avance>)
{<cuerpo>}

 El inicio va separado en dos partes: en la primera, va la declaración y la inicialización de las


variables que van a ser utilizadas después de terminado el ciclo (la variable suma, por
ejemplo, en el método del promedio). En la segunda parte de la zona de inicio van las
variables que serán utilizadas únicamente dentro de la instrucción repetitiva (la variable
índice, por ejemplo, que sólo sirve para desplazarse recorriendo las casillas del arreglo).
 La segunda parte del inicio, lo mismo que el avance del ciclo, se escriben en el encabezado
de la instrucción For.

8. Entrada y Salida estándar en C++

Un programa en C++ puede realizar operaciones de entrada y salida de varias formas distintas. A
continuación describiremos lo que se conoce como flujos. Un flujo de entrada no es más que la
serie de entradas que alimentan un ordenador para que el programa las utilice. En esta sección
supondremos que la entrada proviene del teclado. Asimismo, un flujo de salida es la serie de
salidas que el programa genera. En esta sección supondremos que las salidas se envían a la
pantalla de un terminal.

1. Salidas con cout


Los valores de variables se pueden enviar a la pantalla empleando cout. Es posible enviar a la
pantalla cualquier combinación de variables y cadenas. Por ejemplo:

 cout << num_dulces << “dulces\n”;

Esta instrucción le dice a la computadora que despliegue dos cosas: el valor de la variable
num_dulces y la cadena “dulces\n”. Esta instrucción es equivalente a:

 cout << num_dulces ;


 cout << “dulces\n”;

Se pueden incluir expresiones aritméticas, como se muestra en el siguiente ejemplo:

17
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
 cout << “El precio total es: “ << (precio1 + precio2);

El doble símbolo << se conoce como operador de inserción.

En los ejemplos anteriores hemos utilizado una secuencia de carácteres especial ‘\n’.

Esta secuencia indica al ordenador que salte a una nueva línea en la salida.

Existen otras secuencias especiales. Todas ellas empiezan con ‘\’ y se les llama secuencias de
escape. No deben aparecer espacios entre ‘\’ y el carácter.

Algunas secuencias de escape:

 \n nueva línea
 \t tabulación horizontal.
 \\diagonal invertida
 \” comillas dobles

Ejemplo:

// Envia una línea en blanco a la salida estándar //(pantalla)

cout << “\n”;

Otra forma de enviar un salto de línea es la utilización de endl.

// Envia una línea en blanco a la salida estándar (pantalla) cout << endl;

2. Formateo de salidas con funciones de flujos

La organización de la salida de un programa en C++ es su formato. En C++ podemos controlar el


formato con órdenes que determinan detalles tales como el número de espacios entre los
elementos y el número de dígitos después del punto decimal Veamos algunas funciones o
métodos asociadas a los flujos de salida:

• precisión: Fijar el número de cifras después de la coma: precisión

cout. precisión (2);

18
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
• width: Indica al flujo cuantos espacios debe usar al enviar un elemento a la salida.

cout. Width (4);

El método width solamente afecta a la siguiente salida por pantalla.

• fill: Indica el carácter con lo que completa los espacios en blanco cuando se manda un
elemento a la salida y se fija el número de espacios con la función width.

cout. Fill(‘a’);

Al igual que el método width, el método fill solamente afecta a la siguiente salida por pantalla.

• setf: es una abreviatura de set flags, que significa establecer banderas. Una bandera es
algo que indica que se debe efectuar algo de una de dos posibles maneras. Si damos una
determinada bandera como argumento de setf, dicha bandera le dirá a la computadora que
escriba las salidas en ese flujo de alguna forma específica. El efecto sobre el flujo depende de la
bandera.

Banderas:

 ios:fixed : hace que el flujo envíe a la salida los número en formato de punto fijo (no
notación e).
 ios::showpoint : le dice al flujo que siempre incluya un punto decimal en los números en
punto flotante.
 ios::showpos : le dice al flujo que escribe un signo + para los números positivos.
 ios::left: si esta bandera está establecida y se da algún valor de anchura de campo con una
llamada a la función miembro width, el siguiente número que se despliegue estará en el
extremo derecho del espacio especificado con width.
 ios::rigth: igual que la bandera anterior pero a la derecha.

cout.setf(ios::fixed);

cout.setf(ios::showpos);

cout.setf(ios::showpoint);

cout.setf(ios::left);

cout.setf(ios::right);

19
Lenguaje de programación C++.
23/11/2020.
Equipo 3.

• unsetf: Cualquier bandera establecida se puede desactivar con esta función miembro. Por
ejemplo:

cout.unsetf(ios::showpos);

Nota: una vez establecida una bandera o valor se mantiene en todo el programa a no ser que se
utilice la función miembro unsetf o se varíe el valor con el método adecuado.

3. Entrada con cin

Cin es el flujo de entrada estándar. Supondremos que la entrada estándar es el teclado.

Veamos un ejemplo:

 cin >> num_pasteles;

En la sentencia anterior lo que hacemos es leer un dato introducido por teclado y almacenarlo en
una variable ‘num_pasteles’.

4. Entrada y Salida de caracteres

Todos los datos se envían como caracteres. Cuando un programa envía a la salida el número 10, en
realidad lo que envía son los dos caracteres ‘1’ y ‘0’. Qué la computadora interprete el número 10
o los caracteres ‘1’ y ‘0’ depende del programa.

C++ ofrece algunos recursos para la entrada y salida de datos de caracteres.

Funciones miembro o métodos:

• get: permite a un programa leer un carácter de entrada y guardarlo en una variable de tip
char. Está función toma un argumento, que debe ser una variable de tipo char. Por ejemplo:

 char siguiente_simbolo;

 cin.get(siguiente_simbolo);

Comparación de cin >> y cin.get:

20
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
o char c1,c2,c3,c4,c5;
o //Introduce 4 caracteres en 2 lineas diferentes
o cin.get(c1);
o cin.get(c2);
o cin.get(c3);
o cin.get(c4);
o //Imprimo los caracteres leidos
o cout << "Los 4 caracteres leidos son:\n";
o cout.put(c1);
o cout.put(c2);
o cout.put(c3);
o cout.put(c4);

Con cin >>:

o //Prueba con cin


o Char c1, c2, c3, c4;
o //Introduce 4 caracteres separados por espacios
o cin >> c1;
o cin >> c2;
o cin >> c3;
o cin >> c4;
o cout << "Los 4 caracteres leídos son:\n";
o cout << c1 << c2 << c3 << c4;

La diferencia consiste en que el primero lee los espacios y ‘\n’ y los almacena en las variables y el
segundo ignora estos caracteres y los utiliza como caracteres separadores.

• put: es análoga a la función miembro get sólo que se emplea para salida. Mediante put un
programa puede enviar a la salida un carácter. La función miembro put recibe un argumento que
debe ser una expresión de tipo char (constante o variable). Por ejemplo:

o char ch;
o ch=’a’;
o cout.put(ch);

• ignore: este método permite descartar caracteres existentes en el buffer de entrada.

o char ch1,ch2;

21
Lenguaje de programación C++.
23/11/2020.
Equipo 3.
o cout << “ Introduce 2 caracteres en líneas diferentes:\n”;
o cin.get(ch1);
o cin.ignore(); //Ignora ‘\n’
o cin.get(ch2);
o cin.ignore(); // Ignora ‘\n’
o cout << “Los caracteres leídos son:\n”;
o cout.put(ch1);
o cout.put(‘ ‘); //Escribo un espacio de separacion cout.put(ch2);

Bibliografía
https://sites.google.com/site/algopromecanica/unidad-iii/3-1-caracteristicas-del-lenguaje-de-
programacion
http://es.wikipedia.org/wiki/Programaci%C3%B3n_estructurada

http://es.wikipedia.org/wiki/Compilador 

http://www.bloginformatico.com/la-compilacion-y-sus-fases-o-etapas.php

http://es.wikipedia.org/wiki/Tiempo_de_ejecuci%C3%B3n

https://es.wikipedia.org/wiki/C%2B%2B#Tipos_de_datos

http://www.ehu.eus/juancarlos.gorostizaga/mn11b/programacion/condicional.htm

https://universidad-de-los-andes.gitbooks.io/fundamentos-de-
programacion/content/Nivel3/5_InstruccionesRepetitivas.html

http://courseware.url.edu.gt/Facultades/Facultad%20de%20Ingenier%C3%ADa/Ingenier%C3%ADa
%20en%20Inform%C3%A1tica%20y%20Sistemas/Segundo%20Ciclo%202011/Introducci%C3%B3n
%20a%20la%20Programaci%C3%B3n/Objetos%20de%20aprendizaje/Unidad%203B/Unidad
%203B/qu_es_una_estructura_repetitiva.html

http://repositori.uji.es/xmlui/bitstream/handle/10234/5961/5_Bucles.pdf?
sequence=1&isAllowed=y

https://www.programarya.com/Cursos/C++/Entrada-y-Salida-de-Datos

https://geekelectronica.com/entrada-y-salida-de-datos-en-c-cin-y-cout/

22