programacion en c++ para ciencia e´...

Programación en C++ para Ciencia e Ingenierı́a, por M.Storti, L. Dalcı́n, Rodrigo Paz

Programación en C++ para Ciencia eIngenierı́a

Mario Storti, Jorge D’Elı́a, Victorio Sonzognihttp://www.cimec.org.ar/prog

Facultad de Ingenierı́a y Ciencias Hı́dricasUniversidad Nacional del Litoral http://www.unl.edu.ar

Centro de Investigación de Métodos Computacionales - CIMECINTEC, (CONICET-UNL), http://www.cimec.org.ar

Facultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 1((version vg.2-140-g88a7cebe) (date Thu Nov 14 08:06:23 2019 -0300)(processed-date Thu Nov 14 08:10:01 2019 -0300))

http://www.cimec.org.ar/proghttp://www.unl.edu.arhttp://www.cimec.org.ar


Autores

• Mario Storti • Jorge D’Elı́a, • Victorio Sonzogni,


mailto:[email protected]:[email protected]:[email protected]


Contents

• slide 11.....Elementos básicos de programación. slide 13.....Compilación vs. intérpretes. slide 14.....El proceso de compilación. slide 16.....El preprocesador CPP. slide 19.....Chequeo de tipos. slide 20.....Compilació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.....Concatenació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 estándar de C

. slide 55.....Control de ejecución. True and False

. slide 56.....If-else

. slide 60.....while

. slide 63.....do-while

. slide 64.....Lazo for

. slide 65.....Break and continue

. slide 67.....La sentencia switch

. slide 68.....goto

. slide 70.....Recursion

. slide 72.....Operadores

. slide 73.....Operadores de auto incremento

. slide 75.....Tipos de datosFacultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 4

((version vg.2-140-g88a7cebe) (date Thu Nov 14 08:06:23 2019 -0300)(processed-date Thu Nov 14 08:10:01 2019 -0300))


. slide 78.....Especificadores

. slide 82.....Punteros

. slide 92.....Referencias

. slide 95.....Punteros a void

. slide 97.....Scope de las variables

. slide 99.....Definiendo variables on-the-fly

. slide 103.....Variables locales

. slide 107.....Punteros a variables locales

. slide 108.....Variables estáticas

. slide 110.....Constantes

. slide 111.....Operadores. Asignación

. slide 112.....Operadores matemáticos

. slide 113.....Operadores relacionales

. slide 114.....Operadores lógicos

. slide 115.....El operador hook

. slide 116.....Errores comunes con los operadores

. slide 117.....Operadores de cast

. slide 118.....Operador sizeof

. slide 119.....typedef: Aliases de tipos

. slide 120.....Estructuras

. slide 124.....Arrow operatorFacultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 5



. slide 125.....Enum’s

. slide 128.....Arreglos de estructuras

. slide 129.....Punteros y arreglos

. slide 131.....Arreglos de punteros

. slide 135.....Aritmética de punteros

. slide 137.....Tamaños de estructuras• slide 138.....Programación Orientada a Objetos

. slide 139.....Abstracción de datos

. slide 149.....POO básica

. slide 159.....Inclusion de headers

. slide 163.....Estructuras enlazadas

. slide 171.....Más sobre scoping

. slide 172.....Tipos Abstractos de Datos (ADT)

. slide 173.....Ocultando la implementación

. slide 175.....Control de acceso a los miembros

. slide 179.....Amistad (Friendship)

. slide 182.....Anidamiento (nesting) y amistad

. slide 183.....Object layout

. slide 184.....Clases

. slide 188.....Ocultando totalmente la implementación

. slide 190.....Inicialización y cleanupFacultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 6



. slide 192.....El constructor

. slide 193.....El destructor

. slide 196.....Eliminación del bloque de definición

. slide 198.....Clase stash con ctor/dtor

. slide 202.....Stack con ctor/dtor

. slide 205.....Initialización de agregados

. slide 206.....Inicialización de estructuras

. slide 207.....Sobrecarga de funciones

. slide 211.....Argumentos por default

. slide 212.....Constantes

. slide 215.....Punteros a arreglos constantes de caracteres

. slide 216.....Const en argumentos de funciones

. slide 217.....Const en clases

. slide 218.....Objetos const y funciones de la clase• slide 220.....Chapter 5

. slide 221.....Funciones inline

. slide 225.....Especificaciones de linkedicion

. slide 227.....Referencias en C++

. slide 233.....Reglas para las referencias

. slide 235.....Paso por referencia y por copia

. slide 236.....El constructor por copiaFacultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 7



. slide 237.....Sobrecarga de operadores

. slide 242.....Sobrecarga de operadores unarios

. slide 251.....Sobrecarga de operadores binarios• slide 274.....Chapter 6

. slide 275.....Otros operadores que se pueden sobrecargar

. slide 276.....Creación dinámica de objetos

. slide 277.....Uso de la memoria dinámica en C

. slide 278.....Uso de la memoria dinámica en C++

. slide 280.....Porqué usar new y no arreglos

. slide 281.....Memory exhaust

. slide 282.....Composición

. slide 284.....Composición y la cadena de inicialización

. slide 285.....Herencia

. slide 288.....Redefinición de métodos

. slide 290.....Herencia protegida

. slide 292.....Upcasting

. slide 293.....Polimorfismo

. slide 295.....Ejemplo polimorfismo. Integral 1D/2D/3D

. slide 299.....Clase que calcula integral 1D

. slide 301.....Integral 2D. Versión cruda

. slide 316.....Integral 2D. Versión mejoradaFacultad de Ingenierı́a y Ciencias Hı́dricas FICH - UNL slide 8



. slide 319.....Integral 3D

. slide 322.....Integral 1D/2D/3D. User code

. slide 324.....Polimorfismo: ej. suma de los elementos de un vector

. slide ??.....Ejemplo clase vector sparse• slide 328.....Contenedores de la librerı́a STL

. slide 329.....La librerı́a STL

. slide 330.....La clase vector

. slide 335.....Algoritmos in-place

. slide 337.....La clase list

. slide 340.....La clase set

. slide 344.....La clase map

. slide 347.....Algoritmos

. slide 349.....Programación funcional

. slide 377.....GTP. Grafos

. slide 384.....GTP. Eigen

. slide 386.....Librerı́as y utilidades



Dictado

• Docentes de la cátedra:. Mario Storti . Jorge D’Elı́a, . Victorio Sonzogni, >


mailto:[email protected]:[email protected]:[email protected]>


Elementos básicos de

programación



I KNOW C++!



Compilación vs. intérpretes

• Algunos lenguajes de programación tienen un intérprete, por ejemploMatlab/Octave, Python, Perl, Lisp/Scheme. En un intérprete el usuario vaemitiendo comandos que son interpretados por el intérprete y vadevolviendo un resultado.

• Por contraposición, los lenguajes compilados el usuario escribe unarchivo con lı́neas de código, el cuál es procesado por un compilador, quegenera código de máquina, el cual es ejecutado directamente por elprocesador.

• Ventajas de la compilación: el código suele ser más rápido, y máscompacto.

• Desventajas: el paso de código a ejecutarlo es inmediato, no hay pasosintermedios. Usualmente los intérpretes permiten escribir tareas que serepiten comúnmente en archivos de texto (scripts). El usuario puedeademás mezclar estas funciones con comandos directamente en elintérprete. También con los intérpretes es más fácil debuggear.

• C++ es un lenguaje compilado.



El proceso de compilación

• El caso más simple es cuando todo el código del programa está en unsólo archivo fuente:

1. $$ g++ -o prog prog.cppGenera un archivo ejecutable prog.

• Si el programa es muy grande conviene dividirlo en varias partes, en esecaso

1. $$ g++ -o prog prog1.cpp prog2.cpp• Esto requiere recompilar cada vez todos los *.cpp, si son muchos

conviene hacer1. $$ g++ -o prog1.o -c prog1.cpp2. $$ g++ -o prog2.o -c prog2.cpp3. $$ g++ -o prog prog1.o prog2.o

Los archivos .o son objeto, contienen código de máquina. (No tienerelación con la Programación Orientada a Objetos).



El proceso de compilación (cont.)

• Si solo se modifica uno de los archivos (prog1.cpp), entonces sólo hacefalta recompilar ese.

1. $$ g++ -o prog1.o -c prog1.cpp2. $$ g++ -o prog prog1.o prog2.o• Para mejor organización, si hay muchos *.o conviene ponerlos en una

librerı́a1. $$ g++ -o prog1.o -c prog1.cpp2. $$ g++ -o prog2.o -c prog2.cpp3. $$ g++ -o prog3.o -c prog3.cpp4. $$ ar r libprog.a prog1.o prog2.o prog3.o5. $$ 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 código. En esecaso se pueden usar macros

1. int v[100000];2. if (n


El preprocesador CPP (cont.)

• CPP sólo realiza manipulaciones a nivel de texto, no conoce nadaespecı́fico del lenguaje C/C++, incluso puede usarse (y se usa) para otroslenguajes como Fortran.

• Las directivas más usuales son1. // Incluye todo el texto del archivo library.h2. #include 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, después se puede llamar al macro en otros

lugares del código y es reemplazado por su expansión. Los macrospueden tener argumentos. Por convención se suele dar a los macrosnombres en mayúsculas.

• Se puede conocer cual es el resultado del CPP llamando a g++ con laopció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 estático, en inglés typed language),es decir las variables tienen tipos definidos. El compilador chequea quelos resultados de las expresiones que se asignan a las variablescorrespondan al tipo con el cual fueron definidas, caso contrario seproduce un error en tiempo de compilación. Esto es bueno porquepermite detectar tempranamente errores. (Es equivalente al chequeo deunidades en Fı́sica).

1. // error: asigna un string a una variable entera2. int a;3. a = "Hello";• Otros lenguajes (sobre todos los interpretados) hacen chequeo dinámico

de tipo, esto implica una pérdida de eficiencia.• El chequeo se hace también para los argumentos de una función

1. void fun(int a,string s);2. . . .3. fun(23,45); // ERROR (45 no es un string!)



Compilación por separado

• En C++ se favorece que un programa grande se pueda dividir enfracciones más pequeñas. El mecanismo fundamental para dividir unprograma en partes más pequeñas es usar funciones que realizan tareasbien definidas. Por ejemplo podemos pensar en una función intgcd(int,int); que toma dos enteros y retorna el máximo común divisorde los mismos.

• Las funciones tienen argumentos, una vez que la función termina sutarea, retorna un valor. También puede ser que las funciones tenganefectos colaterales (side effects) es decir que modifiquen susargumentos u otros objetos.



Compilación por separado (cont.)

• Para crear un programa que esté dividido en varios archivos, el código deun archivo debe poder usar las funciones del otro. Supongamos que unarchivo prog1.cpp contiene a la función gcd(). Si queremos usar a gcd()en el código de otro archivo prog2.cpp entonces el compilador debe estarseguro que el tipo de los argumentos que se le van a pasar son loscorrectos. Para eso hay que declarar a la función en prog2.cpp antes depoder llamarla

1. int gcd(int,int); // declara gcd()2. . . .3. r = gcd(m,n); // la puede usar porque ya4. // fue declarada



Declaraciones y definiciones

• Una declaración le dice al compilador que esa función existe y suprototipo o signatura, es decir el tipo de argumentos de entrada y desalida. Por ejemplo

1. int gcd(int,int);• La definición por otra parte dice especı́ficamente como la función realiza

su tarea1. 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 función puede estar declarada varias veces en un archivo (mientrasla signatura de la funció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 función só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.cpp2. int f(int x) { return 2*x; }3.4. // archivo prog2.cpp5. int f(int x) { return 3*x; }6. // -> ERROR: múltiplemente definida



Definiciones y declaraciones de variables

Si declaramos una variable, por ejemplo

1. int m;

si bien parace una declaración, en realidad ya tiene toda la información paraconstruir al objeto (un entero de 4 bytes) por lo tanto el compilador lo tomaademás como una definición. Por eso no podemos incluir dos veces estadeclaración/definició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 declaración y no una definiciónentonces debemos usar el keyword extern

1. extern int m;2. . . .3. extern int m; // OK4. . . .5. int m; // OK• extern se puede usar también con las funciones, para hacer hincapié en

que es una declaració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 funcionesque después utilizaremos en otras partes del programa.

1. // utils.cpp2. 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 declararlas1. // prog.cpp2. 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 cadauno de los archivos prog1.cpp, prog2.cpp... y utils.cpp tiene cientos defunciones. Entonces para resolver esto incluimos todas las declaracionesen un archivo header (cabecera) utils.h:

1. // utils.h2. int gcd(int m,int n);3. double cos(double alpha);4. double sin(double alpha);

Entonces después en prog1.cpp hay que solo incluir el header:1. // prog1.cpp2. #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 encargade buscar el archivo header y crear un archivo temporario donde la lineadel include es reemplazada por los contenidos del archivo.



Incluyendo headers (cont.)

Hay dos versiones de include,

• Una que especifica archivos en forma relativa o absoluta1. #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 compilación

1. $$ g++ -I/home/mstorti/utils -c -o prog.o prog.cpp1. // lo encuentra en /home/mstorti/utils2. #include 3. // lo encuentra en /home/mstorti/utils/src4. #include 5. . . .



Usando librerı́as

• Entonces si tengo que usar una librerı́a matrix que está compuesta devarios archivos fuente matrix2.cpp, matrix1.cpp, matrix3.cpp... en realidadno hace falta que compile todos estos archivos, mientras que eldesarrollador de esa librerı́a provea. Un archivo libmatrix.a con todos los matrix.cpp compilados.. Un archivo header con las declaraciones de las funciones matrix.h.

• Entonces para usar la librerı́a basta con incluir el header1. // myprog.cpp2. #include 3. . . .

y al linkeditar incluir la librerı́a

1. $$ g++ myprog.cpp /usr/lib/libmatrix.a -o myprog



Formato de include para C++

• La extensión que se usa para los archivos fuente puede ser .cpp, .cxx.Para los headers se utiliza .h, .hpp, .hxx.

• Para evitar confusiones y ambigüedad con las extensiones, C++ introdujoel concepto de include sin extensión. El traductor se encarga de convertirel nombre y buscar la extensión.

1. #include • Existe una librerı́a con muchas funciones muy útiles que es estándar de C

y se llama justamente libc.a. Entre otras incluye funciones. Matemá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 // C2. #include // C++



Un primer programa en C++

• Para imprimir por terminal hay que usar el operador


Namespaces

• A medida que una librerı́a o programa crecen cada vez hay más funcionesy es muy posible que se produzca la colisión de nombres. Por ejemplo, siescribo una librerı́a para manipular matrices, puedo querer implementaruna función rand() que llena la matriz con números aleatorios.Lamentablemente la libc ya usa el nombre rand() para generar un úniconumero aleatorio.

• Una solución que se usaba en C era prependizar un prefijo identificadorde 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 lasiguiente forma

1. // matrix.cpp2. namespace matrix {3. void rand(. . .) { /* . . . */ }4. double sum(. . .) { /* . . . */ }5. void prod(. . .) { /* . . . */ }6. }• Entonces después 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 scope1. // prog.cpp2. using namespace matrix;3.4. rand(A);5. double m = max(A);



Namespaces (cont.)

• Muchas utilidades y variables estándar de C++, por ejemplo cout, están enel namespace std de manera que o bien hay que hacer

1. std::cout


Estructura de un programa

• Un programa en C/C++ está compuesto de una colección de funciones yvariables. Cuando uno lanza el programa hay que determinar dónde seempieza a ejecutar el código, o sea el punto de entrada. En C/C++ el puntode entrada es la función main().

• La definición de una función consiste en un valor de retorno, el nombrede la función y su lista de argumentos. El cuerpo de la función (lasinstrucciones que la componen) van entre llaves.

1. int function() {2. // Function code here (this is a comment)3. }• Puede haber más pares de llaves balanceadas ({}) adentro de la función

pero debe haber uno más externo que define el cuerpo de la función.• Como main() es una funció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 indentación o laposición de las variables en la lı́nea son irrelevantes.

• Tampoco es relevante la cantidad espacio en blanco (espacios, tabs, finde lı́nea). Cualquier cantidad de estos caracteres juntos es equivalente aun solo espacio. De hecho un programa en C++ podrı́a escribirse ne unasola lı́nea.

• En C los comentarios van encerrados entre /* y */ (comentario multilı́nea).En C++ se agregó 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 código */ x;3. // Comentario por linea tipo C++



Hello world

1. // Saying Hello with C++2. #include // Stream declarations3. using namespace std;4.5. int main() {6. cout


Concatenación de arreglos de caracters

• Para incluir arreglos de caracteres muy largos se puede simplementeponer uno a continuación de otro (puede ser en diferentes lı́neas). El CPPse encarga de juntarlos todos en una sola lı́nea: "aaa" "bbbb" escompletamente equivalente a "aaabbbb".

1. // Character array Concatenation2. #include 3. using namespace std;4.5. int main() {6. cout


Entrada de datos

cout es console output, cin es console input y permite ingresar datos.

1. // Converts decimal to octal and hex2. #include 3. using namespace std;4.5. int main() {6. int number;7. cout > number;9. cout


Llamando a otros programas

Dentro de la librerı́a estándar de C hay una función muy potente system() quepermite llamar a otros programas desde un programa en C/C++. Se le pasa unarreglo de caracteres con el comando que uno ejecutarı́a en la lı́nea decomandos.1. // Call another program2. #include // Declare ‘‘system()’’3. using namespace std;4.5. int main() {6. system("date -u");7. }



Strings de C

Manipular arreglos de caracteres en C se vuelve muy engorroso.1. #include 2. #include 3. using namespace std;4.5. int main() {6. // concatenate two character arrays s1 and s27. char s1[ ] = "Hola ";8. char s2[ ] = "mundo.";9. cout


Strings de C++

Para eso C++ tiene objetos llamados strings que permiten manipularlos enforma mucho más simple y con menor probabilidad de error.

1. #include 2. #include 3. using namespace std;4.5. int main() {6. // concatenate two character arrays s1 and s27. string s1 = "Hola ";8. string s2 = "mundo.";9. string s = s1 + s2;

10. cout


Strings de C++ (cont.)

1. //: C02:HelloStrings.cpp2. // The basics of the Standard C++ string class3. #include 4. #include 5. using namespace std;6.7. int main() {8. string s1, s2; // Empty strings9. string s3 = "Hello, World."; // Initialized

10. string s4("I am"); // Also initialized11. s2 = "Today"; // Assigning to a string12. s1 = s3 + " " + s4; // Combining strings13. s1 += " 8 "; // Appending to a string14. cout


Escribir y leer de archivos

• Las funciones están declaradas en el header .• 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 función 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 time2. #include 3. #include 4. using namespace std;5. int main() {6. ifstream in("Scopy.cpp"); // Open for reading7. ofstream out("Scopy2.cpp"); // Open for writing8. string s;9. while(getline(in, s)) // Discards newline char

10. out


Escribir y leer de archivos (cont.)

Otro ejemplo es guardar todo el archivo en un sólo string:

1. // Read an entire file into a single string2. #include 3. #include 4. #include 5. using namespace std;6.7. int main() {8. ifstream in("FillString.cpp");9. string s, line;

10. while(getline(in, line))11. s += line + "\n";12. cout


La clase vector

• Un vector es un contenedor que permite guardar un número indefinido deelementos en forma contigua e indexada.

• Se puede agrandar o achicar en forma dinámica, sin perder los elementospreexistentes.

• Está templatizado o sea que se pueden definir vectores de diferentestipos: vector, vector, vector,...

• La funció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 string2. #include 3. #include 4. #include 5. #include 6. using namespace std;7.8. int main() {9. vector v;

10. ifstream in("Fillvector.cpp");11. string line;12. while(getline(in, line))13. v.push-back(line); // Add the line to the end14. // Add line numbers:15. for(int i = 0; i < v.size(); i++)16. cout


La clase vector (cont.)

vector también puede guardar cualquier otro tipo, por ejemplo enteros:1. // Creating a vector that holds integers2. #include 3. #include 4. using namespace std;5.6. int main() {7. vector 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


Ejercicios

1. Crear un programa que abre un archivo y cuenta las palabras (separadaspor whitespace). Ayuda: el operador >> lee de a palabras de un ifstream.

2. Crear un programa que cuenta la cantidad de caracteres que tiene unarchivo.

3. Crear un programa que cuenta la cantidad de ocurrencias de una palabraespecı́fica en un archivo. Ayuda: usar == para comparar strings.

4. Escribir un programa que imprime las lı́neas de un archivo de texto enorden inverso.



El C en C++



Funciones

• Para evitar errores, C/C++ usa el concepto de prototipo o signatura defunciones.

• Antes de usar una función hay que declararla.• Al usar la funció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 algún lugar la función tiene que estar definida, aquı́ los nombres de los

argumentos tienen que aparecer para poder ser usados en la función

1. int translate(float x, float y, float z) {2. x = y = z;3. // . . .4. }



Valores de retorno

• La declaración de la función debe indicar el valor de retorno. Si la funciónno retorna nada usar void:

1. int f1(void); // Returns an int, takes no arguments2. int f2(); // Like f1() in C++ but not in Standard C3. float f3(float, int, char, double); // Returns a float4. void f4(void); // Takes no arguments, returns nothing• Para retornar el valor usar la sentencia return.• Si la función retorna void entonces no se debe llamar a return.• Se puede tener más de un return en la función. Son puntos de salida.• El valor de retorno debe ser compatible con el indicado en la declaración.



Valores de retorno (cont.)

1. // Use of ‘‘return’’2. #include 3. using namespace std;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 > val;19. cout


Usando la librerı́a estándar de C

• C incluye una librerı́a de funciones estándar (también llamada libc). Todoslos compiladores que satisfacen la norma deben incluir estas funcionesen su libc. Esto permite la portabilidad de los programas entre diferentescompiladores.

• Muchos compiladores incluyen funciones adicionales que NO están en lanorma. Por lo tanto hay que prever que si se lleva el proyecto a otraplataforma puede ser que estas funciones no existan en esa plataforma.

• La documentación de las librerı́as usualmente incluye la declaración de lafunción y en que header (archivo .h) está.

• En caso que la librerı́a no esté documentada hay que directamente ver losheaders para encontrarel prototipo de la función.



Control de ejecución. True and False

• Todas los condicionales (por ejemplo if o while) usan expresiones lógicascomo por ejemplo el resultado del operador de comparación A==B. Estaexpresión retorna directamente un valor lógico true o false. No confundiircon el operador de asignación A=B.

• Lo mismo ocurre con otros operadores de comparación1. A==B; //It’s equal?2. A!=B; //It’s distinct?3. A=B; //It’s greater or equal?

Si la expresión no retorna un valor booleano, entonces C trata de convertirlo.Para todos los valores numéricos (enteros, float, double, char, punteros) elvalor es falso si es cero, y en cualquier otra caso es verdadero. Entonces porejemplo el valor lógico de las siguientes expresiones es equivalente1. 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. statement3.4. // o5.6. if (expression)7. statement8. else9. statement

En ambos casos statement puede ser una sentencia simple, terminada en unacoma, o compuesta, es decir un bloque de instrucciones encerrado en {}.

1. if (n>0) x=23; // sentencia simple2.3. if (n>0) { // sentencia compuesta4. x=23;5. s="haha";6. }



If-else (cont.)

1. int i;2. cout i;4. if(i > 5)5. cout


If-else (cont.)

Notar que todo el if actúa como una sola instrucción, por eso no hace faltaencerrarlo con un {}.1. if(i > 5)2. cout


Es una convención mut útil indentar ambos bloques del if para mejorar lalegibilidad.



while

while, do-while y for controlan lazos (loops) de ejecución.1. while(expression)2. statement

Como antes statement puede ser simple o compuesto. La expresión se evalúahasta que la condición de falso. Para que el lazo termine en algún momentoes necesario que statement tenga algún efecto que haga que eventualmenteexpression de falso1. int x=0;2. while (x


while (cont.)

1. // Guess a number (demonstrates ‘‘while’’)2. #include 3. using namespace std;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;12. }13. cout


while (cont.)

En C la condición dentro del condicional puede ser tan elaborada como sequiera, la única restricción es que debe retornar un valor lógico (o convertiblea ló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. do2. statement3. while(expression);

Es similar al while pero ahora statement es ejecutado antes de verificar lacondición.1. n=0;2. while (n>0) /* body. . .*/ ; // body is not executed3.4. n=0;5. do6. /* body. . .*/ ; // body is executed once7. while (n>0);



Lazo for

La forma del for es1. for(initialization; conditional; step)2. statement

Se utiliza mucho cuando simplemente se quiere ejecutar un bloque una seriede veces bien definida1. for (int i=0; i


Break and continue

Adentro de cualquiera de los bloques while, do-while o for se puede usarbreak para salir del lazo inmediatamente.

1. while (true) { // Infinite loop2. cout > n;4. if (is-prime(n)) break;5. cout


Break and continue (cont.)

continue es similar a break pero hace que se ejecute la siguiente iteración dellazo1. for (int j=0; j


La sentencia switch

Va comparando la variable selector hasta que coincide con uno de los case1. switch(selector) {2. case integral-value1 : statement; break;3. case integral-value2 : statement; break;4. case integral-value3 : statement; break;5. case integral-value4 : statement; break;6. case integral-value5 : statement; break;7. (. . .)8. default: statement;9. }

por ejemplo1. char c;2. //. . .3. switch (c) {4. case ’a’: cout


goto

La sentencia goto permite saltar a otro punto del programa. Se lo consideramuchas veces como una mala práctica de programación, aunque a vecespuede ser útil, por ejemplo para saltar de varios lazos anidados cuando seencuentra una condición.1. // The infamous goto is supported in C++2. #include 3. using namespace std;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


Recursion

Muchos problemas son intrı́nsecamente recursivos, es decir la solución de unproblema está dada por la solución de uno menor con el mismo algoritmo,por ejemplo la definición de factorial se puede hacer en forma recursiva

n! = n · (n− 1)! (1)en realidad esto es cierto si n > 1, la definición correcta es

n! =

1; si n = 1;n · (n− 1)! ; si n > 1 (2)decimos que el caso n = 1 corta la recursión.

Usando llamadas recursivas a funciones podemos implementar la funciónfactorial1. int factorial(int n) {2. if (n==1) return 1;3. else return n*factorial(n-1);4. }



Recursion (cont.)

La recursión es muy elegante para resolver problemas, pero puede serdemandante en términos de recursos. Es más simple si calculamos elfactorial con un lazo1. int factorial(int n) {2. int fac=1;3. for (int j=2; j


Operadores

Los operadores no son más que funciones, con una sintaxis especial. Unoperador toma una o má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 cuestión importante con los operadores es la precedencia de losmismos. Para los operadores matemáticos es similar a las reglas queaprendemos 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 introducirparéntesis para forzar el orden en que se evalúan las expresiones.



Operadores de auto incremento

El operador ++ es un atajo para una operación muy común en programación:incrementar una variable de tipo entero en una unidad. Hay dos variantes,prefija y postfija, ambos tienen el mismo efecto colateral (incrementar lavariable) pero en el prefijo retorna el valor de la variable incrementada, y elpostfijo sin incrementar

1. int m,n=5;2. m = n++; // n=6, m=53.4. int m,n=5;5. m = ++n; // n=6, m=6

Por ejemplo la siguiente función retorna el primer primo siguiente (mayor oigual) a n.

1. int next-prime(int n) {2. while (!is-prime(n++)) { }3. return n;4. }



Operadores de auto incremento (cont.)

También hay autodecremento -- prefijo y postfijo.

1. int n=10;2. while (n >= 0) cout


Tipos de datos

Dijimos que C/C++ es un lenguaje de tipeo estático, es decir en el momentode crear las variables hay que decir de que tipo son. Hay tipos de datosbuilt-in como enteros, floats, strings, que ya están definidos en el compilador,y también el programador puede crear sus propios tipos, muchas veces porcomposición. Por ejemplo si estamos creando la base de datos de unaempresa podemos querer tener un tipo de dato employee que contenga unstring (el nombre), un entero (el nú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 almacenarcaracteres.

• int un entero de al menos 16 bits (2 bytes)• float un número de punto flotante con al menos 4 bytes (simple precisión)• double un número de punto flotante con al menos 8 bytes (doble

precisión).



Tipos de datos (cont.)

1. // Defining the four basic data2. // 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 básicos tienen una cantidad de bits fija pueden representar untamaño máximo. Por ejemplo los enteros de 16 bits sólo pueden estar entre-32768 y +32768. Además el tamaño del tipo (la cantidad de bits) puededepender de la máquina y del compilador, entonce los valores máximos ymı́nimos (los lı́mites) están definidos en headers float.h y limits.h,1. #include 2.3. cout


Especificadores

• Para representar enteros se utiliza un bit de los 32 disponibles pararepresentar el signo.

• Si sólo se van a utilizar enteros positivos entonces podemos usar ese bitpara 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.



Especificadores (cont.)

1. //: C03:Specify.cpp2. // Demonstrates the use of specifiers3. #include 4. using namespace std;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 int13. unsigned short int isu;14. unsigned short iisu;15. long int il;16. long iil; // Same as long int17. unsigned long int ilu;18. unsigned long iilu;19. float f;20. double d;



21. long double ld;22. cout23.


Especificadores (cont.)

1. [mstorti@galileo garage]$$ ./sizes.bin2.3. char= 14. unsigned char = 15. int = 46. unsigned int = 47. short = 28. unsigned short = 29. long = 8

10. unsigned long = 811. float = 412. double = 813. long double = 1614. [mstorti@galileo garage]$$



Punteros

Al declarar variables lo que estamos haciendo es dar un nombre a un pedazode la memoria. Cuando decimos int n lo que estamos diciendo al compiladores: resérveme 4 bytes de la memoria y a partir de ahora lo voy a llamar n. Eloperador & nos muestra en que posición de la memoria fue alocada la variable

1. int n;2. cout


Punteros (cont.)

1. #include 2. using namespace std;3.4. int dog, cat, bird, fish;5.6. void f(int pet) {7. cout


Punteros (cont.)

El resultado es1. [mstorti@galileo garage]$$ ./pointers.bin2. f(): 41966303. dog: 62959564. cat: 62959605. bird: 62959646. fish: 62959687. i: 1407366311585728. j: 1407366311585689. k: 140736631158564

10. [mstorti@galileo garage]$$



Punteros (cont.)

• La dirección en memoria de un variable puede cambiar de una corrida aotra.

• Funciones, variables y globales parecen estar en sectores de la memoriadiferentes.

• Enteros parecen ocupar 4 bytes.• Las posiciones en la memoria se pueden guardar en una variable de tipo

especial llamada puntero1. int number;2. int *number-p = &number;• El sufijo _p o simplemente p indica que es un puntero (es sólo una

convenció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 dirección de una

variable, lo cual nos permite modificarla a través de ese proxy1. 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 queesté apuntando a un objeto válido, es deber del programador asignarle alpuntero una posición válida, si no puede dar error en tiempo de ejecuciónal querer usar el puntero.

1. int *p;2. cout


Punteros (cont.)

Los punteros tienen un montón de usos, el primero que veremos es el decausar que una función modifique un objeto. El mecanismo de paso devariables en C/C++ es por copia.1. #include 2. using namespace std;3.4. void f(int a) {5. cout


Punteros (cont.)

Imprime:

1. [mstorti@galileo sources]$$ ./try40.bin2. &x = 0x7ffe99dd33ec3. x = 474. &a = 0x7ffe99dd33bc5. a = 476. a = 57. x = 478. [mstorti@galileo sources]$$ x = 47

Como la variable a en f() es una copia, resulta que la modificación que sehace en f() no persiste, de manera que queda el mismo valor.



Punteros (cont.)

En esta versión en cambio, pasamos la dirección donde está x:1. #include 2. using namespace std;3.4. void f(int* p) {5. cout


Punteros (cont.)

Imprime:

1. [mstorti@galileo sources]$ ./try41.bin2. x = 473. &x = 0x7ffcf3047dcc4. p = 0x7ffcf3047dcc5. *p = 476. p = 0x7ffcf3047dcc7. x = 58. [mstorti@galileo sources]$



Referencias

Los punteros son muy útiles pero engorrosos porque hay que estardereferenciando al puntero cada vez. C++ introdujo las referencias que soncompletamente equivalentes a los punteros pero evitan la dereferenciación.1. #include 2. using namespace std;3.4. void f(int& r) {5. cout


18. }



Referencias (cont.)

Imprime:

1. [mstorti@galileo sources]$ ./try42.bin2. x = 473. &x = 0x7ffd244d1aac4. r = 475. &r = 0x7ffd244d1aac6. r = 57. x = 58. [mstorti@galileo sources]$



Punteros a void

• El compilador sólo acepta que asignemos a una variable de tipo int* ladirección de una variable de tipo int, en otro caso da un error

1. int *p;2. int n;3. p = &n; // OK4. 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 dirección es asignada a un void* el compilador no puedesaber de que tipo es el objeto al cual apunta, y por lo tanto no se puededereferenciar

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 indicado1. 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 ejecución1. int i = 99;2. void* vp = &i;3. // Compila OK, posible error en tiempo de ejecución4. *((string*)vp) = "Hello world";



Scope de las variables

Una variable existe desde su definición hasta la siguiente llave que cierra (}).Eso se llama el scope de la variable.1. // How variables are scoped2. int main() {3. int scp1;4. // scp1 visible here5. {6. // scp1 still visible here7. //. . . . .8. int scp2;9. // scp2 visible here

10. //. . . . .11. {12. // scp1 & scp2 still visible here13. //. .14. int scp3;15. // scp1, scp2 & scp3 visible here16. // . . .17. } // scp3 destroyed here



18. // scp3 not available here19. // scp1 & scp2 still visible here20. // . . .21. } // scp2 destroyed here22. // scp3 & scp2 not available here23. // scp1 still visible here24. //. .25. } // scp1 destroyed here



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 definitions2. #include 3. using namespace std;4.5. int main() {6. //. .7. { // Begin a new scope8. int q = 0; // C requires definitions here9. //. .

10. // Define at point of use:11. for(int i = 0; i < 100; i++) {12. q++; // q comes from a larger scope13. // Definition at the end of the scope:14. int p = 12;15. }16. int p = 1; // A different p17. } // End scope containing q & outer p



18. cout


Definiendo variables on-the-fly (cont.)

Las variables que están fuera de todas las funciones son globales, su scopees todo el programa, incluı́do dentro de las funciones.1. // == file1.cpp ==2. // Demonstration of global variables3. #include 4. using namespace std;5.6. int globe;7. void func();8. int main() {9. globe = 12;

10. cout


18. void func() {19. globe = 47;20. }



Variables locales

Las variables que existen dentro de un scope son locales, también se lesllama automáticas 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 lotanto la variable no retiene el valor que le fue asignado antes.1. void f(int x) {2. int a;3. cout


17. void h(int x) {18. int a;19. f(435);20. cout


Variables locales (cont.)

El resultado es:1. [mstorti@galileo garage]$$ ./try2.bin2. a en f(): 03. &a en f(): 0x7fff6df56d1c4. a en f() despues de asignar: 235. a en g(): 236. &a en g(): 0x7fff6df56d1c7. a en g() despues de asignar: 458. a en f(): 459. &a en f(): 0x7fff6df56d1c

10. a en f() despues de asignar: 2311. a en g(): 2312. &a en g(): 0x7fff6df56d1c13. a en g() despues de asignar: 4514. a en f(): 5915. &a en f(): 0x7fff6df56cdc16. a en f() despues de asignar: 43517. a en h(): 4518. &a en h(): 0x7fff6df56d1c



19. a en h() despues de asignar: 23420. [mstorti@galileo garage]$$



Punteros a variables locales

Si una variable sale de scope, es un error tratar de utilizar punteros queapuntaban a esa variable.

1. int *p;2. for (int j=0; j


Variables estáticas

Si queremos que el área asignada a una variable local sea siempre el mismo,entonces le agregamos el keyword static. Un ejemplo clásico es una funciónque cuenta cuantas veces fue llamada:

1. void f() {2. static int count=0;3. cout


Variables estáticas (cont.)

El resultado es:1. [mstorti@galileo garage]$ ./try14.bin2. f() fue llamada 0 veces3. f() fue llamada 1 veces4. f() fue llamada 2 veces5. f() fue llamada 3 veces6. f() fue llamada 4 veces7. f() fue llamada 5 veces8. f() fue llamada 6 veces9. f() fue llamada 7 veces

10. f() fue llamada 8 veces11. f() fue llamada 9 veces12. [mstorti@galileo garage]$



Constantes

Si se utilizará muchas veces un valor que es constante se pueden hacer através de un macro1. #define PI 3.141459

o bien a través de una variable de tipo const

1. const double pi = 3.141459;

Es más prolijo esto último (le permite al compilador hacer chequeo de tipo).



Operadores. Asignación

El caracter = se utiliza como el operador de asignación:1. A=4;

Lo que está a la izquierda de = es el lvalue y lo que está a la derecha el rvalue.El rvalue puede ser cualquier expresión. El compilador la evalua y asigna elresultado a lo que está en el lvalue. Ahora bien lo que está en el lvalue nopuede ser cualquier cosa, debe ser una variable o cualquier otra cosa a lacual se le pueda asignar un valor. Por ejemplo no puede ser una constante, esdecir no podemos hacer1. 4=A;



Operadores matemáticos

Los operadores matemáticos binarios usuales son +-*/. Cada uno de ellos sepuede usar en forma de acumulación +=, -=, *=, /=. Por ejemplo1. x += 5;

es equivalente a1. x = x + 5;



Operadores relacionales

Son1. >, =,


Operadores lógicos

Son && (and) y || (or). Recordar que en C/C++ muchos tipos se casteanautomáticamente a bool, siendo 0 el valor falso y cualquier otro valorverdadero. Cuando se imprimen los valores booleanos dan 0 o 1. ! es lanegación.

Son operadores cortocircuitados es decir si hacemos1. expr1 && expr2

entonces primero se evalua expr1 y si da falso, entonces expr2 NO se evalúa,ya que no es necesario porque la expresión lógica resultará en falso de todasformas. Eso puede ser importante, por ejemplo

1. if (n>0 && m/n!=3) . . .

está garantizado que no dará error si n==0 ya que si es ası́ directamente ladivisión por n no se hará. Lo mismo ocurre en1. expr1 | | expr2

si la primera da verdadero.



El operador hook

Es una forma muy compacta de escribir un if-else. Por ejemplo esta expresióncalcula el mı́nimo de dos valores1. x = (m


Errores comunes con los operadores

• Las reglas de precedencia a veces son simples, pero si se escribenexpresiones complejas ya no. Ante la duda utilizar paréntesis.

• No confundir = con ==.



Operadores de cast

• Si el compilador ve que estamos mezclando tipos en una asignación,insertará una operación de cast (conversión de tipo) automáticamente

1. int x=5;2. double z=x; // OK3. z=23.3;4. x=z; // se pierde la mantisa (truncamiento)5. x = (int) z; // cast explicito6. x = int(z); // otra forma del cast explicito7.8. int ixp = &x; // error, no puede convertir ptr a int9. long int ixp2 = (long int)&x; // OK!

10. long int ixp3 = static-cast(&x); // OK!



Operador sizeof

• Retorna el tamaño de una variable o tipo en bytes1. cout


typedef: Aliases de tipos

• Permite hacer un alias de un tipo a un nuevo tipo1. typedef unsigned long int ulong;2. . . .3. ulong x;• Simple para tipos básicos, más complicado para punteros

1. typedef int *int-p;• La regla es que se escribe una lı́nea como la declaración de una variable

con typedef al principio y reemplazando la variable por el tipo.• Esto permite hacer expresiones más cortas pero ademá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 precisión:

1. typedef double scalar;



Estructuras

• Se pueden definir nuevos tipos agrupando varios miembros en unaestructura. 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


Estructuras (cont.)

Se pueden tomar punteros a estructuras y enlazarlas1. 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


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 nextc1

c='b' x=2 nextc2

c='c' x=3 nextc3



Estructuras (cont.)

El resultado es1. [mstorti@galileo garage]$$ ./try8.bin2. cp 0x7fff571b2d20, c a, x 13. cp 0x7fff571b2d00, c b, x 24. cp 0x7fff571b2ce0, c c, x 35. cp 0x7fff571b2d20, c a, x 16. . . .7. cp 0x7fff571b2d20, c a, x 18. cp 0x7fff571b2d00, c b, x 29. [mstorti@galileo garage]$$



Arrow operator

Como en el ejemplo anterior es muy común la compinación (*cp).x es decirtener un puntero a una estructura cp y querer tomar un miembro x de laestructura apuntada. Como es tan común hay un atajo sintá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


Enum’s

• Supongamos que queremos definir una estructura shape que contiene unaforma geométrica, digamos las coordenadas x,y de su centro y un enteroque indica su forma. Para ello incluimos un entero gtype (por geometrictype) que define que tipo de forma es. Podemos por ejemplo asignararbitrariamente gtype=0 para cı́rculos, 1=cuadrados, 2=rectángulos.

1. struct shape {2. double x,y;3. int gtype;4. };

Entonces una función que imprime la forma serı́a algo ası́ como1. void draw(shape s) {2. if (s.gtype==0) //. . . imprime un circulo3. else if (s.gtype==1) //. . . imprime un cuadrado4. else if (s.gtype==2) //. . . imprime un rect5. . . .6. }

El problema con esto es que tenemos que guardar mentalmente una tablapara saber que entero correspondı́a a cada forma.



Enum’s (cont.)

Una posibilidad es usar macros

1. #define CIRCLE 02. #define SQUARE 13. #define RECTANGLE 24.5. void draw(shape s) {6. if (s.gtype==CIRCLE) //. . . imprime un circulo7. else if (s.gtype==SQUARE) //. . . imprime un cuadrado8. else if (s.gtype==RECTANGLE) //. . . imprime un rect9. . . .

10. }



Enum’s (cont.)

Pero, como ya dijimos, es preferible no usar macros, para esto está el enum:1. enum GeoType { circle, square, rectangle};2.3. struct shape {4. double x,y;5. GeoType gtype;6. };7.8. void draw(shape s) {9. if (s.gtype==circle) //. . . imprime un circulo

10. else if (s.gtype==square) //. . . imprime un cuadrado11. else if (s.gtype==rectangle) //. . . imprime un rect12. . . .13. }

• Internamente los enums son enteros, pero esto es transparente paranosotros.

• El compilador traduce cada identificador de la lista a un enteroconsecutivo.

• Se puede forzar a que tomen un valor especı́fico1. enum GeoType { circle=5, square=10, rectangle=15};



Arreglos de estructuras

• Vimos que podemos definir arreglos como int v[100].• También lo podemos hacer con estructuras cell cellv[100]• Los elementos son guardados en forma consecutiva

1. struct cell {2. double x;3. cell *next;4. };5.6. for (int j=0; j


Punteros y arreglos

Si imprimimos un arreglo, el compilador lo imprime como hexadecimal, o seacomo si fuera un puntero

1. int v[100];2. cout


Punteros y arreglos (cont.)

Si tomamos un puntero al primer elemento podemos manipular al vector através de ese puntero

1. int v[100];2. int *p= &v[0];3. for (int j=0; j


Arreglos de punteros

• También se pueden tener arreglos de punteros1. int *v[100]; // arreglo de 100 punteros a enteros• Los arreglos de caracteres, son de tipo char* entonces si queremos tener

un arreglo de “strings de C”, tenemos un arreglo de arreglos de char, o loque es equivalente a arreglos de punteros a char

1. char *as[ ];2. char **as; // equivalente



Arreglos de punteros (cont.)

• Un caso frecuente de esto es la segunda forma de llamada a main(). Sillamamos a nuestro programa con argumentos

1. int main(int argc,char **argv) {2. for (int j=0; j



• El acceso a elementos de un arreglo de C es extremadamente rápido.• Sin embargo si se accede a posiciones más allá de la última posición del

vector se puede producir un error

1. int v[100];2. . . .3. v[100] = x; // Muy probablemente SIGSEGV o SEGFAULT• Se debe conocer el tamaño del vector en tiempo de compilación (hay una

forma de hacerlo dinámico, con new[]/delete[] o malloc()/free().• La clase vector es mucho más versátil y más segura.




Podemos verificar que los elementos de un vector están en posicionescontiguas.

1. int a[10];2. cout


Aritmética de punteros

Se pueden hacer cuentas con punteros de tipo ptr = ptr + int y todas lasderivadas, por ejemplo

1. ptr = ptr + int2. int = ptr - ptr3. ptr += int4. ptr++5. ptr--

En todas estas operaciones el entero indica posiciones en el vector, no bytes.



Aritmética de punteros (cont.)

1. int i[10];2. double d[10];3. int* ip = i;4. double* dp = d;5. cout


Tamaños de estructuras

Cuando se usan estructuras con tipos mezclados puede ser que el tamaño deltipo combinado no sea igual a la suma de los tamaños de los tipos (peroseguro es mayor o igual) porque el compilador tiene que alinear los tipos.1. struct A {2. char c;3. double d;4. };

da sizeof(A) -> 16, y

1. struct B { char c; double d; char c2; };2. struct C { char c; char c2; double d; };

da1. sizeof(B) -> 242. sizeof(C) -> 16



Programación Orientada

a Objetos



Abstracción de datos

Un contenedor de elementos de longitud arbitraria1. #ifndef CSTASH-H2. #define CSTASH-H3.4. struct CStash {5. int size; // Size of each space6. int quantity; // Number of storage spaces7. int next; // Next empty space8. // Dynamically allocated array of bytes:9. unsigned char* storage;

10. };11.12. void initialize(CStash* s, int size);13. void cleanup(CStash* s);14. int add(CStash* s, const void* element);15. void* fetch(CStash* s, int index);16. int count(CStash* s);17. void inflate(CStash* s, int increase);18.19. #endif



Abstracción de datos (cont.)

1. struct CStash {2. int size; // Size of each space3. int quantity; // Number of storage spaces4. int next; // Next empty space5. // Dynamically allocated array of bytes:6. unsigned char* storage;7. };

store

quantitynext

size

used free



Abstracción de datos (cont.)

1. // Implementation of example C-like library2. // Declare structure and functions:3. #include "./cstash.h"4. #include 5. #in

programacion en c++ para ciencia e´...

Documents