PDF de programación - Manual de Programación en Lenguaje C++

Manual de Programación en Lenguaje C++

Proyecto de Investigación: Métodos de Funciones de Base Radial para la Solución de EDP.

Servicio Social - DGSCA-UNAM, 2008.

Autor: Linda I. Olivares Flores

Índice general

1. Introducción al lenguaje de programación C++

1.1. Lenguaje C++ . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.2. C++ en un entorno Linux . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.3. Estructura de un programa en C++ . . . . . . . . . . . . . . . . . . . . . . .
1.4. Variables y Tipos de datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.4.1. Conversión de Tipos . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.5. Espacios de nombres en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6. Bloque de sentencias . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.1. Sentencia if
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.2. Comparaciones en C++ . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.3. Asignaciones en C++ . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.4. Sentencia Switch . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.5. Sentencia For . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.6. Sentencias While y do While . . . . . . . . . . . . . . . . . . . . . . .
1.6.7. Sentencia exit y return . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.6.8. Algunos ejemplos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.7. Funciones y Estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.7.1. Funciones . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.7.2. Estructuras . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8.1. Arreglos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.8.2. Apuntadores
1.9. Manejo de Memoría Dinámica . . . . . . . . . . . . . . . . . . . . . . . . . . .
1.10. Estructura de Datos . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .

1.8. Arreglos y Apuntadores

3
3
3
7
9
10
11
12
12
12
13
13
14
14
15
15
18
18
18
20
20
20
23
26

2

Capítulo 1

Introducción al lenguaje de
programación C++

1.1. Lenguaje C++

C++ es un lenguaje de programación, creado a mediados de 1980 por Bjarne Strousstrup,

como extensión del lenguaje C. Este lenguaje abarca tres paradigmas de la programación:

1. Programación Estructurada

2. Programación Genérica

3. Programación Orientada a Objetos

En la actualidad, C++ es un lenguaje versátil, potente y general. Su éxito entre los
programadores le ha llevado a ocupar el primer puesto como herramienta de desarrollo de
aplicaciones, ya sea en Windows o GNU Linux, que es el sistema operativo en el cual basa-
remos este tutorial.

1.2. C++ en un entorno Linux

Comenzaremos diciendo que los programas se pueden escribir en cualquier editor de textos
de GNU, entre ellos se encuentran emacs, vim, kate, gedit, nan, guardando dichos archivos
con extensión .cpp, los cuales serán compilados en GNU/linux utilizando el compilador GNU
de C++, llamado gcc que puede compilar C, C++, y que además se apega al estandar ANSI,
permitiendo la portabilidad de estos códigos. Dicho compilador se invoca con el comando
gcc.

3

Para compilar ponemos la siguiente línea en una terminal previamente ubicada en el

directorio que contiene nuestro archivo:

g++ programa.cpp -o programa.out

-o indica el nombre del archivo de salida el cual será el ejecutable de nuestro proyecto.

Luego para ejecutar, escribimos sobre la línea de comandos: ./programa.out y entonces

podremos ejecutar nuestro programa.

Cuando creamos pequeños programas la compilación de éstos es muy fácil, pero cuando se
trabaja con proyectos grandes, con varios archivos fuente la compilación resulta más dificil,
por lo que Linux proporciona la utilería make de GNU, el cual busca un archivo make donde
encontrará toda la información que necesita para crear el ejecutable, si encuentra el archivo
busca la palabra makefile o Makefile, que son nombres predeterminados.

Los archivos make contienen información acerca de la compilación y enlace del programa,
con una sintaxis muy especifica. Un makefile se define como una lista de normas y depen-
dencias con sus correspondientes comandos para crear objetivos, utilizando dichas normas y
dependencias.

Un archivo Makefile es un archivo de texto en el cual se distinguen cuatro tipos básicos

de declaraciones:

1. Comentarios: Al igual que en los programas, contribuyen a un mejor entendimiento
de las reglas definidas en el archivo. Los comentarios se inician con el caracter #, y se
ignora todo lo que continúe después de ella, hasta el final de línea.

2. Variables: Se definen utilizando el siguiente formato:

nombre = dato

De esta forma, se simplifica el uso de los archivos Makefile. Para obtener el valor se
emplea la variable encerrada entre paréntesis y con el caracter $ al inicio, en este
caso todas las instancias de $(nombre) serán reemplazadas por datos. Por ejemplo, la
siguiente definición

SRC = main.c

origina la siguiente línea:

gcc $ SRC

y será interpretada como:

gcc main.c

Sin embargo, pueden contener más de un elemento. Por ejemplo:

objects = programa 1.o programa 2.o programa 3.o \ programa 4.o programa 5.o

4

programa: $(objects) gcc -o programa $(objects)

Hay que notar que make hace distinción entre mayúsculas y minúsculas.

3. Reglas Explícitas: Estas le indican a make qué archivos dependen de otros, así como

los comandos requeridos para compilar un archivo en particular. Su formato es:

archivoDestino: archivosOrigen

Esta regla indica que, para crear archivoDestino, make debe ejecutar comandos sobre
los archivos archivosOrigen. Por ejemplo:

main: main.c funciones.h
gcc -o main main.c funciones.h

esto significa que, para crear el archivo de destino main, deben existir los archivos
main.c y funciones.h y además debe ejecutar el comando:

gcc -o main main.c funciones.h

4. Reglas Implícitas: Son similares a las reglas explícitas, pero no indican los comandos
a ejecutar, sino que make utiliza los sufijos (extensiones de los archivos) para determinar
que comandos ejecutar. Por ejemplo:

funciones.o: funciones.c funciones.h

origina la siguiente línea:

$(CC) $(CFLAGS) c funciones.c funciones.h

Existe un conjunto de variables que se emplean para las reglas implícitas, y existen dos
categorías: aquellas que son nombres de programas (como CC) y aquellas que tienen
los argumentos para los programas (como CFLAGS). Estas variables son provistas
y contienen valores predeterminados, sin embargo, pueden ser modificadas, como se
muestra a continuación:

CC = gcc CFLAGS = -Wall -O2

En el primer caso, se ha indicado que el compilador que se empleará es gcc y sus
parámetros son -Wall -O2.

Este código debe estar en un archivo llamado Makefile o makefile o tendriamos que
usar la opción -f que nos permite ubicarnos en el directorio raíz.

5

Ejemplo de Makefile.

CPPFLAGS =
CPPLIBS =
main: Conjunto.o main.o
g++ -o main main.o Conjunto.o $(CPPLIGS)

Conjunto.o: Conjunto.cpp Conjunto.h
g++ $(CPPFLAGS) -c -o Conjunto.o Conjunto.cpp

main.o: Conjunto.h
g++ $(CPPFLAGS) -c -o main.o main.cpp

clean:
rm *.o main

Para ejecutar este archivo, escribimos sobre la linea de comandos: make, esta opción

nos creará el archivo de salida, que será el ejecutable.

Es aquí donde viene la verdadera prueba de fuego del programador: cuando lanza la orden

de compilar y enlazar su programa.

Todos los módulos involucrados en los pasos anteriores, compilador, analizador sintáctico
y enlazador pueden detectar errores en nuestro código y mostrar los mensajes correspondien-
tes.

Estos errores son considerados solo de tres tipos:

1. De tiempo de compilación. Se engloban aquí los errores detectados por preprocesa-

dor, el analizador sintáctico y el propio compilador. Los hay meramente sintácticos.

2. De tiempo de enlazado. Son detectados por el enlazador. Por ejemplo una llamada

a función cuya definición no aparece por ninguna parte.

3. De tiempo de (runtime). Existe finalmente una última clase de errores: los que se
producen cuando se ejecuta el programa; son precisamente los más difíciles de diag-
nosticar y verificar, sobre todo en aplicaciones grandes.

6

1.3. Estructura de un programa en C++

Para darnos una idea chequemos el siguiente programa

//Mi primer programa en C++
# include <iostream>
using namespace std;
int main (){
count << "hello World";
return 0;
}

El programa anterior es típico de los programadores aprendices, el resultado de su im-

presión en pantalla es la frase:

”hello World”

Es uno de los más simples programas que pueden estar escritos en C + +, pero ya contiene
los componentes fundamentales que todos los programas escritos en C + +. Vamos a ver
línea por línea en el código lo que hemos escrito:

//Mi primer programa en C++

Se trata de una línea de comentario. Todas las líneas que comiencen con dos signos barra
se consideran comentarios y no tienen ningún efecto sobre el comportamiento del programa.
El programador puede usar para incluir breves explicaciones o alegaciones dentro del código
fuente en sí. En este caso, la línea es una breve descripción de lo que es nuestro programa.

# include <iostream>

Las líneas que comienza con un símbolo de sostenido # son directivas para el preproce-
sador. En este caso, la directiva # include <iostream>le dice al preprocesador que incluya
el iostream estándar de archivo. Este archivo específico (iostream) incluye las declaraciones
de la norma básica de entrada y salida de la biblioteca de C++.

using namespace std;

Todos los elementos del modelo de librería de C++ se declaran dentro de lo que se deno-
mina un espacio de nombres. Por lo tanto,