Manual Del Lenguaje C++

Índice de Contenido
CAPITULO 1. Introducción al lenguaje C++ ...................................................................................................4
1. ¿Qué es un lenguaje de programación? ............................................................................................4
2. Herramientas necesarias para la programación ................................................................................5
3. ¿Qué es C++? ........................................................................................................................................5
3.1 Code: :Blocks ......................................................................................................................................6
3.2 Instalación ..........................................................................................................................................7
3.4 Compilar un programa .....................................................................................................................7
CAPITULO 2. Estructura de un programa ................................................................................................... 13
1. Partes de un programa ...................................................................................................................... 13
2. Comentarios ........................................................................................................................................ 16
CAPITULO 3. Tipos y Variables ..................................................................................................................... 17
1. Identificadores .................................................................................................................................... 17
2. Tipos de datos fundamentales ......................................................................................................... 18
3. Declaración de variables.................................................................................................................... 21
4. Constantes........................................................................................................................................... 22
5. Inicialización de variables ...................................................................... Error! Bookmark not defined.
6. Caracteres................................................................................................ Error! Bookmark not defined.
7. Demostración de datos ......................................................................... Error! Bookmark not defined.
8. Caracteres especiales ............................................................................. Error! Bookmark not defined.
9. Despliegue de números con formato .................................................. Error! Bookmark not defined.
10. Tipos de deducción: auto y decltype ............................................... Error! Bookmark not defined.
CAPITULO 4. Operadores.............................................................................................................................. 24
1. Operadores ............................................................................................. Error! Bookmark not defined.
2. Operador de asignación (=).............................................................................................................. 24
3. Convertir el tipo de datos...................................................................... Error! Bookmark not defined.

4. Operadores aritméticos (+, -, *, /, % ) ............................................................................................. 24
5. Operadores de asignación compleja (+=, -=,…) ............................................................................ 24
6. Incrementos y decrementos (++, --) ............................................................................................... 25
7. Operadores de relaciones y de comparación (==,!=, >, <, >=, <=) ........................................... 25
8. Operadores Lógicos ( !, &&, || ) ........................................................................................................ 26
9. Operador ternario condicional ( ? ).................................................................................................. 27
10. Operador de Coma ( , ) ..................................................................... Error! Bookmark not defined.
11. Operadores Bitwise ( &, |, ^, ~, <<, >> ) ........................................ Error! Bookmark not defined.
12. Sizeof ................................................................................................... Error! Bookmark not defined.
13. Otros operadores ............................................................................... Error! Bookmark not defined.
14. Operadores de precedencia ............................................................. Error! Bookmark not defined.
CAPITULO 5. Entrada y salida de datos ........................................................... Error! Bookmark not defined.
1. Salida de datos estándar (cout) ............................................................ Error! Bookmark not defined.
2. Entrada de datos estándar (cin)............................................................ Error! Bookmark not defined.
3. Cin y Cadenas ......................................................................................... Error! Bookmark not defined.
4. Stringstream ............................................................................................ Error! Bookmark not defined.
CAPITULO 6. Estructura de control .............................................................................................................. 27
1. Estructura secuencial.......................................................................................................................... 27
2. Estructuras de selección o condicional ................................................ Error! Bookmark not defined.
3. Estructura de selección (if) ................................................................................................................ 28
4. Estructura de selección (if else) ........................................................... Error! Bookmark not defined.
5. Estructura condicional múltiple ........................................................................................................ 29
6. Instrucción (switch) ............................................................................................................................. 30
7. Estructura iterativa o repetitiva ......................................................................................................... 32
8. Instrucción (While).............................................................................................................................. 32
9. Instrucción (do while) ......................................................................................................................... 33

10. Instrucción (for)............................................................................................................................... 34
11. Instrucción de Salto ............................................................................ Error! Bookmark not defined.
12. The break statement .......................................................................... Error! Bookmark not defined.
13. The continue statement ..................................................................... Error! Bookmark not defined.
14. The goto statement............................................................................ Error! Bookmark not defined.
CAPITULO 7. Strings o Cadenas ................................................................................................................... 44
1. Definición ............................................................................................................................................ 45
2. Uso de librerías ....................................................................................... Error! Bookmark not defined.
3. Caracteres............................................................................................................................................ 45
5. Convertir todo a minúscula y mayúscula ............................................ Error! Bookmark not defined.
CAPITULO 8. Arreglos .................................................................................................................................... 42
1. Vectores ................................................................................................... Error! Bookmark not defined.
2. Matrices ............................................................................................................................................... 43
CAPITULO 1. Introducción al lenguaje C++
Se dice programación a la implementación de un algoritmo en un lenguaje determinado de
programación, para diseñar un programa se requiere de un conocimiento previo del algoritmo.
Aprender programación no es solamente conocer un lenguaje de programación. También hay que

conocer metodologías para resolver problemas en forma eficiente.
¿Qué es un algoritmo?
Un algoritmo es un conjunto finito de instrucciones o secuencia no ambigua, son reglas establecidas

para resolver o solucionar un problema.
¿Qué es un programa?
(SOFTWARE en inglés) Es una secuencia de instrucciones que a través de un ordenador puede ser
ejecutada o interpretada, Cada programa tiene su propio código fuente, de cual se derivan
programas ejecutables (por ejemplo compilados), le facilita al programador estudiar y desarrollar sus
algoritmos.
Las computadoras solo ejecutan un conjunto de operaciones básicas muy rápidamente. Con este
conjunto básico es que se construyeron los programas que nos permiten posteriormente hacer
tareas más complejas, ejemplo las app’s para teléfonos móviles, programas que son implementados
para la automatización en las diferentes compañías o empresas.
1. ¿Qué es un lenguaje de programación?

Un lenguaje de programación es una herramienta útil que nos permite crear programas (software).
Entre ellos tenemos: C++, C#, Java, Delphi, Visual Basic, Pascal, etc. Un ordenador funciona bajo
control de un programa el cual debe estar almacenada en la memoria principal; tales como el disco
duro.
Los lenguajes de programación representan en forma simbólica, palabras claves, reglas sintácticas;
que son interpretadas por un programador. Cada lenguaje de programación utiliza compilador.
Un compilador es un programa informático que traduce un programa, es escrito en un lenguaje de

programación a otro lenguaje diferente. Usualmente el segundo lenguaje es lenguaje de máquina,
este proceso de traducción se conoce como compilación.
2. Herramientas necesarias para la programación
Para programar tanto en C, como en C++, java o cualquier otro lenguaje de programación,
necesitamos contar con aplicaciones o herramientas que nos permitan poner en funcionamiento
nuestro programa.
El lenguaje de programación C++ es compilado, así que en este caso necesitamos un compilador,
que será el encargado de transformar nuestro código fuente en código que la computadora pueda
ejecutar.
Las herramientas a instalar dependerán del sistema operativo utilizado. A continuación se listan
algunas posibilidades para el sistema operativo Windows o GNU/Linux, no es imprescindible utilizar
estas herramientas en particular, cualquier compilador puede servir.
2.1 Windows
Uno de los entornos de desarrollo más conocidos entre los programadores de C++ sobre Windows,
tanto novatos como expertos, es el codeblocks y Dev-C++. Ambos entornos pueden utilizarse tanto
para C como para C++. También hay otras alternativas como los compiladores de Borland o de
Microsoft (Microsoft Visual C++)
2.2 GNU/Linux
En los sistemas GNU/Linux, será necesario tener

instaladas las herramientas (gcc y make) y la versión 6
de la glibc con su documentación, que son las que
permitirán compilar los programas.
Para escribir y modificar el código, es posible utilizar

cualquier editor de texto plano. Bjarne Stroustrup
Nacido el 30 de diciembre de 1950 en Aarhus,
3. ¿Qué es C++? Dinamarca.
Es un científico de la computación y catedrático
C++ es un lenguaje híbrido orientado a objetos de ciencias de la Computación de la Universidad
A&M de Texas.
diseñado a mediados de los años 1980 por Bjarne Citado palabras del propio Stroustrup:
Stroustrup. Permite la ejecución de un mismo “Inventé C++, escribiendo sus primeras
definiciones, y produciendo la primera
programa en múltiples sistemas operativos, sin implementación… elegí y formulé los criterios de
diseño para C++, confeccioné también sus
necesidad de recompilar el código. Provee soporte
principales utilidades, y fui responsable de
para trabajo en red. Es fácil de utilizar. elaborar extensas proposiciones en el comité de
estándares de C++.”
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 intérpretes tales como ROOT.
El nombre C++ fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado
fuera del laboratorio científico.
¿Qué significa C++?
Antes se había usado el nombre “C con clases”. En C++, la expresión significa “Incremento de C” y
se refiere a que C++ es una extensión de C.
C++ es un lenguaje de programación compilada, esto por la siguiente característica:
Código Código Programa

fuente objeto ejecutable
.cpp .obs .exe
3.1 Code: :Blocks

Codeblocks compilador y entorno C/C++, es un IDE de programación para C y C++ muy potente y
amigable por su entorno gráfico, disponible para todas las plataformas y está licenciado bajo la
licencia pública general de GNU (Software libre). Basado en la idea de DEVC++ (otro compilador de
C) que estaba hecho en Delphi.
Codeblocks es compatible con otros compiladores es decir si se tiene uno anterior se puede
configurar sin problemas. También se puede descargar una versión que tiene compilador MinGW
variación del famoso GCC.
Si desean pueden descargarlo desde http://www.codeblocks.org/downloads/26

3.2 Instalación
La instalación es muy sencilla y rápida, el instalador
con minGW pesa 70 mb y la opción por defecto de la
instalación tiene lo necesario para comenzar a codear,
después de la instalación nos auto detectará los
compiladores, para el caso de la versión con minGW
nos detecta el GNU GCC. Fig (1.1)
Las opciones por default nos quedan perfecto, el

entorno gráfico es muy sencillo pero no simple, se
puede hacer todo tipo de proyecto incluso 3d con
opengl y hasta programar y viaje a marte
Figura 3.1: compiladores
3.4 Compilar un programa

El proceso de compilar un programa utilizando Codeblocks es sencillo. Hay que tener en
cuenta los conceptos que se explican a continuación:
1. Cuando se inicia por primera vez Codeblocks se presentará una pantalla de bienvenida que
provee información y ayuda para su uso. Para salir de esta pantalla se desmarca la vírgula
que está al lado de la etiqueta Show tips at startup. Esta pantalla aparecerá solo la primera
vez.
2. Después de haber cerrado las ventanas secundarias se obtiene el ambiente de trabajo
Esta pantalla tiene varias partes.
3. Para empezar a crear un
programa el primer paso es
crear un proyecto. Desde la
pestaña File-new-Project, ver fig.
(3.1), o directamente del enlace
Create a new project que se
muestra en la fig. (3.2) y
obtenemos la ventana new from
template ver fig. (3.3).
Figura 3.1: Abrir nuevo proyecto
Figura 3.2: Entorno de desarrollo de codeblocks
4. Dentro la ventana seleccionamos el icono Console aplication ver fig (1.4)

Figura 3.3: opciones para crear nuevas plantillas
5. Esta sección nos muestra los proyectos y programas que vamos creando, clic en next.
Figura 3.4: ventana de bienvenida

6. Seleccionamos C++ y clic next.
Figura 3.5: ventana para elegir el lenguaje que deseemos usar
7. En la siguiente ventana vamos a definir nombre de nuestro proyecto.

- En el cuadro de texto Project title ingresamos el título de nuestro proyecto en mi caso puse
“saludo”.
- En el siguiente cuadro de texto Folder to create project in, vamos a definir el directorio del
archivo en el cual se va a crear el proyecto.
- En los últimos dos cuadros de texto; Project filename y Resulting filename no hacemos
ninguna alteración.
Figura 3.6: ventana para nombrar nuestro proyecto

8. En esta ventana nos da la opción de elegir el compilador que tenemos instalado, en este
caso por defecto nos muestra el compilador que ya tenemos instalado, por lo tanto lo
dejamos tal como está, finalmente hacemos clic en finish
Figura 3.7: ventana para configurar compilador
Eso es todo en la parte de

creación de un proyecto,
el siguiente paso es
compilar hacer correr
nuestro programa.
9. En la parte izquierda de la
pantalla, en la pestaña
Projects, nos muestra el
proyecto que creamos de
nombre (Saludo).
Desplegamos del archivo
(sources), posteriormente doble clic en main.cpp, se nos abrirá el programa principal. Ver fig.
(3.8)
Figura 3.8: pantalla de main.cpp

10. En este paso vamos a compilar el programa, guía fig. (3.9).
 Clic en la figura dorada en forma de una rosca.
 Clic en la figura verde en forma de triángulo.
 Después de haber hecho todas las indicaciones, se abrirá una pantalla negra con un
mensaje “Hello world” ver fig. (3.10)
Figura 3.9: ventana de desarrollo
Cuando creamos un proyecto y un programa C++ obtenemos la siguiente estructura de

directorios:
 En el área de trabajo (workspace) una carpeta con el nombre del proyecto.

 En el interior de la carpeta con el nombre de proyecto una carpeta Sources.
 En la carpeta Sources el programa main.cpp.
CAPITULO 2. Estructura de un programa
Un programa, así como un algoritmo tiene una estructura, son casi idénticos solo que en el
programa intervienen librerías, funciones, y otras herramientas.
PROGRAMA Un programa puede considerarse como una secuencia de acciones

(instrucciones) que manipulan un conjunto de objetos (datos). Para ejecutar
Lenguaje un programa se requiere de un lenguaje de programación y un compilador
que pueda interpretar al lenguaje de la máquina. Los ejecutables son
COMPILADOR sistemas binarios cuyo contenido tiene la capacidad de poder ser
INTÉRPRETE
ejecutados de forma independiente. Para determinar un archivo ejecutable
algunos sistemas operativos se basan en la extensión (.exe).
EJECUTABLE
Dentro del bloque de instrucciones de un programa se pueden diferenciar tres partes

fundamentales (Entrada de datos, proceso (CPU) y salida de resultados o de información).
E S
N A
PROCESO
T L
R I
A D
D A
A
1. Partes de un programa
La mejor forma de aprender un lenguaje de programación es escribiendo programas. Típicamente, el
primer programa que los principiantes escriben es un programa designado “Hola Mundo", lo cual
simplemente imprime “Hola Mundo” en la pantalla de la computadora. Aunque es muy simple,
contiene todos los componentes fundamentales que los programas C + + tienen:
1 // Mi primer programa en C++ SALIDA:

2 #include<iostream> Hola Mundo!
3
4 using namespace std;
5 int main()
6 {
7 cout<<"Hola Mundo!";
8 return 0;
9 }
El panel izquierdo de arriba muestra el código C + + para este programa. El panel derecho muestra
el resultado cuando el programa es ejecutado por un ordenador. Los números de color negro a la
izquierda de los paneles son números de línea para facilitar la ubicación de las líneas de código y la
búsqueda de errores. ¡Ojo! No son parte del programa.
Examinemos cada línea del programa:
Línea 1: // Mi primer programa en C++
Estos slashs (//) indican que el resto de la línea es comentario insertado por el programador pero no tiene
efecto en el comportamiento del programa. Los programadores los usan para incluir cortos observaciones
o explicaciones cortas con referencia al código o programa. En este caso, son unas descripciones
introductorias breves del programa.
Línea 2: #include<iostream>
El signo hash (#) es conocido como el preprocesador. Son líneas especiales aclaradas antes de empezar
la compilación del programa. En este caso, la librería (#include <iostream>), instruye el preprocesador
para incluir una sección de código estándar C++, conocido como la cabecera iostream (input-output-
flow), esto permite realizar operaciones estándar de entrada y salida, tal como la escritura de la salida de
este programa (Hola Mundo). #include<nombre de fichero>
Línea 3: Una línea en blanco.
Las líneas en blanco no tienen efecto en un programa. Simplemente mejoran legibilidad del código.
Línea 4: using namespace std;
Esta línea hace referencia al recurso que utiliza los espacios y nombres, todos estos elementos declarados
pertenecen a la biblioteca estándar. Con la instrucción using namespace std estamos indicando que
vamos a usar este espacio de nombres.
Un espacio de nombres es básicamente es un conjunto de nombres de recursos (clases, métodos,
funciones, etc.) en el cual todos los nombres son únicos.
Esta línea se incluirá en la mayoría de programas que usaremos posteriormente.
Línea 5: int main()
Esta línea indica la declaración de una función. Esencialmente, una función es un grupo de códigos y
declaraciones que reciben un nombre: En este caso, esto le proporciona el nombre “main” que significa
principal. Aprenderemos con más detalle sobre las funciones en un posterior capítulo, pero
esencialmente, su definición es introducida con una sucesión de un tipo entero (int), un nombre (main) y
un par de paréntesis (()), incluyendo parámetros opcionales.
Línea 6 y
9: “{”y “}”llaves.
La llave abierta ({) en la línea 6 indica el comienzo de la función principal (main), y la llave de cierre (}) en
la línea 9, indica su fin. Todo el código dentro de las llaves es el cuerpo de la función y toda función usa
las llaves para indicar el comienzo y fin de sus definiciones.
Línea 7: cout<<"Hola Mundo!";
Esta línea muestra por pantalla ¡Hola mundo!
La declaración cout es un objeto que se declara en la librería iostream, es por eso que se debe incluir este
archivo (#include <iostream>) al principio del programa.
Esta declaración tiene tres partes:
Primera parte, cout, character output (salida de caracteres) que identifica el dispositivo.
Segunda parte, el operador de la inserción (<<), indica la salida de información.
Tercera parte, una frase dentro de las comillas (“Hola Mundo!”), Es el contenido insertado en la salida.
Observe que la declaración acaba con un punto y coma (;). Este carácter indica el fin de la instrucción.
Todas las declaraciones en C++ siempre deben finalizar con punto y coma. Uno de los errores sintaxis más
comunes en C++ es olvidar el punto y coma.
Línea 8: return 0;
El return permite que la función devuelva un valor. Este valor debe ser del mismo tipo que se haya
utilizado al definir la función.
En este caso el retorno del valor entero va a ser nulo.
Si no la escribimos la línea cuatro using namespace std, esto afectaría en la instrucción

(cout<<"Hola Mundo!";) Tendríamos que escribirla indicando el espacio de nombres, donde se
declara cout así:
1 // Mi segundo programa en C++ SALIDA:

2 #include<iostream> Hola Mundo! Soy un programa C++
3
4 int main()
5 {
6 std::cout<<"Hola Mundo!";
7 std::cout<<" Soy un programa
C++";
8 }
Las declaraciones son ejecutadas en la misma orden que aparecen dentro del cuerpo de una función.
Las declaraciones, std: : cout, identifica el dispositivo standard character output (salida estándar de
caracteres).
El programa ha sido estructurado en líneas diferentes y debidamente endentado, con el fin de hacer
más fácil de entender para los seres humanos la lectura. Pero C++ no tiene reglas estrictas sobre la
sangría o sobre cómo dividir instrucciones en líneas diferentes.
Por ejemplo, en vez de:
1 int main()
2 {
1 std::cout << " Hola Mundo!";
2 }
Podemos escribir:
int main(){ std::cout<<"Hola Mundo!";}
Todo en una sola línea, y esto tendría exactamente el mismo significado como el código precedente.
Ahora, añadámosle una declaración adicional a nuestro primer programa:
1 // Mi segundo programa en C++ SALIDA:

2 #include<iostream> ¡Hola Mundo!
3 Soy un programa C++
4 int main()
5 {
6 std::cout<<"Hola Mundo\n!";
7 std::cout<<" Soy un programa C++";
8 }
En este caso, el programa realizó dos inserciones en std::cout en dos sentencias diferentes. Otra vez,
la separación en líneas diferentes de código simplemente le proporciona una mejor legibilidad al
programa.
Salto de línea \n significa que no se mostrará el mensaje en una sola línea, como en el ejemplo
anterior. Si no en dos líneas como se muestra en la pantalla de salida actual.
Ya que el programa anterior podría haber sido perfectamente válido definido de esta manera:
int main(){std::cout<<"Hola Mundo!"; std::cout<<" Soy un programa C++";}
El código fuente también pudo haberse dividido en más líneas de código:
int main()
{
std::cout<<
"Hola Mundo!";
std::cout
<<" Soy un programa C++";
}
El resultado sería de nuevo el mismo que en los ejemplos anteriores.
2. Comentarios
Como vemos anteriormente los comentarios, no afecta la operación del programa; Sin embargo,
proveen una herramienta importante para documentar en seguida dentro del código fuente lo que el
programa hace y cómo funciona.
C++ utiliza dos formas de comentar código:
1 // Comentario de la línea
2 /* comentario de un Bloque */
La primera de ellas, conocido como comentario de línea, lo descarta todo de donde el par de slashs
(//) se encuentran hasta el fin de esa misma línea.
El segundo, conocido como comentario del bloque, descarta todo dentro del /*comentario */ con la
posibilidad de incluir múltiples líneas.
Vamos a añadir los comentarios a nuestro segundo programa:
1 /* Mi segundo programa en C++ SALIDA:

2 Con mas comentarios */ ¡Hola Mundo!
3 #include<iostream> Soy un programa C++
4
5 int main()
6 {
7 std::cout<<"Hola Mundo!\n";// Imprime Hola mundo
8 std::cout<<" Soy un programa C++";//Imprime Soy un
programa C++
9 }
CAPITULO 3. Tipos y Variables

Cuando se crea una Variable reservamos un lugar en la memoria, o un espacio en la memoria para
almacenar valores. El traductor que trasforma de C++ a lenguaje máquina, pide que indiques el tipo
de dato para cada variable que declares. Ejemplo:
TIPO DE DATO Valores Descripción

Entero 4, 34, 2, … Si se declara una variable de tipo entero, siempre vamos
a utilizar los números enteros
Reales 4.5, 3.24, … Con éste tipo de dato ya podemos utilizar decimales.
Caracteres A, d, y, … Si declaramos de tipo carácter actuarán los caracteres del
A-Z o a-z.
1. Identificadores
C++ requiere que especifiques el tipo y el identificador para cada variable definida
Un identificador es un nombre que se usa para identificar ya sea una función, clase, módulo, etc.
Un identificador válido:
PERMITIDO NO PERMITIDO
A, s,… (letras) /, *, -, +, $, %,… Símbolos
Hola, indent,… (palabras o formación de Útil, hä, año,… Signos de puntuación
letras )
Nota_Final,… (Unido dos palabras con Nota final, Los espacios no pueden ser parte
guion baja) del identificador.
Pero tales identificadores en la mayoría de los casos son palabras reservadas del compilador o
identificadores externos.
C++ usa una serie de palabras claves para identificar operaciones y descripciones de datos; Los
identificadores por consiguiente, creados por un programador no pueden corresponder a estas
palabras claves. Las palabras claves reservadas estándar, no puede un programador hacer el uso de
los identificadores ya creadas por defecto, entre ellos están:
alignas, alignof, and, and_eq, asm, auto, bitand, bitor, bool, break, case,
catch, char, char16_t, char32_t, class, compl, const, constexpr, const_cast,
continue, decltype, default, delete, do, double, dynamic_cast, else, enum,
explicit, export, extern, false, float, for, friend, goto, if, inline, int,
long, mutable, namespace, new, noexcept, not, not_eq, nullptr, operator, or,
or_eq, private, protected, public, register, reinterpret_cast, return, short,
signed, sizeof, static, static_assert, static_cast, struct, switch, template,
this, thread_local, throw, true, try, typedef, typeid, typename, union,
unsigned, using, virtual, void, volatile, wchar_t, while, xor, xor_eq.
Muy Importante: El lenguaje C++ es un "caso sensible". Eso significa que un identificador escrito en
mayúsculas no es lo mismo que otro identificador escrito con el mismo nombre pero en letras
minúsculas. Así, por ejemplo, la variable de “RESULTADO” no equivale a la variable de “resultado” o
la variable de “Resultado”. Éstos son tres identificadores muy distintos o tres variables diferentes.
2. Tipos de datos fundamentales

Los tipos de datos más usadas veremos a continuación:
 Tipo de datos numéricos enteros:
Pueden almacenar un valor entero y pueden ser positivos o negativos.
Tipo de dato Descripción Tamaño (bits) Rango
Short Entero corto 16 -32768 a 32767
Int Entero 32 -2147483648 a 2147483647
Long Entero largo 32 -2147483648 a 2147483647
Char Carácter 8 -128 a 127

Los calificadores signed y unsigned, indican los signos.
Grupo Tipos Descripción Tamaño

signed char Caracter 8
signed short int Entero corto 16
Enteros signed int Entero 16
(Asignados)
signed long int Entero largo 32
signed long long int Entero más largo 64
unsigned char Caracter sin signo
unsigned short int Entero corto sin signo
Enteros (no unsigned int Entero sin signo (Mismo tamaño que sus
asignados) unsigned long int Entero largo sin signo signed)
unsigned long long Entero más largo sin signo

int
Por ejemplo,
Las siguientes declaraciones son equivalentes y utilizan calificador:
unsigned int v; es lo mismo: unsigned v;
Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros sin utilizar el
calificador:
signed int w; es equivalente: int w;
Ⓔ. Asignar un valor a la variable e imprimirla.
1 #include<iostream> SALIDA:
2
3 using namespace std; 5
int main()
4
{
5 int Variable = 5;
6 cout<<Variable;//cout sirve para imprimir un valor
7
8 return 0;
9 }
 Tipo de datos numéricos flotantes:
Pueden representar valores reales, como: 3.14 o 0.01, con niveles diferentes de precisión, a merced del
cual de los tres tipos en coma flotante es usado.

Float Real en punto flotante 32 Positivos: 3.4E-38 a 3.4E38
Negativos: -3.4E-38 a -3.4E38
Doublé Real de doble precision Positivos: 1.7E-308 a 1.7E308

64
Negativos: -1.7E-308 a -1.7E308
long double Real doble largo Positivos: 3.4E-4932 a 1.1E4932

80
Negativos: -3.4E-4932 a -1.1E4932
Ⓔ. Imprime un número real.
2
3 using namespace std; 5.5
int main()
4
{
5 int a,b; //declarando dos variables de tipo entero
6 a = 2; b = 3;//asignando valores a la variable declarada
7 float c = 0.5; //define un número real
8 cout<<a + b + c;//al visualizar, suma las tres variables
9
10 return 0;
11 }
 Tipo Booleano:
El tipo booleano o lógico, conocido en C++ como bool, sólo puede representar uno de dos estados,
verdadero (1) o falso (0).

bool Tipo de dato lógico 8 0,1
Ⓔ. Asignar un valor a la variable e imprimirla.
2
3 using namespace std; 1
4 int main()
5 {
6 float x = 1.5;
7 int y = (int)x; //Asignando la variable declarada a una nueva
8 bool z = bool(1);
9 y ==1?; cout<<z: cout<<"No";//esta línea lo vamos a
10 //ver en los próximos capítulos
11 return 0;
12 }
 Tipo carácter:
Solo Pueden representar un carácter, algo como 'A' o ' $ '. El tipo básico es char, lo cual es un carácter
de un byte. Otros tipos son también provistos para caracteres más largos.
Tipos Descripción Tamaño

char 8 bits
char16_t 16 bits
Caracteres en formato
char32_t Unicode 32 bits
wchar_t Puede representar o soportar

grandes conjuntos de caracteres.
SINTAXIS:
Nombretipo nombre_Variable = valor;

EJEMPLO:
char alfa = ‘a’;
Ejemplo
3 int main() EL CODIGO ASCII DE A ES 65
4 {
5 char c = 'A';
6 int x = c;
7 cout<<"EL CODIGO ASCII DE "<<c<<" ES "<<x;
8 return 0;
9 }
Aquí está la lista completa de tipos de datos fundamentales en C++:
3. Trabajando con variables

Al crear una variable reservamos un lugar de la memoria, o un espacio en la memoria para
almacenar valores. El compilador requiere que indiques el tipo de datos para cada variable que
declaraciones.
ENTRADA DEL USUARIO.
Para permitir al usuario que ingrese un valor utiliza cin en combinación con el operador extracción
(>>).
Ejemplo1. Recibir la entrada de un usuario y almacenarla en una variable num.
int num, a;
cin>> num;
Al igual que cout, las extracciones con cin pueden ser encadenadas para solicitar más de una
entrada en una misma declaración: cin >> x >> y;
Ejemplo El siguiente programa solicita al usuario que ingrese un número;

1 #include<iostream>
2
4 int main()
5 {
6 int x;
7 cout << ”Ingrese un numero\n”;
8 Cin >>x;
9 return 0;
10 }
11 //entrada 3
12 //Salida 3
Cuando el programa es ejecutado, esperará tanto con sea necesario hasta que el usuario ingrese un
número, y luego presione la tecla enter.
Ejemplo 2. Programa que sume dos números ingresados, puede aceptar múltiples entradas de
usuario.
1 #include<iostream> Input:
3 int main() Ingrese un numero: 5
4 { Ingrese otro numero: 6
5 int a, b;
6 cout<<"Ingrese un numero: "; cin >>a; Output:
7 cout<<"\nIngrese otro numero: "; cin >>b;
8 cout<<"\nLa suma es: "<<a + b<<endl; La suma es 11
9 return 0;
10 }
4. Constantes
En C++ se pueden definir constantes de dos formas, la primera es por medio de comando define y
la segunda es usando la palabra clave const.
Uso de #define para declarar constantes en C++
Sintaxis:
#define nombre_constante valor
Ejemplo.
1 #include<iostream> Output:
2 #define PI 3.1416/*Definimos una constante
3 llamada PI*/ Imprimiendo el valor de PI:
4 using namespace std; 3.1416
5 int main()
6 {
7 cout<<"Imprimiendo el valor de PI : "<<PI;
8 return 0;
9 }
Uso de const para declarar constantes en C++
La instrucción const nos permite declarar constantes de una manera más adecuada. Y se declara
dentro de nuestro código como un tipo cualquiera.
Sintaxis:
const Nombretipo nombreVariable = valor;
Ejemplo 1. Programa en C++ que imprime la constante pi.
1 #include<iostream> Output:
3 const char nuevaLinea = '\n'; /*Definimos una Imprimiendo el valor de PI:
4 constante nuevaLinea*/ 3.1416
5 int main()
6 {
7 const float PI=3.1416; /*Definimos una
8 constante llamada PI*/
10 cout<<nuevaLinea;
11 return 0;
12 }
Ejemplo 2. Programa que calcula el área de una circunferencia, usando la librería <cmath>. La
librería cmath nos sirve para el cálculo de una potencia.
Sintaxis
Sintaxis:
nombreVariable = pow(base,exponente);
1 using namespace std; Output:

3 int main() Imprimiendo el valor de PI:
4 { 3.1416
5 const float PI=3.1415926536; /*Definimos
6 una constante llamada PI*/
7 float area;
9 cout<<nuevaLinea;
10 return 0;
11 }
12
CAPITULO 4. Operadores
Una vez introducidas las variables y las constantes, podemos comenzar a operar con ellas utilizando
operadores. Lo que sigue es una lista compleja de operadores. En este punto, es probable que no
sea necesario conocerlos todos, pero todos ellos se enumeran aquí para servir de referencia.
1. Operador de asignación (=)

El operador de asignación asigna un valor a una variable.
EJEMPLO:
y = 2 + (x = 5);
x = 5;
y = 2 + x;
x = y = z = 5;
2. Operadores aritméticos
C++ soporta los siguientes operadores aritméticos.
OPERADOR SÍMBOLO
Adición +
Sustracción -
Multiplicación *
División /
Módulo %
3. Operadores de asignación compleja (+=, -=,…)

C++ provee operadores reducidos que tienen la capacidad de realizar una operación y una
asignación al mismo tiempo.
int x = 5;
x += 4; // equivalente a x = X + 4
x -= 3; // equivalente a x = X – 3
x *= 4; // equivalente a x = X * 4
x /= 3; // equivalente a x = X / 3
x %= 4; // equivalente a x = X % 4
4. Incrementos y decrementos (++, --)
Incremento
El operador de incremento es utilizado para incrementar el valor de un entero en una unidad.

y ++; // equivalente a: y = y + 1
Ejemplo
int y = 21; Output:

y ++; // y=y+1
cout << y; 22
x = 4; x = 3;
y = ++x; y = x++;
// x contiene 4, y contiene 4 // x contiene 4, y contiene 3
Decremento
El operador de decremeto es utilizado para disminuir el valor de un entero en una unidad.

y --; // equivalente a: y = y - 1
Ejemplo
int y = 20; Output:

y --; // y=y-1
cout << y; 19
5. Operadores de relaciones y de comparación (==, !=, >, <, >=, <=)

Se pueden comparar dos expresiones utilizando operadores relacionales y de igualdad. Por ejemplo
para saber si dos valores son iguales o si uno es mayor que el otro. El resultado de tal operación es
verdadero o falso (Es decir un valor booleano).
Los operadores relacionales en C++ son:
operator description
== Igual a
!= Diferente a
< Menor que
> Mayor que
<= Menor o igual que
>= Menor o igual que
Ejemplo
1 (4 == 5) // Evalúa false, ya que 4 no es igual 5

2 (2*4 >= 8) // Evalúa true, ya que 8 es igual 8
3 (2+4 > 1*8) // Evalúa false, son iguales
6. Operadores Lógicos ( !, &&, || )
El símbolo ‘ ! ’ en C++ es un operador de negación. Niega toda la expresión a partir del símbolo.
Ejemplo:
1 !(5 == 5) // Evalúa falso porque la expresión (5 == 5) es verdadera

2 !(6 <= 4) // Evalúa verdadero porque (6<=4)es falsa
3 !true // Evalúa falso
4 !false // Evalúa verdadero
Los operadores lógicos && y || son usados cuando se evalúa dos expresiones.
El operador && Corresponde a la operación lógica Y o AND. Da como resultado verdadero si ambos
opeandos son verdaderas, lo demás falso.
El siguiente cuadro muestra los resultados evaluado la expresión &&
&& OPERADOR (and)

a b a && b
true true true
true false false
false true false
false false false
El operador || corresponde la operación lógica booleana O u OR, que da como resultado verdadero
si cualquiera de sus operandos es verdadero, siendo así falso sólo cuando ambos operandos son
falsos. Estos son los resultados posibles de los (a || b).
|| OPERADOR (or)
a b a || b
true true true
true false true
false true true
false false false
Por ejemplo:
1 ( (5 == 5) && (3 > 6) ) // Evalúa falso ( true && false )

2 ( (5 == 5) || (3 > 6) ) // Evalúa verdad ( true || false )
Esto es importante sobre todo cuando la expresión de la derecha tiene efectos secundarios, como
alterar valores.
if ( (i<10) && (++i<n) ) { /*...*/ } /* tenga en cuidado con la condición

del incremento*/
7. Operador condicional ternario ( ? )
El operador condicional evalúa la expresión, devolviendo un valor si esa expresión se evalúa como
verdadera y otro diferente si la expresión se evalúa como falsa.
Sintaxis:
(Condición)? result1 : result2
Si la condición es verdadera, toda la expresión se evalúa como resut1, de lo contrario como result2.
Ejemplo. Programa para saber el mayor de dos números.
1 #include <iostream> Input

2 using namespace std; 6 9
3 int main() Output:
4 {
5 int a,b,c; El numero mayor es 9
6 cout<<"Digite dos valores ";cin>>a>>b;
7 c = (a>b)? a:b;
8 cout<<"El numero mayor es "<<c;
9 return 0;
10 }
CAPITULO 5. Estructura de control

Las estructuras de control determinan la secuencia en la que se ejecutarán las instrucciones de un
programa. Las estructuras de control se dividen en tres categorías en función del flujo de ejecución:
 Estructura secuencial.
 Estructura alternativa o condicional.
 Estructura iterativa o repetitiva.
1. Estructura secuencial
La estructura secuencial está formada por una secuencia de instrucciones que se ejecutan en orden
una a continuación de la otra.
Cada una de las instrucciones están separadas por el carácter punto y coma (;). No obstante, en
algunos casos nos interesará agrupar en un bloque una serie de instrucciones, como veremos al
explicar las estructuras de selección y de iteración. El bloque de sentencia se define por el carácter
llave de apertura ({) para marcar el inicio del mismo y el carácter llave del cierre (}) para marcar el final.
Sintaxis:
1 {
2
3 instruccion 1;
4 instruccion 2;
6 .
7 ..
8 instruccion n;
}
Sin embargo, en caso de que el bloque de sentencias este constituido por una única sentencia no es
obligatorio el uso de las llaves de apertura y cierre ({}).
Ejemplo: Programa que calcula la edad de una persona.
2. Estructura de selección (if, else)

Las estructuras controlan si una sentencia o bloque de sentencias se ejecutan, en función del
cumplimiento o no de una condición o expresión lógica.
Esta instrucción hace que se ejecuten unas sentencias u otras dependiendo del valor que toma
condición. La instrucción if puede ser simple o doble.
Sintaxis:
Alternativa simple: Alternativa doble:

if(condición)
Instrucción 1;
else
if(condición) instrucción 2;
Instrucción 1; if(condición)
if(condición) {
{ Instrucción 1;
Instrucción 1; Instrucción 2;
Instrucción 2; }
Instrucción 3; else
{
} Instrucción 3;
Instrucción 4;
}
Ejemplo. Programa que lee un número entero por teclado y muestra si es par o impar.
#include<iostream> Input
using namespace std;
int main() 5
{ Output:
int num;
cout<<"Introduzca numero: "; Es impar
cin>>num;
if((num%2)==0)
cout<<" Es par"<<endl;
else
cout<<"Es impar"<<endl;
return 0;
}
Las instrucciones if-else se puede anidar obteniéndose una estructura condicional
3. Estructura condicional múltiple
1 if(condicion 1)
2 instruccion 1;
3 else if(condicion 2)
4 instruccion 2;
6 instruccion 3;
8 instruccion 4;
9 else
10 instruccion 5;
instruccion 6;
instruccion 7;
En este caso se evalúa la condición 1; si es cierta, se ejecuta la instrucción 1 y se continúa por la

instrucción 6 después del bloque de if de else anidados. Si la condición uno es falsa, se evalúa la
condición 2, y así sucesivamente.
En caso de no ser cierta ninguna de las condiciones, la sentencia que se ejecuta es la del último else,
es decir la instrucción 5.
Ejemplo de estructura condicional múltiple en C++, programa que lee un número entero que
corresponde a una hora y muestra un mensaje según la hora que se haya leído.
#include<stdlib.h> 6 9
using namespace std; Output:
int main(void)
{ El numero mayor es 9
int hora;
cout<<"\nIntroduzca una hora(entre 0 y
24): ";
cin>>hora;
if((hora>=0)and(hora<12))
cout<<"\nBuenos Dias\n";
else if((hora>=12)and(hora<19))
cout<<"\nBuenas Tardes\n";
else if((hora>=19)and(hora<24))
cout<<"\nBuenas Noches\n";
else
cout<<"\nHora no valida\n";
system("pause");/*ESTE LINE DE CODIGO
FUNCIONA CON LA LIBRERIA STDLIB.H*/
}
Otro ejemplo de estructura condicional múltiple en C++. Programa que lee la calificación numérica
obtenida por un alumno en un examen que muestra la nota equivalente en texto.
#include<iostream>
#include<cstdlib>
using namespace std;
int main()
{
unsigned int nota;
cout<<"Introduzca una calificacion numerica(entre 0 y 100): ";
cin>>nota;
cout<<"El alumno tiene una calificacion ";
if(nota==100)
cout<<"Matricula de honor"<<endl;
else if(nota>=90)
cout<<"Sobresaliente"<<endl;
else if(nota>=70)
cout<<"Muy bueno"<<endl;
else if(nota>50)
cout<<"bien "<<endl;
else
cout<<"Reprobado"<<endl;
system("pause"); 21
}
4. Instrucción (switch)
a. Instrucción switch.
La sentencia switch selecciona una de entre múltiples alternativas.

La forma general de esta expresión es la siguiente:
1 switch(expresion)
2 {
Case constante 1:
instrucciones; break;
Case constante 2:
instrucciones; break;
…
efault:
instruccion 2;
}
En una instrucción switch, expresión debe ser una expresión con valor entero, y constante 1,
constante 2, deben ser constantes enteras, constantes de tipo carácter o una expresión constante de
valor entero.
Expresión también puede ser de tipo char ya que los caracteres individuales deben valores enteros.
Dentro de una case puede aparecer una sola instrucción o un bloque de instrucciones.
La instrucción switch evalúa la expresión entre paréntesis y compara su valor con las constantes de
cada case. Se ejecutarán las instrucciones de aquel case cuya constante coincida con el valor de la
expresión, y continúa hasta el final del bloque o hasta una instrucción que transfiera el control fuera
del bloque de switch (una instrucción break o return). Si no existe una constante igual al valor de la
expresión entonces se ejecutan las sentencias que están a continuación de default, si existe (no es
obligatorio que exista, y no tiene porqué ponerse siempre al final).
Ejemplo de uso de la instrucción switch en C++. Programa que lee dos números y una operación y
realiza la operación entre esos números.
using namespace std; 6 9
int main() Output:
{
int A,B,resultado; El numero mayor es 9
char operador;
cout<<"Introduzca un numero: ";
cin>>A;
cout<<"Introduzca otro numero: ";
cin>>B;
cout<<"Introduzca un operador(+,-,*,/):";
cin>>operador;
resultado=0;
switch(operador)
{
case '+': resultado=A+B; break;
case '-': resultado=A-B; break;
case '*': resultado=A*B; break;
case '/': resultado=A/B;
break;//suponiendo B!=0
default: cout<<"Operador no
valido"<<endl;
}
cout<<"El resultado es: ";
cout<<resultado<<endl;
return 0;
}
Otro ejemplo de switch en C++. Programa que determina si un carácter leído es o no una vocal en
ese caso como la sentencia a ejecutar por todas las etiquetas casi es la misma, esta sentencia se
pone una única vez a final.
int main(void) Output:
{
char car; El numero mayor es 9
cout<<"Introduzca un caracter: ";
cin>>car;
switch(car)
{
case 'a':
case 'A':
case 'e':
case 'E':
case 'i':
case 'I':
case 'o':
case 'O':
case 'u':
case 'U':
cout<<car<<" es una vocal"<<endl;break;
default: cout<<car<<" No es una
vocal"<<endl;
}
return 0;
}
ESTRUCTURA ITERATIVA O REPETITIVA

5. Instrucción (While)
C++ dispone de tres estructuras repetitivas:
While
do while
For
.
1.1 Instrucción while.
while(condicion)
{
Instrucciones 1;
…
Instrucciones N;
}
Ejecuta una instrucción o un bloque de instrucciones cero o más veces, dependiendo del valor de la
condición.
Se evalúa la condición y si es cierta, se ejecuta la instrucción o bloque de instrucciones y se vuelve a
evaluar la condición; pero si la condición es falsa, se pasa a ejecutar la siguiente instrucción después
del valle.
Ejemplo de instrucción while en C++. Programa que lee números enteros hasta que se lee un
número negativo. Se muestra la suma de todos los números leídos excepto el número negativo.
int main(void) Output:
{
int num,suma=0; El numero mayor es 9
cout<<"Introduzca un numero";
cin>>num;
while(num>0)
{
suma+=num;
cout<<"Introduzca un numero ";
cin>>num;
}
cout<<endl<<"La suma es "<<suma<<endl;
return 0;
}
6. Instrucción (do while)

7. Estructuras repetitivas o iterativas.
1 a. Instrucción do..while
2
do
{
Instrucciones 1;
Instrucciones N;
} while(condición);
Ejecuta una instrucción o un bloque de instrucciones, una o más veces dependiendo del valor de la
condición.
Se ejecuta la instrucción o bloque de instrucciones y a continuación se ejecuta la condición. Si la
condición es cierta se vuelve a ejecutar la instrucción o bloque de instrucciones, y si es falsa, pasa a
ejecutarse la siguiente instrucción después de do-while.
Cuando se utiliza una instrucción do-while el bloque de instrucciones se ejecuta al menos una vez,
ya que la condición se evalúa al final. En cambio, con una instrucción while, puede suceder que el
bloque de instrucciones no llegue a ejecutarse nunca si la condición inicialmente es falsa.
Ejemplo de instrucción do-while en C++. Programa que lee números enteros mientras que el
número ingresado sea menor a uno o mayor a diez.
using namespace std; 6
int main(void)
{
int num;
do
{
cout<<"Introduzca un numero entre 1 y
10: ";
cin>>num;
}while(num < 1 || num > 10);
return 0;
}
Ejemplo: Generar la siguiente serie y su sumatoria.

4 8 6 10 8 12 10
Ejemplo:
ENTRADA SALIDA
N=6 4 8 6 10 8 12
1 #include <iostream>
3 int main()
4 {
5 int N,i=1,s=0,c;
6 cin>>N;
7 do{
8 if(i%2==0)
9 c=i+6;
10 else
11 c=i+3;
12 cout<<'\t'<<c;
13 s=s+c;
14 i++;
15 }while(i<=N);
16 cout<<'\n'<<"la sumatoria es: "<<s;
17 }
8. Instrucción (for)
1.1 Instrucción for.
Un bucle for hace que una instrucción o bloque de instrucciones se repitan un número
determinado de veces mientras se cumpla la condición
1 for(inicialización;condicion;incremento/decremento);
{
2
Instrucciones 1;
3 ..
4 Instrucciones N;
5 }
A continuación de la palabra for entre paréntesis debe haber siempre tres zonas separadas
por punto y coma:
1. Zona de inicialización
2. Zona de condición
3. Zona de incremento o decremento
En alguna ocasión puede no ser necesario escribir alguna de ellas. En ese caso se pueden
dejar en blanco, pero los puntos y comas deben aparecer.
El funcionamiento de un bucle for el siguiente:
1. Se inicializa la variable o las variables de control.
2. Se evalúa la condición.
3. Si la condición es cierta se ejecutan las instrucciones. Si es falsa, finaliza la ejecución del
bucle y continúa el programa en la siguiente instrucción después del for.
4. Se actualiza la variable o variables de control (incremento/decremento).
5. Se pasa al punto 2).
Esta instrucción es especialmente indicada para bucles donde se conozca el número de
repeticiones que se van a hacer.
Como regla práctica podríamos decir que las instrucciones while y do-while se utilizan
generalmente cuando no se conocen a priori el número de pasadas, y la instrucción for
se utiliza generalmente cuando si se conoce el número de pasadas.
Ejemplo. Programa que muestra los números naturales del 1 al 10
Ejemplo de
#include<iostream> EJEMPLO DE SALIDA
using namespace std; 1
int main(void) 2
{ 3
int n; 4
for(n=1;n<=10;n++) 5
{ 6
cout<<n<<endl; //endl salto de línea 7
} 8
return 0; 9
} 10
N números impares. Dado un número entero, el programa debe mostrar N primeros números
impares.
Ejemplo:
ENTRADA SALIDA
N=6 1, 3, 5, 7, 9, 11
3 int main(void)
4 {
5 int N,impar=1;
6 cin>>N;
7 for(int i=1;i<=N;i++)
8 {
9 cout<<impar<<'\t'; // ‘\t’ tabulación separa en el momento de
imprimir
10 impar = impar+2; // su equivalencia es: impar+=2;
11 }
12 return 0;
13 }
Multiplos de TRES. Realizar un programa en C++ para saber la cantidad de múltiplos de 3 que se
encuentran en un rango dado A y B.
Ejemplo de entrada:
ENTRADA SALIDA
A = 20 4 numeros son múltiplos de tres
B = 32
3 int main()
4 {
5 int A,B;
6 short int cont=0;///Contador de multiplos de 3
7 cin>>A>>B;
8 for(int i=A;i<=B;i++){
9 if(i%3==0) cont++;
10 }
11 cout<<cont<<" numeros son multiplos de tres";
12 }
SERIES: Realizar un programa para generar los siguientes series, para N números enteros.
Ejemplo: 1 3 7 13 21… N
3 int main()
4 {
5 int N;
6 cin>>N;
7 short int j=1,k=2;
8 for(int it = 1; it < N; it++)
9 {
10 cout<<j<<'\t';
11 j=(k*it)+j;
12 }
13 return 0;
14 }
Ejemplo: 1 4 9 16 25 36… N
3 int main()
4 {
5 int N;
6 cin>> N;
7 short int x = 1,y = 1;
8 for(int it = 1 ; it < N ; it++)
9 {
10 cout<<y<<'\t';
11 x + = 2; y + = x;
12 }
13 return 0;
14 }
Ejemplo: 1 2 6 15 31… N
3 int main()
4 {
5 int N,se = 1;
6 cin>> N;
7
8 for(int i = 1 ; i < N ; i++)
9 {
10 cout<<se<<'\t';
11 se=(i*i)+se;
12 }
13 return 0;
14 }
4 8 6 10 8 12 10… N
3 int main()
4 {
5 int N, i = 1, s = 0;
6 cin>> N;
7
8 for(int i = 1 ; i < N ; i++)
9 {
10 cout<<se<<'\t';
11 se=(i*i)+se;
12 }
13 return 0;
14 }
0 1 2 3 6 5 12 7 20… N
3 int main()
4 {
5 int n,im=-1,s=0,b=0;
6 cin>>n;
7 for(int i=1;i<=n;i++)
8 {
9 if(i%2==0)
10 {
11 im+=2;
12 cout<<'\t'<<im;
13 }
14 else
15 {
16 b=b+2;
17 cout<<'\t'<<s;
18 s=s+b;
19 }
20 }
21 return 0;
22 }
Serie de FIBONACCI
1 1 2 3 5 8 13… N
3 int main()
4 {
5 int N,a=1,b=1,c=1;
6 cin>>N;
7 for(int j=1;j<=N;j++)
8 {
9 cout<<'\t'<<a;
10 c = a+b;
11 a=b;
12 b=c;
13 }
14 }
Generar la siguiente serie:

𝟏 𝟑 𝟓 𝟕 𝟗 𝟏𝟏
… 𝑵
𝟐 𝟒 𝟔 𝟖 𝟏𝟎 𝟏𝟐
3 int main()
4 {
5 int N;
6 cin>>N;
7 for(int j=1;j<=N;j++)
8 {
9 cout<<'\t'<<(2* j -1)/(2*j)a;
10 }
11 }
Ejercicios:
Realizar un programa para realizar la tabla de multiplicar dato “N” hasta 10.
Ejemplo:
N=3
ENTRADA SALIDA
3 3*1=3
3*2=6
3*3=9
3 * 4 = 12
3 * 5 = 15
3 * 6 = 18
3 * 7 = 21
3 * 8 = 14
3 * 9 = 27
3 * 10 = 30
3 int main()
4 {
5 short int N; cin>>N;
6 for(int m=1;m<=10;m++)
7 {
8 cout<<N<<" * "<<m<<" = "<<m*N<<'\n';
9 }
10 return 0;
11 }
Realizar un programa para invertir un número

Ejemplo:
ENTRADA SALIDA
123 321
3 int main()
4 {
5 int short Num,inv = 0;cin>>Num;
6 while(!Num == 0)
7 {
8 inv=Num % 10+inv*10;
9 Num /= 10;
10 }
11 cout<<inv;
12 return 0;
13 }
Implementar un programa para saber, si un número ingresado es capicúa.

Capicúa es cuando el número tiene el mismo valor una vez invertido.
Ejemplo:
ENTRADA SALIDA
131 Es capicúa
12131 No es capicúa
555 Es capicúa
3 int main()
4 {
5 int num,i=0,m;cin>>num;
6 m=num;
7 while(m!=0)
8 {
9 i=i*10+m%10;
10 m/=10;
11 }
12 if(i==num)
13 cout<<"Es capicua";
14 else
15 cout<<"No es capicua";
16 return 0;
17 }
Realizar un programa para determinar si un número ingresado por teclado es primo.

Ejemplo:
ENTRADA SALIDA
11 Es primo
27 No es primo
553 No es primo
2 Es primo
3 int main()
4 {
5 int num,cont=0;
6 cin>>num;
7 for(int a=1;a <= num;a++)
8 {
9 if(num % a = = 0)
10 {
11 cont++;
12 }
13 }
14 if(cont == 2)
15 cout<<"Es primo\n";
16 else
17 cout<<"No es primo\n";
18 return 0;
19 }
Realizar un programa para imprimir N primeros números primos.

Ejemplo:
ENTRADA SALIDA
5 2 3 5 7 11
3 int main()
4 {
5 int N,cont = 0,np = 2,cp = 0;
6 cin>>N;
7 do
8 {
9 for(int x=1;x <= np;x ++)
10 {
11 if(np % x = = 0)
12 {
13 cont++;
14 }
15 }
16 if(cont = = 2)
17 {
18 cout<<'\t'<<np;//imprime N primos
19 cp ++;//contador de primos
20 }
21 cont = 0;
22 np ++;
23 }while(N > cp);
24 cout<<'\n';
25 return 0;
26 }
CAPITULO 7. Arreglos
Un arreglo es un conjunto de datos del mismo tipo ordenados de forma lineal uno después del otro, los
elementos o los componentes de un arreglo, se referencian mediante un índice de desplazamiento para
acceder a una posición utiliza una iteración.
1. Arreglos unidimensionales
Los arreglos unidimensionales o vectores, son utilizados para almacenar una colección de datos, o una
colección de variables, todas del mismo tipo.
Su declaración será:
1 int nombre [tamaño];
Cuando declares un arreglo, especifica siempre el tipo.
Por ejemplo:
1 int miVect[5];
En el ejemplo anterior, la variable “miVect” fue declarada como un arreglo de cinco valores enteros
[especificando en los corchetes].
Se puede inicializar un arreglo definiendo los valores que almacenará:
1 int miVect[5]={ 11, 33, 5, 22,35};
Los valores son proporcionados en una lista separada por comas, rodeada de {llaves}.
El número de valores dentro de las llaves {} no debe exceder el número de elementos declarados dentro de
los corchetes.
Cada elemento, o miembro, del arreglo tiene un índice, que marca la posición específica del elemento.
El primer elemento del arreglo tiene al 0 (cero) como índice, el segundo tiene 1 como índice.
De esta forma hasta el último elemento.
11 33 5 22 35
[0] [1] [2] [3] [4]
Por ejemplo para acceder al número 11 y 22, usamos los índices:
int a[] = {11,33,5,22,35}

cout<< a[0] << endl;
//Salida 11
cout<< a[3] << endl;
//Salida 22
Utilizando arreglos en bucles.
Es necesario iterar sobre los elementos de un arreglo, ya sea para acceder al elemento o realizar
operaciones.
Vamos a declarar un arreglo, que va almacenar 5 enteros, y le asignaremos un valor a cada elemento
utilizando el bucle FOR.
int main() Output:
{
float arr[4]={ 2.5, 3.8, 45.5, 12.2}; El numero mayor es 9
for(int i=0;i<5;i++)
{
cout<<arr[i]<<”\t”<<endl;
}
return 0;
}
A cada elemento en el arreglo le es asignado el número 7.
2. Matrices
La matriz es un array bidimensional con doble subíndice, no es más que una serie de vectores:
Columna 0 Columna 1 Columna 2
Fila 0 A[0][ 0] A[0][1] A[0][2]

Fila 1 A[1][ 0] A[1][1] A[1][2]
Fila 2 A[2][ 0] A[2][1] A[2][2]
Subíndice de columna
Diagonal principal
Triangular superior Subíndice de filas
Triangular inferior Nombre del arreglo
En el ejemplo se observa una matriz de 3x3, la tabla puede ser de dimensión MxN. Las matrices
permiten almacenar múltiples valores en una misma variable.
Diagonal principal sus subíndices son siempre iguales.
Triangular superior tiene subíndice de columnas mayor a subíndice de filas.
Triangular inferior tiene subíndice de columnas menor a subíndice de filas.
Declaración de una matriz en C++

Es muy similar a la de un vector, se deben seguir las mismas normas para declarar una variable
teniendo en cuenta los tipos según el caso, el nombre de array la dimensión para filas y columnas.
La sintaxis para declarar una matriz en C++ es la siguiente:
1 int nombre [tamaño filas][tamaño columnas];
Ejemplo:
Nombre de la matriz miMatriz
Dimensión Fila = 2; Columna =2.
Valores
1 2
3 4
Imprimir el número 4; se encuentra en su posición (1,1)
1 #include <iostream> SALIDA:

3 int main() 4
4 {
5 int miMatriz[2][2]={{1,2},{3,4}};
6 cout<<miMatriz[1][1]<<endl;
7 return 0;
8 }
Ahora imprimimos todo los elementos de la tabla.
1 #include <iostream> SALIDA:

3 int main() 1 2
4 { 3 4
5 int miMatriz[2][2]={{1,2},{3,4}};
6
7 for(int i=0;i<2;i++){
8 for(int j=0;j<2;j++){
9 cout<<miMatriz[i][j]<<"\t";
10 }
11 cout<<endl;
12 }
13 return 0;
14 }
Para imprimir todos los elementos de la matriz necesitamos dos bucles for para recorrer por cada
elemento e ir imprimiendo las variables de cada instrucción iterativa, ambos bucles tienen
inicializado con (0), significa que está apuntando al primer elemento de la matriz en posición (0,0)
CAPITULO 8. Manejo de cadenas de caracteres

Se dice strings a un conjunto de caracteres
En C++ se denominan tipos de datos string y pertenecen a los archivos de encabezado de la clase
<string>
1. Definición
Se define como secuencia de caracteres, generalmente todos estos textos están en ASCII. Este un
tema que además de ser fácil es bastante importante ya que gran parte de la información está
basado en texto.
2. Declaración y asignación a un tipo string

En C++ se denominan tipos de datos string y pertenecen a los archivos de encabezado de la clase
<string>. Se pueden asignar otros objetos del mismo tipo, cadenas entre comillas dobles e incluso
un único carácter de tipo string:
1 /* incluyendo la librería para trabajar con cadenas */

3 #include <string>
4
6 int main()
7 {
8 //Instrucciones
9 }
La sintaxis para cadena es:
Nombretipo nombreVariable = “carácter”;

EJEMPLO:
string saludo = “Hola”; // cadena
Asignar un solo carácter
string cad = ‘P’; // cadena
3. Caracteres
4. La sintaxis de C++ para carácter es:
Nombretipo nombreVariable = “micaracter”;
EJEMPLO:
char saludo2[ ] = “hola ”; //caracter
5. Acceso a una cadena de tipo string

1 #include <iostream> Ejemplo de SALIDA:
2 #include <string> Cual es su nombre?
3 using namespace std; Alex
4 int main () Donde Vive?
5 { Bolivia
6 char pregunta1[] = "Cual es su nombre? ";
7 string pregunta2 = "Donde Vive? "; Hola, Alex de Bolivia!
8 char respuesta1 [80];
9 string respuesta2;
10 cout << pregunta1;
11 cin >> respuesta1;
12 cout << pregunta2;
13 cin >> respuesta2;
14 cout << "Hola, " << respuesta1;
15 cout << " de " << respuesta2 << "!\n";
16 return 0;
17 }
6. Acceso a una cadena de tipo string

La forma más fácil y común de acceder a un carácter en una determinada posición que deseemos es
mediante el uso de corchetes [](corchetes) de manera similar a un array.
Ejemplo: Si tenemos un tipo string de nombre STR al cual le asignaremos la palabra “cadena” y
queremos que se nos retorne la letra que está en la posición 4, se cuenta desde cero.
2 #include <string>
4 int main()
5 {
6 string STR;
7 STR = "cadena";
8 cout<<STR[4]<<endl;
9 //Salida n
10 return 0;
11 }
7. Comparaciones entre string

Para la comparación de strings recordaremos el capítulo cuatro, que son los mismos que se usan para las
operaciones de tipo lógica, las minúsculas y las mayúsculas hacen mucho la diferencia.
La tabla ascci es una buena referencia para distinguir los símbolos, ya sea numéricas o alfabéticas.
En el siguiente ejemplo tenemos dos cadenas (cad1 y cad2) que son iguales y el programa nos indicará en la
el consola.
2 #include <string>
4 int main()
5 {
6 string cad1 = "hola";
7 string cad2 = "hola";
8 if(cad1==cad2)//comparamos si las cadenas son
iguales
9 cout<<cad1<<" es igual a "<<cad2;
10 return 0;
11 }
8. Concatenación de strings
El operador (+) nos permite concatenar dos o más cadenas.
Entonces si tengo dos cadenas diferentes cad1=“Julio”, cad2 = “Cesar” debemos unirlo e imprimir en
una sola cadena, el código es el siguiente.
2 #include <string>
4 int main()
5 {
6 string cad1 = "Julio";
7 string cad2 = "Cesar";
8 cad1 +=cad2;//cad1=cad1+cad2 equivalente
9 cout<<cad1<<endl;
10 return 0;
11 }
9. Búsqueda de subcadenas o caracteres dentro del tipo string.

Este tipo de búsquedas se puede llevar a cabo de izquierda a derecha o viceversa, con uso de
método .find
Ejemplo.
2 #include <string>
4 int main()
5 {
6 string cadena = "asdfghjk";
7 if(cadena.find("cad")==string::npos)
8 cout<<"Cadena no encontrada"<<endl;
9 else
10 cout<<"Cadena encontrada.."<<endl;
11 //Retorna la posicion del primer caracter de "fgh"
12 cout<<cadena.find_first_of("fgh")<<endl; // salida 3
13 //Retorna el ultimo posicion de la subcadena
14 cout<<cadena.find_last_of("fgh")<<endl; // salida 5
15 //Retorna la posicion del primer caracter de la cadena
16 cout<<cadena.find_first_not_of("fgh")<<endl; // salida 0
17 //Retona la ultima posicion de la cadena
18 cout<<cadena.find_last_not_of("fgh")<<endl; // salida 7
19 return 0;
20 }
10. Obtener subcadenas de una cadena principal

El método .substring nos permite obtener una subcadena, que en su forma básica recibe dos
parámetros el primero indica la posición del primer carácter a obtener y el segundo indica cuantos
caracteres tomaremos, a partir del que se tomó primero.
Ejemplo.
2 #include <string>
4 int main()
5 {
6 string cad1 = "Hola Mundo";
7 string cad2;
8 ///Asignamos a cad2 la subcadena que estÃ¡ desde la
posicion 5 "M"
9 cad2 = cad1.substr(5,5);
10 cout<<"El contenido de cad1 es: "<<cad1<<endl;
11 cout<<"El contenido de cad2 es: "<<cad2<<endl;
12 return 0;
13 }
Obtener y modificar el tamaño de una cadena
Para obtener un tamaño en caso de string, tenemos dos métodos .length() y .size() ninguno recibe
parámetros, ambos tienen un retorno de tipo enterto int.
2 #include <string>
4 int main()
5 {
6 string cad="hola";
7 cout<<"Longitud con .length(): "<<cad.length()<<endl;
8 // salida 4
9 cout<<"longitud con .size(): "<<cad.size()<<endl;
10 //salida 4
11 return 0;
12 }
Para variar el tamaño de una cadena, usaremos el método .resize(), esto recibe como parámetro un
número entero que indica el nuevo tamaño de la cadena, podemos acortarla o hacerla más larga
dependiendo de la necesidad.
El código es lo siguiente.
2 #include <string>
4 int main()
5 {
6 string c = "hola";
7 //longitud de la cadena
8 cout<<"longitud: "<<c.length()<<endl;
9 //Aplicamos el resize() duplicando la longitud
10 c.resize(c.length()*2);
11 //imprimiendo la nueva longitud
12 cout<<"\nLa nueva longitud con resize() es:
"<<c.size()<<endl;
13 //la cadena permanece inalterada
14 cout<<"la cadena continua siendo: "<<c<<endl;
15 return 0;
16 }
11. Uso del método .empty()

Este método nos sirve para saber si el objeto string está vacío o contiene datos.
Ejemplo.
2 #include <string>
4 int main()
5 {
6 string cad = "";
7 if(cad.empty())///determina si la cadena se enccuentra
vacia
8 cout<<"\nLa cadena se encuentra vacia...";
9 else
10 cout<<"\nLa cadena contiene datos";
11 return 0;
12 }
12. Leer espacios con el método getline
El operador de extracción sobre cin no sirve para leer cadenas de caracteres con espacios en blanco.
Para esto se utiliza el método getline.
La sintaxis es la siguiente:
cin.getline (cadena, número, carácter final)
Getline lee la serie de caracteres desde el flujo de entrada y los guarda en una variable de tipo
cadena. Se leen hasta el final del flujo, hasta el primer carácter que coincide con el carcter final que
se haya especificado. Getline añade el carácter nulo al final de la cadena de manera automática.
3 int main()
4 {
5 char nombre[200],Color[100];
6 cout<<"Ingrese su nombre: ";cin.getline(nombre,200);
7 cout<<"\nDigite su color favorita: ";cin.getline(Color,200);
8 cout<<"\n"<<nombre<<" tu color favorito es "<<Color;
9 cin.get();
10 return 0;
11 }
Convertir número a cadena y cadena a número
Para convertir una cadena a un entero utilizamos la función atoi de la librería <cstdlib>Esta función
nos retorna el valor convertido.
Ejemplo. Programa que convierte una cadena a un entero y divide entre dos.
ENTRADA SALIDA
22 11
2 #include <cstdlib>
4 int main()
5 {
6 int i;
7 char cadena[100];
8 cout<<"Digite un numero: ";cin>>cadena;
9 i=atoi(cadena)/2;
10 cout<<"\nTu numero es: "<<i;
11 return 0;
12 }
Utilizando tipo string
2 #include <cstdlib>
4 int main()
5 {
6 int i;
7 string cadena;
8 cout<<"Digite un numero: ";cin>>cadena;
9 i=atoi(cadena.c_str())/2;
10 cout<<"\nTu numero es: "<<i;
11 return 0;
12 }

Manual Del Lenguaje C++

Încărcat de

Informații document

Titlu original

Drepturi de autor

Formate disponibile

Partajați acest document

Partajați sau inserați document

Opțiuni de partajare

Vi se pare util acest document?

Este necorespunzător acest conținut?

Drepturi de autor:

Formate disponibile

Manual Del Lenguaje C++

Încărcat de

Drepturi de autor:

Formate disponibile

Índice de Contenido

CAPITULO 1. Introducción al lenguaje C++ ...................................................................................................4

1. ¿Qué es un lenguaje de programación? ............................................................................................4

2. Herramientas necesarias para la programación ................................................................................5

3. ¿Qué es C++? ........................................................................................................................................5

3.1 Code: :Blocks ......................................................................................................................................6

3.2 Instalación ..........................................................................................................................................7

3.4 Compilar un programa .....................................................................................................................7

CAPITULO 2. Estructura de un programa ................................................................................................... 13

1. Partes de un programa ...................................................................................................................... 13

CAPITULO 3. Tipos y Variables ..................................................................................................................... 17

2. Tipos de datos fundamentales ......................................................................................................... 18

5. Inicialización de variables ...................................................................... Error! Bookmark not defined.

6. Caracteres................................................................................................ Error! Bookmark not defined.

7. Demostración de datos ......................................................................... Error! Bookmark not defined.

8. Caracteres especiales ............................................................................. Error! Bookmark not defined.

9. Despliegue de números con formato .................................................. Error! Bookmark not defined.

1. Operadores ............................................................................................. Error! Bookmark not defined.

2. Operador de asignación (=).............................................................................................................. 24

3. Convertir el tipo de datos...................................................................... Error! Bookmark not defined.

5. Operadores de asignación compleja (+=, -=,…) ............................................................................ 24

6. Incrementos y decrementos (++, --) ............................................................................................... 25

7. Operadores de relaciones y de comparación (==,!=, >, <, >=, <=) ........................................... 25

8. Operadores Lógicos ( !, &&, || ) ........................................................................................................ 26

9. Operador ternario condicional ( ? ).................................................................................................. 27

10. Operador de Coma ( , ) ..................................................................... Error! Bookmark not defined.

12. Sizeof ................................................................................................... Error! Bookmark not defined.

13. Otros operadores ............................................................................... Error! Bookmark not defined.

14. Operadores de precedencia ............................................................. Error! Bookmark not defined.

CAPITULO 5. Entrada y salida de datos ........................................................... Error! Bookmark not defined.

1. Salida de datos estándar (cout) ............................................................ Error! Bookmark not defined.

2. Entrada de datos estándar (cin)............................................................ Error! Bookmark not defined.

3. Cin y Cadenas ......................................................................................... Error! Bookmark not defined.

4. Stringstream ............................................................................................ Error! Bookmark not defined.

CAPITULO 6. Estructura de control .............................................................................................................. 27

2. Estructuras de selección o condicional ................................................ Error! Bookmark not defined.

3. Estructura de selección (if) ................................................................................................................ 28

4. Estructura de selección (if else) ........................................................... Error! Bookmark not defined.

5. Estructura condicional múltiple ........................................................................................................ 29

6. Instrucción (switch) ............................................................................................................................. 30

7. Estructura iterativa o repetitiva ......................................................................................................... 32

9. Instrucción (do while) ......................................................................................................................... 33

11. Instrucción de Salto ............................................................................ Error! Bookmark not defined.

12. The break statement .......................................................................... Error! Bookmark not defined.

13. The continue statement ..................................................................... Error! Bookmark not defined.

14. The goto statement............................................................................ Error! Bookmark not defined.

CAPITULO 7. Strings o Cadenas ................................................................................................................... 44

2. Uso de librerías ....................................................................................... Error! Bookmark not defined.

5. Convertir todo a minúscula y mayúscula ............................................ Error! Bookmark not defined.

CAPITULO 8. Arreglos .................................................................................................................................... 42

1. Vectores ................................................................................................... Error! Bookmark not defined.

Aprender programación no es solamente conocer un lenguaje de programación. También hay que

Un algoritmo es un conjunto finito de instrucciones o secuencia no ambigua, son reglas establecidas

1. ¿Qué es un lenguaje de programación?

Un compilador es un programa informático que traduce un programa, es escrito en un lenguaje de

En los sistemas GNU/Linux, será necesario tener

Para escribir y modificar el código, es posible utilizar

¿Qué significa C++?

C++ es un lenguaje de programación compilada, esto por la siguiente característica:

Código Código Programa

.cpp .obs .exe

3.1 Code: :Blocks

Si desean pueden descargarlo desde http://www.codeblocks.org/downloads/26