Programacion en C++ para Ciencia e Ingeniería

Programación en C++ para Ciencia e Ingenier´ıa, por M.Storti, L. Dalc´ın, Rodrigo Paz
Programación en C++ para Ciencia e
Ingenier´ıa
Mario Storti, Lisandro Dalc´ın, Rodrigo Paz
http://www.cimec.org.ar/prog
Facultad de Ingenier´ıa y Ciencias H´ıdricas
Universidad Nacional del Litoral http://www.unl.edu.ar
Centro de Investigación de Métodos Computacionales - CIMEC
INTEC, (CONICET-UNL), http://www.cimec.org.ar
Facultad de Ingenier´ıa y Ciencias H´ıdricas FICH - UNL slide 1
((version texstuff-1.2.9-12-ge83ced6) (date Wed May 27 12:15:38 2015 -0300)
(processed-date Wed May 27 12:45:10 2015 -0300))

Autores
• Mario Storti <mario.storti@gmail.>
• Lisandro Dalc´ın, <dalcinl@gmail.com>
• Rodrigo Paz, <rodrigo.r.paz@gmail.com>

Contents
• slide 11.....Elementos básicos de programación
slide 13.....Compilación vs. intérpretes
slide 14.....El proceso de compilación
slide 16.....El preprocesador CPP
slide 19.....Chequeo de tipos
slide 20.....Compilación por separado
slide 22.....Declaraciones y definiciones
slide 24.....Definiciones y declaraciones de variables
slide 26.....Incluyendo headers
slide 29.....Usando librer´ıas
slide 30.....Formato de include para C++
slide 31.....Un primer programa en C++
slide 32.....Namespaces
slide 35.....Estructura de un programa
slide 37.....Hello world
slide 38.....Concatenación de arreglos de caracters
slide 39.....Entrada de datos
slide 40.....Llamando a otros programas

slide 41.....Strings de C
slide 42.....Strings de C++
slide 44.....Escribir y leer de archivos
slide 46.....La clase vector
slide 49.....Ejercicios
• slide 50.....El C en C++
slide 51.....Funciones
slide 52.....Valores de retorno
slide 54.....Usando la librer´ıa est´andar de C
slide 55.....Control de ejecuci´on. True and False
slide 57.....If-else
slide 61.....while
slide 64.....do-while
slide 65.....Lazo for
slide 66.....Break and continue
slide 68.....La sentencia switch
slide 70.....goto
slide 72.....Recursion
slide 74.....Operadores
slide 75.....Operadores de auto incremento
slide 77.....Tipos de datos

slide 80.....Especificadores
slide 84.....Punteros
slide 94.....Referencias
slide 96.....Punteros a void
slide 98.....Scope de las variables
slide 100.....Definiendo variables on-the-fly
slide 104.....Variables locales
slide 108.....Punteros a variables locales
slide 109.....Variables estáticas
slide 111.....Constantes
slide 112.....Operadores. Asignación
slide 113.....Operadores matemáticos
slide 114.....Operadores relacionales
slide 115.....Operadores lógicos
slide 116.....El operador hook
slide 117.....Errores comunes con los operadores
slide 118.....Operadores de cast
slide 119.....Operador sizeof
slide 120.....typedef: Aliases de tipos
slide 121.....Estructuras
slide 125.....Arrow operator

slide 126.....Enum’s
slide 129.....Arreglos de estructuras
slide 130.....Punteros y arreglos
slide 132.....Arreglos de punteros
slide 136.....Aritmética de punteros
slide 138.....Tamaños de estructuras
• slide 139.....Programación Orientada a Objetos
slide 140.....Abstracción de datos
slide 150.....POO básica
slide 160.....Inclusion de headers
slide 164.....Estructuras enlazadas
slide 172.....Más sobre scoping
slide 173.....Tipos Abstractos de Datos (ADT)
slide 174.....Ocultando la implementación
slide 176.....Control de acceso a los miembros
slide 180.....Amistad (Friendship)
slide 183.....Anidamiento (nesting) y amistad
slide 184.....Object layout
slide 185.....Clases
slide 189.....Ocultando totalmente la implementación
slide 191.....Inicialización y cleanup

slide 193.....El constructor
slide 194.....El destructor
slide 197.....Eliminación del bloque de definición
slide 199.....Clase stash con ctor/dtor
slide 203.....Stack con ctor/dtor
slide 206.....Initialización de agregados
slide 207.....Inicialización de estructuras
slide 208.....Sobrecarga de funciones
slide 212.....Argumentos por default
slide 213.....Constantes
slide 216.....Punteros a arreglos constantes de caracteres
slide 217.....Const en argumentos de funciones
slide 218.....Const en clases
slide 219.....Objetos const y funciones de la clase
• slide 221.....Chapter 5
slide 222.....Funciones inline
slide 226.....Especificaciones de linkedicion
slide 228.....Referencias en C++
slide 234.....Reglas para las referencias
slide 236.....Paso por referencia y por copia
slide 237.....El constructor por copia

slide 238.....Sobrecarga de operadores
slide 243.....Sobrecarga de operadores unarios
slide 251.....Sobrecarga de operadores binarios
• slide 273.....Chapter
slide 274.....Otros operadores que se pueden sobrecargar
slide 275.....Creación dinámica de objetos
slide 276.....Uso de la memoria dinámica en C
slide 277.....Uso de la memoria dinámica en C++
slide 279.....Porqué usar new y no arreglos
slide 280.....Memory exhaust
slide 281.....Composición
slide 283.....Composición y la cadena de inicialización
slide 284.....Herencia
slide 287.....Redefinición de métodos
slide 289.....Herencia protegida
slide 291.....Upcasting
slide 292.....Polimorfismo
slide 294.....Ejemplo polimorfismo. Integral 1D/2D/3D
slide 298.....Clase que calcula integral 1D
slide 300.....Integral 2D. Versión cruda
slide 315.....Integral 2D. Versión mejorada

slide 318.....Integral 3D
slide 321.....Integral 1D/2D/3D. User code
slide 323.....Polimorﬁsmo: ej. suma de los elementos de un vector
slide ??.....Ejemplo clase vector sparse
• slide 326.....Contenedores de la librer´ıa STL
slide 328.....La librer´ıa STL
slide 328.....La clase vector
slide 333.....Algoritmos in-place
slide 335.....La clase list
slide 338.....La clase set
slide 342.....La clase map
slide 345.....Algoritmos
slide 347.....Programaci´on funcional

Dictado
• Docentes de la c´atedra:
Mario Storti <mario.storti@gmail.>
Lisandro Dalc´ın, <dalcinl@gmail.com>
Rodrigo Paz, <rodrigo.r.paz@gmail.com>

Elementos b´asicos de
programaci´on

I KNOW C++!

Compilación vs. intérpretes
• Algunos lenguajes de programación tienen un intérprete, por ejemplo
Matlab/Octave, Python, Perl, Lisp/Scheme. En un intérprete el usuario va
emitiendo comandos que son interpretados por el intérprete y va
devolviendo un resultado.
• Por contraposición, los lenguajes compilados el usuario escribe un
archivo con l´ıneas de código, el cuál es procesado por un compilador, que
genera código de máquina, el cual es ejecutado directamente por el
procesador.
• Ventajas de la compilación: el código suele ser más rápido, y más
compacto.
• Desventajas: el paso de código a ejecutarlo es inmediato, no hay pasos
intermedios. Usualmente los intérpretes permiten escribir tareas que se
repiten comúnmente en archivos de texto (scripts). El usuario puede
además mezclar estas funciones con comandos directamente en el
intérprete. También con los intérprete es más fácil debuggear.
• C++ es un lenguaje compilado.

El proceso de compilación
• El caso más simple es cuando todo el código del programa está en un
sólo archivo fuente:
1 $$ g++ -o prog prog.cpp
Genera un archivo ejecutable prog.
• Si el programa es muy grande conviene dividirlo en varias partes, en ese
caso
1 $$ g++ -o prog prog1.cpp prog2.cpp
• Esto requiere recompilar cada vez todos los *.cpp, si son muchos
conviene hacer
1 $$ g++ -o prog1.o -c prog1.cpp
3 $$ g++ -o prog prog1.o prog2.o
Los archivos .o son objeto, contienen código de máquina. (No tiene
relación con la Programación Orientada a Objetos).

El proceso de compilación (cont.)
• Si solo se modifica uno de los archivos (prog1.cpp), entonces sólo hace
falta recompilar ese.
2 $$ g++ -o prog prog1.o prog2.o
• Para mejor organización, si hay muchos *.o conviene ponerlos en una
librer´ıa
4 $$ ar r libprog.a prog1.o prog2.o prog3.o
5 $$ g++ -o prog main.cpp libprog.a
• A veces la librer´ıa puede ser que haya sido desarrollada por un tercero:
libpetsc.a, libmkl.a.

El preprocesador CPP
• Muchas veces hay texto que se repite muchas veces en el código. En ese
caso se pueden usar macros
1 int v[100000];
2 if (n<100000) {
3 . . . .
4 }
Se puede simplificar de la siguiente forma
1 #define MAX 100000
2 int v[MAX];
3 if (n<MAX) {
4 . . . .
5 }
Estos macros son manejados por el preprocesador, el cual se llama
normalmente cpp (por C preprocesor). Podemos pensar que el CPP
genera un paso intermedio en el cual toma el archivo prog.cpp y genera
un archivo intermedio tempo.cpp que es el que finalmente es compilado.

El preprocesador CPP (cont.)
• CPP sólo realiza manipulaciones a nivel de texto, no conoce nada
espec´ıfico del lenguaje C/C++, incluso puede usarse (y se usa) para otros
lenguajes como Fortran.
• Las directivas más usuales son
1 // Incluye todo el texto del archivo library.h
2 #include <library.h>
3
4 #define CHECK(a,n) if (a>n) error()
• Para #include el preprocesador simplemente incluye todo el archivo
mencionado en el punto donde se invoca el include.
• #define define un macro, después se puede llamar al macro en otros
lugares del código y es reemplazado por su expansión. Los macros
pueden tener argumentos. Por convención se suele dar a los macros
nombres en mayúsculas.
• Se puede conocer cual es el resultado del CPP llamando a g++ con la
opción -E
1 $$ g++ -o tempo.cpp -E prog.cpp
• El CPP es un programa separado que se puede llamar por s´ı mismo

(/usr/bin/cpp).

Chequeo de tipos
• C++ es un lenguaje tipado (aka tipeo estático, en inglés typed language),
es decir las variables tienen tipos definidos. El compilador chequea que
los resultados de las expresiones que se asignan a las variables
correspondan al tipo con el cual fueron definidas, caso contrario se
produce un error en tiempo de compilación. Esto es bueno porque
permite detectar tempranamente errores. (Es equivalente al chequeo de
unidades en F´ısica).
1 // error: asigna un string a una variable entera
2 int a;
3 a = "Hello";
• Otros lenguajes (sobre todos los interpretados) hacen chequeo dinámico
de tipo, esto implica una pérdida de eficiencia.
• El chequeo se hace también para los argumentos de una función
1 void fun(int a,string s);
2 . . .
3 fun(23,45); // ERROR (45 no es un string!)

Compilación por separado
• En C++ se favorece que un programa grande se pueda dividir en
fracciones más pequeñas. El mecanismo fundamental para dividir un
programa en partes más pequeñas es usar funciones que realizan tareas
bien definidas. Por ejemplo podemos pensar en una función int
gcd(int,int); que toma dos enteros y retorna el máximo común divisor
de los mismos.
• Las funciones tienen argumentos, una vez que la función termina su
tarea, retorna un valor. También puede ser que las funciones tengan
efectos colaterales (side effects) es decir que modifiquen sus
argumentos u otros objetos.

Compilación por separado (cont.)
• Para crear un programa que esté dividido en varios archivos, el código de
un archivo debe poder usar las funciones del otro. Supongamos que un
archivo prog1.cpp contiene a la función gcd(). Si queremos usar a gcd()
en el código de otro archivo prog2.cpp entonces el compilador debe estar
seguro que el tipo de los argumentos que se le van a pasar son los
correctos. Para eso hay que declarar a la función en prog2.cpp antes de
poder llamarla
1 int gcd(int,int); // declara gcd()
2 . . .
3 r = gcd(m,n); // la puede usar porque ya
4 // fue declarada

Declaraciones y definiciones
• Una declaración le dice al compilador que esa función existe y su
prototipo o signatura, es decir el tipo de argumentos de entrada y de
salida. Por ejemplo
1 int gcd(int,int);
• La definición por otra parte dice espec´ıficamente como la función realiza
su tarea
1 int gcd(int x, int y) {
2 int a = x, b = y;
3 if (b>a) {
4 a = y; b = x;
5 }
6 while (true) {
7 int c = a % b;
8 if (c==0) return b;
9 a = b; b = c;
10 }
11 }

Declaraciones y definiciones (cont.)
• Cada función puede estar declarada varias veces en un archivo (mientras
la signatura de la función sea la misma en cada una de las declaraciones).
1 int f(int x);
2 . . .
3 int f(int); // OK, misma signatura
• Por el contrario, la función sólo puede estar definida una sola vez en todos
los archivos del programa, ya que si no el compilador no sabr´ıa cual usar.
1 // archivo prog1.cpp
2 int f(int x) { return 2*x; }
3
4 // archivo prog2.cpp
5 int f(int x) { return 3*x; }
6 // -> ERROR: múltiplemente definida

Definiciones y declaraciones de variables
Si declaramos una variable, por ejemplo
1 int m;
si bien parace una declaración, en realidad ya tiene toda la información para
construir al objeto (un entero de 4 bytes) por lo tanto el compilador lo toma
además como una definición. Por eso no podemos incluir dos veces esta
declaración/definición, aunque sea del mismo tipo.
1 int m;
2 . . .
3 int m; // ERROR

Definiciones y declaraciones de variables (cont.)
• Si queremos forzar a que sea una declaración y no una definición
entonces debemos usar el keyword extern
1 extern int m;
2 . . .
3 extern int m; // OK
4 . . .
5 int m; // OK
• extern se puede usar también con las funciones, para hacer hincapié en
que es una declaración, por ejemplo
1 extern int f(int x);
pero no es necesario.

Incluyendo headers
• Es usual que en nuestros programas escribamos una serie de funciones
que despu´es utilizaremos en otras partes del programa.
1 // utils.cpp
2 int gcd(int m,int n) { /* . . . */ }
3 double cos(double alpha) { /* . . . */ }
4 double sin(double alpha) { /* . . . */ }
5 . . .
• Cuando queremos usar estas funciones en otro archivo fuente prog.cpp
primero tenemos que declararlas
1 // prog.cpp
2 int gcd(int m,int n);
3 double cos(double alpha);
4 double sin(double alpha);
5 . . .
6 int x = gcd(m,n);
7 double c = cos(alpha);
8 double s = sin(theta);
9 . . .
Esto se vuelve muy engorroso si hay que incluir las declaraciones en cada

uno de los archivos prog1.cpp, prog2.cpp... y utils.cpp tiene cientos de
funciones. Entonces para resolver esto incluimos todas las declaraciones
en un archivo header (cabecera) utils.h:
1 // utils.h
2 int gcd(int m,int n);
3 double cos(double alpha);
4 double sin(double alpha);
Entonces despu´es en prog1.cpp hay que solo incluir el header:
1 // prog1.cpp
2 #include "utils.h"
3 . . .
4 int x = gcd(m,n);
5 double c = cos(alpha);
6 double s = sin(theta);
7 . . .
Recordemos que lo que ocurre es que el preprocesador CPP se encarga
de buscar el archivo header y crear un archivo temporario donde la linea
del include es reemplazada por los contenidos del archivo.

Incluyendo headers (cont.)
Hay dos versiones de include,
• Una que especifica archivos en forma relativa o absoluta
1 #include ". ./utils.h"
2 #include "utils2.h"
3 #include "/usr/include/utils3.h"
4 . . .
• Otra que busca los headers en una serie de directorios que el usuario
define en el comando de compilación
1 $$ g++ -I/home/mstorti/utils -c -o prog.o prog.cpp
1 // lo encuentra en /home/mstorti/utils
2 #include <utils4.h>
3 // lo encuentra en /home/mstorti/utils/src
4 #include <src/utils5.h>
5 . . .

Usando librer´ıas
• Entonces si tengo que usar una librer´ıa matrix que est´a compuesta de
varios archivos fuente matrix2.cpp, matrix1.cpp, matrix3.cpp... en realidad
no hace falta que compile todos estos archivos, mientras que el
desarrollador de esa librer´ıa provea
Un archivo libmatrix.a con todos los matrix<n>.cpp compilados.
Un archivo header con las declaraciones de las funciones matrix.h.
• Entonces para usar la librer´ıa basta con incluir el header
1 // myprog.cpp
2 #include <matrix.h>
3 . . .
y al linkeditar incluir la librer´ıa
1 $$ g++ myprog.cpp /usr/lib/libmatrix.a -o myprog

Formato de include para C++
• La extensión que se usa para los archivos fuente puede ser .cpp, .cxx.
Para los headers se utiliza .h, .hpp, .hxx.
• Para evitar confusiones y ambigüedad con las extensiones, C++ introdujo
el concepto de include sin extensión. El traductor se encarga de convertir
el nombre y buscar la extensión.
1 #include <matrix>
• Existe una librer´ıa con muchas funciones muy útiles que es estándar de C
y se llama justamente libc.a. Entre otras incluye funciones
Matemáticas math.h: round, cos, sin, floor, ceil, ...
Input/output stdio.h: printf, scanf, read, write,
stdlib.h: rand, system, ...
En C++ estos headers es mejor incluirlos sin el .h y con una c:
1 #include <stdio.h> // C
2 #include <cstdio> // C++

Un primer programa en C++
• Para imprimir por terminal hay que usar el operador << de la clase
iostream:
1 #include <iostream>
2 . . .
3 cout << "Hola";
El operador << en C quiere decir en realidad otra cosa: es para desplazar
los bits en un n´umero entero. Pero C++ permite redeﬁnir los operadores
(lo que se llama sobrecarga de operadores) de manera que en este
contexto << quiere decir “enviar a”.

Namespaces
• A medida que una librer´ıa o programa crecen cada vez hay más funciones
y es muy posible que se produzca la colisión de nombres. Por ejemplo, si
escribo una librer´ıa para manipular matrices, puedo querer implementar
una función rand() que llena la matriz con números aleatorios.
Lamentablemente la libc ya usa el nombre rand() para generar un único
numero aleatorio.
• Una solución que se usaba en C era prependizar un prefijo identificador
de la librer´ıa a todas las funciones de la misma matrix_rand(),
matrix_sum(), matrix_prod(). Esto se vuelve muy engorroso.

Namespaces (cont.)
• C++ provee un mecanismo para evitar colisiones llamado namespaces.
Todos los archivos de la librer´ıa se incluyen en un namespace de la
siguiente forma
1 // matrix.cpp
2 namespace matrix {
3 void rand(. . .) { /* . . . */ }
4 double sum(. . .) { /* . . . */ }
5 void prod(. . .) { /* . . . */ }
6 }
• Entonces despu´es las funciones se deben llamar con el operador de
scope ::: por ejemplo matrix::rand().
• Si en un archivo fuente se va a utilizar mucho una librer´ıa entonces puede
incluir todo el namespace, de manera que no hay que hacer el scope
1 // prog.cpp
2 using namespace matrix;
3
4 rand(A);
5 double m = max(A);

Namespaces (cont.)
• Muchas utilidades y variables est´andar de C++, por ejemplo cout, est´an en
el namespace std de manera que o bien hay que hacer
1 std::cout << "Hola";
o si no
1 using namespace std;
2 . . .
3 cout << "Hola";

Estructura de un programa
• Un programa en C/C++ está compuesto de una colección de funciones y
variables. Cuando uno lanza el programa hay que determinar dónde se
empieza a ejecutar el código, o sea el punto de entrada. En C/C++ el punto
de entrada es la función main().
• La definición de una función consiste en un valor de retorno, el nombre
de la función y su lista de argumentos. El cuerpo de la función (las
instrucciones que la componen) van entre llaves.
1 int function() {
2 // Function code here (this is a comment)
3 }
• Puede haber más pares de llaves balanceadas ({}) adentro de la función
pero debe haber uno más externo que define el cuerpo de la función.
• Como main() es una función, debe respetar estos requisitos. main() no
tiene argumentos y retorna un int.

Estructura de un programa (cont.)
• C/C++ es un lenguaje de formato libre (free form), la indentación o la
posición de las variables en la l´ınea son irrelevantes.
• Tampoco es relevante la cantidad espacio en blanco (espacios, tabs, fin
de l´ınea). Cualquier cantidad de estos caracteres juntos es equivalente a
un solo espacio. De hecho un programa en C++ podr´ıa escribirse ne una
sola l´ınea.
• En C los comentarios van encerrados entre /* y */ (comentario multil´ınea).
En C++ se agregó un nuevo tipo de comentario que es por l´ınea desde un
// hasta el final de la l´ınea. (Esto viola un poco el concepto de free form).
1 /* Comentario multilinea tipo C */
2 int /* comentario en el medio del código */ x;
3 // Comentario por linea tipo C++

Hello world
1 // Saying Hello with C++
2 #include <iostream> // Stream declarations
4
5 int main() {
6 cout << "Hello, World. I am "
7 << 8 << " Today" << endl;
8 }
• Le pasamos a cout una serie de elementos de diferentes tipos: enteros,
arreglos de caracteres.
• endl es un final de l´ınea.
• En C se llama string a un pedazo de texto entre comillas. No confundir
con la clase string de C++ que cumple funciones similares pero es mucho
más potente. A los strings de C se los debe llamar más correctamente
arreglos de caracteres.
• Dentro del texto entre comillas se pueden incluir secuencias de escape
que permiten incluir caracteres especiales con precedidos de una barra
invertida: n es un caracter de fin de l´ınea, t un TAB, 0 un NULL, una
barra invertida.

Concatenaci´on de arreglos de caracters
• Para incluir arreglos de caracteres muy largos se puede simplemente
poner uno a continuaci´on de otro (puede ser en diferentes l´ıneas). El CPP
se encarga de juntarlos todos en una sola l´ınea: "aaa" "bbbb" es
completamente equivalente a "aaabbbb".
1 // Character array Concatenation
4
5 int main() {
6 cout << "This is far too long to put on a "
7 "single line but it can be broken up with "
8 "no ill effectsnas long as there is no "
9 "punctuation separating adjacent character "
10 "arrays.n";
11 }

Entrada de datos
cout es console output, cin es console input y permite ingresar datos.
1 // Converts decimal to octal and hex
4
5 int main() {
6 int number;
7 cout << "Enter a decimal number: ";
8 cin >> number;
9 cout << "value in octal = 0"
10 << oct << number << endl;
11 cout << "value in hex = 0x"
12 << hex << number << endl;
13 }
oct y hex son manipulators, cambian el estado de cout.

Llamando a otros programas
Dentro de la librer´ıa est´andar de C hay una funci´on muy potente system() que
permite llamar a otros programas desde un programa en C/C++. Se le pasa un
arreglo de caracteres con el comando que uno ejecutar´ıa en la l´ınea de
comandos.
1 // Call another program
2 #include <cstdlib> // Declare ‘‘system()’’
4
5 int main() {
6 system("date -u");
7 }

Strings de C
Manipular arreglos de caracteres en C se vuelve muy engorroso.
2 #include <cstring>
4
5 int main() {
6 // concatenate two character arrays s1 and s2
7 char s1[ ] = "Hola ";
8 char s2[ ] = "mundo.";
9 cout << strlen(s1) << endl;
10 int n1 = strlen(s1);
11 int n2 = strlen(s2);
12 char *s = new char[n1+n2+1];
13 strncpy(s,s1,n1);
14 strncpy(s+n1,s2,n2);
15 s[n1+n2] = ’0’;
16 cout << s << endl;
17 delete[ ] s;
18 return 0;
19 }

Strings de C++
Para eso C++ tiene objetos llamados strings que permiten manipularlos en
forma mucho m´as simple y con menor probabilidad de error.
2 #include <string>
4
5 int main() {
6 // concatenate two character arrays s1 and s2
7 string s1 = "Hola ";
8 string s2 = "mundo.";
9 string s = s1 + s2;
10 cout << s << endl;
11 return 0;
12 }

Strings de C++ (cont.)
1 //: C02:HelloStrings.cpp
2 // The basics of the Standard C++ string class
3 #include <string>
6
7 int main() {
8 string s1, s2; // Empty strings
9 string s3 = "Hello, World."; // Initialized
10 string s4("I am"); // Also initialized
11 s2 = "Today"; // Assigning to a string
12 s1 = s3 + " " + s4; // Combining strings
13 s1 += " 8 "; // Appending to a string
14 cout << s1 + s2 + "." << endl;
15 }

Escribir y leer de archivos
• Las funciones est´an declaradas en el header <fstream>.
• Para escritura hay que crear un objeto de tipo ofstream (como cout).
• Para lectura hay que crear un objeto de tipo ifstream (como cin).
• La funci´on getline(stream,s) lee una l´ınea de stream y la guarda en el
string s
1 // Copy one file to another, a line at a time
2 #include <string>
3 #include <fstream>
5 int main() {
6 ifstream in("Scopy.cpp"); // Open for reading
7 ofstream out("Scopy2.cpp"); // Open for writing
8 string s;
9 while(getline(in, s)) // Discards newline char
10 out << s << "n"; // . . . must add it back
11 }

Escribir y leer de archivos (cont.)
Otro ejemplo es guardar todo el archivo en un s´olo string:
1 // Read an entire file into a single string
2 #include <string>
6
7 int main() {
8 ifstream in("FillString.cpp");
9 string s, line;
10 while(getline(in, line))
11 s += line + "n";
12 cout << s;
13 }
¿Que pasa si queremos guardar cada l´ınea en un string separado?

La clase vector
• Un vector es un contenedor que permite guardar un número indefinido de
elementos en forma contigua e indexada.
• Se puede agrandar o achicar en forma dinámica, sin perder los elementos
preexistentes.
• Está templatizado o sea que se pueden definir vectores de diferentes
tipos: vector<int>, vector<double>, vector<string>,...
• La función push_back() permite agregar un nuevo objeto al final del vector.

La clase vector (cont.)
1 // Copy an entire file into a vector of string
2 #include <string>
5 #include <vector>
7
8 int main() {
9 vector<string> v;
10 ifstream in("Fillvector.cpp");
11 string line;
12 while(getline(in, line))
13 v.push-back(line); // Add the line to the end
14 // Add line numbers:
15 for(int i = 0; i < v.size(); i++)
16 cout << i << ": " << v[i] << endl;
17 }

La clase vector (cont.)
vector tambi´en puede guardar cualquier otro tipo, por ejemplo enteros:
1 // Creating a vector that holds integers
3 #include <vector>
5
6 int main() {
7 vector<int> v;
8 for(int i = 0; i < 10; i++)
9 v.push-back(i);
10 for(int i = 0; i < v.size(); i++)
11 cout << v[i] << ", ";
12 cout << endl;
13 for(int i = 0; i < v.size(); i++)
14 v[i] = v[i] * 10; // Assignment
15 for(int i = 0; i < v.size(); i++)
16 cout << v[i] << ", ";
17 cout << endl;
18 }

Ejercicios
1. Crear un programa que abre un archivo y cuenta las palabras (separadas
por whitespace). Ayuda: el operador >> lee de a palabras de un ifstream.
2. Crear un programa que cuenta la cantidad de caracteres que tiene un
archivo.
3. Crear un programa que cuenta la cantidad de ocurrencias de una palabra
espec´ıﬁca en un archivo. Ayuda: usar == para comparar strings.
4. Escribir un programa que imprime las l´ıneas de un archivo de texto en
orden inverso.

El C en C++

Funciones
• Para evitar errores, C/C++ usa el concepto de prototipo o signatura de
funciones.
• Antes de usar una función hay que declararla.
• Al usar la función los argumentos con que es llamada deben coincidir con
el el tipo que fueron declarados.
1 int translate(float x, float y, float z);
2 int translate(float, float, float);
• En algún lugar la función tiene que estar definida, aqu´ı los nombres de los
argumentos tienen que aparecer para poder ser usados en la función
1 int translate(float x, float y, float z) {
2 x = y = z;
3 // . . .
4 }

Valores de retorno
• La declaración de la función debe indicar el valor de retorno. Si la función
no retorna nada usar void:
1 int f1(void); // Returns an int, takes no arguments
2 int f2(); // Like f1() in C++ but not in Standard C
3 float f3(float, int, char, double); // Returns a float
4 void f4(void); // Takes no arguments, returns nothing
• Para retornar el valor usar la sentencia return.
• Si la función retorna void entonces no se debe llamar a return.
• Se puede tener más de un return en la función. Son puntos de salida.
• El valor de retorno debe ser compatible con el indicado en la declaración.

Valores de retorno (cont.)
1 // Use of ‘‘return’’
4
5 char cfunc(int i) {
6 if(i == 0)
7 return ’a’;
8 if(i == 1)
9 return ’g’;
10 if(i == 5)
11 return ’z’;
12 return ’c’;
13 }
14
15 int main() {
16 cout << "type an integer: ";
17 int val;
18 cin >> val;
19 cout << cfunc(val) << endl;
20 } ///:˜

Usando la librer´ıa estándar de C
• C incluye una librer´ıa de funciones estándar (también llamada libc). Todos
los compiladores que satisfacen la norma deben incluir estas funciones
en su libc. Esto permite la portabilidad de los programas entre diferentes
compiladores.
• Muchos compiladores incluyen funciones adicionales que NO están en la
norma. Por lo tanto hay que prever que si se lleva el proyecto a otra
plataforma puede ser que estas funciones no existan en esa plataforma.
• La documentación de las librer´ıas usualmente incluye la declaración de la
función y en que header (archivo .h) está.
• En caso que la librer´ıa no esté documentada hay que directamente ver los
headers para encontrarel prototipo de la función.

Control de ejecución. True and False
• Todas los condicionales (por ejemplo if o while) usan expresiones lógicas
como por ejemplo el resultado del operador de comparación A==B. Esta
expresión retorna directamente un valor lógico true o false. No confundiir
con el operador de asignación A=B.
• Lo mismo ocurre con otros operadores de comparación
1 A==B; //It’s equal?
2 A!=B; //It’s distinct?
3 A<B; //It’s smaller?
4 A<=B; //It’s smaller or equal?
5 A>B; //It’s greater?
6 A>=B; //It’s greater or equal?
Si la expresión no retorna un valor booleano, entonces C trata de convertirlo.
Para todos los valores numéricos (enteros, float, double, char, punteros) el
valor es falso si es cero, y en cualquier otra caso es verdadero. Entonces por
ejemplo el valor lógico de las siguientes expresiones es equivalente
1 if (n) { . . . }
2 if (n!=0) { . . . . }

3 if (!(n==0)) { . . . . } // ! is negation

If-else
El if puede existir de dos formas, con o sin else
1 if (expression)
2 statement
3
4 // o
5
6 if (expression)
7 statement
8 else
9 statement
En ambos casos statement puede ser una sentencia simple, terminada en una
coma, o compuesta, es decir un bloque de instrucciones encerrado en {}.
1 if (n>0) x=23; // sentencia simple
2
3 if (n>0) { // sentencia compuesta
4 x=23;
5 s="haha";
6 }

If-else (cont.)
1 int i;
2 cout << "type a number and ’Enter’" << endl;
3 cin >> i;
4 if(i > 5)
5 cout << "It’s greater than 5" << endl;
6 else
7 if(i < 5)
8 cout << "It’s less than 5 " << endl;
9 else
10 cout << "It’s equal to 5 " << endl;
11
12 cout << "type a number and ’Enter’" << endl;
13 cin >> i;
14 if(i < 10)
15 if(i > 5) // ‘‘if’’ is just another statement
16 cout << "5 < i < 10" << endl;
17 else
18 cout << "i <= 5" << endl;
19 else // Matches ‘‘if(i < 10)’’
20 cout << "i >= 10" << endl;

If-else (cont.)
Notar que todo el if actúa como una sola instrucción, por eso no hace falta
encerrarlo con un {}.
1 if(i > 5)
2 cout << "It’s greater than 5" << endl;
3 else
4 if(i < 5)
6 else
8
9 // es equivalente a
10
11 if(i > 5) { cout << "It’s greater than 5" << endl; }
12 else {
13 if(i < 5)
15 else
17 }
Es una convención mut útil indentar ambos bloques del if para mejorar la

legibilidad.

while
while, do-while y for controlan lazos (loops) de ejecución.
1 while(expression)
2 statement
Como antes statement puede ser simple o compuesto. La expresión se evalúa
hasta que la condición de falso. Para que el lazo termine en algún momento
es necesario que statement tenga algún efecto que haga que eventualmente
expression de falso
1 int x=0;
2 while (x<5) x=34; // ejecuta una vez el lazo
3 x=0;
4 while (x<5) x=2; // ejecuta indefinidamente
5
6 x=0;
7 while (x<5) x++; // ejecuta el bloque 5 veces

while (cont.)
1 // Guess a number (demonstrates ‘‘while’’)
4
5 int main() {
6 int secret = 15;
7 int guess = 0;
8 // != is the not-equal conditional:
9 while(guess != secret) { // Compound statement
10 cout << "guess the number: ";
11 cin >> guess;
12 }
13 cout << "You guessed it!" << endl;
14 }

while (cont.)
En C la condición dentro del condicional puede ser tan elaborada como se
quiera, la única restricción es que debe retornar un valor lógico (o convertible
a lógico), incluso puede ser que el cuerpo del lazo este vac´ıo
1 while(do-a-lot-of-work()) ;
2 while(do-a-lot-of-work()) { }
por ejemplo
1 while(is-prime(n)) n++; // busca el primer n no primo

do-while
1 do
2 statement
3 while(expression);
Es similar al while pero ahora statement es ejecutado antes de veriﬁcar la
condici´on.
1 n=0;
2 while (n>0) /* body. . .*/ ; // body is not executed
3
4 n=0;
5 do
6 /* body. . .*/ ; // body is executed once
7 while (n>0);

Lazo for
La forma del for es
1 for(initialization; conditional; step)
2 statement
Se utiliza mucho cuando simplemente se quiere ejecutar un bloque una serie
de veces bien deﬁnida
1 for (int i=0; i<n; i++) {
2 // This block is executed n times
3 }
Esto es completamente equivalente a
1 int i=0;
2 while(i<n) {
3 // This block is executed n times
4 i++;
5 }

Break and continue
Adentro de cualquiera de los bloques while, do-while o for se puede usar
break para salir del lazo inmediatamente.
1 while (true) { // Infinite loop
2 cout << "Enter a number: ";
3 cin >> n;
4 if (is-prime(n)) break;
5 cout << n << " es un número compuesto" << endl;
6 }
Si hay más de un lazo anidado entonces break sale del lazo más interno
1 for (int i=0; i<n; i++) {
2 for (int j=0; j<n; j++) {
3 if (j>i*i) break;
4 //. . .
5 }
6 // break transfers execution here
7 }

Break and continue (cont.)
continue es similar a break pero hace que se ejecute la siguiente iteraci´on del
lazo
1 for (int j=0; j<n; j++) {
2 //. . . .
3 if (!is-prime(j)) continue;
4 // do this only for primes. . .
5 }

La sentencia switch
Va comparando la variable selector hasta que coincide con uno de los case
1 switch(selector) {
2 case integral-value1 : statement; break;
7 (. . .)
8 default: statement;
9 }
por ejemplo
1 char c;
2 //. . .
3 switch (c) {
4 case ’a’: cout << "It’s an a" << endl; break;
5 case ’b’: cout << "It’s a b" << endl; break;
6 default: cout << "Neither a or b" << endl;
7 }

Si no se incluyen los break entonces la ejecuci´on sigue al siguiente case.

goto
La sentencia goto permite saltar a otro punto del programa. Se lo considera
muchas veces como una mala práctica de programación, aunque a veces
puede ser útil, por ejemplo para saltar de varios lazos anidados cuando se
encuentra una condición.
1 // The infamous goto is supported in C++
4
5 int main() {
6 long val = 0;
7 for(int i = 1; i < 1000; i++) {
8 for(int j = 1; j < 100; j += 10) {
9 val = i * j;
10 if(val > 47000)
11 goto bottom;
12 // Break would only go to the outer ’for’
13 }
14 }
15 bottom: // A label
16 cout << val << endl;

17 }

Recursion
Muchos problemas son intr´ınsecamente recursivos, es decir la solución de un
problema está dada por la solución de uno menor con el mismo algoritmo,
por ejemplo la definición de factorial se puede hacer en forma recursiva
n! = n · (n − 1)! (1)
en realidad esto es cierto si n > 1, la definición correcta es
n! =



1; si n = 1;
n · (n − 1)! ; si n > 1
(2)
decimos que el caso n = 1 corta la recursión.
Usando llamadas recursivas a funciones podemos implementar la función
factorial
1 int factorial(int n) {
2 if (n==1) return 1;
3 else return n*factorial(n-1);
4 }

Recursion (cont.)
La recursión es muy elegante para resolver problemas, pero puede ser
demandante en términos de recursos. Es más simple si calculamos el
factorial con un lazo
1 int factorial(int n) {
2 int fac=1;
3 for (int j=2; j<=n; j++) fac *= j;
4 return fac;
5 }
El operador *= quiere decir aqu´ı
1 fac = fac*j;
Se puede aplicar a otros operadores binarios como +*-/, operadores lógicos
||&&, concatenación de strings...

Operadores
Los operadores no son más que funciones, con una sintaxis especial. Un
operador toma una o más series de valores y devuelve un resultado.
1 a = b + c;
podemos pensar que es traducido por el compilador en
1 a = sum(b,c);
Una cuestión importante con los operadores es la precedencia de los
mismos. Para los operadores matemáticos es similar a las reglas que
aprendemos en la escuela
1 a = b * c + d;
es equivalente a
1 a = (b * c) + d;
porque * tiene mayor precedencia que +. Ante la duda, se pueden introducir
paréntesis para forzar el orden en que se evalúan las expresiones.

Operadores de auto incremento
El operador ++ es un atajo para una operación muy común en programación:
incrementar una variable de tipo entero en una unidad. Hay dos variantes,
prefija y postfija, ambos tienen el mismo efecto colateral (incrementar la
variable) pero en el prefijo retorna el valor de la variable incrementada, y el
postfijo sin incrementar
1 int m,n=5;
2 m = n++; // n=6, m=5
3
4 int m,n=5;
5 m = ++n; // n=6, m=6
Por ejemplo la siguiente función retorna el primer primo siguiente (mayor o
igual) a n.
1 int next-prime(int n) {
2 while (!is-prime(n++)) { }
3 return n;
4 }

Operadores de auto incremento (cont.)
También hay autodecremento -- prefijo y postfijo.
1 int n=10;
2 while (n >= 0) cout << n-- << ", ";
3 cout << "Boom!!" << endl;
1 [mstorti@galileo garage]$$ ./boom.bin
2 10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0, Boom!!

Tipos de datos
Dijimos que C/C++ es un lenguaje de tipeo estático, es decir en el momento
de crear las variables hay que decir de que tipo son. Hay tipos de datos
built-in como enteros, floats, strings, que ya están definidos en el compilador,
y también el programador puede crear sus propios tipos, muchas veces por
composición. Por ejemplo si estamos creando la base de datos de una
empresa podemos querer tener un tipo de dato employee que contenga un
string (el nombre), un entero (el número de empleado) y un float (el sueldo).
Los tipos built-in son
• char un entero de al menos 8 bits, usualmente se usa para almacenar
caracteres.
• int un entero de al menos 16 bits (2 bytes)
• float un número de punto flotante con al menos 4 bytes (simple precisión)
• double un número de punto flotante con al menos 8 bytes (doble
precisión).

Tipos de datos (cont.)
1 // Defining the four basic data
2 // types in C and C++
3
4 int main() {
5 // Definition without initialization:
6 char protein;
7 int carbohydrates;
8 float fiber;
9 double fat;
10 // Simultaneous definition & initialization:
11 char pizza = ’A’, pop = ’Z’;
12 int dongdings = 100, twinkles = 150,
13 heehos = 200;
14 float chocolate = 3.14159;
15 // Exponential notation:
16 double fudge-ripple = 6e-4;
17 }

Tipos de datos (cont.)
Como los tipos básicos tienen una cantidad de bits fija pueden representar un
tamaño máximo. Por ejemplo los enteros de 16 bits sólo pueden estar entre
-32768 y +32768. Además el tamaño del tipo (la cantidad de bits) puede
depender de la máquina y del compilador, entonce los valores máximos y
m´ınimos (los l´ımites) están definidos en headers float.h y limits.h,
1 #include <climits>
2
3 cout << "Minimum and maximum integers are "
4 << endl << INT-MIN << " and " << INT-MAX
5 << endl;
6 }
1 [mstorti@galileo garage]$$ ./intmax.bin
2 Minimum and maximum integers are
3 -2147483648 and 2147483647

Especificadores
• Para representar enteros se utiliza un bit de los 32 disponibles para
representar el signo.
• Si sólo se van a utilizar enteros positivos entonces podemos usar ese bit
para extender un factor 2 el rango.
• int en el rango [-2147483648,2147483647]
• unsigned int en el rango [0,4294967295]
unsigned es un specifier, otros son: signed, unsigned, short, long.

Especiﬁcadores (cont.)
1 //: C03:Specify.cpp
2 // Demonstrates the use of specifiers
5
6 int main() {
7 char c;
8 unsigned char cu;
9 int i;
10 unsigned int iu;
11 short int is;
12 short iis; // Same as short int
13 unsigned short int isu;
14 unsigned short iisu;
15 long int il;
16 long iil; // Same as long int
17 unsigned long int ilu;
18 unsigned long iilu;
19 float f;
20 double d;
21 long double ld;

22 cout
23 << "n char= " << sizeof(c)
24 << "n unsigned char = " << sizeof(cu)
25 << "n int = " << sizeof(i)
26 << "n unsigned int = " << sizeof(iu)
27 << "n short = " << sizeof(is)
28 << "n unsigned short = " << sizeof(isu)
29 << "n long = " << sizeof(il)
30 << "n unsigned long = " << sizeof(ilu)
31 << "n float = " << sizeof(f)
32 << "n double = " << sizeof(d)
33 << "n long double = " << sizeof(ld)
34 << endl;
35 } ///:˜

Especiﬁcadores (cont.)
1 [mstorti@galileo garage]$$ ./sizes.bin
2
3 char= 1
4 unsigned char = 1
5 int = 4
6 unsigned int = 4
7 short = 2
8 unsigned short = 2
9 long = 8
10 unsigned long = 8
11 float = 4
12 double = 8
13 long double = 16
14 [mstorti@galileo garage]$$

Punteros
Al declarar variables lo que estamos haciendo es dar un nombre a un pedazo
de la memoria. Cuando decimos int n lo que estamos diciendo al compilador
es: resérveme 4 bytes de la memoria y a partir de ahora lo voy a llamar n. El
operador & nos muestra en que posición de la memoria fue alocada la variable
1 int n;
2 cout << "variable n is in position " << &n << endl;
1 [mstorti@galileo garage]$$ ./ptr.bin
2 variable n is in position 0x7fff1c46d92c
Los punteros son impresos normalmente en formato de hexadecimales, si
quisiéramos verlo en formato decimal podemos castear (convertir) el puntero
a un entero
1 int n;
2 cout << "variable n is in position " << (long)&n << endl;
1 [mstorti@galileo garage]$$ ./ptr.bin
2 variable n is in position 140737075615260

Punteros (cont.)
3
4 int dog, cat, bird, fish;
5
6 void f(int pet) {
7 cout << "pet id number: " << pet << endl;
8 }
9
10 int main() {
11 int i, j, k;
12 cout << "f(): " << (long)&f << endl;
13 cout << "dog: " << (long)&dog << endl;
14 cout << "cat: " << (long)&cat << endl;
15 cout << "bird: " << (long)&bird << endl;
16 cout << "fish: " << (long)&fish << endl;
17 cout << "i: " << (long)&i << endl;
18 cout << "j: " << (long)&j << endl;
19 cout << "k: " << (long)&k << endl;
20 }

Punteros (cont.)
El resultado es
1 [mstorti@galileo garage]$$ ./pointers.bin
2 f(): 4196630
3 dog: 6295956
4 cat: 6295960
5 bird: 6295964
6 fish: 6295968
7 i: 140736631158572
8 j: 140736631158568
9 k: 140736631158564

Punteros (cont.)
• La dirección en memoria de un variable puede cambiar de una corrida a
otra.
• Funciones, variables y globales parecen estar en sectores de la memoria
diferentes.
• Enteros parecen ocupar 4 bytes.
• Las posiciones en la memoria se pueden guardar en una variable de tipo
especial llamada puntero
1 int number;
2 int *number-p = &number;
• El sufijo _p o simplemente p indica que es un puntero (es sólo una
convención).

Punteros (cont.)
• Algunos programadores ponen el * junto al tipo.
1 int* number-p;
Es totalmente equivalente, pero confuso,
1 int* number-p,n-p,m-p;
Declara a number_p, pero n_p y m_p son declarados enteros. Lo correcto es
1 int *number-p,*n-p,*m-p;
• Podemos asignar a una variable de tipo puntero la dirección de una
variable, lo cual nos permite modificarla a través de ese proxy
1 int number=100;
2 int *number-p = &number;
3 *number-p = 25; // Ahora number contiene 25!!

Punteros (cont.)
• OJO: el hecho de declarar una variable de tipo puntero no significa que
esté apuntando a un objeto válido, es deber del programador asignarle al
puntero una posición válida, si no puede dar error en tiempo de ejecución
al querer usar el puntero.
1 int *p;
2 cout << "contenido de *p " << *p << endl; // ERROR
3 int x;
4 p = &x;
5 cout << "contenido de *p " << *p << endl; // OK

Punteros (cont.)
Los punteros tienen un montón de usos, el primero que veremos es el de
causar que una función modifique un objeto. El mecanismo de paso de
variables en C/C++ es por copia.
3
4 void f(int a) {
5 cout << "&a = " << &a << endl;
6 cout << "a = " << a << endl;
7 a = 5;
8 cout << "a = " << a << endl;
9 }
10
11 int main() {
12 int x = 47;
13 cout << "&x = " << &x << endl;
14 cout << "x = " << x << endl;
15 f(x);
16 cout << "x = " << x << endl;
17 }

Punteros (cont.)
Imprime:
1 [mstorti@galileo sources]$$ ./try40.bin
2 &x = 0x7ffe99dd33ec
3 x = 47
4 &a = 0x7ffe99dd33bc
5 a = 47
6 a = 5
7 x = 47
8 [mstorti@galileo sources]$$ x = 47
Como la variable a en f() es una copia, resulta que la modiﬁcaci´on que se
hace en f() no persiste, de manera que queda el mismo valor.

Punteros (cont.)
En esta versión en cambio, pasamos la dirección donde está x:
3
4 void f(int* p) {
5 cout << "p = " << p << endl;
6 cout << "*p = " << *p << endl;
7 *p = 5;
8 cout << "p = " << p << endl;
9 }
10
11 int main() {
12 int x = 47;
13 cout << "x = " << x << endl;
14 cout << "&x = " << &x << endl;
15 f(&x);
16 cout << "x = " << x << endl;
17 }

Punteros (cont.)
Imprime:
1 [mstorti@galileo sources]$ ./try41.bin
2 x = 47
3 &x = 0x7ffcf3047dcc
4 p = 0x7ffcf3047dcc
5 *p = 47
6 p = 0x7ffcf3047dcc
7 x = 5
8 [mstorti@galileo sources]$

Referencias
Los punteros son muy ´utiles pero engorrosos porque hay que estar
dereferenciando al puntero cada vez. C++ introdujo las referencias que son
completamente equivalentes a los punteros pero evitan la dereferenciaci´on.
3
4 void f(int& r) {
5 cout << "r = " << r << endl;
6 cout << "&r = " << &r << endl;
7 r = 5;
8 cout << "r = " << r << endl;
9 }
10
11 int main() {
12 int x = 47;
13 cout << "x = " << x << endl;
14 cout << "&x = " << &x << endl;
15 f(x); // Looks like pass-by-value,
16 // is actually pass by reference
17 cout << "x = " << x << endl;
18 }

Referencias (cont.)
Imprime:
1 [mstorti@galileo sources]$ ./try42.bin
2 x = 47
3 &x = 0x7ffd244d1aac
4 r = 47
5 &r = 0x7ffd244d1aac
6 r = 5
7 x = 5
8 [mstorti@galileo sources]$

Punteros a void
• El compilador s´olo acepta que asignemos a una variable de tipo int* la
direcci´on de una variable de tipo int, en otro caso da un error
1 int *p;
2 int n;
3 p = &n; // OK
4 double a;
5 p = &a; // Error
• El tipo void* permite almacenar un puntero a cualquier tipo de variable
1 void* vp;
2 char c;
3 int i;
4 float f;
5 double d;
6 vp = &c;
7 vp = &i;
8 vp = &f;
9 vp = &d;

Punteros a void (cont.)
• Una vez que una dirección es asignada a un void* el compilador no puede
saber de que tipo es el objeto al cual apunta, y por lo tanto no se puede
dereferenciar
1 int i = 99;
2 void* vp = &i;
3 *vp = 3; // Error de compilacion
• Para poder recuperar el objeto tenemos que castear el puntero, de esa
forma le estamos diciendo al compilador que es del tipo indicado
1 int i = 99;
2 void* vp = &i;
3 *((int*)vp) = 3; // OK!
• Si casteamos al tipo incorrecto el compilador no protesta, pero se puede
producir un error en tiempo de ejecución
1 int i = 99;
2 void* vp = &i;
3 // Compila OK, posible error en tiempo de ejecución
4 *((string*)vp) = "Hello world";

Scope de las variables
Una variable existe desde su deﬁnici´on hasta la siguiente llave que cierra (}).
Eso se llama el scope de la variable.
1 // How variables are scoped
2 int main() {
3 int scp1;
4 // scp1 visible here
5 {
6 // scp1 still visible here
7 //. . . . .
8 int scp2;
9 // scp2 visible here
10 //. . . . .
11 {
12 // scp1 & scp2 still visible here
13 //. .
14 int scp3;
15 // scp1, scp2 & scp3 visible here
16 // . . .
17 } // scp3 destroyed here
18 // scp3 not available here

19 // scp1 & scp2 still visible here
20 // . . .
22 // scp3 & scp2 not available here
23 // scp1 still visible here
24 //. .

Definiendo variables on-the-fly
En C todas las variables deben ser definidas al comienzo del scope. En C++
se pueden definir en cualquier lugar.
1 // On-the-fly variable definitions
4
5 int main() {
6 //. .
7 { // Begin a new scope
8 int q = 0; // C requires definitions here
9 //. .
10 // Define at point of use:
11 for(int i = 0; i < 100; i++) {
12 q++; // q comes from a larger scope
13 // Definition at the end of the scope:
14 int p = 12;
15 }
16 int p = 1; // A different p
17 } // End scope containing q & outer p
18 cout << "Type characters:" << endl;

19 while(char c = cin.get() != ’q’) {
20 cout << c << " wasn’t it" << endl;
21 if(char x = c == ’a’ | | c == ’b’)
22 cout << "You typed a or b" << endl;
23 else
24 cout << "You typed " << x << endl;
25 }
26 cout << "Type A, B, or C" << endl;
27 switch(int i = cin.get()) {
28 case ’A’: cout << "Snap" << endl; break;
29 case ’B’: cout << "Crackle" << endl; break;
30 case ’C’: cout << "Pop" << endl; break;
31 default: cout << "Not A, B or C!" << endl;
32 }
33 }

Definiendo variables on-the-fly (cont.)
Las variables que están fuera de todas las funciones son globales, su scope
es todo el programa, inclu´ıdo dentro de las funciones.
1 // == file1.cpp ==
2 // Demonstration of global variables
5
6 int globe;
7 void func();
8 int main() {
9 globe = 12;
10 cout << globe << endl;
11 func(); // Modifies globe
12 cout << globe << endl;
13 }
14 // == file2.cpp ==
15 // Accessing external global variables
16 extern int globe;
17 // (The linker resolves the reference)
18 void func() {

19 globe = 47;
20 }

Variables locales
Las variables que existen dentro de un scope son locales, tambi´en se les
llama autom´aticas ya que son creadas en el momento de llegar a ese bloque.
La memoria que le es asignada no tiene porque ser siempre la misma, por lo
tanto la variable no retiene el valor que le fue asignado antes.
1 void f(int x) {
2 int a;
3 cout << "a en f(): " << a << endl;
4 cout << "&a en f(): " << &a << endl;
5 a=x;
6 cout << "a en f() despues de asignar: " << a << endl;
7 }
8
9 void g(int x) {
10 int a;
11 cout << "a en g(): " << a << endl;
12 cout << "&a en g(): " << &a << endl;
13 a=x;
14 cout << "a en g() despues de asignar: " << a << endl;
15 }
16
17 void h(int x) {

18 int a;
19 f(435);
20 cout << "a en h(): " << a << endl;
21 cout << "&a en h(): " << &a << endl;
22 a=x;
23 cout << "a en h() despues de asignar: " << a << endl;
24 }
25
26 int main() {
27 f(23);
28 g(45);
29 f(23);
30 g(45);
31 h(234);
32 return 0;
33 }

Variables locales (cont.)
El resultado es:
1 [mstorti@galileo garage]$$ ./try2.bin
2 a en f(): 0
3 &a en f(): 0x7fff6df56d1c
4 a en f() despues de asignar: 23
5 a en g(): 23
6 &a en g(): 0x7fff6df56d1c
7 a en g() despues de asignar: 45
8 a en f(): 45
9 &a en f(): 0x7fff6df56d1c
11 a en g(): 23
12 &a en g(): 0x7fff6df56d1c
13 a en g() despues de asignar: 45
14 a en f(): 59
15 &a en f(): 0x7fff6df56cdc
17 a en h(): 45
18 &a en h(): 0x7fff6df56d1c

19 a en h() despues de asignar: 234

Punteros a variables locales
Si una variable sale de scope, es un error tratar de utilizar punteros que
apuntaban a esa variable.
1 int *p;
2 for (int j=0; j<N; j++) {
3 int z;
4 p = &z;
5 . . .
6 }
7 // ERROR (z no existe mas)
8 cout << "contenido de *p " << *p << endl;

Variables estáticas
Si queremos que el área asignada a una variable local sea siempre el mismo,
entonces le agregamos el keyword static. Un ejemplo clásico es una función
que cuenta cuantas veces fue llamada:
1 void f() {
2 static int count=0;
3 cout << "f() fue llamada " << count << " veces" << endl;
4 cout++;
5 }
6
7 int main() {
8 for (int j=0; j<10; j++)
9 f();
10 return 0;
11 }

Variables est´aticas (cont.)
El resultado es:
1 [mstorti@galileo garage]$ ./try14.bin
2 f() fue llamada 0 veces
12 [mstorti@galileo garage]$

Constantes
Si se utilizará muchas veces un valor que es constante se pueden hacer a
través de un macro
1 #define PI 3.141459
o bien a través de una variable de tipo const
1 const double pi = 3.141459;
Es más prolijo esto último (le permite al compilador hacer chequeo de tipo).

Operadores. Asignación
El caracter = se utiliza como el operador de asignación:
1 A=4;
Lo que está a la izquierda de = es el lvalue y lo que está a la derecha el rvalue.
El rvalue puede ser cualquier expresión. El compilador la evalua y asigna el
resultado a lo que está en el lvalue. Ahora bien lo que está en el lvalue no
puede ser cualquier cosa, debe ser una variable o cualquier otra cosa a la
cual se le pueda asignar un valor. Por ejemplo no puede ser una constante, es
decir no podemos hacer
1 4=A;

Operadores matemáticos
Los operadores matemáticos binarios usuales son +-*/. Cada uno de ellos se
puede usar en forma de acumulación +=, -=, *=, /=. Por ejemplo
1 x += 5;
es equivalente a
1 x = x + 5;

Operadores relacionales
Son
1 >, <, >=, <=, ==, !=

Operadores lógicos
Son && (and) y || (or). Recordar que en C/C++ muchos tipos se castean
automáticamente a bool, siendo 0 el valor falso y cualquier otro valor
verdadero. Cuando se imprimen los valores booleanos dan 0 o 1. ! es la
negación.
Son operadores cortocircuitados es decir si hacemos
1 expr1 && expr2
entonces primero se evalua expr1 y si da falso, entonces expr2 NO se evalúa,
ya que no es necesario porque la expresión lógica resultará en falso de todas
formas. Eso puede ser importante, por ejemplo
1 if (n>0 && m/n!=3) . . .
está garantizado que no dará error si n==0 ya que si es as´ı directamente la
división por n no se hará. Lo mismo ocurre en
1 expr1 | | expr2
si la primera da verdadero.

El operador hook
Es una forma muy compacta de escribir un if-else. Por ejemplo esta expresión
calcula el m´ınimo de dos valores
1 x = (m<n ? m : n);
Se puede usar también en un lvalue. La siguiente expresión asigna al menor
de m,n el valor 23.
1 (m<n ? m : n) = 23;

Errores comunes con los operadores
• Las reglas de precedencia a veces son simples, pero si se escriben
expresiones complejas ya no. Ante la duda utilizar par´entesis.
• No confundir = con ==.

Operadores de cast
• Si el compilador ve que estamos mezclando tipos en una asignación,
insertará una operación de cast (conversión de tipo) automáticamente
1 int x=5;
2 double z=x; // OK
3 z=23.3;
4 x=z; // se pierde la mantisa (truncamiento)
5 x = (int) z; // cast explicito
6 x = int(z); // otra forma del cast explicito
7
8 int ixp = &x; // error, no puede convertir ptr a int
9 long int ixp2 = (long int)&x; // OK!
10 long int ixp3 = static-cast<long int>(&x); // OK!

Operador sizeof
• Retorna el tama˜no de una variable o tipo en bytes
1 cout << "sizeof(char) " << sizeof(char) << endl; // ->1
2 cout << "sizeof(int) " << sizeof(int) << endl; // ->4
3 cout << "sizeof(float) " << sizeof(float) << endl; // ->4
4 cout << "sizeof(double) " << sizeof(double) << endl; // ->8
5
6 double a;
7 cout << "sizeof(a) " << sizeof(a) << endl; // ->8
8 cout << "sizeof(&a) " << sizeof(&a) << endl; // ->8 (in x86-64)
9 int x;
10 cout << "sizeof(&x) " << sizeof(&x) << endl; // ->8 (in x86-64)

typedef: Aliases de tipos
• Permite hacer un alias de un tipo a un nuevo tipo
1 typedef unsigned long int ulong;
2 . . .
3 ulong x;
• Simple para tipos básicos, más complicado para punteros
1 typedef int *int-p;
• La regla es que se escribe una l´ınea como la declaración de una variable
con typedef al principio y reemplazando la variable por el tipo.
• Esto permite hacer expresiones más cortas pero además tiene un uso muy
importante. Permitir cambiar de tipo todas las variables de un programa
1 typedef float scalar;
2 scalar i,j,k;
Para cambiar todo el programa a doble precisión:
1 typedef double scalar;

Estructuras
• Se pueden deﬁnir nuevos tipos agrupando varios miembros en una
estructura. Los miembros de la estructura se toman con el operador .:
1 struct A {
2 char c;
3 int m;
4 float f;
5 double b;
6 };
7
8 void printa(A a) {
9 cout << "structure is (" << a.c << "," << a.m << ","
10 << a.f << "," << a.b << ")" << endl;
11 }
12 . . .
13
14 A a1, a2;
15 a1.c = ’h’;
16 a2.m = 23;
17 printa(a1);

Estructuras (cont.)
Se pueden tomar punteros a estructuras y enlazarlas
1 struct cell {
2 char c;
3 double x;
4 cell *next;
5 };
6
7 int main() {
8 cell c1,c2,c3;
9 c1.c = ’a’; c1.x = 1; c1.next = &c2;
10 c2.c = ’b’; c2.x = 2; c2.next = &c3;
11 c3.c = ’c’; c3.x = 3; c3.next = &c1;
12
13 cell *cp = &c1;
14 for (int k=0; k<20; k++) {
15 cout << "cp " << cp << ", c "
16 << (*cp).c << ", x " << (*cp).x << endl;
17 cp = (*cp).next;
18 }
19 }

Estructuras (cont.)
1 cell c1,c2,c3;
2 c1.c = ’a’; c1.x = 1; c1.next = &c2;
3 c2.c = ’b’; c2.x = 2; c2.next = &c3;
4 c3.c = ’c’; c3.x = 3; c3.next = &c1;
c='a' x=1
next
c1
c='b' x=2
next
c2
c='c' x=3
next
c3

Estructuras (cont.)
El resultado es
1 [mstorti@galileo garage]$$ ./try8.bin
2 cp 0x7fff571b2d20, c a, x 1
3 cp 0x7fff571b2d00, c b, x 2
4 cp 0x7fff571b2ce0, c c, x 3
5 cp 0x7fff571b2d20, c a, x 1
6 . . .
7 cp 0x7fff571b2d20, c a, x 1
8 cp 0x7fff571b2d00, c b, x 2

Arrow operator
Como en el ejemplo anterior es muy común la compinación (*cp).x es decir
tener un puntero a una estructura cp y querer tomar un miembro x de la
estructura apuntada. Como es tan común hay un atajo sintáctico para eso
1 (*cp).x es equivalente a cp->x
Entonces el lazo del programa anterior pasa a ser
1 for (int k=0; k<20; k++) {
2 cout << "cp " << cp << ", c " << cp->c
3 << ", x " << cp->x << endl;
4 cp = cp->next;
5 }

Programacion en C++ para Ciencia e Ingeniería

Programacion en C++ para Ciencia e Ingeniería

Recomendados

Recomendados

Más contenido relacionado

Destacado

Destacado (20)

Similar a Programacion en C++ para Ciencia e Ingeniería

Similar a Programacion en C++ para Ciencia e Ingeniería (20)

Más de Storti Mario

Más de Storti Mario (12)

Último

Último (11)

Programacion en C++ para Ciencia e Ingeniería