C++

Ian Cortez

General

Mostrar strings en consola: Se usa el comando cout <<.

Recibir información del usuario: Existen algunas formas para recibir informa-
ción del usuario:

• Usando cin: cin se utiliza para obtener datos de tipo int, float y char. Esto se
debe a que solo considera el valor ingresado hasta encontrar un espacio. Se usa
cin >>.
• Usando (cin.getline): El usuario puede ingresar una serie de caracteres y po-
nerlos en un array de caracteres. Se usa ası́: cin.getline(n, 10, ENTER). n es
la variable donde se guardará la cadena, 10 son los caracteres que se guardarán
y ’\n’ indica hasta donde se leerán los datos.

Salto de lı́nea: El salto de lı́nea se representa como ’\n’, y con: endl.

Tipos de datos

Int: El dato de tipo entero representa número enteros tanto negativos como posi-
tivos. Ocupa alrededor de 32-bits en la memoria. Tı́picamente ocupan valores de
entre (-2147483648) a (2147483647).

Char: El dato de tipo char es un caracter, este dato ocupa 4-bits de memoria.

Float: El dato de tipo float es un dato que utiliza notación de punto flotante y se usa
para almacenar números decimales. Se utilizan 32-bits de memoria para almacenar
este dato. Tiene una precisión en el rango de (1,18 × 1038 ) hasta (3,4 × 1038 ); en los
positivos y negativos.

Double: El dato de tipo double guarda números en la memoria usando notación de

punto flotante. Tiene el doble de precisión que el float y ocupa 64-bits.

1
Condicionales

If y else: Los condicionales if y else se utilizan para realizar una acción si se cumple
una acción y realizar otra en los otros casos. Adicionalmente, existe el ”else if” que
funciona como un if diferente del if inicial. La estructura es la siguiente:

if (x > 0){
cout << ”El número es mayor a 0.” << endl;
} else {
cout << ”El número es menor o igual a 0.” << endl;
}

Switch: La función de ”switch” funciona como un ”if - else” pero en el caso del
”switch” este salta directamente al caso que corresponde y ejecuta la acción perte-
neciente al caso.

int x;
cout << ”Ingrese un valor: ”; cin >> x
switch (x){
case 1: cout << ”El número es 1” << endl; break;
case 2: cout << ”El número es 2” << endl; break;
case 3: cout << ”El número es 3” << endl; break;
default: cout << ”El número es mayor a 3” << endl; break;
}

Bucles:

While: Este bucle verifica una condición y luego realiza una acción si se cumple.

int i = 1;
while (i ≤ 10){
cout << i << endl;
i++;
}

Do, While: El bucle realiza una acción y luego verifica una condición para volver
a ejecutarla, si no continua el programa. Se ejecuta al menos una vez.

int i = 0;
do {
cout << i << endl;
i++;
} while(i < 10);

For: Este bucle inicia una variable de iterador, se indica la condición para terminar
el bucle y una expresión que indique el incremento del iterador en cada repetición.
Van en ese orden y separados por punto y coma.

2
for (int i=0; i<10; i++){
cout << i << endl;
}

3
Arrays

Crear un array: Para inicializar un array se debe establecer el tipo de variable, su

nombre y la cantidad de elementos que va a tener. Ejemplo:

int numeros[5];

4
Cadenas

Declarar una cadena: Para declarar una cadena se necesita declarar un array de
caracteres con la cantidad de caracteres que entrarán en el array.

char palabra[10];

Inicializar una cadena: Las cadenas se inicializan de la misma manera que cual-
quier otro array. Se puede asignar un texto y C++ entenderá que se trata de un
arreglo de caracteres y les asignará una posición.

char palabra[4] = ”Hola”;

La otra forma es declara caracter por caracter dentro de {}.

char palabra[4] = {’H’, ’o’, ’l’, ’a’};

strlen(): Devuelve un entero con la longitud de la cadena, incluyendo espacios. Se

usa ası́:
int longitud = strlen(palabra);

strcpy(): Copia una variable con una cadena de caracteres a otra. Se usa

strcpy(cadena2, cadena1);

Donde cadena2 es la cadena vacı́a y cadena1 tiene el contenido que queremos poner
en la cadena vacı́a.

strcmp(): Compara dos cadenas según su tamaño y su orden alfabetico.

strcmp(cadena1, cadena2);

Al devolver un entero, se puede usar para igualdad y comparación.

strcat(): Concatena(junta) dos cadenas de caracteres.

strcat(cadena2, cadena1)

La cadena2 es la cadena que va en la parte delantera, la cadena1 se agrega al final

de la cadena 2.

strrev(): Invierte los caracteres de variable de tipo cadena y reemplaza la cadena

invertida en la variable.
strrev(palabra);

strupr(): Convierte todos los caracteres de una variable de tipo cadena a mayúscu-
las y lo guarda en la variable.

strupr(palabra);

strlwr(): Convierte todos los caracteres de una variable de tipo cadena a minúsculas
y lo guarda en la variable.
strlwr(palabra);

5
atoi(): Convierte una cadena de caracteres al valor entero correspondiente. Ejemplo:

char palabra[] = ”123”;

int entero;
numero = atoi(palabra);
En este ejemplo, la cadena ”123” se convierte a un entero que se almacena en la
variable entero.

atof(): Convierte una cadena de caracteres a su valor real correspondiente. Ejemplo:

char palabra[] = ”12.5”;

float real;
numero = atof(palabra);
En este ejemplo, la cadena ”12.5” se convierte en un número real y se almacena en
la variable real.

6
Ordenamiento

Ordenamiento burbuja: Toma dos valores en un array y los compara. Si el primer

valor es mayor al segundo los intercambia, si no pasa al siguiente par de valores.
Algoritmo de método burbuja:

for (i=0; i<tamañoArreglo; i++){

for (j=0; j<tamañoArreglo; j++){
if (array[j] > array[j+1]){
aux = array[j];
array[j] = array[j+1];
array[j+1] = aux;
}
}
}

Ordenamiento por inserción: El ordenamiento por inserción compara un valor

dentro de un array con todos los elementos a la izquierda de este. Si el valor que
se compara a los demás es menor, se cambia de posición hasta que la condición se
cumpla.

int arreglo[n] = {a1 , a2 , . . ., an };

for (int i=0; i < tamañoArreglo; i++){
pos = i;
aux = numero[i];
while ((pos > 0) && (numero[pos-1] > aux)){
numero[pos] = numero[pos-1];
pos -= 1;
}
numeros[pos] = aux;
}

Ordenamiento por selección:

Búsqueda

Búsqueda secuencial: Este tipo de búsqueda recorre todos los elementos de un

arreglo hasta encontrar el elemento deseado y devolver si está en el arreglo o no. No
es necesario que el arreglo este ordenado. Ejemplo:

int a[] = {3, 4, 2, 1, 5};

int i, dato;
char band = ’F’;
dato = ”dato deseado”;

i = 0;
while ( (band == ’F’) && (i < ”tamaño de a[]”) ) {
if (a[i] == dato) band = ’V’;
i++;

7
}
if (band == ’V’){
cout << ”El numero a buscar esta en la posición: ” << i - 1 << endl;
} else if {
cout << ”El número no esta en el arreglo.” << endl;
}

Búsqueda binaria: Este tipo de búsqueda recorre un arreglo de elementos ordena-

dos. Empezando por la mitad del arreglo, determina si el elemento a buscar esta en
la primera o segunda mitad del arreglo. Ignora todos los elementos de la mitad que
no haya tomado y repite la acción para la mitad que eligió. Se repite hasta encontrar
el número o hasta ser incapaz de encontrar el número. Ejemplo:

int a[] = {1, 2, 3, 4, 5};

int inf, sup, mitad, dato;
char band = ’F’;
dato = ”dato deseado”;

inf = 0;
sup = ”tamaño del arreglo” → 5;
while (inf ≤ sup ) {
mitad = (inf + sup)/2;
if (a[mitad] == dato){
band = ’V’;
break;
} else if (numeros[mitad] > dato){
sup = mitad - 1;
} else if (numeros[mitad] < dato){
inf = mitad + 1;
}
}

if (band == ’V’){
cout << ”El numero a buscar esta en la posición: ” << i - 1 << endl;
} else if {
cout << ”El número no esta en el arreglo.” << endl;
}

8
Estructuras
Concepto: Las estructuras son colecciones de uno o más tipos de elementos deno-
minados campos. Se debe especificar el nombre de la estructura además del tipo de
dato y el nombre del campo que pertenece a la estructura.

Inicializar una estructura: Las estructuras se inician antes de la función principal

o el main. Estas se ven de la siguiente forma:

struct Persona{
char nombre[20];
char apellido[20];
int edad;
};

En el ejemplo, la estructura Persona tiene un campo llamado nombre que es un

arreglo de 20 caracteres, otro campo llamado apellido que es un arreglo de caracteres
del mismo tamaño y una campo de tipo entero para la edad en años.

Declarar variables struct: Para declara una variable de tipo struct existen dos
formas. La primera, donde se pone los nombres de los elementos de tipo struct al
terminar la inicialización del struct. La segunda donde se declaran las variables de
tipo struct en la función principal. Adicionalmente, se puede crear un arreglo donde
se almacenará cada variable que corresponda al struct.

1. struct Persona{
char nombre[20];
char apellido[20];
int edad;
}P1, P2, P3;
2. struct Persona{
char nombre[20];
char apellido[20];
int edad;
};

int main(){
struct Persona P1, P2, P3;
}
3. struct Persona{
char nombre[20];
char apellido[20];
int edad;
}personas[100];

Estructuras anidada: Se pueden utilizar estructuras dentro de otras estructuras.

A esto se le conoce como anidar estructuras.

Llenar los campos dentro del struct: El llenado de los campos de un struct
se realiza dependiendo del tipo de campo que se este llenando. Se debe referir al
campo que se quiere llenar con el nombre de la variable del tipo struct y un punto.
Ejemplo:

9
struct Persona{
char nombre[20];
char apellido[20];
int edad;
};

int main(){
struct Persona P1;
P1.nombre = ”Ian”;
P1.apellido = ”Cortez”;
P1.edad = 17;
}

10
Funciones

Concepto: Las funciones se usan para realizar una tarea concreta y puede ser
diseñadas e implementadas de manera independiente del código principal, la función
int main().

Inicializar una función: Las funciones se inicializan fuera de la función principal.

Necesitan un nombre y un tipo de valor para retornar. Las funciones también pueden
necesitar parámetros para funcionar pero no es necesario. Los parámetros que se le
den a la función deben ser el mismo tipo valor que la función va a retornar. Pasarle
parámetros numéricos a una función se le conoce como pasar parámetros por valor,
dar el valor exacto con el que la función va a trabajar. Adicionalmente, las funciones
pueden ser de tipo void, donde no retornará ningún valor.

tipo nombre(tipo var1, tipo var2, . . .){

instrucciones;
return (tipo);
}

Ejemplos:

1. int cuadrado(int x){

x ∗ = x;
return x;
}
2. void mostrar(float x, float y){
cout << x << y;
}

Prototipos de función: La estructura general de un programa incluye lo que se

llama un prototipo de función. Sirve para indicarle al compilador que existe una
función definida en el programa con el nommbre, tipo, y parámetros de la función.

#include <iostream>
using namespace std;

void hacer(tipo var1, . . .);

int main(){
instrucciones;
}

void hacer(){
instrucciones;
}

Plantillas de función: Las plantillas de función se utilizan cuando no se sabe que

tipo de dato se va a utilizar para una función. Se puede utilizar tanto en el valor de
retorno de la función como en el tipo de variables que se le da a la función. Ejemplo:

11
template <class TIPOD>
void funcion (TIPOD var, . . .){
instrucciones;
}

Cuando se utiliza una plantilla de función, se debe incluir en el prototipo de la

función.

template <class TIPOD>

void funcion (TIPOD var, . . .);

int main(){
instrucciones;
}

template <class TIPOD>

void funcion (TIPOD var, . . .){
instrucciones;
}

Parámetros por referencia: Al dar un valor por referencia a una función, la

función alterará directamente el lugar de memoria donde se este almacenando la
variable dada. Dentro de los parámetros que se le pasa a la función debe ir el sı́mbolo
de ”&” al lado del tipo de valor de la variable. Esto indica la posición en memoria
de la variable y permite modificarlo directamente en esa posición. Un ejemplo es:

#include <iostream>
using namespace std;

void valNuevo(int&, int&);

int main(){
int num1, num2;
cout << ”Digite 2 numeros: ”; cin >> num1 >> num2;
valNuevo(num1, num2);

cout << ”El valor de num1 nuevo es: ” << num1 << endl;
cout << ”El valor de num2 nuevo es: ” << num2 << endl;
}

void valNuevo(int& xnum, int& ynum){

cout << ”El valor de num1 es: ” << xnum << endl;
cout << ”El valor de num2 es: ” << ynum << endl;
xnum = 89;
ynum = 45;
}

En este ejemplo, se ingresan dos valores, num1 y num2. Estos se le pasa a la función
”valNuevo” donde se muestra el valor que se le asigno a la variable por el usuario.
Luego se cambia directamente el valor de las variables num1 y num2 por 89 y 45
respectivamente. Por lo que, los nuevos valores de num1 y num2 que se muestran
en consola serı́an 89 y 45.

12
Retornar más de un valor: Para que una función retorne más de un valor se
necesita usar los parámetros por referencia ya que la función esta limitada a retornar
solo un valor. Adicionalmente se pueden retornar otros tipos de dato que contengan
más valores dentro.

Pasar arrays a funciones: Es posible pasar arrays de todo tipo a una función
como parámetros. Para realizar esto es necesario pasar por valor a la función el
nombre del array y su tamaño. Ejemplo:

Prototipo de función:
void nombreFuncion(tipo nombreArray[], int tamañoArray);

Parámetros de función:
void nombreFuncion(tipo nombreArray[], int tamañoArray){
instrucciones;
}

Llamar función:
nombreFuncion(nombreArray, tamañoArray);

Nota: Cuando se pasa un array a una función, la función alterará directamente el

valor del array, como usar un puntero. Esto se debe a que tanto C como C++ no
permiten pasar un array como parámetro de una función y lo interpretan como si
se pasará un parámetro por referencia.

Pasar matrices como parámetros: Al igual que cuando se pasan arrays como
parámetros de una función, se debe ingresar el tipo de la variable de la matriz con
la cantidad de columnas especificada. Además se debe pasar la cantidad de filas y
columnas por separado. Ejemplo:

Prototipo de función:
void nombreFuncion(tipo matriz[][NroColumnas], int NroFilas, int NroColumnas);

Parámetros de función:
void nombreFuncion(tipo matriz[][NroColumnas], int NroFilas, int NroColumnas){
instrucciones;
}

Llamar función:
nombreFuncion(nmatriz, NroFilas, NroColumnas);

Pasar parámetros de tipo struct: Para pasar una variable de tipo struct se debe
dar el nombre de la estructura dentro de los parámetros de la función. Ejemplo:

Estructura:
struct Persona{
char nombre[20];
int edad;
}p1;

Prototipo de función:

13
void nombreFuncion(Persona);

Parámetros de función:
void nombreFuncion(Persona p){
instrucciones;
}

Llamar función:
nombreFuncion(p1);

Recursividad: Una función que se llama ası́ misma para resolverse, en esta debe
incluirse un caso base y una forma de llegar al caso base. Utilizar mucha recursividad
puede aumentar considerablemente la complejidad algorı́tmica. Ejemplo:

long factorial(long n){

if(n==0) n = 1;
else n = n * factorial(n-1);
return n;
}

14
Punteros

Concepto: Un puntero es una variable que guarda la dirección de memoria donde

se guarda otra variable.

LLamar la dirección de memoria: Para llamar a la dirección de memoria de una

variable se utiliza ”&” al lado del nombre de la variable. Ejemplo:

int num = 20;

cout << ”Numero: ” << num << endl; //imprime 20
cout << ”Dirección: ” << &num << endl;

Crear una variable puntero: Para crear una variable puntero se le asigna un
tipo, se coloca un ”*” y se nombra la variable. Esto apunta a cualquier posición de
memoria. Para guardar la posición de memoria de una variable se llama la dirección
de memoria de esa variable. Ejemplo:

int num = 20, *dirNum = &num;

cout << ”Numero: ” << num << endl; //imprime 20
cout << ”Dirección: ” << dirNum << endl;

Mostrar un valor usando una variable puntero: Para mostrar el valor señalado
por un puntero se usa un ”*”. Se llama del siguiente modo:

int numero = 5, *dirNum = &numero;

cout << *dirNum << endl; //se imprime el valor de numero

Arrays y punteros: Se pueden usar punteros para guardar la posición del valor
dentro de un array. El puntero debe empezar en la posición del primer valor del
array. Luego se puede cambiar el valor al que apunta el puntero a los demás valores
del array.

int numeros[] = {1, 3, 5, 7};

int *dirNum;
dirNum = numeros; // tambien se puede hacer dirNum = &numeros[0];
for (int i=0; i<4; i++){
cout << ”El valor es: ” << *dirNum++ << endl;
cout << ”Posicion del array: ” << i << endl;
}

En este ejemplo, ”dirNum” apunta a la dirección de memoria de la posición inicial

de ”numeros”. Se usa el ”*” antes del puntero para mostrar el valor al que apunta,
no la dirección. Al sumar uno ”dirNum”, se cambia la variable a la que apunta al
siguiente valor del array.

Asignación dinámica de arreglos: Se puede crear arrays sin desperdiciar memo-

ria.Para esto se separa la memoria necesaria para almacenar todos los valores del
array. Para esto se usa la librerı́a ”stdlib.h”. Se utilizan new y delete.
new separa la memoria necesaria para todos los elementos del arreglo y delete
borra la memoria que se usó. Se hace del siguiente modo:

15
int cantidadElementos, *arreglo;
arreglo = new int[cantidadElementos];
for (int i=0; i<cantidadElementos; i++){
arreglo[i] = i;
}
for (int i=0; i<cantidadElementos; i++){
cout << arreglo[i] << endl;
}
delete[] arreglo;
return 0;

En este ejemplo, se crea un array separando memoria suficiente para todos los
elementos que se van a incluir en el array. Luego, se le asigna a cada espacio del
array un valor y se luego se muestran. Al final, se borra la memoria separada para
el array.

Transmisión de direcciones: Es posible pasar un puntero como un argumento a

una función. Esto se hace del siguiente modo:

Prototipo:
void nombreFuncion(tipo *, tipo *);

Parámetros de función:
void nombreFuncion(tipo *dirVar1, tipo *dirVar2){
instrucciones;
}

Llamar función:
int main(){
int a = 5, b = 10;
nombreFuncion(&a,&b);
return 0;
}

Transmitir arreglos a funciones con punteros: También es posible transmitir

arreglos, utilizando punteros, a una función. Se debe pasar el número de elementos
en el array y además la dirección de la primera posición del array. Ejemplo:

Prototipo de función:
tipo nombreFuncion(tipo *, int cantidadElementos);

Parámetros de función:
tipo nombreFuncion(tipo *dirArray, int cantidadElementos){
instrucciones;
return tipo;
}

Llamar función:
int main(){
int cantidadElementos = 5;
int numeros[cantidadElementos] = {1, 2, 3, 4, 5};

16
 nombreFuncion(numeros, cantidadElementos);
return 0;
}

Punteros a matrices: Se pueden crear matrices dinámicas de una manera similar

a la creación de arreglos dinámicos. Se realiza del siguiente modo:

int **puntero matriz, nFilas, nCols;

int main(){
cout << ”Ingrese las filas y columnas: ”;
cin >> nFilas >> nCols;

//Reservar memoria
puntero matriz = new int*[nFilas];
for (int i=0; i<nFilas; i++){
puntero matriz[i] = new int[nCols];
}

for (int i=0; i<nFilas; i++){

for (int j=0; j<nCols; j++){
cout << ”Ingrese un valor: ”;
cin >> *(*(puntero matriz+i)+j);
}
}
}

Se elimina la memoria separada del siguiente modo:

for (int i=0; i<nFilas; i++){

delete[] puntero matriz[i];
}
delete[] puntero matriz;

Punteros a estructuras: Se crea una estructura y se crea una variable pertene-

ciente a esa estructura. Ası́ mismo, se crea un puntero con la dirección de memoria
de la variable perteneciente a la estructura. Ejemplo:

Crear variables y asignar al puntero:

struct Persona{
char nombre[30];
int edad;
}persona, *puntero persona = &persona;

LLenado de datos:
cin.getline(puntero persona − >nombre, 30, ’\n’);
cin >> puntero persona − > edad;

Si se quiere hacer esto para un array perteneciente a una estructura se debe realizar
del siguiente modo:

17
Crear variables y asignar al puntero:
struct Persona{
char nombre[30];
int edad;
}persona[3], *puntero persona = persona;

LLenado de datos:
for (int i=0; i<3; ++i){
cin.getline((puntero persona + i) − >nombre, 30, ’\n’);
cin >> (puntero persona + i)− > edad;
}

Consideraciones:

1. Cuando se crea una variable y se quiere crear un puntero que apunte a la

dirección de memoria de dicha variable, el tipo de variable deben ser el mismo.

18
Pilas

Concepto de Pilas: Una pila es una estructura de datos que solo se pueden in-
troducir y eliminar por un lado llamado cima. En las pilas, el último en entrar es el
primero en salir, sistema LIFO(Last In First Out).

Operaciones de pila: Las operaciones que se pueden realizar con una pila son
Insertar(push) donde se añade un elemento en la cima de la pila y Quitar(pop)
donde se elimina un elemento de la pila.

Forma de la pila: La pila consiste de grupos de datos y un puntero, a esto se les

llama nodos. El puntero en cada nodo apunta a los datos del siguiente nodo en la
pila, a excepción del último puntero(del primer elemento en ingresar a la pila) que
tiene un puntero nulo.

Construir una pila:

19