Programacion C PDF

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;
}
Contenidos
El entorno UNIX
¿Qué es programar?
Herramientas de desarrollo I
Técnicas de programación
Estructuras de programación
Estilo de codificación
Tipos y estructuras de datos
Operadores
Funciones y parámetros
Preproceso y bibliotecas
Herramientas de desarrollo II
© Francisco Rosales
& Jose María Peña Programación C++ 3
El Entorno UNIX
¿Qué es UNIX?
¡Cómo es UNIX!
¡Cómo es Linux!
Usuarios y Grupos
Sesión de trabajo
Procesos y Concurrencia
Sistema de Ficheros
Descriptores 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ña
password
■ 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úmero
GID 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)
Write eXecute
Read rwxrwxrwx
Others
Owner Group
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 mandatos
prompt> _
■ Para terminar...
exit o
logout
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 III
mandato [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. Juegos
7. Miscelánea
8. 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 otro
cd Invocado sin argumento
nos devuelve al HOME
cd . Realmente nos deja en el
directorio actual de trabajo
cd .. 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 debidamente
0 Entrada estándar
De él se leerán los datos a procesar
1 Salida estándar
En él se escribirán los resultados del proceso
2 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 software
Ciclo de programación
¿Cómo es un ordenador por dentro?
Memoria Arquitectura Controladoras
Principal de Perifericos
RAM
Mapas de
Von Newmann
memoria de Controladora
programa Gráfica AGP
µP
PILA
PILA
PILA
Controladora
ALU de Disco IDE
DATOS Bus de datos Bus de Controladora

DATOS Registros Entrada/Salida
DATOS USB
TEXTO
TEXTO
TEXTO
Controladora
ROM
RS232 Modem
¿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
A.-- 1, 1.5
B.-- ...2
C.--
1.--
Análisis 2.--
Especificación
3.--
Ciclo de vida Diseño
del software I main(){}
Usuario
A.OK
B.OK Programación
C.OK
Implantación Validación
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
Editor
Compilador
Depurador
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 I
La 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 abstractos
Razonamiento descendente
Modularizació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
Secuencia
Selección
Iteración
Función o Procedimiento
Estructuras de Programación
■ Se identifican un conjunto mínimo de
estructuras básicas de programación:
Secuencia
Selección
Iteración
■ 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
Comentario] - - - - [Comienzo de bloque
Hacer antes
- - [En estricta secuencia
Hacer después
- - [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 II
IF_THEN if (num != 0)
{
num = num * 2;
Condición }
FALSO
CIERTO
Hacer
Selección IF-THEN-ELSE III
IF_THEN_ELSE if (num != 0)
{
num = num * 2;
Condición }
FALSO CIERTO
else
Hacer Hacer {
num = num - 1;
}
Selección SWITCH IV
SWITCH switch(num + 5)
{
Selección case -1:
CASO 1
num = num * num;
Hacer
break;
CASO 2
BREAK
case 0:
Hacer break;
DEFAULT
BREAK default:
Hacer
num = num / 2;
}
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 II
WHILE while (num < 0)
{
num = num + 1;
}
Mientras
FALSO
■ Mientras la condición se
evalúe a CIERTO
CIERTO
Hacer
■ Puede no ser ejecutado
ni una sola vez
Iteración DO-WHILE III
DO_WHILE do
{
num = num - 1;
} while (num > 0);
Hacer
■ Es ejecutado al menos
CIERTO
una vez
Mientras
■ Hasta que la condición se
FALSO evalúe a FALSO
Iteración FOR IV
FOR for (num = 0; num < MAX; num++)
{
Desde sum = sum + num;
}
Mientras ■ Básicamente un WHILE con:
FALSO
CIERTO
■ Una etapa de inicialización
Hacer
■ Otra de incremento
Paso (o decremento)
Estilo de Codificación
Nombrado
Indentación
Comentarios
Restricciones
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 II
void bar(m R)
{
int c = R.c;
int nc = 10;
int pc = rand() % c;
...
}
Nombrado BIEN III
void 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 II
if (n == 0)
{
n = 1;
if (n == 1) {
n = 2;
}
else {
n = 3;
}n = n + 1;}
Indentación BIEN III
if (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 III
desfase_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 II
goto
■ Salto incondicional
■ No usar jamás
Restricción III
break
■ Sale fuera del bucle o switch más interno
■ Usar sólo en el switch
Restricción IV
continue
■ Salta a la siguiente iteración más interna
■ Usar sólo como cuerpo de bucles vacíos
while (time() < limite)

continue;
break y continue 1
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 2
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;
}
Restricción V
return
■ 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 constantes
Valor y formato
Tipos básicos
Estructuras 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 nombre
Su ámbito de vida
Su visibilidad
El 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 visibilidad
int 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 variables
static
■ 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 formato
Un Kilo de oro
tiene un determinado valor,
independiente de su formato:
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ásicos
Sin tipo
Lógico: CIERTO FALSO
Carácter: a A z Z 1 9 ...
Entero: -1 33
Real: 3.14 -5*10-15
Enumerado: lunes martes ...
Puntero: NULL
Vectores: tablero[8][8]
Estructuras: {Nombre, edad, peso}
Sin tipo
void barajar(...)
■ Para declarar procedimientos
■ No existen variables de este tipo
Lógico
bool 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ácter
char 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',...
Entero
int 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, 0xFea0
Octal(8): 00, -01, 07777, 0177240
Decimal(10): 0, -1, 4095, 65184
Modificadores de tipos enteros
unsigned 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
Real 42*10-11
float 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
Enumerado
enum {femenino, masculino} genero;
genero = femenino;
■ Puede tomar cualquiera de los valores

simbólicos que se enumeran
■ Internamente se representan como entero
Puntero
int * puntero_a_entero=NULL;
Tipo al que apunta
■ "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
Puntero Ej.
Operador “dirección de”
int variable = 7;
puntero_a_entero = & variable;
*puntero_a_entero = 8;
/* Ahora variable vale 8 */
Operador “derreferenciar” ...
puntero_a_entero = NULL;
*puntero_a_entero = 2; /* ERROR */
Paso de referencias por valor 1
■ Se recibe un puntero que apunta a la variable
int 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 variable
reiniciar(&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 variable
int reiniciar(int *p, int v)
{
■ Se modifica allí donde apunta el puntero
*p = 0; v = 0;
}
... Acceso a dirección inválida
int x=2, y=2,*ptr; No inicializado
■ Se pasa el valor de la dirección de la variable
reiniciar(&x,y); /* x == 0, y == 2 */
reiniciar(ptr, 5);/* ERROR ¿porqué? */
Vectores y matrices
char 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 Arrays
int 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 apuntan
if (*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 Strings
char Hola[12] = "Hola Mundo!";
char * str = Hola;
■ Para manipular tiras existen funciones de biblioteca
int strlen(char*str); /* Devuelve longitud */
if (strlen(str) == 11) ... /*CIERTO, pero ocupa 12*/
■ Para recorrer tiras usamos punteros a carácter
void strcopy(char * des, char * org)
{
while ((*des++ = *org++)) /* '\0' vale 0 */
continue;
}
strcopy(str,"Adios");
if (strlen(str) == 5) ... /* CIERTO, pero ocupa 6 */
Estructuras
struct 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 II
struct 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 { union datos {
int a, x[2]; int a, x[2];
char c; char c;
} d; } d;
d.x
d.a d.a
d.x[0]
d.x[1]
d.c
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;
}© Francisco Rosales
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 responsabilidad
float 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 tipos
typedef 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 II
int * 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éticos
De asignación
Lógicos
De bit
Otros
Operadores Aritméticos
= asignación
+ suma
- resta
* multiplicación
/ división
% módulo (resto)
++ auto-incremento (pre ó post)
-- auto-decremento (pre ó post)
Ej. Aritméticos
int 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ón
a *= 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 CIERTO
int 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 perezosa

a = (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 Bit
unsigned char a = 48; 00110000 a
unsigned char b = 19; 00010011 b
unsigned char x,y,z,w,t,s;
x = a & b; 00010000 x = 16
y = a | b; 00110011 y = 51
z = a ^ b; 00100011 z = 35
w = ~a; 11001111 w = 207
t = a>>2; 00001100 t = 12
s = b<<3; 10011000 s = 152
Operador sizeof()
■ Vale el número de bytes que ocupa (en
memoria) una variable o un tipo de datos
int 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 Ternario
A?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 Argumentos

Recursividad
Paso 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 argumentos
char* 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 r o \0
argv[5] NULL
Argumentos de invocación III
#include <iostream>
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
Qué devuelve Qué hace Qué recibe

(tipo) (nombre) (tipo)
unsigned factorial(unsigned);
Punto y coma
Función – invocación V
int main(void)
Argumento
{
cout <<"3! = "<<factorial(3)<<endl;
cout <<"7! = "<<factorial(7)<<endl;
return 0;
}
■ Varias invocaciones a la misma función son
independientes
Función – definición VI
unsigned factorial(unsigned n)
{ Variable local Parámetro formal
unsigned result = 1;
/* Recorre de n a 2 */
for (; n > 1; n--)
result = result * n;
return result;
}
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>
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) = 1
factorial(n) = n * factorial(n-1)
Para n natural (entero no negativo)
Solución
unsigned 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 valor
int 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ón
static
■ 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
Preproceso
Bibliotecas
Herramientas de Desarrollo II
Compilación separada
Archivador y bibliotecas
Constructor y otras
Compilación y montaje
Son 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
Auto Leyenda
iostream Fich Herram Producto
Diagrama de fases
cstdlib Dependen entre si
libstdc++.a
main.cpp libc.a
g++ -c main.o
prim.h ld primes
g++ -c prim.o
prim.cpp
libm.a
cmath
Ficheros
Módulos estándar
de de Compilación Ficheros Bibliotecas
usuario © Francisco
cabecera Rosales separada objeto estándar Montaje Ejecutable
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
# Esto es un comentario
CC=gcc # Esto son macros
Makefile
CFLAGS=-g
OBJS2=test.o prim.o I
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

Programacion C PDF

Transféré par

Informations du document

Titre original

Copyright

Formats disponibles

Partager ce document

Partager ou intégrer le document

Options de partage

Avez-vous trouvé ce document utile ?

Ce contenu est-il inapproprié ?

Droits d'auteur :

Formats disponibles

Programacion C PDF

Transféré par

Droits d'auteur :

Formats disponibles

Programación en C++

■ Campos separados por espacios

¿Cómo es un ordenador por dentro?

DATOS Bus de datos Bus de Controladora

■ pico nano Simple Editor

■ “programa principal”, “función principal” o “main”:

■ Mínimo programa totalmente correcto

■ El compilador informa los problemas que encuentre

■ Y sobre todo... la experiencia

”cómo se juega al mus”

“desarrollo de una partida de mus”

en una jerarquía con las fases del juego

Trate de identificar los módulos de

un programa que juegue al mus

- - [En estricta secuencia

while (time() < limite)

'\0', 'a', 'Ü', '?', '\n'

■ Con o sin signo

float angulo, distancia=42E-11;

■ Números positivos o negativos

■ Puede tomar cualquiera de los valores

typedef struct nodo * lista_t;

char * str = malloc(strlen("Hola") + 1);

■ Toda expresión sirve de expresión lógica considerándose:

■ La evaluación de expresiones lógicas es perezosa

Programa Principal y Argumentos

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

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

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

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

for(int i=0; i<argc; i++)

Qué devuelve Qué hace Qué recibe

La función principal de un programa que

muestre el factorial de los números

Programe la siguiente función

unsigned binomial(unsigned m, unsigned n)

Una versión recursiva de la función:

■ Se pasa el valor de la expresión evaluada,

iostream Fich Herram Producto

primes: main.o prim.o # Esta es otra regla

test: $(OBJS2) # Aquí usamos las macros

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

clean: # Esta no depende de nada, es obligatoria.

Vous aimerez peut-être aussi