programación en c++ - laurel.datsi.fi.upm.es · el entorno unix ¿qué es programar? herramientas...

Programación en C++

#include <iostream> using namespace std;

int main(void) {

for (int cnt = 0; cnt < 500; cnt++) cout << ″I will not throw airplanes in class.\n″;

return 0; }

© Francisco Rosales & Jose María Peña Programación C++ 3

ContenidosEl entorno UNIX¿Qué es programar?Herramientas de desarrollo ITécnicas de programaciónEstructuras de programaciónEstilo de codificaciónTipos y estructuras de datosOperadoresFunciones y parámetrosPreproceso y bibliotecasHerramientas de desarrollo II


El Entorno UNIX¿Qué es UNIX?¡Cómo es UNIX!¡Cómo es Linux!Usuarios y GruposSesión de trabajoProcesos y ConcurrenciaSistema de FicherosDescriptores de fichero


¿Qué es UNIX?Uno de los SSOO más extensos y potentes

■ Multiusuario■ Mucho usuarios simultáneos

■ Multiproceso■ Cada usuario ejecutando simultáneamente

muchos procesos■ Multiplataforma

■ Escrito 99% en C■ Portado a multitud de plataformas


¡Cómo es UNIX!■ Sensible al tipo de letra

unix <> Unix <> UNIX

■ Para usuarios NO torpes■ Hace lo que se le pide sin preguntar

rm –r * borraría TODO

■ Lo borrado es irrecuperable


¡Cómo es Linux!■ Estándar POSIX

■ Portable Operating System Interface■ Licencia GNU

■ Debe suministrarse el código fuente!■ Evoluciona

■ Programadores voluntarios de todo el mundo lo mantienen al día

■ Gratis■ Se paga la "Distribución"


Usuario I■ Debe tener abierta cuenta en el sistema■ Se identifica con un nombre de usuario

login name

■ Cuentas protegida por contraseñapassword

■ Internamente el sistema identifica al usuario con un número

UID User Identifier


Grupo II■ Los usuarios están organizados en

grupos■ Cada usuario pertenece al menos a un

grupo■ Internamente el sistema identifica al

grupo con un númeroGID Group Identifier


Privilegios III■ Operaciones que un usuario puede

realizar en el sistema■ Delimitadas en función de:

■ Su identidad (pareja UID y GID)■ Permisos de acceso al fichero (9 bits)

ReadWrite eXecute

OthersGroupOwner

rwxrwxrwx


Superusuario IV■ También denominado root■ Encargado de administrar el sistema■ Tiene UID = 0 (cero)■ No tiene restricciones de ningún tipo

■ Puede hacer y deshacer lo que quiera■ La administración de UNIX es:

■Delicada y de responsabilidad■Exige amplios conocimientos


Sesión de trabajo I■ Periodo de tiempo que un usuario está

utilizando el sistema■ Identificación frente al sistema

login: loginname_passwd: *******_

■ Se arranca un intérprete de mandatosprompt> _

■ Para terminar...exit ologout


Intérprete de mandatos II■ La interacción del usuario con el

sistema UNIX suele ser a través de un intérprete de mandatos

■ Se le denomina shell (concha)■ No hay una sino varias, a escoger.■ Para uso interactivo y programación■ Para más información, realizar el tutorial

http://laurel.datsi.fi.upm.es/~ssoo/FPSO/download/Entorno%20UNIX.ps


Mandatos IIImandato [opciones] [argumentos...]

■ Campos separados por espacios■ [ ] indica opcional■ ... indica uno o varios■ Las opciones comienzan por un - (menos)■ Petición de ayuda sobre un mandato

-h o--help


man [what] Manual Pages■ Copia online de los manuales del sistema■ Secciones:

1. Mandatos (ej. sh, man, cat)2. Llamadas al sistema (ej. open, umask)3. Funciones de librería (ej. printf, fopen)4. Dispositivos (ej. null)5. Formato de ficheros (ej. passwd)6. Juegos7. Miscelánea8. Mandatos de Administración del Sistema


Procesos I■ Al invocar un mandato:

■ Se ejecuta el fichero con ese nombre

■ Todo programa en ejecución es un proceso

■ Internamente el sistema identifica cada proceso con un número

PID Process Identifier


Concurrencia II■ Cada proceso activo de cada usuario del

sistema, compite con los demás por ejecutar■ El sistema operativo decide cuál ejecuta en

cada momento■ Todo sucede muy muy deprisa:

■ Cada proceso avanza como si fuera el único■ Todos están avanzando simultáneamente

■ ps Muestra los procesos del sistema


Jerarquía III■ Los procesos se organizan en una

jerarquía padre--hijo(s)■ El ancestro es el proceso init

con PID = 1■ Cada proceso está asociado a su

proceso padre por el PPID


Árbol de Ficheros I■ Una única estructura jerárquica de ficheros■ En UNIX los dispositivos se “montan”

■ NO existe el concepto de “unidad”■ Directorio raíz

■ Es la raíz de la jerárquica de nombres■ se denota con / (dividido) no con el \

■ Directorio HOME■ Al entrar al sistema, nos situamos en el HOME■ Pertenece al usuario

■ Por debajo de él podemos crear cuantos subdirectorios o ficheros queramos


Tipos de objeto II■ Directorios:

■ Contienen siempre las dos entradas:. (punto) refiere al directorio que la contiene.. (punto punto) refiere al directorio padre de este

■ Ficheros normales:■ Secuencias de bytes

■ Ficheros especiales:■ Son el interfaz de acceso a los dispositivos■ Están bajo el directorio /dev■ Se tratan exactamente igual que los ficheros

normales, de forma que son indistinguibles


pwd Print Working Directory■ Cuál es el directorio en que nos

encontramos en cada momento, al cuál denominamos directorio actual de trabajo


cd [dir] Change Directory■ Cambia del actual directorio a otrocd Invocado sin argumento

nos devuelve al HOMEcd . Realmente nos deja en el

directorio actual de trabajocd .. Cambia al directorio padre

del directorio actual


ls [-opt] [dirs...] List Directory■ Presenta el contenido en los directorios

indicados■ Si no se indica se asume el directorio actual■ Las opciones más usadas:

■ -l Una línea por entrada con: permisos, propietario, grupo, tamaño, fecha, etc

■ -a Muestra entradas que empiezan por . (punto), que normalmente no se ven

■ -R Recursivamente los subdirectorios


Descriptores de fichero I■ Los procesos manejan ficheros a través

de los denominados descriptores de fichero■ El resultado de abrir un fichero es un

descriptor■ Las operaciones de manejo (lectura,

escritura, etc.) usan el descriptor■ Para los programas, un descriptor no es

más que un número entero positivo


Descriptores estándar II■ Son los descriptores 0, 1 y 2■ Se considera que siempre están abiertos■ Los programas estándar los usan debidamente0 Entrada estándar

De él se leerán los datos a procesar1 Salida estándar

En él se escribirán los resultados del proceso2 Error estándar

En él se escribirán los errores del proceso

¿Qué es programar?

¿Cómo es un ordenador por dentro?¿Qué sabe hacer un ordenador?¿Para qué se usan los ordenadores?Ciclo de vida del softwareCiclo de programación


¿Cómo es un ordenador por dentro?

Registros

µP

ALU

RAM

MemoriaPrincipal

ROM

DATOS

TEXTO

PILA

DATOS

TEXTO

PILA

DATOS

TEXTO

PILA

Mapas dememoria deprograma

Bus de datos Bus deEntrada/Salida

ControladoraGráfica AGP

Controladorade Disco IDE

ControladoraUSB

ControladoraRS232 Modem

Controladorasde Perifericos

Arquitectura Von Newmann


¿Qué sabe hacer un ordenador?

Muy poco Rapidííííííííísimo■ Ejecuta un único hilo de instrucciones:

■ Aritméticas: suma, resta, multiplicación...■ Lógicas: igual, mayor, menor...■ Salto: condicional, incondicional, llamada...

■ A una increíble velocidad■ PC a 3000 MIPS y subiendo

■ Sin pausa


¿Para qué se usan los ordenadores?

■ Sólo hará lo que alguien le diga cómo hacer■ Problemas tengan solución “a mano”■ Programas útiles para alguien:

■Tareas complejas, de precisión, tediosas, etc

■ Es necesario desarrollar software■ No es trivial


1, 1.5...2

Análisis

Usuario

Especificación

A.--B.--C.--

1.--2.--3.--

Diseño

main(){}

Programación

Validación

A.OKB.OKC.OK

Implantación

Ciclo de vida del software I


Ciclo de vida del software II■ Especificación

■ ¿Qué quiere exactamente el usuario final?■ Contrato

■ Análisis■ ¿Cómo resolver el problema?■ Descomposición

■ Diseño■ Cada una de las partes y su interconexión


Ciclo de vida del software III■ Programación■ Integración

■ Calidad e integración de cada módulo

■ Validación■ Cumplimiento de las especificaciones

■ Implantación■ Correcto funcionamiento y aceptación


Ciclo de programación I■ Codifica

■ Implementa con precisión cada módulo

■ Comenta el código fuente■ Ayudar a su lectura y comprensión

■ Verifica■ Casos de prueba■ Herramientas de cobertura de código


Ciclo de programación II■ Depura

■ Localiza y corrige los errores de todo tipo

■ Documenta■ Genera documentación para utilizar

correctamente el programa


En resumen■ El ordenador:

■ Un tonto muy rápido, preciso e infatigable

■ El programador:■ Sabe como instruirle de forma precisa■ Labor creativa y gratificante, de precisión

■ El usuario:■ Impredecible y exigente

Herramientas de Desarrollo I

EditorCompiladorDepurador


Editor¿Qué es un fichero de texto?

■ pico nano Simple Editor■ Muy sencillo de usar pero poco potente

■ vi vim Visual Editor (Improved)■ Lo encontramos en cualquier máquina UNIX

■ emacs GNU Project Editor■ Mucho más que un simple editor■ Entorno que integra múltiples aplicaciones:

correo electrónico, navegador web, news, etc.


El código fuente ■ Con un editor de texto, escribimos en un archivo el

código fuente del programa en el lenguaje elegido

■ “programa principal”, “función principal” o “main”:■ El punto de entrada al programa■ Imprescindible para obtener un ejecutable autónomo

■ Mínimo programa totalmente correcto

int main(void) {

return 0; }


Compilación■ Traducir nuestro programa (un archivo .c o .cpp con

el “código fuente”) en el correspondiente ejecutable (archivo en formato interno apto para ser arrancado)

■ La compilación realmente involucra múltiples etapas■ Preprocesado de macros■ Análisis sintáctico del código■ Traducción a ensamblador■ Traducción a lenguaje máquina con referencias externas■ Montaje contra bibliotecas para resolver esas referencias■ Producción del ejecutable

■ El compilador informa los problemas que encuentre


Errores y Warnings■ El compilador debe indicar:

■ Errores■ Problemas graves que evitan que la compilación

concluya■ Es imprescindible corregir estos errores

■ Warnings■ Problemas leves o alertas de posibles problemas■ La compilación puede terminar pero...■ Es muy recomendable corregir el motivo de estos

warnings, porque son fuente de futuros errores

■ El objetivo es la compilación limpia, sin ningún tipo de mensaje


gcc GNU C Compiler■ g++ para compilar C++■ Muy bueno, rápido y eficiente■ Admite multitud de opciones (consulte man):

■ -c file.c Sólo compilar, no montar■ -o name Nombre del fichero resultante■ -Wall Detección de todos los warnings■ -g Añade información para depuración■ -O Activa optimización■ -l library Montaje con biblioteca indicada■ -L directory Directorio de bibliotecas


Depurador ILa compilación limpia de un programa

no implica que sea correcto■ Ciertos errores sólo serán visibles al ejecutar■ Para eliminarlos necesitamos un depurador

■ De bajo nivel:■ Ejecución paso a paso■ De código máquina o ensamblador■ Inspección de registros y posiciones de memoria

■ De alto nivel o simbólico:■ Ejecución línea a línea■ Del código fuente que hemos escrito■ Inspeccionar de las variables de nuestro programa


Depurador II■ Debe haber compilado con –g■ Algunas de las funciones del depurador:

■ Establecer puntos de parada (breakpoints)■ Examinar el valor de variables■ Ejecutar el programa línea a línea

■ Usaremos el gdb, dbx o similar


Fichero core■ Si un proceso termina bruscamente con un

mensaje como:segmentation fault: core dumped

■ Ha realizado un acceso ilegal a memoria■ El sistema operativo lo ha matado■ Se ha generado un fichero de nombre: core

■ Es un volcado de la imagen de memoria del proceso en el instante del fallo

■ Sirve para depurar tal fallo:gdb ejecutable core


gdb prog [core] GNU debugger■ help Menú de ayuda■ run Ejecuta el programa■ break Establece un breakpoint■ list Muestra el código■ print Muestra el valor de una variable■ continue Continúa después de un breakpoint■ next Ejecuta línea sin entrar en función■ step Ejecuta línea entrando en función■ quit Sale del depurador

Técnicas de programación

Términos abstractosRazonamiento descendenteModularización

■ Y sobre todo... la experiencia


Términos abstractos■ La solución no informática de un

problema es independiente de la herramienta■ Concebir el programa en el vocabulario

natural del problema■ Identificar estos términos y las relaciones

entre ellos


Ejercicio

Enumere y describa

10 términos de

”cómo se juega al mus”


Razonamiento descendente■ Si la magnitud del problema no permite

visualizarlo en toda su extensión■ Identificar etapas o fases■ Dividir el problema subproblemas■ De lo general a lo específico■ Razonando en términos abstractos■ Ir refinando una solución


Ejercicio

Descomponga el problema

“desarrollo de una partida de mus”

en una jerarquía con las fases del juego


Modularización■ Perfilar más y más hasta delimitar cada

módulo de nuestro programa■ ¿Es suficientemente genérico?■ ¿Está suficientemente delimitado?■ ¿Merece ser una pieza independiente?■ ¿Puede ser reutilizable?


Ejercicio

Trate de identificar los módulos de

un programa que juegue al mus

Estructuras de Programación

SecuenciaSelecciónIteraciónFunción o Procedimiento


Estructuras de Programación■ Se identifican un conjunto mínimo de

estructuras básicas de programación:SecuenciaSelecciónIteraciónFunción o Procedimiento

■ Los programas serán:■ Más fiables■ Más eficientes■ Adaptables


Secuencia I■ Un único hilo de ejecución■ Sucesivos pasos o acciones que se

ejecutan en estricto orden


Secuencia (ordinograma) II

Hacer después

Comentario] - - - - [Comienzo de bloque

- - [En estricta secuencia

Hacer antes

- - [Fin de bloque


Secuencia (pseudocódigo) III

# Esto es un comentario.

# Los comentarios no ejecutan.

PRINT "Introduzca un número "

INPUT valor

PRINT "Introdujo el ", valor, NL


Secuencia (código C++) IV

// Esto es un comentario de línea.

/* Esto es un comentario de bloque.

Los comentarios no ejecutan. */

cout << "Introduzca un número >= 0 ";

cin >> valor;

cout << "Introdujo el " << valor << endl;


Selección I■ Dirigir el flujo de ejecución a una de

entre varias alternativas■ Escoge en función de condiciones

establecidas sobre los datos■ Expresiones booleanas, valores lógicos

■ CIERTO■ FALSO


Selección IF-THEN IIif (num != 0)

{

num = num * 2;

}Condición

CIERTOFALSO

IF_THEN

Hacer


Selección IF-THEN-ELSE IIIif (num != 0)

{

num = num * 2;

}

else

{

num = num - 1;

}

CondiciónFALSO CIERTO

IF_THEN_ELSE

HacerHacer


Selección SWITCH IVswitch(num + 5)

{

case -1:

num = num * num;

break;

case 0:

break;

default:

num = num / 2;

}

Selección

Hacer

DEFAULT

CASO 2

BREAK

Hacer

Hacer

CASO 1

SWITCH

BREAK


Iteración I■ Estructuras llamadas bucles■ Ejecutar ninguna, una o varias veces cuerpo

del bucle■ La iteración está controlada por una

condición■ La condición ha de cambiar de estado en el

cuerpo del bucle para que pueda terminar■ De otro modo, bucle infinito


Iteración WHILE IIwhile (num < 0)

{

num = num + 1;

}

■ Mientras la condición se evalúe a CIERTO

■ Puede no ser ejecutado ni una sola vez

Mientras

CIERTO

FALSO

WHILE

Hacer


Iteración DO-WHILE IIIdo

{

num = num - 1;

} while (num > 0);

■ Es ejecutado al menos una vez

■ Hasta que la condición se evalúe a FALSOFALSO

MientrasCIERTO

DO_WHILE

Hacer


Iteración FOR IVfor (num = 0; num < MAX; num++)

{

sum = sum + num;

}

■ Básicamente un WHILE con:■ Una etapa de inicialización■ Otra de incremento

(o decremento)

Mientras

CIERTOFALSO

Paso

Desde

FOR

Hacer

Estilo de Codificación

NombradoIndentaciónComentariosRestricciones


Estilo de codificación

■ Objetivos:■ mejorar la legibilidad del código■ hacerlo más comprensible■ independizarlo del autor

■ Su uso no implica cambio en la estructura del programa

■ Pero marca la diferencia entre buena y mala programación


Nombrado I■ Mantener explícitos los términos

abstractos del problema■ Nombres de variable y/o función

deberán ser claros y específicos


Nombrado MAL IIvoid bar(m R)

{

int c = R.c;

int nc = 10;

int pc = rand() % c;

...

}


Nombrado BIEN IIIvoid barajar(mazo_naipes restantes)

{

int cuantos = restantes.cantidad;

int num_cortes = 10;

int primer_corte = rand() % cuantos;

...

}


Indentación I■ El “dibujo” del código ha de reflejar su

estructura. Ver y entender■ Usar “blancos” para encolumnar■ “Tabular” las líneas indicando su

profundidad■ Situar los delimitadores de bloque { y }

uniformemente


Indentación MAL IIif (n == 0)

{

n = 1;

if (n == 1) {

n = 2;

}

else {

n = 3;

}n = n + 1;}


Indentación BIEN IIIif (n == 0) {

n = 1;

if (n == 1) {

n = 2;

} else {

n = 3;

}

n = n + 1;

}


Comentarios I■ “Codificar la idea” implica pérdida de

información■ Codificar es estrictamente indicar cómo hacer algo■ El razonamiento seguido, no queda reflejado

■ Se debe comentar el código para “iluminar” al lector (y a nosotros mismos) sobre las decisiones tomadas

■ Un buen nombrado puede evitar comentarios inútiles


Comentarios MAL II

H = H - 1; // Resto 1

...

/* Elevo al cuadrado */

r = r * r;

/* Multiplico por PI */

s = r * 3.14159;


Comentarios BIEN IIIdesfase_horario = -1;

hora = hora + desfase_horario;

...

const float PI = 3.141592654;

/* Es una circunferencia */

superf = r * r * PI;


Restricciones I■ Muchos lenguajes tienen cláusulas que

“rompen” la estructura del programa■ Son saltos bruscos (incondicionales)

del hilo de ejecución■ Hay que restringir su uso,

evitar su abuso


Restricción IIgoto

■ Salto incondicional■ No usar jamás


Restricción IIIbreak

■ Sale fuera del bucle o switch más interno■ Usar sólo en el switch


Restricción IVcontinue

■ Salta a la siguiente iteración más interna■ Usar sólo como cuerpo de bucles vacíos

while (time() < limite)

continue;


int main(void) {

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

if (i%2==0) continue;

if (i%17==0) break;

cout << i<<endl; } return 0;

}

break y continue 1


int main(void) {

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

if (i%2==0) continue; // A la siguiente iteración

if (i%17==0) break; // Directamente fuera

cout << i<<endl; } return 0;

}

break y continue 2


Restricción Vreturn

■ Sale de la función devolviendo un valor■ Sólo debe haber uno único como última

sentencia de cada función

Tipos y estructuras de datos

Variables y constantesValor y formatoTipos básicosEstructuras dinámicas de datos


Variables y constantes■ Representan cantidades y/o cualidades■ Antes de usarlas debemos declararlas

para que el compilador (o intérprete) sepa:

Su nombreSu ámbito de vidaSu visibilidadEl tipo de datos asociado


Declaración de variables■ Simple:

char c;int i;

■ Múltiple:char c, d;int i, j, k;

■ Con asignación de valor:char c=’A’;int i=-133, j=i, k;


Nombrado I■ Debe ser no ambiguo y reflejar los

términos abstractos del problema■ El lenguaje puede restringir el

nombrado■ Variables cuyo nombre coincida con

palabras reservadas del lenguaje■ Otras restricciones (ej. Longitud)


Nombrado II■ Evitar las palabras reservadas, en C++:

asm, auto, bool, break, case, catch, char, class, const, const_cast, continue, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutable, namespace, new, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_cast, struct, switch, template, this, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while

■ Identificador correcto: {a-zA-Z_}[a-zA-Z_0-9]*


Ámbito de vida

■ Determina durante cuánto tiempo existe■ Variable global a módulo o programa:

■ durante todo el tiempo de ejecución (toman valor inicial 0)

■ Variable local a, o parámetro formal de, una función■ sólo durante cada llamada

(toman valor inicial basura)


Visibilidad■ Determina desde dónde podemos usarla■ Variable global al programa

■ desde cualquier punto

■ Variable global a un módulo■ sólo desde dicho módulo

■ Variable local o parámetro formal de función■ sólo desde dicha función

■ Una variable local oculta la global con el mismo nombre


Ejemplo de ámbito y visibilidadint x,y; /* Globales */void funcion(void){

/* Aquí x e y son variables enteras *//* La variable z no existe */

}int main(void){

float x,z; /* Locales *//* Aquí x y z son reales e y es entera */

}


Modificadores de variablesstatic

■ Si global, sólo global al módulo■ Si local, conserva valor entre invocaciones■ Valor inicial 0

register■ Se preferiría ubicar en un registro (por eficiencia)

volatile■ Podría cambiar de valor espontáneamente por efecto de

algo "externo" al programa (Ej. registro de controlador de dispositivo)

const■ Su valor no debe ser alterado


Tipos de datos■ Podrá ser uno de los tipos básicos o bien un

tipo derivado de aquellos (los veremos)■ Se escoge según el conjunto de valores que

queremos que la variable pueda tomar■ Los tipos numéricos básicos determinan el

rango de posibles valores■ Un entero no podrá valer 3.75 (decimal)■ Un sin-signo no podrá valer –1


Valor y formatoUn Kilo de oroUn Kilo de oro

tiene un determinadotiene un determinado valorvalor,, independiente de su independiente de su formatoformato::

lingote, polvo...lingote, polvo...■ Una cosa es el valor que una variable

tiene (o contiene) y otra el formato en que es almacenado o representado■ Más sobre esto en los próximos ejemplos


Tipos básicosSin tipoLógico: CIERTO FALSOCarácter: a A z Z 1 9 ...Entero: -1 33Real: 3.14 -5*10-15

Enumerado: lunes martes ...Puntero: NULLVectores: tablero[8][8]Estructuras: {Nombre, edad, peso}


Sin tipovoid barajar(...)

■ Para declarar procedimientos■ No existen variables de este tipo


Lógicobool salir=false;

■ Existe en muchos lenguajes para representar valores lógicos true y false

■ Es de este tipo el resultado las comparaciones y de su combinación mediante operadores lógicos AND, OR, NOT, etc

■ En C no existe como tipo básico■ Cualquier expresión sirve de expresión lógica■ Se considera FALSO el valor numérico cero■ Por negación cualquier valor numérico distinto de

cero es CIERTO


Carácterchar letra='a';

'\0', 'a', 'Ü', '?', '\n'■ Son valores numéricos de tamaño 1 byte...■ ...que representan (o representados por)

caracteres según una convención dada (código ASCII o Latin1)

■ Constante entre comillas simples (apóstrofo ')■ Secuencias de escape: '\r', '\t', '\b',...■ Valor en octal: '\013',...


Enteroint saldo_bancario=-1000; /* negros o rojos */unsigned numero_de_amarracos=30;

■ Con o sin signo■ Para contar o numerar■ Diferentes bases de representación:

Hexadecimal(16): 0x0, -0x1, 0xFFF, 0xFea0Octal(8): 00, -01, 07777, 0177240

Decimal(10): 0, -1, 4095, 65184


Modificadores de tipos enterosunsigned char byte; /* 8 bits: 0 a 255 */signed char desfase; /* 8 bits: -127 a 128 */short int dia_anyo; /* 16 bits (aprox) */long microsegundos; /* 32 bits (aprox) */long long n_atomos; /* 64 bits (GNU C)*/■ Pueden combinarse■ Si derivan de int puede omitirse■ El tamaño depende de compilador y arquitectura■ Normalmente se usa simplemente int


Realfloat angulo, distancia=42E-11;double PI=3.14159265358979323846;

■ Números positivos o negativos con o sin decimales

■ “coma flotante”■ Notación decimal o científica

42*10-11


Enumeradoenum {femenino, masculino} genero;genero = femenino;

■ Puede tomar cualquiera de los valores simbólicos que se enumeran

■ Internamente se representan como entero


Punteroint * puntero_a_entero=NULL;

■ "Vale" la dirección de otra variable del tipo indicado

■ La constante NULL vale 0 y no se puede derreferenciar, pero si comparar

■ Son la base para las estructuras dinámicas de datos

Tipo al que apunta


Puntero Ej.int variable = 7;puntero_a_entero = & variable;*puntero_a_entero = 8;/* Ahora variable vale 8 */

...puntero_a_entero = NULL;*puntero_a_entero = 2; /* ERROR */

Operador “dirección de”

Operador “derreferenciar”


Paso de referencias por valor 1■ Se recibe un puntero que apunta a la variableint reiniciar(int *p, int v) {■ Se modifica allí donde apunta el puntero

*p = 0; v = 0; }...int x=2, y=2,*ptr;■ Se pasa el valor de la dirección de la variablereiniciar(&x,y); /* x == 0, y == 2 */ reiniciar(ptr, 5);/* ERROR ¿porqué? */


Paso de referencias por valor 2■ Se recibe un puntero que apunta a la variableint reiniciar(int *p, int v) {■ Se modifica allí donde apunta el puntero

*p = 0; v = 0; }...int x=2, y=2,*ptr;■ Se pasa el valor de la dirección de la variablereiniciar(&x,y); /* x == 0, y == 2 */ reiniciar(ptr, 5);/* ERROR ¿porqué? */

Acceso a dirección inválidaNo inicializado


Vectores y matriceschar vocal[5]={'a','e','i','o','u'};float tablero[8][8];

■ Agrupaciones de información homogénea■ Se almacenan en memoria contigua■ Se indexan con enteros desde el 0

vocal[0] = 'A';tablero[8][8] = 2.1; /* ERROR FUERA */


Punteros y Arraysint Prim[9]={2,3,5,7,11,13,17,19,23};

■ El nombre de un vector es (equivale a) la dirección de su primer elemento

int * ptr = Prim; /* Prim == &Prim[0] */■ Los punteros se indexan e incrementan en la

cuantía del tamaño del tipo al que apuntanif (*ptr == ptr[0]) ... /* Siempre CIERTO */if (ptr[1] == Prim[1]) ... /* CIERTO */ptr++;if (*ptr == Prim[1]) ... /* CIERTO*/


Tiras de caracteres■ Constantes entre comillas dobles

char Hola[20] = "Hola Mundo!";■ Es la declaración de su valor inicial■ Luego NO se asignan así

Hola = "Adios"; /* ERROR */■ Son también vectores de caracteres

if (Hola[0] == 'H') ... /* CIERTO */■ El último carácter ha de ser el nulo '\0'

if (Hola[11] == '\0') ... /* CIERTO */■ Hemos reservado 20 caracteres pero sólo

estamos usando 12!! (11 + el nulo)


Punteros y Stringschar Hola[12] = "Hola Mundo!";char * str = Hola;

■ Para manipular tiras existen funciones de bibliotecaint strlen(char*str); /* Devuelve longitud */if (strlen(str) == 11) ... /*CIERTO, pero ocupa 12*/

■ Para recorrer tiras usamos punteros a caráctervoid strcopy(char * des, char * org) {

while ((*des++ = *org++)) /* '\0' vale 0 */continue;

}strcopy(str,"Adios");if (strlen(str) == 5) ... /* CIERTO, pero ocupa 6 */


Estructurasstruct Fecha {

int Anyo, Mes, Dia;} Nacimiento;

■ Agrupaciones de información heterogénea■ Se almacenan en memoria contigua■ Sus campos se indexan con el punto

Nacimiento.Mes = 1;


Punteros y Structs IIstruct Fecha {

int Anyo, Mes, Dia;} Nacimiento, *ptr;ptr = &Nacimiento;

■ Derreferenciamos e indexamos el campo

*ptr.Anyo = 1970;■ ó utilizamos la notación menos mayor (flecha)

ptr->Dia = 1;


Uniones I■ Similar a una estructura, pero sus campos

comparten la memoria (son alternativos)struct datos {

int a, x[2];char c;

} d;

union datos {int a, x[2];char c;

} d;

d.ad.x[0]d.x[1]

d.c

d.ad.x

d.c


Uniones II■ Varias representaciones del mismo dato

struct empleado { ... enum {en_nomina, a_destajo} tipo_contrato;

union { int sueldo_base; float euros_hora;

} sueldo; } fulano;float euros; if (fulano.tipo_contrato == a_destajo) {

euros = horas * fulano.sueldo.euros_hora; } else {

euros = fulano.sueldo.sueldo_base * 100; }


Conversión explícita de tipo■ Casting: mecanismo para explicitar el

cambio de tipo de expresión o variable■ Le indicamos al compilador que asumimos

la responsabilidadfloat f = 65.2;int a;char c;

a=(int) f; /* a vale 65 */c=(char) a; /* c vale 65 (Código ASCII de 'A') */


Definición de nuevos tipostypedef int logico; logico terminar_ya = 0;

typedef struct nodo * lista_t; typedef struct nodo {

int valor; lista_t siguiente;

} nodo_t; nodo_t nodos[400]; lista_t lista = NULL;


Estructuras dinámicas I■ Permiten manejar agrupaciones de

datos cuya cantidad desconocemos de antemano

■ Se construyen mediante otras estructuras con “punteros” para interconectarse

■ Los punteros con valor NULL marcan los “extremos” de la estructura

■ Se ubican en memoria dinámica


Memória dinámica I■ Se getiona sobre el HEAP, o parte superior del

segmento de datos, con las siguientes funciones:void *malloc(size_t);

■ Ubica espacio suficiente para los bytes indicados

void *calloc(size_t num, size_t size);■ Ubica espacio (inicializado a ceros) para num elementos de

tamaño size

void *realloc(void *, size_t);■ Reubicar. Ajustar a nuevo tamaño

void free(void *);■ Liberar espacio previamente ubicado


Memória dinámica IIint * ptr = malloc(sizeof(int));*ptr = 8;free(ptr);

char * str = malloc(strlen("Hola") + 1);strcpy(str, "Hola");str = realloc(str, 20);strcat(str, "y adios");str = realloc(str, strlen(str) + 1);free(str);


Estructuras dinámicas II■ Para usar estructuras dinámicas hay

que tener (o programar), funciones de utilidad sobre dicho tipo:■ Insertar y extraer un elemento■ Buscar por contenido■ Ordenar■ etc


Listas■ Estructura lineal de elementos, como

los eslabones de una cadena■ Simplemente / doblemente encadenada■ FIFO / LIFO


Árboles■ Estructura arborescente de nodos.■ Un nodo raíz■ Nodos hoja si no tienen descendientes

■ Binario / N-ario


Tablas Hash■ Estructura mixta compuesta de un de

punteros a otras estructuras dinámicas■ Utiliza una función de barajado (hash)

sobre un campo clave de cada elemento para acotar la búsqueda

Operadores

AritméticosDe asignaciónLógicosDe bitOtros


Operadores Aritméticos= asignación+ suma- resta* multiplicación/ división% módulo (resto)++ auto-incremento (pre ó post)-- auto-decremento (pre ó post)


Ej. Aritméticosint a = 5 - (2 * 2); int b; float f;a++; /* a = a + 1 */a=3; b=a++; /* a=4 b=3 */a=3; b=++a; /* a=4 b=4 */a=3; b=a--; /* a=2 b=3 */f=4/3; /* == 1 Div. entera */b=4%3; /* == 1 == (4 – (4/3)*3)*/ f=4.0/3; /* == 1.333 Div. real */f=(float)4/3; /* == 1.333 Div. real */


Operadores de Asignacióna *= 2; /* Igual a: a = a * 2; */a /= c+3; /* Igual a: a = a / (c+3); */

■ Usar cast en asignaciones entre variables y expresiones de diferente tipo:

a=(int)(f/2.34);


Operadores de Comparación y Lógicos== Igual!= Distinto> Mayor>= Mayor o igual< Menor<= Menor o igual&& AND lógico|| OR lógico! NOT lógico


Ej. Comparación y Lógicos■ El valor resultante de evaluar operadores lógicos es

0 sii FALSO ó 1 sii CIERTOint a = (3>2 || 5==4) && !1; /* a = 0 (==FALSO) */int b = (3>2 || 5==4) && 7; /* b = 1 (==CIERTO) */

■ Toda expresión sirve de expresión lógica considerándose: FALSA si la expresión se evalúa a CERO ó CIERTA si la expresión se evalúa a cualquier otro valor

if (a) ... /* Idéntico a: if (a != 0) ... */if (!b) ... /* Idéntico a: if (b == 0) ... */

■ La evaluación de expresiones lógicas es perezosaa = (3>2 || b==4); /* b==4 no se llega a evaluar */


Operadores de Bit& AND| OR^ XOR~ NOT<< Desplazamiento a la izquierda>> Desplazamiento a la derecha


Ej. De Bitunsigned char a = 48;unsigned char b = 19;unsigned char x,y,z,w,t,s;

x = a & b;y = a | b;z = a ^ b;w = ~a;t = a>>2;s = b<<3;

00110000 a00010011 b

00010000 x = 1600110011 y = 5100100011 z = 3511001111 w = 20700001100 t = 1210011000 s = 152


Operador sizeof()■ Vale el número de bytes que ocupa (en

memoria) una variable o un tipo de datosint a; if (sizeof(a) == sizeof(int)) ... /*CIERTO*/

■ Se sabe durante la compilación NO es función sino operador

■ Relaciones conocidas:1 == sizeof(char) <= sizeof(short) <= sizeof(int) == sizeof(unsigned) <= sizeof(long) <= sizeof(long long)

sizeof(float) <= sizeof(double)sizeof(int*) == sizeof(char*) == sizeof(void*)


Operador TernarioA ? B : C

■ Sii (A) entonces vale B, si no vale C

int num; char * str;...str = (num%2 ? "par" : "impar");

Funciones y Parámetros

Programa Principal y ArgumentosFunción o Procedimiento

RecursividadPaso de parámetros


El programa principal I■ Es el punto de entrada al programa■ Imprescindible para conseguir un

ejecutable autónomo o “programa”■ Mínimo programa totalmente correcto

int main(void) {

return 0; }


Argumentos de invocación I■ Los argumentos con los que es

invocado el ejecutable son accesibles desde la función principal main

int main(int argc, char* argv[])

int argc : Número de argumentoschar* argv[] : Argumentos de invocación


Argumentos de invocación II$ gcc prog.c -o prog$ ./prog uno dos tres cuatro

int main(int argc, char* argv[])argc == 5

argv[0] p r o g\0

argv[1] u n o\0

argv[2] d o s\0

argv[3] t r e s\0

argv[4] c u a t \0r oNULLargv[5]


Argumentos de invocación III#include <iostream>using namespace std;

int main(int argc, char *argv[]){

cout <<"Ejecutable: "<< argv[0]<<endl;

for(int i=0; i< argc; i++)cout<<"Argumento["<<i<<"]: "<< argv[i]<<endl;

return 0;}


Función – Procedimiento I■ Semejante a función matemática■ Invocación, argumentos, valor devuelto

■ Un único punto de entrada■ Un único punto de salida

■ Procedimiento■ Si no devuelve ningún valor


Funcionalidades II■ Crear una función

para cada “bien delimitada” funcionalidad o método

de cada módulo del programa

■ ¡Aunque sólo se use una vez!■ Programa = conjunto de funciones


Función – descripción III■ Qué es lo que hace (funcionalidad)■ El nombre debe resumirlo■ Ejemplo clásico

■ factorial(n) = n * (n-1) * ... * 2 * 1■ factorial(0) = 1■ Para n natural (entero no negativo)


Función – declaración IV■ Dice cómo se usarla■ No dice cómo está hecha■ Se declara su prototipo

unsigned factorial(unsigned);

Qué devuelve (tipo)

Qué hace (nombre)

Qué recibe (tipo)

Punto y coma


Función – invocación Vint main(void){

cout <<"3! = "<<factorial(3)<<endl;cout <<"7! = "<<factorial(7)<<endl;return 0;

}

■ Varias invocaciones a la misma función son independientes

Argumento


Función – definición VIunsigned factorial(unsigned n)

{

unsigned result = 1;

/* Recorre de n a 2 */

for (; n > 1; n--)

result = result * n;

return result;

}

Parámetro formalVariable local


Ejercicio

Programe:

La función principal de un programa que

muestre el factorial de los números

del 0 al 20 inclusive


Solución

#include <iostream>

using namespace std;

int main(void)

{

unsigned n;

for (n = 0; n <= 20; n++)

cout <<n<<"! = "<<factorial(n)<<endl;

return 0;

}


Ejercicio

Programe la siguiente función definida sobre

m y n naturales

binomial(m,n) = m! / (n!*(m-n)!)


Solución

unsigned binomial(unsigned m, unsigned n)

{

return factorial(m) / (factorial(n)*factorial(m-n));

}


Función – recursividad VII■ Facultad de las funciones de invocarse

a sí mismas■ Forma natural de expresar ciertos

problemas autocontenidos■ Ejemplo clásico

■ factorial(n) = n * factorial(n-1)■ factorial(0) = 1


Ejercicio

Programe:

Una versión recursiva de la función:

factorial(0) = 1factorial(n) = n * factorial(n-1)

Para n natural (entero no negativo)


Soluciónunsigned factorial(unsigned n)

{

if (n == 0)

n = 1;

else

n = n * factorial(n - 1);

return n;

}


Función – recursividad VIII■ Funcionalmente equivalente iterar■ La implementación:

■ no contiene ningún bucle■ pero si una condición de terminación

■ Es mucho más difícil de seguir■ La recursión infinita es fatal


Paso de argumentos por valorint main(void){

unsigned num = 5, res;res = factorial(num);/* num sigue valiendo 5 */

■ Se pasa el valor de la expresión evaluada, no la variable en sí■Esto es siempre así en C■En C++ existe el paso por referencia


Modificadores de funciónstatic

■ Sólo visible dentro del módulo

extern■ Función (o variable) declarada, pero definida en

algún otro sítio (Ej. en biblioteca)

inline■ Expandir su código en vez llamar a la función■ Aumenta la eficiencia y el tamaño del código

Preproceso y Bibliotecas

PreprocesoBibliotecas

Herramientas de Desarrollo II

Compilación separadaArchivador y bibliotecasConstructor y otras


Compilación y montajeSon etapas separadas

■ Compilación: traducir de formato fuente a formato objeto (lenguaje máquina, más lista de referencias externas no resueltas)

■ Montaje: enlazar ficheros objeto entre sí y con las bibliotecas necesarias, resolviendo todas las referencias externas

■ Se produce un ejecutable: en formato interno apto para situar el proceso en memoria para su ejecución


Compilación separada■ En la figura:

■ Compilación separada de los módulos■main.cpp y prim.cpp

■ Montaje de los objetos con las bibliotecas■main.o, prim.o y libstdc++ y otras (libm, libc)

■ Obtención del fichero ejecutable■primes


Diagrama de fases

prim.h

prim.cpp

main.cpp

cmath

iostream

g++ -c

g++ -c

main.o

prim.old primes

cstdlib

libc.a

libm.a

Módulos de

usuario

Ficheros estándar

de cabecera

Compilaciónseparada

Ficheros objeto

Bibliotecas estándar Montaje Ejecutable

Dependen

Fich Herram Producto

Auto

entre si

Leyenda

libstdc++.a


Extensiones■ Le indican al compilador el contenido de

fichero, y el tratamiento que debe realizar:■ .c .cpp Fuentes de C y C++

■ Deben ser preprocesados, compilados y ensamblados■ .h Fichero de cabecera de C o de C++

(/usr/include y /usr/include/c++)■ Declaraciones de tipos de datos, prototipos y clases■ Deben ser preprocesados

■ .o Fichero objeto■ Deben ser enlazados (resueltos sus símbolos)

■ .a .so Bibliotecas estática y dinámica■ Para resolver símbolos de funciones estándar usadas


Bibliotecas■ Utilizar código probado, no reinventar

■ Consultar el manual■ Usar fichero(s) de cabecera

#include <xx.h> /* en C */#include <xx> // en C++ del std::

■ Montar contra la biblioteca (opción –l)■ libc.a Biblioteca estándar de C

■ Tiras de caracteres, entrada y salida estándar, etc.■ El montaje contra esta biblioteca es automático

■ libm.a Biblioteca de cálculo matemático■ sqrt, pow, hypot, cos, atan, etc.■ Hay que incluir <math.h> o <cmath>■ Hay que montar con la opción -lm


ar Manage Archive■ Para crear nuestras propias bibliotecas

■ -d Elimina ficheros■ -r Añade (o reemplaza) ficheros■ -u Igual que -r sólo si es más nuevo■ -t Muestra el contenido■ -v Verbose■ -x Extrae ficheros


Constructor■ Permite automatizar el proceso de

construcción de un programa que está convenientemente descompuesto en múltiples módulos

■ Herramienta make


make Application Maintainer■ Determina qué partes de un programa

deben recompilarse■ Debe conocer las dependencias entre

los ficheros:■ Un fichero debe actualizarse si alguno de

los que depende es más nuevo■ Makefile

■ Contiene las reglas de dependencia y mandatos para actualizarlo


Makefile I# Esto es un comentario CC=gcc # Esto son macros CFLAGS=-g OBJS2=test.o prim.o

all: primes test # Esta es la primera regla

primes: main.o prim.o # Esta es otra regla gcc -g -o primes main.o prim.o -lm # Este es el mandato asociado

test: $(OBJS2) # Aquí usamos las macros ${CC} ${CFLAGS} -o $@ ${OBJS2}

main.o prim.o test.o : prim.h # Esta es una dependencia.

clean: # Esta no depende de nada, es obligatoria. rm -f main.o ${OBJS2}


Makefile II■ Las líneas con mandatos deben tabuladas

■ make Dispara la primera regla■ make clean Explicitando la regla a disparar

■ La regla objetivo dispara sus dependencias recursivamente

■ Macros especiales■ $@, $*, $<, etc.

■ Se pueden especificar reglas basadas en la extensión de los ficheros■ Cómo pasar de un .c a un .o


Otras herramientas■ Existen variedad de herramientas útiles para

el desarrollador de código■ gprof Realizar un perfil de ejecución

Indica dónde se pierde el tiempo Dice qué optimizar

■ gcov Verificación del programa Asegura que el 100% del código han sido comprobado

■ indent Indentación de ficheros fuente en C Da estilo uniforme al código Es muy parametrizable

programación en c++ - laurel.datsi.fi.upm.es · el entorno unix ¿qué es programar? herramientas...

Documents