C/C

++
Curso de Programación
4.ª edición
Fco. Javier Ceballos Sierra
Profesor titular de la
Escuela Politécnica Superior
Universidad de Alcalá

http://www.fjceballos.es/

C/C++: Curso de programación. 4.ª edición
© Fco. Javier Ceballos Sierra
© De la edición: RA-MA 2015
MARCAS COMERCIALES: las marcas de los productos citados en el contenido de este libro
(sean o no marcas registradas) pertenecen a sus respectivos propietarios. RA-MA no está
asociada a ningún producto o fabricante mencionado en la obra, los datos y los ejemplos
utilizados son ficticios salvo que se indique lo contrario.
RA-MA es una marca comercial registrada.
Se ha puesto el máximo empeño en ofrecer al lector una información completa y precisa.
Sin embargo, RA-MA Editorial no asume ninguna responsabilidad derivada de su uso,
ni tampoco por cualquier violación de patentes ni otros derechos de terceras partes que pudieran
ocurrir. Esta publicación tiene por objeto proporcionar unos conocimientos precisos y acreditados
sobre el tema tratado. Su venta no supone para el editor ninguna forma de asistencia legal,
administrativa ni de ningún otro tipo. En caso de precisarse asesoría legal u otra forma de ayuda
experta, deben buscarse los servicios de un profesional competente.
Reservados todos los derechos de publicación en cualquier idioma.
Según lo dispuesto en el Código Penal vigente, ninguna parte de este libro puede ser
reproducida, grabada en sistema de almacenamiento o transmitida en forma alguna ni
por cualquier procedimiento, ya sea electrónico, mecánico, reprográfico, magnético o
cualquier otro, sin autorización previa y por escrito de RA-MA; su contenido está protegido
por la ley vigente, que establece penas de prisión y/o multas a quienes intencionadamente
reprodujeren o plagiaren, en todo o en parte, una obra literaria, artística o científica.
Editado por:
RA-MA Editorial
C/ Jarama, 3A, Polígono industrial Igarsa
28860 Paracuellos del Jarama, Madrid
Teléfono: 91 658 42 80
Telefax: 91 662 81 39
Correo electrónico: editorial@ra-ma.com
Internet: www.ra-ma.es y www.ra-ma.com
ISBN: 978-84-9964-527-8
Depósito Legal: M-2512-2015
Autoedición: Fco. Javier Ceballos
Filmación e impresión: Copias Centro, S.L.
Impreso en España
Primera impresión: marzo 2015

La mente es como un paracaídas.
Solo funciona si la tenemos abierta.
Einstein
Dedico esta obra
a María del Carmen, mi esposa,
y a mis hijos Francisco y Javier.

CONTENIDO
PRÓLOGO.............................................................................................................. XIX 
CAPÍTULO 1. FASES EN EL DESARROLLO DE UN PROGRAMA ............

QUÉ ES UN PROGRAMA.................................................................................
LENGUAJES DE PROGRAMACIÓN...............................................................
Compiladores .................................................................................................
Intérpretes.......................................................................................................
¿QUÉ ES C? ........................................................................................................
HISTORIA DEL LENGUAJE C ........................................................................
Lenguaje C++.................................................................................................
REALIZACIÓN DE UN PROGRAMA EN C ...................................................
Edición de un programa .................................................................................
¿Qué hace este programa?.........................................................................
Guardar el programa escrito en el disco .........................................................
Compilar y ejecutar el programa ....................................................................
Biblioteca de funciones .............................................................................
Guardar el programa ejecutable en el disco ...................................................
Depurar un programa .....................................................................................
UN AVANCE SOBRE LA PROGRAMACIÓN CON C ...................................
Entrada y salida ..............................................................................................
Matrices ..........................................................................................................
Sentencias de control .....................................................................................
Funciones .......................................................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................











10 
10 
11 
12 
13 
13 
14 
15 
16 
18 
19 
21

VIII

C/C++: CURSO DE PROGRAMACIÓN

CAPÍTULO 2. ELEMENTOS DEL LENGUAJE C ...........................................

23 

PRESENTACIÓN DE LA SINTAXIS DE C .....................................................
CARACTERES DE C .........................................................................................
Letras, dígitos y carácter de subrayado ..........................................................
Espacios en blanco .........................................................................................
Caracteres especiales y signos de puntuación ................................................
Secuencias de escape......................................................................................
TIPOS DE DATOS .............................................................................................
Tipos primitivos .............................................................................................
char............................................................................................................
short ..........................................................................................................
int ..............................................................................................................
long ...........................................................................................................
enum..........................................................................................................
Creación de una enumeración ..............................................................
float ...........................................................................................................
double........................................................................................................
Ejemplo: tipos de datos ..................................................................................
Tipos derivados ..............................................................................................
SINÓNIMOS DE UN TIPO ................................................................................
LITERALES .......................................................................................................
Literales enteros .............................................................................................
Literales reales ...............................................................................................
Literales de un solo carácter ...........................................................................
Literales de cadenas de caracteres ..................................................................
IDENTIFICADORES .........................................................................................
PALABRAS CLAVE ..........................................................................................
COMENTARIOS ................................................................................................
DECLARACIÓN DE CONSTANTES SIMBÓLICAS ......................................
Constantes C++ ..............................................................................................
¿Por qué utilizar constantes? ..........................................................................
DECLARACIÓN DE UNA VARIABLE ...........................................................
Iniciación de una variable ..............................................................................
EXPRESIONES NUMÉRICAS ..........................................................................
OPERADORES...................................................................................................
Operadores aritméticos...................................................................................
Operadores de relación...................................................................................
Operadores lógicos .........................................................................................
Operadores unitarios ......................................................................................
Operadores a nivel de bits ..............................................................................
Operadores de asignación ..............................................................................
Operador condicional .....................................................................................

23 
24 
24 
24 
25 
25 
26 
26 
27 
28 
28 
28 
29 
29 
31 
32 
32 
33 
33 
35 
35 
36 
36 
37 
38 
38 
39 
39 
40 
40 
40 
41 
42 
42 
42 
44 
45 
46 
46 
47 
49 

CONTENIDO

IX

Otros operadores ............................................................................................
Operador sizeof .........................................................................................
Operador coma ..........................................................................................
Operador dirección-de ..............................................................................
Operador de indirección ............................................................................
PRIORIDAD Y ORDEN DE EVALUACIÓN ...................................................
CONVERSIÓN ENTRE TIPOS DE DATOS.....................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

50 
50 
51 
51 
52 
53 
54 
58 
60

CAPÍTULO 3. ESTRUCTURA DE UN PROGRAMA...........................................

63 

ESTRUCTURA DE UN PROGRAMA C ..........................................................
Directrices para el preprocesador ...................................................................
Directriz de inclusión ................................................................................
Directriz de sustitución .............................................................................
Definiciones y declaraciones..........................................................................
Sentencia simple ............................................................................................
Sentencia compuesta o bloque .......................................................................
Funciones .......................................................................................................
Declaración de una función ......................................................................
Definición de una función .........................................................................
Llamada a una función ..............................................................................
Función main..................................................................................................
Un ejemplo .....................................................................................................
PASANDO ARGUMENTOS A LAS FUNCIONES..........................................
PROGRAMA C FORMADO POR MÚLTIPLES FICHEROS ..........................
ÁMBITO DE UNA VARIABLE ........................................................................
Variables globales y locales ...........................................................................
CLASES DE ALMACENAMIENTO DE UNA VARIABLE............................
Calificación de variables globales ..................................................................
Calificación de variables locales ....................................................................
Calificación de funciones ...............................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

63 
67 
68 
68 
69 
69 
70 
70 
71 
73 
75 
75 
76 
77 
81 
83 
84 
86 
86 
88 
90 
90 
93

CAPÍTULO 4. ENTRADA Y SALIDA ESTÁNDAR .........................................

99 

DATOS NUMÉRICOS Y CADENAS DE CARACTERES ..............................
FLUJOS DE E/S ESTÁNDAR ...........................................................................
SALIDA CON FORMATO ................................................................................
ENTRADA CON FORMATO ............................................................................

100 
101 
102 
108 

X

C/C++: CURSO DE PROGRAMACIÓN

CARÁCTER FIN DE FICHERO ........................................................................
CARÁCTER \n ...................................................................................................
Limpiar el buffer de la entrada estándar.........................................................
LEER UN CARÁCTER DE LA ENTRADA ESTÁNDAR ...............................
ESCRIBIR UN CARÁCTER EN LA SALIDA ESTÁNDAR ...........................
FUNCIONES getch y getche ..............................................................................
LEER UNA CADENA DE CARACTERES ......................................................
VALIDAR UN DATO DE ENTRADA ..............................................................
REUTILIZAR CÓDIGO .....................................................................................
LIMPIAR LA PANTALLA ................................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

114 
115 
117 
118 
119 
120 
121 
124 
126 
128 
128 
133

CAPÍTULO 5. SENTENCIAS DE CONTROL ................................................... 139 
SENTENCIA if ...................................................................................................
ANIDAMIENTO DE SENTENCIAS if .............................................................
ESTRUCTURA else if ........................................................................................
SENTENCIA switch ...........................................................................................
SENTENCIA while .............................................................................................
Bucles anidados..............................................................................................
SENTENCIA do ... while ....................................................................................
SENTENCIA for .................................................................................................
SENTENCIA break .............................................................................................
SENTENCIA continue ........................................................................................
SENTENCIA goto ..............................................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

139 
141 
144 
147 
151 
154 
157 
160 
163 
164 
164 
165 
180

CAPÍTULO 6. TIPOS ESTRUCTURADOS DE DATOS .................................. 187 
INTRODUCCIÓN A LAS MATRICES .............................................................
MATRICES NUMÉRICAS UNIDIMENSIONALES ........................................
Definir una matriz ..........................................................................................
Acceder a los elementos de una matriz ..........................................................
Trabajar con matrices unidimensionales ........................................................
Iniciar una matriz ...........................................................................................
Matrices asociativas .......................................................................................
CADENAS DE CARACTERES .........................................................................
Leer y escribir una cadena de caracteres ........................................................
Funciones gets y fgets ...............................................................................
Función puts ..............................................................................................

188 
189 
189 
190 
191 
195 
196 
200 
201 
201 
203 

CONTENIDO

Trabajar con cadenas de caracteres ................................................................
Funciones de la biblioteca de C .....................................................................
TIPO Y TAMAÑO DE UNA MATRIZ .............................................................
MATRICES MULTIDIMENSIONALES ...........................................................
Matrices numéricas multidimensionales ........................................................
Matrices de cadenas de caracteres ..................................................................
COPIAR MATRICES .........................................................................................
TRABAJAR CON BLOQUES DE BYTES .......................................................
ESTRUCTURAS ................................................................................................
Crear una estructura .......................................................................................
Definir variables de un tipo de estructura ......................................................
Acceso a los miembros de una estructura ......................................................
Miembros que son estructuras ........................................................................
Operaciones con estructuras ...........................................................................
Matrices de estructuras ...................................................................................
UNIONES ...........................................................................................................
Estructuras variables ......................................................................................
CAMPOS DE BITS ............................................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

XI

206 
207 
208 
209 
209 
214 
218 
220 
221 
221 
222 
224 
225 
226 
231 
234 
237 
242 
246 
259

CAPÍTULO 7. PUNTEROS .................................................................................. 267 
CREACIÓN DE PUNTEROS ............................................................................
Operadores .....................................................................................................
Importancia del tipo del objeto al que se apunta ............................................
OPERACIONES CON PUNTEROS ..................................................................
Operación de asignación ................................................................................
Operaciones aritméticas .................................................................................
Comparación de punteros...............................................................................
Punteros genéricos .........................................................................................
Puntero nulo ...................................................................................................
Punteros constantes ........................................................................................
PUNTEROS Y MATRICES ...............................................................................
Punteros a cadenas de caracteres....................................................................
MATRICES DE PUNTEROS .............................................................................
Punteros a punteros ........................................................................................
Matriz de punteros a cadenas de caracteres ...................................................
Ordenar matrices de cadenas de caracteres ....................................................
ASIGNACIÓN DINÁMICA DE MEMORIA ....................................................
Funciones para administrar dinámicamente la memoria ..................................
malloc........................................................................................................

267 
269 
270 
271 
271 
272 
274 
274 
276 
277 
277 
282 
286 
288 
291 
295 
299 
299 
299 

XII

C/C++: CURSO DE PROGRAMACIÓN

free ............................................................................................................
Reasignar un bloque de memoria ...................................................................
MATRICES DINÁMICAS .................................................................................
Matrices dinámicas numéricas .......................................................................
Matrices dinámicas de una dimensión ......................................................
Matrices dinámicas de dos dimensiones ...................................................
Matrices dinámicas de cadenas de caracteres.................................................
PUNTEROS A ESTRUCTURAS .......................................................................
PUNTEROS COMO PARÁMETROS EN FUNCIONES ..................................
DECLARACIONES COMPLEJAS ....................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

301 
302 
304 
305 
305 
309 
313 
317 
320 
326 
327 
337

CAPÍTULO 8. MÁS SOBRE FUNCIONES ........................................................ 347 
PASAR UNA MATRIZ COMO ARGUMENTO A UNA FUNCIÓN .....................
Matrices estáticas ...........................................................................................
Matrices dinámicas.........................................................................................
PASAR UN PUNTERO COMO ARGUMENTO A UNA FUNCIÓN ......................
PASAR UNA ESTRUCTURA A UNA FUNCIÓN ...........................................
DATOS RETORNADOS POR UNA FUNCIÓN ...............................................
Retornar una copia de los datos .....................................................................
Retornar un puntero al bloque de datos..........................................................
Retornar la dirección de una variable declarada static ...................................
ARGUMENTOS EN LA LÍNEA DE ÓRDENES ..............................................
REDIRECCIÓN DE LA ENTRADA Y DE LA SALIDA .................................
FUNCIONES RECURSIVAS.............................................................................
PUNTEROS A FUNCIONES .............................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

347 
348 
350 
352 
354 
358 
359 
360 
361 
363 
365 
367 
369 
376 
392

CAPÍTULO 9. TRABAJAR CON FICHEROS................................................... 401 
VISIÓN GENERAL DE LOS FLUJOS DE E/S.................................................
VISIÓN GENERAL DE UN FICHERO.............................................................
ABRIR UN FICHERO ........................................................................................
fopen ..............................................................................................................
freopen ...........................................................................................................
CERRAR UN FICHERO ....................................................................................
fclose ..............................................................................................................
MANIPULACIÓN DE ERRORES .....................................................................
ferror ..............................................................................................................

403 
405 
409 
409 
411 
412 
412 
413 
413 

CONTENIDO

XIII

clearerr ...........................................................................................................
feof .................................................................................................................
perror ..............................................................................................................
POSICIÓN DEL PUNTERO DE L/E .................................................................
ftell .................................................................................................................
fseek ...............................................................................................................
rewind ............................................................................................................
E/S CARÁCTER A CARÁCTER.......................................................................
fputc ...............................................................................................................
fgetc................................................................................................................
E/S DE CADENAS DE CARACTERES ............................................................
fputs................................................................................................................
fgets ................................................................................................................
ENTRADA/SALIDA CON FORMATO ............................................................
fprintf .............................................................................................................
fscanf ..............................................................................................................
E/S UTILIZANDO REGISTROS .......................................................................
fwrite ..............................................................................................................
fread ...............................................................................................................
ABRIENDO FICHEROS PARA ACCESO SECUENCIAL ..............................
Un ejemplo de acceso secuencial ...................................................................
ESCRIBIR DATOS EN UNA IMPRESORA .....................................................
Escribir en una impresora USB ......................................................................
CONTROL DEL BUFFER ASOCIADO CON UN FLUJO...............................
setvbuf ............................................................................................................
fflush ..............................................................................................................
FICHEROS TEMPORALES ..............................................................................
tmpfile ............................................................................................................
ABRIENDO FICHEROS PARA ACCESO ALEATORIO ................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

413 
414 
415 
417 
417 
417 
418 
418 
419 
420 
422 
422 
423 
425 
425 
426 
427 
428 
428 
429 
430 
434 
436 
437 
438 
441 
441 
441 
441 
445 
464

CAPÍTULO 10. EL PREPROCESADOR DE C ................................................. 471 
DIRECTRIZ #define ...........................................................................................
Macros predefinidas .......................................................................................
El operador # ..................................................................................................
El operador ## ................................................................................................
DIRECTRIZ #undef ............................................................................................
DIRECTRIZ #include .........................................................................................
COMPILACIÓN CONDICIONAL ....................................................................
Operador defined............................................................................................

472 
475 
476 
476 
476 
477 
477 
479 

XIV

C/C++: CURSO DE PROGRAMACIÓN

CONSTANTE DEFINIDA EN LA ORDEN DE COMPILACIÓN ...................
DIRECTRICES #ifdef e #ifndef .........................................................................
DIRECTRIZ #line ...............................................................................................
DIRECTRIZ #error .............................................................................................
UTILIZACIÓN DE FICHEROS DE CABECERA ............................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

479 
482 
482 
483 
483 
486 
488

CAPÍTULO 11. ESTRUCTURAS DINÁMICAS ................................................ 495 
LISTAS LINEALES ...........................................................................................
Listas lineales simplemente enlazadas ...........................................................
Operaciones básicas .......................................................................................
Inserción de un elemento al comienzo de la lista ......................................
Buscar en una lista un elemento con un valor x ........................................
Inserción de un elemento en general .........................................................
Borrar un elemento de la lista ...................................................................
Recorrer una lista ......................................................................................
Borrar todos los elementos de una lista ....................................................
UN EJEMPLO CON LISTAS LINEALES.........................................................
Interfaz genérica para listas lineales...............................................................
LISTAS CIRCULARES .....................................................................................
Interfaz para manipular una lcse ....................................................................
PILAS..................................................................................................................
COLAS ................................................................................................................
Ejemplo ..........................................................................................................
LISTA DOBLEMENTE ENLAZADA ...............................................................
Lista circular doblemente enlazada ................................................................
Interfaz para manipular una lcde ...............................................................
Ejemplo .....................................................................................................
ÁRBOLES...........................................................................................................
Árboles binarios .............................................................................................
Formas de recorrer un árbol binario ...............................................................
ÁRBOLES BINARIOS DE BÚSQUEDA ..........................................................
Interfaz para manipular un árbol binario de búsqueda ...................................
Buscar un nodo en el árbol .............................................................................
Insertar un nodo en el árbol............................................................................
Borrar un nodo del árbol ................................................................................
Utilización de la interfaz abb .........................................................................
ÁRBOLES BINARIOS PERFECTAMENTE EQUILIBRADOS ......................
Interfaz para manipular un árbol perfectamente equilibrado .........................
Utilización de la interfaz abe..........................................................................

496 
496 
500 
501 
502 
502 
503 
504 
504 
505 
509 
520 
522 
527 
528 
530 
533 
533 
534 
540 
542 
543 
544 
546 
547 
550 
550 
552 
554 
558 
559 
564 

CONTENIDO

XV

EJERCICIOS RESUELTOS ............................................................................... 567 
EJERCICIOS PROPUESTOS............................................................................. 582
CAPÍTULO 12. ALGORITMOS DE USO COMÚN .......................................... 591 
RECURSIVIDAD ...............................................................................................
ORDENACIÓN DE DATOS ..............................................................................
Método de la burbuja .....................................................................................
Método de inserción .......................................................................................
Método quicksort ...........................................................................................
Comparación de los métodos expuestos.........................................................
BÚSQUEDA DE DATOS ..................................................................................
Búsqueda secuencial ......................................................................................
Búsqueda binaria ............................................................................................
Búsqueda de cadenas .....................................................................................
ORDENACIÓN DE FICHEROS EN DISCO.....................................................
Ordenación de ficheros. Acceso secuencial ...................................................
Ordenación de ficheros. Acceso aleatorio ......................................................
ALGORITMOS HASH .......................................................................................
Matrices hash .................................................................................................
Método hash abierto .......................................................................................
Método hash con desbordamiento ..................................................................
Eliminación de elementos ..............................................................................
Interfaz hash abierto .......................................................................................
Un ejemplo de una matriz hash ......................................................................
EJERCICIOS RESUELTOS ...............................................................................
EJERCICIOS PROPUESTOS.............................................................................

591 
597 
598 
600 
602 
605 
605 
606 
606 
607 
610 
611 
616 
619 
619 
621 
622 
623 
623 
627 
629 
633

A. ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C................................ 639 
FUNCIONES DE CADENAS Y DE CARACTERES .......................................
strcat ...............................................................................................................
strcpy ..............................................................................................................
strchr ..............................................................................................................
strrchr .............................................................................................................
strcmp .............................................................................................................
strcspn ............................................................................................................
strlen ...............................................................................................................
strncat .............................................................................................................
strncpy ............................................................................................................
strncmp ...........................................................................................................
strspn ..............................................................................................................

639 
639 
640 
640 
640 
642 
643 
644 
644 
645 
645 
645 

XVI

C/C++: CURSO DE PROGRAMACIÓN

strstr................................................................................................................
strtok ..............................................................................................................
strlwr ..............................................................................................................
strupr ..............................................................................................................
Funciones para conversión de datos ...............................................................
atof .................................................................................................................
atoi..................................................................................................................
atol..................................................................................................................
sprintf .............................................................................................................
Funciones de caracteres..................................................................................
toascii .............................................................................................................
tolower ...........................................................................................................
toupper ...........................................................................................................
FUNCIONES MATEMÁTICAS ........................................................................
acos ................................................................................................................
asin .................................................................................................................
atan .................................................................................................................
atan2 ...............................................................................................................
cos ..................................................................................................................
sin ...................................................................................................................
tan ...................................................................................................................
cosh ................................................................................................................
sinh .................................................................................................................
tanh .................................................................................................................
exp ..................................................................................................................
log ..................................................................................................................
log10 ..............................................................................................................
ceil ..................................................................................................................
fabs .................................................................................................................
floor ................................................................................................................
pow .................................................................................................................
sqrt..................................................................................................................
NÚMEROS SEUDOALEATORIOS ..................................................................
rand ................................................................................................................
srand ...............................................................................................................
FUNCIONES DE FECHA Y HORA ..................................................................
clock ...............................................................................................................
time.................................................................................................................
ctime ...............................................................................................................
localtime .........................................................................................................
FUNCIONES PARA MANIPULAR BLOQUES DE MEMORIA ....................
memset ...........................................................................................................
memcpy ..........................................................................................................

645 
646 
647 
647 
647 
648 
648 
648 
649 
650 
650 
650 
650 
651 
652 
652 
652 
652 
653 
653 
653 
653 
653 
654 
654 
654 
654 
654 
655 
655 
655 
655 
656 
656 
656 
656 
656 
657 
657 
658 
659 
659 
659 

CONTENIDO

XVII

memcmp ......................................................................................................... 660
B. ENTORNOS DE DESARROLLO.................................................................... 661 
MICROSOFT VISUAL STUDIO .......................................................................
Añadir ficheros existentes a un proyecto .......................................................
Depurar la aplicación .....................................................................................
INTERFAZ DE LÍNEA DE ÓRDENES EN WINDOWS..................................
CREAR UNA BIBLIOTECA DE FUNCIONES................................................
NETBEANS ........................................................................................................
Depurar una aplicación con NetBeans ...........................................................
INTERFAZ DE LÍNEA DE ÓRDENES EN UNIX/LINUX ..............................
El depurador gdb de Unix/Linux ...................................................................
CODE::BLOCKS ................................................................................................

661 
666 
666 
668 
669 
672 
676 
678 
679 
680

C. CÓDIGOS DE CARACTERES ....................................................................... 685 
UTILIZACIÓN DE CARACTERES ANSI CON WINDOWS ..........................
JUEGO DE CARACTERES ANSI .....................................................................
UTILIZACIÓN DE CARACTERES ASCII .......................................................
JUEGO DE CARACTERES ASCII....................................................................
JUEGO DE CARACTERES UNICODE ............................................................

685 
686 
687 
688 
689 

ÍNDICE ................................................................................................................... 691

PRÓLOGO
Aprender C nunca ha sido fácil. Por eso el autor, apoyándose en su experiencia
docente, ha puesto todo su empeño en escribir un libro fácil de leer, progresivo en
el aprendizaje y con muchos ejemplos que aclaren lo expuesto.

Para quién es este libro
Este libro está pensado para aquellas personas que quieran aprender a escribir
programas, utilizando el lenguaje C, siguiendo una metodología fundamentada en
técnicas de desarrollo que conducen a realizar una programación estructurada.
Para ello, ¿qué debe hacer el lector? Pues simplemente leer ordenadamente los
capítulos del libro, resolviendo cada uno de los ejemplos que en ellos se detallan.
Es evidente que el lenguaje C ha ido evolucionando a lo largo de su historia.
Producto de esta evolución fue el lenguaje C++ y, finalmente, el diseño de una
amplia biblioteca de funciones para el desarrollo de aplicaciones con interfaz gráfica (programación visual). De ahí que este libro sea el primero de una colección
de tres libros orientados al desarrollo de aplicaciones con C/C++. Entre los tres, y
en el orden comentado a continuación, cubren los siguientes aspectos: programación estructurada con C y programación orientada a objetos con C++.
Este es el primero, C/C++: Curso de programación. Abarca todo lo relativo
a la programación estructurada con C. También incluye diversos algoritmos de
uso común así como desarrollos con estructuras dinámicas de datos. ¿Por qué el
título C/C++? Porque C++ fue desarrollado a partir del lenguaje de programación
C y con pocas excepciones incluye a C. Esta parte de C incluida en C++ es conocida como C–, y podría compilarse bajo C++ sin problemas. No obstante, cuando
C++ se utiliza para lo que fue pensado, para realizar una programación orientada a
objetos, los conocimientos nuevos que hay que adquirir son cuantiosos.

XX

C/C++: CURSO DE PROGRAMACIÓN

El segundo, Programación orientada a objetos con C++, estudia, como su
nombre indica, el desarrollo de aplicaciones orientadas a objetos. Esta tecnología
es imprescindible conocerla si su propósito es llegar a desarrollar aplicaciones vistosas como lo son las aplicaciones a base de ventanas, más bien conocidas como
aplicaciones para Windows.
Y el tercero, Enciclopedia de C++, incluye a los dos anteriores, pero con un
nuevo enfoque, ya que a lo largo de todos los capítulos del libro solo se utiliza la
biblioteca de C++.
Por el contrario, si lo que usted persigue es profundizar en aplicaciones C incluyendo llamadas al sistema UNIX, entonces le recomiendo el libro de Francisco
Manuel Márquez titulado UNIX, Programación Avanzada, publicado también por
la editorial RA-MA.

Cómo está organizado el libro
El libro se ha dividido en doce capítulos que van presentando el lenguaje poco a
poco, empezando por lo más sencillo, viendo cada tema a su tiempo, hasta llegar
al final donde se habrá visto todo lo referente a la programación con el lenguaje
C, sin apenas encontrar dificultades. Se completa el estudio de C con un capítulo
referente a estructuras dinámicas y otro de algoritmos de uso común. El lector podrá comprobar al final de esta obra que el nivel de conocimientos que ha adquirido es elevado.
El primer capítulo introduce al lector en el mundo de la programación C. El
segundo capítulo presenta de una sola vez todos los elementos del lenguaje que el
lector utilizará constantemente en el resto de los capítulos; por eso, debe simplemente leerse fijándose en los ejemplos y, por el momento, no preocuparse de más;
posteriormente se podrá retornar a él todas las veces que sean necesarias. El tercer
capítulo presenta la estructura general de un programa C con un ejemplo; el lector
debe también leerlo con un objetivo: asimilar cómo es la estructura de un programa C y cuál es su secuencia de ejecución, sin tratar de aprender en este instante
todos los conceptos que ahí se exponen. Leídos estos tres capítulos, el lector tendrá claro el escenario donde se va a mover. A partir del capítulo 4 empezará a
aprender a programar; por lo tanto, el lector debe tener un poco de paciencia hasta
que se inicie en este capítulo.
Este libro posee varias características dignas de resaltar. Es breve en teoría y
abundante en ejemplos (más de 250 ejercicios resueltos), lo que le hará aún más
fácil el aprendizaje.

PRÓLOGO XXI

Estos capítulos y apéndices que componen la materia total de C/C++: Curso
de programación se resumen así:
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
A.
B.
C.

Fases en el desarrollo de un programa.
Elementos del lenguaje C.
Estructura de un programa.
Entrada y salida estándar.
Sentencias de control.
Tipos estructurados de datos.
Punteros.
Más sobre funciones.
Trabajar con ficheros.
El preprocesador de C.
Estructuras dinámicas.
Algoritmos de uso común.
Algunas funciones de la biblioteca de C.
Entornos de desarrollo.
Códigos de caracteres.

Todo esto se ha documentado con abundantes ejemplos, ejercicios resueltos y
ejercicios propuestos, de los cuales también se da su solución en un ZIP, muchos
de ellos válidos como parte integrante en el desarrollo de aplicaciones.

Agradecimientos
He recibido ideas y sugerencias de algunas personas durante la preparación de este libro, entre las que se encuentran, cómo no, mis alumnos, que con su interés por
aprender me hacen reflexionar sobre objetivos que a primera vista parecen inalcanzables, pero que una vez logrados sirven para que todos aprendamos; a todos
ellos les estoy francamente agradecido.
En especial, quiero expresar mi agradecimiento a Martín Knoblauch Revuelta, por sus buenas recomendaciones y aportaciones para esta nueva edición, y
a Inmaculada Rodríguez Santiago, por sus consejos en las versiones anteriores,
así como a Alfredo Gallego Gandarillas y a Francisco Manuel Márquez García, por su participación en la corrección de las versiones anteriores, y a David
Jurado González, porque aportó una solución para la mayoría de los ejercicios
propuestos.
Francisco Javier Ceballos Sierra
http://www.fjceballos.es/

APÉNDICE A
 F.J.Ceballos/RAMA

ALGUNAS FUNCIONES DE LA
BIBLIOTECA DE C
Además de las funciones expuestas a lo largo de esta obra, hay otras muchas. Este
apéndice muestra algunas de las funciones más útiles de la biblioteca de C que
aún no han sido expuestas. Todas estas funciones se pueden agrupar en las siguientes categorías:





Funciones de E/S.
Funciones de cadenas y de caracteres.
Funciones matemáticas.
Funciones de fecha y hora.
Funciones de asignación dinámica.
Otras funciones.

FUNCIONES DE CADENAS Y DE CARACTERES
La biblioteca de C proporciona un amplio número de funciones que permiten realizar diversas operaciones con cadenas de caracteres, como copiar una cadena en
otra, añadir una cadena a otra, etc. A continuación se describen las más utilizadas.

strcat
#include <string.h>
char *strcat( char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

640

C/C++: CURSO DE PROGRAMACIÓN

La función strcat añade la cadena2 a la cadena1, finaliza la cadena resultante
con el carácter nulo y devuelve un puntero a cadena1.

strcpy
#include <string.h>
char *strcpy( char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

La función strcpy copia la cadena2, incluyendo el carácter de terminación
nulo, en la cadena1 y devuelve un puntero a cadena1.
/* Este programa utiliza strcpy y strcat
* strcpy.c
*/
#include <stdio.h>
#include <string.h>
main(void)
{
char cadena[81];
strcpy( cadena, "Hola, " );
strcat( cadena, "strcpy " );
strcat( cadena, "y " );
strcat( cadena, "strcat te saludan!" );
printf( "cadena = %s\n", cadena );
}
Ejecución del programa:
cadena = Hola, strcpy y strcat te saludan!

strchr
#include <string.h>
char *strchr( const char *cadena, int c );
Compatibilidad: ANSI, UNIX y Windows

La función strchr devuelve un puntero a la primera ocurrencia de c en cadena
o un valor NULL si el carácter no es encontrado. El carácter c puede ser el carácter nulo (‘\0’).

strrchr
#include <string.h>
char *strrchr( const char *cadena, int c );
Compatibilidad: ANSI, UNIX y Windows

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

641

La función strrchr devuelve un puntero a la última ocurrencia de c en cadena
o un valor NULL si el carácter no se encuentra. El carácter c puede ser un carácter nulo (‘\0’).
/* Este programa ilustra cómo buscar un carácter con strchr
* (hacia delante) o con strrchr (hacia atrás).
/* strchr.c
*/
#include <stdio.h>
#include <string.h>
main( void )
{
int car = 'i';
char cadena[] = "La biblioteca de C proporciona muchas funciones";
char dec1[] =
"
1
2
3
4
5";
char uni2[] =
"12345678901234567890123456789012345678901234567890";
char *pdest;
int resu;
printf( "Cadena en la que se busca: \n%s\n", cadena );
printf( "%s\n%s\n\n", dec1, uni2 );
printf( "Buscar el carácter: %c\n\n", car );
// Buscar de adelante hacia atrás
pdest = strchr( cadena, car );
resu = pdest - cadena;
if ( pdest != NULL )
printf( "La %c primera está en la posición %d\n", car, resu );
else
printf( "%c no se encuentra en la cadena\n" );
// Buscar desde atrás hacia delante
pdest = strrchr( cadena, car );
resu = pdest - cadena;
if ( pdest != NULL )
printf( "La última %c está en la posición %d\n\n", car, resu );
else
printf( "%c no se encuentra en la cadena\n" );
}
Ejecución del programa:
Cadena en la que se busca:
La biblioteca de C proporciona muchas funciones
1
2
3
4
01234567890123456789012345678901234567890123456789
Buscar el carácter: i
La i primera está en la posición 4
La última i está en la posición 42

642

C/C++: CURSO DE PROGRAMACIÓN

Sabemos que los elementos de una matriz de caracteres, igual que los de
cualquier otra matriz, ocupan posiciones sucesivas en memoria. También sabemos
que el nombre de una matriz es la dirección de comienzo de la matriz y coincide
con la dirección del primer carácter. Así mismo, observe que el valor retornado
por strchr y strrchr está definido como un puntero a un char; esto es, una dirección que hace referencia al lugar donde está almacenado el carácter que se busca.
cadena

pdest
L

a

b

i

b

...

u

n

c

i

o

n

e

s

\0

Por lo tanto, una sentencia como:
resu = pdest - cadena;

da como resultado la posición 0, 1, 2,... del carácter buscado dentro de la cadena,
que es lo que hace el programa planteado.

strcmp
#include <string.h>
int strcmp( const char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

La función strcmp compara la cadena1 con la cadena2 lexicográficamente y
devuelve un valor:
<0 si la cadena1 es menor que la cadena2,
=0 si la cadena1 es igual a la cadena2 y
>0 si la cadena1 es mayor que la cadena2.
En otras palabras, la función strcmp nos permite saber si una cadena está en
orden alfabético antes (es menor) o después (es mayor) que otra y el proceso que
sigue es el mismo que nosotros ejercitamos cuando lo hacemos mentalmente:
comparar las cadenas carácter a carácter.
La función strcmp diferencia las letras mayúsculas de las minúsculas. Las
mayúsculas están antes por orden alfabético. Esto es así porque en la tabla ASCII
las mayúsculas tienen asociado un valor entero menor que las minúsculas.
/* strcmp.c
*/
#include <stdio.h>
#include <string.h>

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

643

main(void)
{
char cadena1[] = "La Comunidad de Cantabria es muy bonita";
char cadena2[] = "La Comunidad de CANTABRIA es muy bonita";
char temp[20];
int resu;
// Se diferencian mayúsculas de minúsculas
printf( "Comparar las cadenas:\n\n%s\n%s\n\n", cadena1, cadena2 );
resu = strcmp( cadena1, cadena2 );
if ( resu > 0 )
strcpy( temp, "mayor que" );
else if ( resu < 0 )
strcpy( temp, "menor que" );
else
strcpy( temp, "igual a" );
printf( "strcmp: cadena 1 es %s cadena 2\n", temp );
}
Ejecución del programa:
Comparar las cadenas:
La Comunidad de Cantabria es muy bonita
La Comunidad de CANTABRIA es muy bonita
strcmp: cadena 1 es mayor que cadena 2

La solución de este problema es que la cadena1 es mayor que la cadena2
porque alfabéticamente Cantabria está después de CANTABRIA.

strcspn
#include <string.h>
size_t strcspn( const char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

La función strcspn da como resultado la posición (subíndice) del primer carácter de cadena1, que pertenece al conjunto de caracteres contenidos en cadena2.
Este valor corresponde a la longitud de la subcadena de cadena1 formada por caracteres no pertenecientes a cadena2. Si ningún carácter de cadena1 pertenece a
cadena2, el resultado es la posición del carácter de terminación (\0) de cadena1;
esto es, la longitud de cadena1.
/* strcspn.c
*/
#include <stdio.h>
#include <string.h>
main(void)

644

C/C++: CURSO DE PROGRAMACIÓN

{
char cadena[] = "xyzabc";
int pos;
pos = strcspn( cadena, "abc" );
printf( "Primer a, b o c en %s es el carácter %d\n", cadena, pos );
}
Ejecución del programa:
Primer a, b o c en xyzabc es el carácter 3

strlen
#include <string.h>
size_t strlen( char *cadena );
Compatibilidad: ANSI, UNIX y Windows

La función strlen devuelve la longitud en bytes de cadena, no incluyendo el
carácter de terminación nulo. El tipo size_t es sinónimo de unsigned int.
/* strlen.c
*/
#include <stdio.h>
#include <string.h>
main(void)
{
char cadena[80] = "Hola";
printf("El tamaño de cadena es %d\n", strlen(cadena));
}
Ejecución del programa:
El tamaño de cadena es 4

strncat
#include <string.h>
char *strncat( char *cadena1, const char *cadena2, size_t n );
Compatibilidad: ANSI, UNIX y Windows

La función strncat añade los primeros n caracteres de cadena2 a la cadena1,
termina la cadena resultante con el carácter nulo y devuelve un puntero a cadena1. Si n es mayor que la longitud de cadena2, se utiliza como valor de n la longitud de cadena2.

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

645

strncpy
#include <string.h>
char *strncpy( char *cadena1, const char *cadena2, size_t n );
Compatibilidad: ANSI, UNIX y Windows

La función strncpy copia n caracteres de la cadena2 en la cadena1 (sobrescribiendo los caracteres de cadena1) y devuelve un puntero a cadena1. Si n es
menor que la longitud de cadena2, no se añade automáticamente un carácter nulo
a la cadena resultante. Si n es mayor que la longitud de cadena2, la cadena1 es rellenada con caracteres nulos (‘\0’) hasta la longitud n.

strncmp
#include <string.h>
int strncmp( const char *cadena1, const char *cadena2, size_t n );
Compatibilidad: ANSI, UNIX y Windows

La función strncmp compara lexicográficamente los primeros n caracteres de
cadena1 y de cadena2, distinguiendo mayúsculas y minúsculas, y devuelve un valor:
<0 si la cadena1 es menor que la cadena2,
=0 si la cadena1 es igual a la cadena2 y
>0 si la cadena1 es mayor que la cadena2.
Si n es mayor que la longitud de la cadena1, se toma como valor la longitud
de la cadena1.

strspn
#include <string.h>
size_t strspn( const char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

La función strspn da como resultado la posición (subíndice) del primer carácter de cadena1, que no pertenece al conjunto de caracteres contenidos en cadena2.
Esto es, el resultado es la longitud de la subcadena inicial de cadena1, formada
por caracteres pertenecientes a cadena2.

strstr
#include <string.h>
char *strstr( const char *cadena1, const char *cadena2 );

646

C/C++: CURSO DE PROGRAMACIÓN

Compatibilidad: ANSI, UNIX y Windows

La función strstr devuelve un puntero a la primera ocurrencia de cadena2 en
cadena1 o un valor NULL si la cadena2 no se encuentra en la cadena1.

strtok
#include <string.h>
char *strtok( char *cadena1, const char *cadena2 );
Compatibilidad: ANSI, UNIX y Windows

La función strtok permite obtener de la cadena1 los elementos en los que se
divide según los delimitadores especificados en cadena2.
Para obtener el primer elemento, strtok debe tener cadena1 como primer argumento y para obtener los siguientes elementos, debe tener NULL. Cada llamada a strtok devuelve un puntero al siguiente elemento o NULL si no hay más
elementos.
Si un elemento finaliza con un delimitador, este es sustituido con un \0 y se
guarda un puntero al siguiente carácter para la siguiente llamada a strtok. Puede
ponerse más de un delimitador entre elemento y elemento, y también puede variarse el conjunto de caracteres que actúan como delimitadores, de una llamada a
otra. Finalmente, tiene que saber que esta función modifica su primer argumento,
por lo tanto, debe existir un espacio de memoria sobre el que la función pueda escribir. Por ejemplo, para cadena1 serían válidas cualesquiera de las dos definiciones siguientes:
char cadena1[] = "Una cadena de caracteres";
char *cadena1 = (char *)malloc(nBytes);
strcpy(cadena1, "Una cadena de caracteres");

En cambio, no sería válida la siguiente definición porque cadena1 apunta a
una zona de memoria sobre la que no se puede escribir (se trata de una constante).
char *cadena1 = "Una cadena de caracteres";

El ejemplo siguiente divide la cadena de caracteres especificada por cadena
en los elementos definidos por los delimitadores espacio en blanco y coma.
/* strtok.c
*/
#include <stdio.h>
#include <string.h>

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

647

main(void)
{
char cadena[] = "Esta cadena, está formada por varias palabras";
char *elemento;
elemento = strtok(cadena," ,");
while (elemento != NULL)
{
printf("%s\n", elemento);
elemento = strtok(NULL," ,");
}
}
Ejecución del programa:
Esta
cadena
está
formada
por
varias
palabras

strlwr
#include <string.h>
char *strlwr(char *cadena );
Compatibilidad: Windows

La función strlwr convierte las letras mayúsculas de cadena en minúsculas.
El resultado es la propia cadena en minúsculas.

strupr
#include <string.h>
char *strupr(char *cadena );
Compatibilidad: Windows

La función strupr convierte las letras minúsculas de cadena en mayúsculas.
El resultado es la propia cadena en mayúsculas.

Funciones para conversión de datos
Las funciones de la biblioteca de C que se muestran a continuación permiten convertir cadenas de caracteres a números y viceversa, suponiendo que la conversión
sea posible.

648

C/C++: CURSO DE PROGRAMACIÓN

atof
#include <stdlib.h>
double atof( const char *cadena );
Compatibilidad: ANSI, UNIX y Windows

La función atof convierte una cadena de caracteres a un valor de tipo double.

atoi
#include <stdlib.h>
int atoi( const char *cadena );
Compatibilidad: ANSI, UNIX y Windows

La función atoi convierte una cadena de caracteres a un valor de tipo int.

atol
#include <stdlib.h>
long atol( const char *cadena );
Compatibilidad: ANSI, UNIX y Windows

La función atol convierte una cadena de caracteres a un valor de tipo long.
Cuando las funciones atof, atoi y atol toman de la variable cadena un carácter que no es reconocido como parte de un número, interrumpen la conversión.
/* Este programa muestra como los números almacenados como
* cadenas de caracteres pueden ser convertidos a valores
* numéricos utilizando las funciones atof, atoi y atol.
*
* atof.c
*/
#include <stdio.h>
#include <stdlib.h>
main(void)
{
char *s = NULL; double x = 0; int i = 0; long l = 0;
s = " -3208.15E-13";
// para ver cómo trabaja atof
x = atof( s );
printf( "atof: cadena ASCII: %-17s float: %e\n", s, x );
s = "8.7195642337X120"; // para ver cómo trabaja atof
x = atof( s );
printf( "atof: cadena ASCII: %-17s float: %e\n", s, x );
s = " -8995 libros";
// para ver cómo trabaja atoi
i = atoi( s );
printf( "atoi: cadena ASCII: %-17s int : %d\n", s, i );

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

649

s = "89954 euros";
// para ver cómo trabaja atol
l = atol( s );
printf( "atol: cadena ASCII: %-17s long : %ld\n", s, l );
}
Ejecución del programa:
atof:
atof:
atoi:
atol:

cadena
cadena
cadena
cadena

ASCII:
-3208.15E-13
ASCII: 8.7195642337X120
ASCII:
-8995 libros
ASCII: 89954 euros

double: -3.208150e-010
double: 8.719564e+000
int : -8995
long : 89954

sprintf
#include <stdio.h>
int sprintf( char *buffer, const char *formato [, argumento] ... );
Compatibilidad: ANSI, UNIX y Windows

La función sprintf convierte los valores de los argumentos especificados a
una cadena de caracteres que almacena en buffer. La cadena de caracteres finaliza
con el carácter nulo. Cada argumento es convertido y almacenado de acuerdo con
el formato correspondiente que se haya especificado. La descripción de formato
es la misma que la que se especificó para printf.
La función sprintf devuelve como resultado un entero correspondiente al
número de caracteres almacenados en buffer sin contar el carácter nulo de terminación. Por ejemplo:
/* sprintf.c. Este programa utiliza sprintf para almacenar
* en buffer la cadena de caracteres formada por:
*
*
Cadena:
ordenador
*
Carácter: /
*
Entero:
40
*
Real:
1.414214
*/
#include <stdio.h>
main(void)
{
char buffer[200], s[] = "ordenador", c = '/';
int
i = 40, j;
float f = 1.414214F;
j = sprintf( buffer,
"\tCadena:
%s\n", s );
j += sprintf( buffer + j, "\tCarácter: %c\n", c );
j += sprintf( buffer + j, "\tEntero:
%d\n", i );
j += sprintf( buffer + j, "\tReal:
%f\n", f );
printf( "Salida:\n%s\nNúmero de caracteres = %d\n", buffer, j );
}

650

C/C++: CURSO DE PROGRAMACIÓN

Ejecución del programa:
Salida:
Cadena:
Carácter:
Entero:
Real:

ordenador
/
40
1.414214

Número de caracteres = 72

Funciones de caracteres
Las funciones de la biblioteca de C que se exponen a continuación actúan sobre
un entero para dar como resultado un carácter.

toascii
#include <ctype.h>
int toascii( int c );
Compatibilidad: UNIX y Windows

La función toascii pone a 0 todos los bits de c, excepto los siete bits de menor
orden. Dicho de otra forma, convierte c a un carácter ASCII.

tolower
#include <stdlib.h>
int tolower( int c );
Compatibilidad: ANSI, UNIX y Windows

La función tolower convierte c a una letra minúscula, si procede.

toupper
#include <stdlib.h>
int toupper( int c );
Compatibilidad: ANSI, UNIX y Windows

La función toupper convierte c a una letra mayúscula, si procede.
/* tolower.c
*/
#include <stdio.h>
#include <stdlib.h>
main()

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

651

{
char car;
// ...
do
{
printf("¿Desea continuar? s/n ");
car = getchar();
fflush(stdin);
}
while (tolower(car) != 'n' && tolower(car) != 's');
// ...
}

Este ejemplo admite una respuesta sí o no (s|S|n|N) en minúsculas o en mayúsculas, pero la comparación se hace en minúsculas.

FUNCIONES MATEMÁTICAS
Las declaraciones para las funciones matemáticas que a continuación se describen
están en el fichero de cabecera math.h. Quiere esto decir que, cuando se utilice
una función matemática en un programa, debe especificarse la directriz:
#include <math.h>

Los argumentos para estas funciones son de tipo double y el resultado devuelto es también de tipo double. Por ello, en muchos casos utilizaremos una
conversión explícita de tipo (conversión cast) para convertir explícitamente los
argumentos al tipo deseado. Por ejemplo, suponiendo que valor es un int:
a = acos((double)valor);

calcula el arco coseno de valor. Se puede observar que el argumento pasado a la
función acos es convertido explícitamente a tipo double.
Las funciones matemáticas las podemos clasificar en las siguientes categorías:



Funciones trigonométricas.
Funciones hiperbólicas.
Funciones exponencial y logarítmica.
Otras varias.

652

C/C++: CURSO DE PROGRAMACIÓN

acos
La función acos da como resultado el arco, en el rango 0 a , cuyo coseno es x. El
valor de x debe estar entre 1 y 1; de lo contrario se obtiene un error (argumento
fuera del dominio de la función).
#include <math.h>
double acos( double x );
Compatibilidad: ANSI, UNIX y Windows

asin
La función asin da como resultado el arco, en el rango /2 a /2, cuyo seno es x.
El valor de x debe estar entre 1 y 1; si no se obtiene un error (argumento fuera
del dominio de la función).
#include <math.h>
double asin( double x );
Compatibilidad: ANSI, UNIX y Windows

atan
La función atan da como resultado el arco, en el rango /2 a /2, cuya tangente
es x.
#include <math.h>
double atan( double x );
Compatibilidad: ANSI, UNIX y Windows

atan2
La función atan2 da como resultado el arco, en el rango a , cuya tangente es
y/x. Si ambos argumentos son 0, se obtiene un error (argumento fuera del dominio
de la función).
#include <math.h>
double atan2( double y, double x);
Compatibilidad: ANSI, UNIX y Windows
/* acos.c
*/
#include <stdio.h>
#include <math.h>
main()

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

{
double valor = 0;
do
{
printf("%lf %lf\n", acos(valor), atan2(valor, 1.0));
valor += 0.1;
}
while (valor <= 1.0);
}

cos
La función cos da como resultado el coseno de x (x en radianes).
#include <math.h>
double cos( double x );
Compatibilidad: ANSI, UNIX y Windows

sin
La función sin da como resultado el seno de x (x en radianes).
#include <math.h>
double sin( double x );
Compatibilidad: ANSI, UNIX y Windows

tan
La función tan da como resultado la tangente de x (x en radianes).
#include <math.h>
double tan( double x );
Compatibilidad: ANSI, UNIX y Windows

cosh
La función cosh da como resultado el coseno hiperbólico de x (x en radianes).
#include <math.h>
double cosh( double x );
Compatibilidad: ANSI, UNIX y Windows

sinh
La función sinh da como resultado el seno hiperbólico de x (x en radianes).

653

654

C/C++: CURSO DE PROGRAMACIÓN

#include <math.h>
double sinh( double x );
Compatibilidad: ANSI, UNIX y Windows

tanh
La función tanh da como resultado la tangente hiperbólica de x (x en radianes).
#include <math.h>
double tanh( double x );
Compatibilidad: ANSI, UNIX y Windows

exp
La función exp da como resultado el valor de ex (e = 2.718282).
#include <math.h>
double exp( double x );
Compatibilidad: ANSI, UNIX y Windows

log
La función log da como resultado el logaritmo natural de x.
#include <math.h>
double log( double x );
Compatibilidad: ANSI, UNIX y Windows

log10
La función log10 da como resultado el logaritmo en base 10 de x.
#include <math.h>
double log10( double x );
Compatibilidad: ANSI, UNIX y Windows

ceil
La función ceil da como resultado un valor double, que representa el entero más
pequeño que es mayor o igual que x.
#include <math.h>
double ceil( double x );
Compatibilidad: ANSI, UNIX y Windows

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

655

double x = 2.8, y = -2.8;
printf("%g %g\n", ceil(x), ceil(y)); // resultado: 3 -2

fabs
La función fabs da como resultado el valor absoluto de x. El argumento x es un
valor real en doble precisión. Igualmente, abs y labs dan el valor absoluto de un
int y un long, respectivamente.
#include <math.h>
double fabs( double x );
Compatibilidad: ANSI, UNIX y Windows

floor
La función floor da como resultado un valor double, que representa el entero más
grande que es menor o igual que x.
#include <math.h>
double floor( double x );
Compatibilidad: ANSI, UNIX y Windows
double x = 2.8, y = -2.8;
printf("%g %g\n", floor(x), floor(y)); // resultado: 2 -3

pow
La función pow da como resultado xy. Si x es 0 e y negativo o si x e y son 0 o si x
es negativo e y no es entero, se obtiene un error (argumento fuera del dominio de
la función). Si xy da un resultado superior al valor límite para el tipo double, el resultado es este valor límite (1.79769e+308).
#include <math.h>
double pow( double x, double y);
Compatibilidad: ANSI, UNIX y Windows
double x = 2.8, y = -2.8;
printf("%g\n", pow(x, y)); // resultado: 0.0559703

sqrt
La función sqrt da como resultado la raíz cuadrada de x. Si x es negativo, ocurre
un error (argumento fuera del dominio de la función).
#include <math.h>

656

C/C++: CURSO DE PROGRAMACIÓN

double sqrt( double x );
Compatibilidad: ANSI, UNIX y Windows

NÚMEROS SEUDOALEATORIOS
La biblioteca de C proporciona también, entre otras, funciones para generar números aleatorios.

rand
La función rand da como resultado un número seudoaleatorio entero, entre 0 y
RAND_MAX (32767).
#include <stdlib.h>
int rand(void);
Compatibilidad: ANSI, UNIX y Windows

srand
La función srand fija el punto de comienzo para generar números seudoaleatorios; en otras palabras, inicia el generador de números seudoaleatorios en función
del valor de su argumento. Cuando esta función no se utiliza, el valor del primer
número seudoaleatorio generado siempre es el mismo para cada ejecución (corresponde a un argumento de valor 1).
#include <stdlib.h>
void srand(unsigned int arg);
Compatibilidad: ANSI, UNIX y Windows

FUNCIONES DE FECHA Y HORA
clock
La función clock indica el tiempo empleado por el procesador en el proceso en
curso.
#include <time.h>
clock_t clock(void);
Compatibilidad: ANSI, UNIX y Windows

El tiempo expresado en segundos se obtiene al dividir el valor devuelto por
clock entre la constante CLOCKS_PER_SEC. Si no es posible obtener este tiem-

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

657

po, la función clock devuelve el valor (clock_t)1. El tipo clock_t está declarado
así:
typedef long clock_t;

time
La función time retorna el número de segundos transcurridos desde las 0 horas del
1 de enero de 1970.
#include <time.h>
time_t time(time_t *seg);
Compatibilidad: ANSI, UNIX y Windows

El tipo time_t está definido así:
typedef long time_t;

El argumento puede ser NULL. Según esto, las dos sentencias siguientes para
obtener los segundos transcurridos son equivalentes:
time_t segundos;
time(&segundos);
segundos = time(NULL);

ctime
La función ctime convierte un tiempo almacenado como un valor de tipo time_t,
en una cadena de caracteres de la forma:
Thu Jul 08 12:01:29 2010\n\0
#include <time.h>
char *ctime(const time_t *seg);
Compatibilidad: ANSI, UNIX y Windows

Esta función devuelve un puntero a la cadena de caracteres resultante o un
puntero nulo si seg representa un dato anterior al 1 de enero de 1970. Por ejemplo,
el siguiente programa presenta la fecha actual y, a continuación, genera cinco números seudoaleatorios, uno cada segundo.
/********** Generar un número aleatorio cada segundo **********/
/* time.c
*/
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

658

C/C++: CURSO DE PROGRAMACIÓN

main()
{
long x, tm;
time_t segundos;
time(&segundos);
printf("\n%s\n", ctime(&segundos));
srand((unsigned)time(NULL));
for (x = 1; x <= 5; x++)
{
do
// tiempo de espera igual a 1 segundo
tm = clock();
while (tm/CLOCKS_PER_SEC < x);
// Se genera un número aleatorio cada segundo
printf("Iteración %ld: %d\n", x, rand());
}
}

localtime
La función localtime convierte el número de segundos transcurridos desde las 0
horas del 1 de enero de 1970, valor obtenido por la función time, a la fecha y hora
correspondiente (corregida en función de la zona horaria en la que nos encontremos). El resultado es almacenado en una estructura de tipo tm, definida en time.h.
#include <time.h>
struct tm *localtime(const time_t *seg);
Compatibilidad: ANSI, UNIX y Windows

La función localtime devuelve un puntero a la estructura que contiene el resultado, o un puntero nulo si el tiempo no puede ser interpretado. Los miembros
de la estructura son los siguientes:
Campo

Valor almacenado

tm_sec
tm_min
tm_hour
tm_mday
tm_mon
tm_year
tm_wday
tm_yday

Segundos (0 - 59).
Minutos (0 - 59).
Horas (0 - 23).
Día del mes (1 - 31).
Mes (0 - 11; enero = 0).
Año (actual menos 1900).
Día de la semana (0 - 6; domingo = 0).
Día del año (0 - 365; 1 de enero = 0).

El siguiente ejemplo muestra cómo se utiliza esta función.

APÉNDICE A: ALGUNAS FUNCIONES DE LA BIBLIOTECA DE C

659

/* localtime.c
*/
#include <stdio.h>
#include <time.h>
main()
{
struct tm *fh;
time_t segundos;
time(&segundos);
fh = localtime(&segundos);
printf("%d horas, %d minutos\n", fh->tm_hour, fh->tm_min);
}

La función localtime utiliza una variable de tipo static struct tm para realizar
la conversión y lo que devuelve es la dirección de esa variable.

FUNCIONES PARA MANIPULAR BLOQUES DE MEMORIA
La biblioteca de C/C++ proporciona un conjunto de funciones para manipular
bloques de bytes consecutivos en memoria. Comentamos a continuación las más
utilizadas.

memset
La función memset permite iniciar un bloque de memoria.
#include <string.h>
void *memset( void *destino, int b, size_t nbytes );
Compatibilidad: ANSI, UNIX y Windows

El argumento destino es la dirección del bloque de memoria que se desea iniciar, b es el valor empleado para iniciar cada byte del bloque y nbytes es el número de bytes del bloque que se iniciarán. Por ejemplo, el siguiente código inicia a 0
la matriz a:
double a[10][10];
// ...
memset(a, 0, sizeof(a));

memcpy
La función memcpy copia un bloque de memoria en otro.
#include <string.h>
void *memcpy( void *destino, const void *origen, size_t nbytes );

660

C/C++: CURSO DE PROGRAMACIÓN

Compatibilidad: ANSI, UNIX y Windows

El argumento destino es la dirección del bloque de memoria destino de los datos, origen es la dirección del bloque de memoria origen de los datos y nbytes es
el número de bytes que se copiarán desde el origen al destino. Por ejemplo, el siguiente código copia la matriz a en b:
double a[10][10], b[10][10];
// ...
memcpy(b, a, sizeof(a));

memcmp
La función memcmp compara byte a byte dos bloques de memoria.
#include <string.h>
int memcmp( void *bm1, const void *bm2, size_t nbytes );
Compatibilidad: ANSI, UNIX y Windows

Los argumentos bm1 y bm2 son las direcciones de los bloques de memoria a
comparar y nbytes es el número de bytes que se compararán. El resultado devuelto
por la función es el mismo que se expuso para strcmp. Por ejemplo, el siguiente
código compara la matriz a con la b:
double a[10][10], b[10][10];
// ...
if ( memcmp(a, b, sizeof(a)) == 0 )
printf("Las matrices a y b contienen los mismos datos\n");
else
printf("Las matrices a y b no contienen los mismos datos\n");

APÉNDICE B
 F.J.Ceballos/RA-MA

ENTORNOS DE DESARROLLO
Un entorno de desarrollo integrado (EDI, en inglés IDE: Integrated Development
Environment) es una aplicación que agrupa varias herramientas de programación,
básicamente, las necesarias para escribir, compilar y depurar un programa. El EDI
puede utilizar un solo lenguaje de programación, o bien puede ser compatible con
varios, tales como C/C++, C#, Visual Basic, Java, PHP, Python, etc. Dicho EDI
presentará al usuario una interfaz gráfica que le abstraerá del manejo individual, a
nivel de línea de órdenes, de cada una de esas herramientas de programación.
Para realizar los ejemplos de este libro, el autor propone utilizar alguno de los
entornos indicados a continuación: Microsoft Visual Studio Express para Windows, NetBeans para Windows/Linux/Mac OS X o Code::Blocks para Windows/Linux/Mac OS X. Estos EDI pueden descargarse de Internet y utilizarlos sin
coste alguno.

MICROSOFT VISUAL STUDIO
Este entorno de desarrollo lo puede descargar gratuitamente desde Internet
(www.fjceballos.es > Utilidades) en su edición Express. En la figura siguiente se
puede observar la interfaz gráfica de este entorno de desarrollo integrado: Microsoft Visual Studio Express. Dicho entorno muestra una barra de menús y otra de
herramientas, un panel de edición (en el ejemplo muestra un programa C), el explorador de soluciones (en el ejemplo muestra un proyecto progC correspondiente
al programa que estamos realizando), el panel de propiedades y el panel de resultados (en el ejemplo muestra los resultados de la compilación).

662

C/C++: CURSO DE PROGRAMACIÓN

Para editar y ejecutar el programa avance.c expuesto en el capítulo 1 utilizando este entorno de desarrollo, los pasos a seguir son los siguientes:
1. Partiendo de la página de inicio de Microsoft Visual Studio Express, hacemos
clic en Nuevo proyecto de la página principal para crear un proyecto nuevo o
bien ejecutamos la orden Archivo > Nuevo proyecto. Esta acción hará que se
visualice una ventana análoga a la siguiente:

APÉNDICE B: ENTORNOS DE DESARROLLO

663

Esta ventana muestra en su panel izquierdo los tipos de proyectos que se pueden crear y a la derecha de este, las plantillas que se pueden utilizar; la elección de una o de otra dependerá del tipo de aplicación que deseemos
construir. Para nuestro ejemplo, elegimos el tipo de proyecto Visual C++
Win32 y la plantilla Aplicación de consola Win32. Después especificamos el
nombre del proyecto y su ubicación (no hace falta que marque Crear directorio para la solución); observe que el proyecto será creado en una carpeta con
el mismo nombre. A continuación pulsamos el botón Aceptar. Esta acción visualizará la ventana mostrada en la figura siguiente, que permitirá establecer
la configuración de la aplicación; por ejemplo, aplicación de consola, proyecto vacío:

2. Una vez configurada la aplicación, pulsamos el botón Finalizar. El resultado
será un proyecto vacío al que podremos añadir ficheros. Por ejemplo, para
añadir el fichero avance.c, hacemos clic con el botón derecho del ratón sobre
el nombre del proyecto y seleccionamos la orden Agregar > Nuevo elemento
del menú contextual.

664

C/C++: CURSO DE PROGRAMACIÓN

3. La acción ejecutada en el punto anterior muestra la ventana que se expone a
continuación, la cual nos permitirá elegir la plantilla para el fichero. En nuestro caso, al no haber una plantilla para archivos C, hemos añadido la extensión .c a continuación del nombre del fichero en la caja Nombre.

APÉNDICE B: ENTORNOS DE DESARROLLO

665

4. El siguiente paso es escribir el código que se almacenará en este fichero, según muestra la figura siguiente:

En esta figura observamos una ventana principal que contiene otras ventanas
o paneles. La que está en la parte izquierda superior está mostrando la página
de edición del fichero avance.c que estamos editando. La que está en la parte
derecha superior está mostrando el explorador de soluciones; este lista el
nombre de la solución (una solución puede contener uno o más proyectos), el
nombre del proyecto o proyectos y el nombre de los ficheros que componen el
proyecto; en nuestro caso solo tenemos el fichero avance.c donde escribiremos el código de las acciones que tiene que llevar a cabo nuestra aplicación.
Al lado de la pestaña de la ventana del explorador puede haber otras pestañas
como, por ejemplo, la Vista de clases. Y la ventana que hay debajo de la página de edición puede mostrar varios paneles, por ejemplo, el de resultados de
la compilación.
5. Una vez editado el programa, para compilarlo ejecutamos la orden Compilar... del menú Compilar y para ejecutarlo, seleccionamos la orden Iniciar sin
depurar del menú Depurar o bien pulsamos las teclas Ctrl+F5.

666

C/C++: CURSO DE PROGRAMACIÓN

Añadir ficheros existentes a un proyecto
Supongamos que disponemos de un fichero .c que deseamos añadir a un proyecto
vacío o no. ¿Cómo podemos hacerlo? Una vez abierto el proyecto, basta con ejecutar la orden Proyecto > Agregar elemento existente y seleccionar el fichero que
deseamos añadir.

Depurar la aplicación
¿Por qué se depura una aplicación? Porque los resultados que estamos obteniendo
con la misma no son correctos y no sabemos por qué. El proceso de depuración
consiste en ejecutar la aplicación paso a paso, indistintamente por sentencias o por
funciones, con el fin de observar el flujo seguido durante su ejecución, así como
los resultados intermedios que se van sucediendo, con la finalidad de detectar
dónde está la anomalía que produce un resultado final erróneo.
Hay dos configuraciones, como se puede observar en la figura siguiente, bajo
las que se puede compilar una aplicación: Release y Debug:

La primera permite obtener un programa ejecutable optimizado en código y
en velocidad, y la segunda, un programa ejecutable con código extra necesario para depurar la aplicación. Por lo tanto, para depurar una aplicación utilizando el
depurador del entorno de desarrollo de Visual Studio, debe activar la configuración Win32 Debug antes de iniciar su compilación. Para ello, ejecute la orden

APÉNDICE B: ENTORNOS DE DESARROLLO

667

Administrador de configuración... del menú Compilar y seleccione dicha configuración.
Una vez construida la aplicación bajo la configuración Win32 Debug podrá, si
lo necesita, depurar la misma. Para ello, ejecute la orden Depurar > Paso a paso
por instrucciones y utilice las órdenes del menú Depurar o los botones correspondientes de la barra de herramientas (para saber el significado de cada botón,
ponga el puntero del ratón sobre cada uno de ellos).

De forma resumida, las órdenes de que dispone para depurar una aplicación
son las siguientes:

Iniciar o F5. Inicia la ejecución de la aplicación en modo depuración hasta
encontrar un punto de parada o hasta el final si no hay puntos de parada.

Alternar puntos de interrupción o F9. Pone o quita un punto de parada en la
línea sobre la que está el punto de inserción.

Detener depuración o Mayús+F5. Detiene el proceso de depuración.

Paso a paso por instrucciones o F11. Ejecuta la aplicación paso a paso. Si la
línea a ejecutar coincide con una llamada a una función definida por el usuario, dicha función también se ejecutará paso a paso.

Paso a paso por procedimientos o F10. Ejecuta la aplicación paso a paso. Si
la línea a ejecutar coincide con una llamada a una función definida por el
usuario, dicha función no se ejecutará paso a paso, sino de una sola vez.

Paso a paso para salir o Mayús+F11. Cuando una función definida por el
usuario ha sido invocada para ejecutarse paso a paso, utilizando esta orden se
puede finalizar su ejecución en un solo paso.

Ejecutar hasta el cursor o Ctrl+F10. Ejecuta el código que hay entre la última línea ejecutada y la línea donde se encuentra el punto de inserción.

Inspección rápida o Ctrl+Alt+Q. Visualiza el valor de la variable que está bajo el punto de inserción o el valor de la expresión seleccionada (sombreada).
El simple hecho de poner el punto de inserción sobre dicha variable ya visualiza su valor.

668

C/C++: CURSO DE PROGRAMACIÓN

Para ejecutar la aplicación en un solo paso, seleccione la orden Iniciar sin depurar (Ctrl+F5) del menú Depurar.
Además de la barra de herramientas Depurar, dispone también de otras barras
de herramientas que puede mostrar ejecutando la orden Barras de herramientas
del menú Ver.

INTERFAZ DE LÍNEA DE ÓRDENES EN WINDOWS
Los ficheros que componen una aplicación C pueden ser escritos utilizando cualquier editor de texto ASCII; por ejemplo, el Bloc de notas. Una vez editados y
guardados todos los ficheros que componen la aplicación, el siguiente paso es
compilarlos y enlazarlos para obtener el fichero ejecutable correspondiente a la
misma. La orden para realizar estas operaciones es la siguiente:
cl fichero01.c [fichero02 [fichero03] ...]

El nombre del fichero ejecutable resultante será el mismo que el nombre del
primer fichero especificado, pero con extensión .exe.
Previamente, para que el sistema operativo encuentre la utilidad cl, los ficheros de cabecera (directriz include) y las bibliotecas dinámicas y estáticas, cuando
son invocados desde la línea de órdenes, hay que definir en el entorno de trabajo
(en la consola sobre la que estemos trabajando) las siguientes variables:
set path=%path%;ruta de los ficheros .exe y .dll
set include=ruta de los ficheros .h
set lib=ruta de los ficheros .lib

La expresión %path% representa el valor actual de la variable de entorno
path. Una ruta va separada de la anterior por un punto y coma. Estas variables
también pueden ser establecidas ejecutando el fichero vcvars32.bat que aporta Visual Studio en la ruta (no tiene porqué coincidir con la de su instalación):
C:\Archivos de programa\Microsoft Visual Studio xx.x\VC\bin

Una vez establecidas estas variables, ya puede invocar al compilador C y al
enlazador. En la figura siguiente se puede observar, como ejemplo, el proceso seguido para compilar avance.c:

APÉNDICE B: ENTORNOS DE DESARROLLO

669

Observe que primero hemos ejecutado vcvars32.bat para establecer las variables de entorno, después hemos cambiado al directorio de la aplicación (cd), a
continuación hemos visualizado los ficheros .c de ese directorio (dir) y finalmente
hemos invocado al compilador C (cl). El resultado es avance.exe. Para ejecutar este fichero, escriba avance en la línea de órdenes y pulse Entrar. El resultado será
el mostrado en la figura.

CREAR UNA BIBLIOTECA DE FUNCIONES
Visual Studio proporciona, entre otros, el tipo de proyecto Win32 Static Library
que permite crear una biblioteca de funciones (ficheros con extensión .lib) análoga a las proporcionadas por C. Esto nos permitirá agrupar todas nuestras funciones de interés general en un solo fichero y utilizarlas en cualquier aplicación igual
que utilizamos las funciones de la biblioteca C, printf, scanf, etc. Eso sí, antes de
compilar una aplicación que utilice funciones de nuestra biblioteca, debemos es-

670

C/C++: CURSO DE PROGRAMACIÓN

pecificar en la lista de ficheros o en las opciones del enlazador (linker) el nombre
de esa biblioteca.
Para crear una de estas bibliotecas siga los pasos indicados a continuación.
Como ejemplo, vamos a crear una biblioteca hash.lib con las funciones incluidas
en el fichero cap12\hash\hash.c incluido en el ZIP que acompaña al libro.
1. Ejecute el entorno de desarrollo de Visual Studio.
2. Seleccione la orden Archivo > Nuevo > Proyecto.
3. Seleccione el tipo de proyecto Win32 y la plantilla Aplicación de consola
Win32. Escriba el nombre del proyecto en la caja Nombre y en la caja Ubicación seleccione el directorio donde desea crear este proyecto. En nuestro caso
vamos a dar al proyecto el nombre Hash. Pulse el botón Aceptar. Se visualiza
la siguiente ventana:

4. En esta ventana seleccione Biblioteca estática, no seleccione Encabezado
precompilado y haga clic en el botón Finalizar.
5. Ahora tenemos un proyecto vacío. Ejecute la orden Proyecto > Agregar elemento existente y añada el fichero o los ficheros que contengan las funciones
que desea incluir en su biblioteca (hash.lib), así como los ficheros de cabecera
necesarios para poder compilar el código escrito en cada una de las funciones.
En nuestro caso, según muestra la figura siguiente, añadiremos el fichero

APÉNDICE B: ENTORNOS DE DESARROLLO

671

hash.c que contiene las funciones de nuestro interés y el fichero de cabecera
hash.h que incluye las declaraciones de esas funciones.

6. Finalmente, ejecute la orden Compilar > Compilar... para compilar el proyecto y generar el fichero .lib. En nuestro caso se generará el fichero hash.lib con
las funciones que incluía hash.c.
Para utilizar esta biblioteca vamos a realizar otro ejemplo. Cree un nuevo
proyecto ApHash formado por los ficheros: apHash.c, hash.h y hash.lib. El fichero apHash.c simplemente hará uso de las funciones de la biblioteca hash.lib lo
que requerirá incluir el fichero hash.h. En la fase de enlace será necesario poder
acceder a hash.lib, ya que apHash.c invoca a funciones de esta biblioteca. Por lo
tanto, asegúrese de que ha añadido al proyecto la biblioteca hash.lib; después,
compile y ejecute el proyecto.

672

C/C++: CURSO DE PROGRAMACIÓN

NETBEANS
Evidentemente, para poder escribir programas C/C++ en una plataforma Linux se
necesita un entorno de desarrollo válido para dicha plataforma. NetBeans, entre
otros, puede ser este entorno de desarrollo. Se trata de un EDI libre, gratuito y sin
restricciones de uso. Puede descargarlo de https://netbeans.org.
Este EDI fue construido principalmente para el lenguaje Java, pero soporta
otros lenguajes como C/C++. Está escrito en java, por lo que para ser ejecutado es
necesario haber instalado previamente la máquina virtual de Java, que también
puede descargar gratuitamente de http://java.com/es/.
En la figura siguiente se puede observar la interfaz gráfica de este entorno de
desarrollo integrado:

APÉNDICE B: ENTORNOS DE DESARROLLO

673

Para personalizar el EDI, ejecute la orden Options del menú Tools.
Para editar y ejecutar el programa avance.c expuesto en el capítulo 1 utilizando este entorno de desarrollo, los pasos a seguir se indican a continuación:
1. Suponiendo que ya se está visualizando el entorno de desarrollo, ejecute la
orden File > New Project (Archivo > Nuevo Proyecto). Se muestra la ventana
New Project.
2. Seleccione C/C++ en la lista Categories (Categorías) y en la lista Projects
(Proyectos) seleccione C/C++ Application (Aplicación C o C++). Después
haga clic en el botón Next (siguiente). Se muestra la ventana New C/C++ Application.
3. Escriba el nombre del proyecto (Project Name); en nuestro caso será ProgC
y, a continuación, seleccione la carpeta donde quiere guardarlo.
4. Asegúrese de que la casilla Create Main File (crear fichero/archivo principal)
está marcada, establezca el nombre, en nuestro caso avance, y elija el lenguaje C (se añadirá la extensión correspondiente al fichero cuando se cree).

674

C/C++: CURSO DE PROGRAMACIÓN

5. Para finalizar haga clic en el botón Finish. El resultado será el siguiente:

El EDI crea la carpeta NetBeansProjects/ProgC en la que guardará el proyecto compuesto en este caso por un solo fichero de código fuente, avance.c, que almacenará el código correspondiente al programa.

APÉNDICE B: ENTORNOS DE DESARROLLO

675

En la ventana mostrada en la figura anterior distinguimos otras tres ventanas,
algunas de ellas, con varios paneles. La que está en la parte superior derecha está
mostrando el panel de edición para el código fuente de nuestra aplicación y tiene
oculto el panel de inicio. La que está en la parte superior izquierda muestra el panel de proyectos; este lista el nombre del proyecto y el nombre de los ficheros que
componen el proyecto. Observe el fichero avance.c; contiene el código de las acciones que tiene que llevar a cabo nuestra aplicación. También distinguimos otros
nodos para otros tipos de ficheros, por ejemplo, para los ficheros de cabecera. Finalmente, la ventana que hay debajo de la de proyectos permite navegar por el código del proyecto. Puede visualizar otras ventanas desde el menú Window; por
ejemplo, la ventana Output, que será utilizada para mostrar los resultados de la
compilación y de la ejecución.
Una vez creado el esqueleto de la aplicación, editamos el código de la misma.
En nuestro caso, este código ya fue expuesto en el capítulo 1.
El paso siguiente es construir el fichero ejecutable (fichero progc en la carpeta
ProgC/dist/Debug/GNU-Linux-x86). Para ello, ejecute la orden Run > Build Project, o bien pulse la tecla F11. Si la compilación es correcta, puede pasar a ejecutar la aplicación ejecutando la orden Run > Run Project, o bien pulsando la tecla
F6; observe el resultado en la ventana Output.
En este caso, la ventana Output muestra un error: En la función ‘log’: avance.c:16: referencia a ‘log10’ sin definir. Para hacer uso de la biblioteca matemática en Linux tenemos que utilizar la opción –lm. Por ejemplo:
cc avance.c -o avance.exe -lm

La opción –lm indica al compilador que utilice la biblioteca matemática
libm.a como alternativa a la biblioteca estándar libc.a.
Para especificar esta opción de compilación desde el entorno de desarrollo,
haga clic con el botón secundario del ratón sobre el nombre del proyecto y seleccione Properties (propiedades del proyecto). Se muestra la ventana que se muestra a continuación; seleccione Build > C Compiler > Additional Options y escriba
la opción –lm.

676

C/C++: CURSO DE PROGRAMACIÓN

Cuando la aplicación necesite más de un fichero, el proceso es igual de sencillo. Añadir otro fichero a una aplicación, por ejemplo un nuevo fichero que almacene una nueva clase, supone hacer clic con el botón derecho del ratón sobre el
nombre del proyecto, elegir la orden New y seleccionar del menú contextual que
se visualiza el tipo de elemento que se desea añadir.

Depurar una aplicación con NetBeans
Anteriormente ya comentamos que una aplicación se depura porque los resultados
que estamos obteniendo con la misma no son correctos y no sabemos por qué.
Por ejemplo, para depurar una aplicación utilizando el depurador del entorno
de desarrollo NetBeans, debe establecer un punto de parada inicial. Para ello, haga
clic con el botón derecho del ratón sobre la sentencia a partir de la cual quiere ejecutar el código de su aplicación paso a paso y ejecute la orden Toggle Line
Breakpoint (poner un punto de parada) del menú contextual que se visualiza, o
haga clic en la zona sombreada a su izquierda:

APÉNDICE B: ENTORNOS DE DESARROLLO

677

Después, ejecute la orden Debug > Debug Project, o bien pulse las teclas
Ctrl+F5 para iniciar la depuración. Continúe la ejecución paso a paso utilizando
las órdenes del menú Debug o los botones correspondientes de la barra de herramientas Debug (para saber el significado de cada botón, ponga el puntero del ratón sobre cada uno de ellos).

De forma resumida, las órdenes disponibles para depurar una aplicación son
las siguientes:

Debug Project o Ctrl+F5. Inicia la ejecución de la aplicación en modo depuración hasta encontrar un punto de parada o hasta el final si no hay puntos de
parada.

Toggle Line Breakpoint o Ctrl+F8. Pone o quita un punto de parada en la línea sobre la que está el punto de inserción.

Finish Debugger Session o Mayús+F5. Detiene el proceso de depuración.

Step Into o F7. Ejecuta la aplicación paso a paso. Si la línea a ejecutar coincide con una llamada a un método definido por el usuario, dicho método también se ejecuta paso a paso.

Step Over o F8. Ejecuta la aplicación paso a paso. Si la línea a ejecutar coincide con una llamada a un método definido por el usuario, dicho método no se
ejecuta paso a paso, sino de una sola vez.

Step Out o Ctrl+F7. Cuando un método definido por el usuario ha sido invocado para ejecutarse paso a paso, utilizando esta orden se puede finalizar su
ejecución en un solo paso.

Run to Cursor o F4. Ejecuta el código que hay entre la última línea ejecutada
y la línea donde se encuentra el punto de inserción.

Para ver los valores intermedios que van tomando las variables ponga el cursor sobre ellas, o bien utilice las ventanas Variable, etc., del fondo del EDI. Para
añadir o quitar ventanas ejecute la orden Window > Debuggin.

678

C/C++: CURSO DE PROGRAMACIÓN

INTERFAZ DE LÍNEA DE ÓRDENES EN UNIX/LINUX
Los ficheros que componen una aplicación C realizada bajo UNIX/LINUX pueden ser escritos utilizando cualquier editor de texto ASCII proporcionado por este.
Una vez editados y guardados todos los ficheros .c que componen la aplicación, el
siguiente paso es compilarlos y enlazarlos para obtener el fichero ejecutable correspondiente a la misma. La orden para realizar estas operaciones es la siguiente:
cc fich01.c [fich02 [fich03] ...] –o fich_ejecutable opciones

En el caso de UNIX/LINUX las rutas de acceso para que el sistema operativo
encuentre la utilidad cc, los ficheros de cabecera .h y las bibliotecas, cuando son
invocados desde la línea de órdenes, ya están definidas en el entorno de trabajo.
En la figura siguiente se puede observar, como ejemplo, el proceso seguido
para compilar avance.c:

Observe que primero hemos cambiado al directorio de la aplicación (cd), después hemos visualizado el contenido de ese directorio (ls -l) y finalmente hemos
invocado al compilador C (cc). El fichero ejecutable resultante es el especificado
por la opción –o, en el ejemplo progc, o a.out por omisión.
Para ejecutar la aplicación del ejemplo, escriba progc en la línea de órdenes y
pulse Entrar. El resultado será el que muestra la figura anterior. Si al realizar esta
operación se encuentra con que no puede hacerlo porque el sistema no encuentra

APÉNDICE B: ENTORNOS DE DESARROLLO

679

el fichero especificado, tiene que añadir la ruta del directorio actual de trabajo a la
variable de entorno PATH. Esto se hace así:
PATH=$PATH:.

o bien especificar explícitamente la ruta a partir del directorio actual:
./progc

La expresión $PATH representa el valor actual de la variable de entorno
PATH. Una ruta va separada de la anterior por dos puntos. El directorio actual está representado por el carácter punto.

El depurador gdb de Unix/Linux
Cuando se tiene la intención de depurar un programa C escrito bajo UNIX, en el
momento de compilarlo se debe especificar la opción g. Esta opción indica al
compilador que incluya información extra para el depurador en el fichero objeto.
Por ejemplo:
cc -g prog01.c -o prog01

La orden anterior compila y enlaza el fichero fuente prog01.c. El resultado es
un fichero ejecutable prog01 con información para el depurador.
Una vez compilado un programa con las opciones necesarias para depurarlo,
invocaremos a gdb para proceder a su depuración. La sintaxis es la siguiente:
gdb fichero-ejecutable
El siguiente ejemplo invoca al depurador gdb de UNIX, que carga el fichero
ejecutable prog01 en memoria para depurarlo.
gdb prog01

Una vez que se ha invocado el depurador, desde la línea de órdenes se pueden
ejecutar órdenes como las siguientes:

break [fichero:]función. Establece un punto de parada en la función indicada
del fichero especificado. Por ejemplo, la siguiente orden pone un punto de parada en la función escribir.
b escribir

680

C/C++: CURSO DE PROGRAMACIÓN

break [fichero:]línea. Establece un punto de parada en la línea indicada. Por
ejemplo, la siguiente orden pone un punto de parada en la línea 10.
b 10

delete punto-de-parada. Elimina el punto de parada especificado. Por ejemplo, la siguiente orden elimina el punto de parada 1 (primero).
d 1

run [argumentos]. Inicia la ejecución de la aplicación que deseamos depurar.
La ejecución se detiene al encontrar un punto de parada o al finalizar la aplicación. Por ejemplo:
run

print expresión. Visualiza el valor de una variable o de una expresión. Por
ejemplo, la siguiente orden visualiza el valor de la variable total.
p total

next. Ejecuta la línea siguiente. Si la línea coincide con una llamada a una
función definida por el usuario, no se entra a depurar la función. Por ejemplo:
n

continue. Continúa con la ejecución de la aplicación. Por ejemplo:
c

step. Ejecuta la línea siguiente. Si la línea coincide con una llamada a una
función definida por el usuario, se entra a depurar la función. Por ejemplo:
s

list. Visualiza el código fuente. Por ejemplo:
l

bt. Visualiza el estado de la pila de llamadas en curso (las llamadas a funciones).

help [orden]. Solicita ayuda sobre la orden especificada.

quit. Finaliza el trabajo de depuración.

CODE::BLOCKS
Otro entorno de desarrollo integrado para escribir programas C/C++ del que existen versiones para Windows, Linux y Mac OS X es Code::Blocks. Se trata de un
EDI libre, gratuito y sin restricciones de uso que puede descargar de Internet desde la dirección http://www.codeblocks.org/. En la figura siguiente se puede observar el aspecto de este entorno de desarrollo integrado.

APÉNDICE B: ENTORNOS DE DESARROLLO

681

Para editar y ejecutar el programa avance.c visto en el capítulo 1, o cualquier
otro programa, utilizando este entorno de desarrollo integrado, los pasos a seguir
se indican a continuación:
1. Suponiendo que ya está visualizado el entorno de desarrollo, creamos un nuevo proyecto C++ (File, New, Project). Se muestra la ventana siguiente:

682

C/C++: CURSO DE PROGRAMACIÓN

2. Elegimos la categoría consola (Console), la plantilla Console application y
pulsamos el botón Go. Se muestra la ventana siguiente:

3. Seleccionamos el lenguaje C y hacemos clic en el botón Next. Se muestra la
ventana siguiente:

APÉNDICE B: ENTORNOS DE DESARROLLO

683

4. Especificamos el nombre del proyecto, la carpeta donde será guardado y hacemos clic en Next. Se muestra la ventana siguiente:

5. Si los datos presentados en la ventana anterior son correctos, hacemos clic en
el botón Finish. El proyecto está creado; contiene un fichero main.c que incluye la función main por donde se iniciará y finalizará la ejecución del pro-

684

C/C++: CURSO DE PROGRAMACIÓN

grama. Si lo desea, puede cambiar el nombre main.c por avance.c. Después,
edite este fichero igual que lo hizo en el capítulo 1.

6. A continuación, según se puede observar en la figura anterior, editamos el código que compone el programa y lo guardamos.
7. Después, para compilar el programa, ejecutamos la orden Build del menú
Build y, una vez compilado (sin errores), lo podemos ejecutar seleccionando
la orden Run del mismo menú (si no pudiéramos ver la ventana con los resultados porque desaparece ‒no es el caso‒, añadiríamos al final de la función
main, antes de return, la sentencia “system("pause");” y al principio del
fichero .c la directriz #include <cstdlib>, si fuera necesario).
En el caso de que la aplicación esté compuesta por varios ficheros fuente,
simplemente tendremos que añadirlos al proyecto ejecutando la orden New del
menú File.

APÉNDICE C

 F.J.Ceballos/RA-MA

CÓDIGOS DE CARACTERES
Una tabla de códigos es un juego de caracteres donde cada uno tiene asignado un
número utilizado para su representación interna. Algunos lenguajes como Java
utilizan UNICODE para almacenar y manipular cadenas, y otros como C utilizan
ANSI o ASCII.

UTILIZACIÓN DE CARACTERES ANSI CON WINDOWS
ANSI (American National Standards Institute) es el juego de caracteres estándar
más utilizado por los equipos personales. Como el estándar ANSI solo utiliza un
byte para representar un carácter, está limitado a un máximo de 256 caracteres.
Aunque es adecuado para el inglés, no acepta totalmente muchos otros idiomas.
Para escribir un carácter ANSI que no esté en el teclado:
1. Localice en la tabla que se muestra en la página siguiente el carácter ANSI
que necesite y observe su código numérico.
2. Pulse la tecla Bloq Núm (Num Lock) para activar el teclado numérico.
3. Mantenga pulsada la tecla Alt y utilice el teclado numérico para pulsar el 0 y a
continuación las teclas correspondientes al código del carácter.
Por ejemplo, para escribir el carácter  en el entorno Windows, mantenga
pulsada la tecla Alt mientras escribe 0177 en el teclado numérico (ver la tabla de
códigos en la página siguiente).

686

C/C++: CURSO DE PROGRAMACIÓN

JUEGO DE CARACTERES ANSI

APÉNDICE C: CÓDIGOS DE CARACTERES

687

UTILIZACIÓN DE CARACTERES ASCII
En MS-DOS y fuera del entorno Windows se utiliza el juego de caracteres ASCII.
Para escribir un carácter ASCII que no esté en el teclado:
1. Busque el carácter en la tabla de códigos que coincida con la tabla activa.
Utilice la orden chcp para saber qué tabla de códigos está activa.
2. Mantenga pulsada la tecla Alt y utilice el teclado numérico para pulsar las teclas correspondientes al número del carácter que desee.
Por ejemplo, si está utilizando la tabla de códigos 850, para escribir el carácter  mantenga pulsada la tecla Alt mientras escribe 227 en el teclado numérico
(ver la tabla de códigos en la página siguiente).

688

C/C++: CURSO DE PROGRAMACIÓN

JUEGO DE CARACTERES ASCII

APÉNDICE C: CÓDIGOS DE CARACTERES

689

JUEGO DE CARACTERES UNICODE
UNICODE es un juego de caracteres en el que se emplean 2 bytes (16 bits) para
representar cada carácter. Esto permite la representación de cualquier carácter en
cualquier lenguaje escrito en el mundo, incluyendo los símbolos del chino,
japonés o coreano.
Códigos UNICODE de los dígitos utilizados en español:
\u0030-\u0039

0-9 ISO-LATIN-1

Códigos UNICODE de las letras y otros caracteres utilizados en español:
\u0024
\u0041-\u005a
\u005f
\u0061-\u007a
\u00c0-\u00d6
\u00d8-\u00f6
\u00f8-\u00ff

$ signo dólar
A-Z
_
a-z
ÀÁÂÃÄÅÆÇÈÉÊËÌÍÎÏÐÑÒÓÔÕÖ
ØÙÚÛÜÝÞßàáâãäåæçèéêëìíîïðñòóôõö
øùúûüýþÿ

Dos caracteres son idénticos solo si tienen el mismo código Unicode.

ÍNDICE

#, 476 
##, 476 
#define, 39, 68, 472 
#elif, 477 
#else, 477 
#endif, 477 
#error, 483 
#if, 477 
#include, 68, 477, 483 
#line, 482 
#undef, 476 


abrir un fichero, 409 
acceso aleatorio, 441 
acceso secuencial, 429, 453 
Ackerman, 592 
acos, 652 
algoritmo Boyer y Moore, 607 
algoritmos hash, 619 
ámbito de una variable, 83 
ancho, 103 
anidar if, 141 
anidar while, do, o for, 154 
ANSI, 72, 685 
ANSI C, 475 
árbol, 542 
árbol binario, 543 
 

 
 
árbol binario de búsqueda, 546 
árbol binario perfectamente equilibrado, 558 
árbol, recorrer, 544 
archivo, 402 
argumento, 71 
argumentos en la línea de órdenes, 363 
argumentos pasados por valor, 77 
argumentos por referencia, 78 
argumentos, pasar a una función, 77 
aritmética de punteros, 272, 277, 278, 286 
ASCII, 687 
asignación, 100 
asignación dinámica de memoria, 299 
asignar bytes desde una dirección, 270 
asin, 652 
ASSERT, 486 
atan, 652 
atan2, 652 
atof, 208, 648 
atoi, 208, 648 
atol, 208, 648 
auto, 86 


biblioteca de funciones, 669 
bit, 2 
bits de error, 413 
bloque, 70 
borrar los elementos de una lista, 504 
borrar nodo, 552 
borrar un elemento de una lista, 503 

692

C/C++: CURSO DE PROGRAMACIÓN

Boyer y Moore, 607 
break, 149, 163 
buffer, 404 
  flujo, 437 
  vaciar, 441 
burbuja, 598 
buscar nodo, 550 
buscar un elemento en una lista, 502 
búsqueda binaria, 606 
búsqueda de cadenas, 607 
búsqueda secuencial, 606 
byte, 2 


cadenas de caracteres, 200 
  leer, 121 
  leer y escribir, 201 
cadena, principio y final, 282 
calificación de funciones, 90 
calificadores, 86 
calloc, 304 
campo, 402 
campo de bits, 242 
carácter \n, 115 
caracteres de C, 24 
  manipular, 198 
cast, 55 
ceil, 654 
cerrar un fichero, 412 
char, 27 
clearerr, 413 
clock, 656 
cola, 528 
comentario, 39 
compilación condicional, 477 
compilación, constante simbólica, 479 
compilador, 4 
const, 40 
constante simbólica, 39, 472 
contador, 199 
continue, 164 
conversión, 42 
conversión entre tipos, 54 
conversión forzada, 55 
copiar matrices, 218 
copiar un fichero en otro, 421 
copiar una matriz, 280 
cos, 653 
cosh, 653 

CR, 115 
CR+LF, 410 
ctime, 657 


decimal, 35 
declaración, 69 
declaración compleja, 326 
declaración de una función, 71 
define, 68 
defined, 479 
definición, 69 
definición de una función, 73 
depurar, 666, 676 
dirección de, 51 
dirección de memoria, 78, 267 
directrices, 67 
directrices #if, #elif, #else y #endif, 477 
directrices para el preprocesador, 471 
directriz, 471 
  #define, 472 
  #error, 483 
  #include, 477, 483 
  #line, 482 
  #undef, 476 
  de inclusión, 68 
  de sustitución, 68 
dispositivos estándar, 434 
do ... while, 157 
double, 32 


E/S carácter a carácter, 418 
E/S con formato, 425 
E/S de cadenas de caracteres, 422 
E/S utilizando registros, 427 
EDI, 661 
else if, 144 
ensamblador, 2 
enum, 29 
EOF, 115 
errno, 416 
errores en operaciones de E/S, 413 
escribir con formato, 102 
escribir en un fichero, 430 
escribir un carácter, 119 
estática vs dinámica, 301 
estructura como argumento, 354 

ÍNDICE

estructura else if, 144 
estructura FILE, 403 
estructuras, 221 
  abstractas de datos, 496 
  acceso a sus miembros, 224 
  crear, 221 
  definir variables, 222 
  dinámicas, 495 
  miembros, 225 
  operaciones, 226 
  variables, 237 
exit, 131, 302 
exp, 654 
expresión, 42 
expresiones booleanas, 45 
extern, 86 


fabs, 655 
fclose, 412 
feof, 415 
ferror, 413 
fflush, 117, 441 
fgetc, 420 
fgets, 423 
fichero, 402 
  abrir, 409 
  cerrar, 412 
  de cabecera, 483 
  escribir, 430 
  indexado, crear, 637 
  leer, 433 
  temporal, 441 
ficheros binarios, 406 
ficheros de texto, 406 
FILE, 403 
fin de fichero, 115, 415 
float, 31 
floor, 655 
flujo, 102, 403 
  buffer, 437 
fopen, 410 
for, 160 
formato, especificaciones, 102 
fprintf, 425 
fputc, 419 
fputs, 422 
fread, 429 
free, 301 

freopen, 411 
fscanf, 426 
fseek, 417, 442 
ftell, 417, 418, 442, 444, 461 
fugas de memoria, 301 
función, 63, 70 
  acos, 652 
  asin, 652 
  atan, 652 
  atan2, 652 
  atof, 648 
  atoi, 648 
función 
  atol, 648 
  calloc, 304 
  ceil, 654 
  clearerr, 413 
  clock, 656 
  cos, 653 
  cosh, 653 
  ctime, 657 
  es recursiva, 367 
  exit, 131, 302 
  exp, 654 
  fabs, 655 
  fclose, 412 
  feof, 415 
  ferror, 413 
  fflush, 117, 441 
  fgetc, 420 
  fgets, 423 
  floor, 655 
  fopen, 410 
  fprintf, 425 
  fputc, 419 
  fputs, 422 
  fread, 429 
  free, 301 
  frente a macro, 473 
  freopen, 411 
  fscanf, 426 
  fseek, 417 
  ftell, 417 
  fwrite, 428 
  getch, 120 
  getchar, 118 
  getche, 120 
  gets, 201, 423 
  localtime, 658 
  log, 654 

693

694

C/C++: CURSO DE PROGRAMACIÓN

getchar, 118 
getche, 120 
gets, 122, 201, 423 
getw, 422 

  log10, 654 
  malloc, 299 
  memcmp, 660 
  memcpy, 220, 659 
  memset, 220, 659 
  perror, 415 
  pow, 655 
  printf, 102 
  putchar, 119 
  puts, 203 
  rand, 656 
  realloc, 302 
  rewind, 418 
  scanf, 81, 108 
  setvbuf, 438 
  sin, 653 
función 
  sinh, 653 
  sprintf, 649 
  sqrt, 655 
  srand, 656 
  strcat, 640 
  strchr, 640 
  strcmp, 642 
  strcpy, 640 
  strcspn, 643 
  strlen, 644 
  strlwr, 647 
  strncat, 644 
  strncmp, 645 
  strncpy, 645 
  strrchr, 641 
  strspn, 645 
  strstr, 646 
  strtok, 646 
  strupr, 647 
  system, 128 
  tan, 653 
  tanh, 654 
  time, 657 
  tmpfile, 441 
  toascii, 650 
  tolower, 650 
  toupper, 650 
fwrite, 428 


Hanoi, 595 
hash, 619 
hexadecimal, 36 


identificadores, 38 
if anidados, 141 
impresora, 434 
include, 68 
indirección, 52, 288 
inorden, 544 
inserción, 600 
insertar nodo, 550 
insertar un elemento en una lista, 501 
int, 28 
interfaz genérica, 509 
intérprete, 4 


gdb, 679 
getch, 120 

lagunas de memoria, 301 
leer con formato, 108 
leer de un fichero, 433 
leer un carácter, 118 
lenguaje máquina, 3 
lenguajes de alto nivel, 3 
LF, 115 
limpiar el buffer asociado con un flujo, 117 
limpiar la pantalla, 128 
línea de órdenes, 363, 668 
LINUX, 678 
lista circular, 520 
lista circular doblemente enlazada, 533 
lista doblemente enlazada, 533 
lista lineal simplemente enlazada, 496 
lista lineal, recorrer, 504 
listas lineales, 496 
literal, 35 
literal de cadena de caracteres, 37 
literal de un solo carácter, 36 
literal entero, 35 
literal real, 36 

ÍNDICE

llamada a una función, 75 
localtime, 658 
log, 654 
log10, 654 
long, 28 
long double, 32 
LPT1, 435 


macro, 472 
macro frente a función, 473 
macros predefinidas, 475 
main, 75 
malloc, 299 
matrices, 187, 188 
matrices de punteros, 286 
matrices dinámicas, 304 
matrices dinámicas de cadenas de caracteres, 
313 
matrices dinámicas de dos dimensiones, 309 
matrices dinámicas de una dimensión, 305 
matriz, 15, 121 
matriz asociativa, 196 
matriz de cadenas de caracteres, 214 
matriz de estructuras, 231 
matriz de punteros a cadenas de caracteres, 
291 
matriz multidimensional, 209 
matriz numérica multidimensional, 209 
matriz sparse, 265 
matriz static, 195 
matriz, acceder a un elemento, 190 
matriz, definir, 189 
matriz, iniciar, 195 
matriz, tipo y tamaño, 208 
memcmp, 220, 660 
memcpy, 220, 659 
memoria intermedia, 404 
memset, 220, 308, 659 
mensajes de error, 415 
método de inserción, 600 
método de la burbuja, 598 
método de quicksort, 602 
mezcla natural, 611 
milisegundos transcurridos desde el 1 de enero 
de 1970, 332 

695


nivel de indirección, 288 
nodo de un árbol, 544 
NULL, 276, 498 
números aleatorios, 330 


octal, 35 
operaciones con punteros, 271 
operador
  #, 476 
  ##, 476 
  &, 51 
  *, 52 
  coma, 51 
  condicional, 49 
  defined, 479 
  sizeof, 50 
  ternario, 49 
operadores, 42 
  a nivel de bits, 46 
  aritméticos, 42 
  de asignación, 47 
  de relación, 44 
  lógicos, 45 
  prioridad, 53 
  unitarios, 46 
ordenación, 597 
ordenar cadenas de caracteres, 295 
ordenar un fichero, 610 
ordenar un fichero utilizando acceso aleatorio, 
616 


palabras clave, 38 
pantalla, limpiar, 128 
parámetros, 72, 74 
path, 668 
perror, 415 
pila, 527 
polinomios, 327 
postorden, 545 
pow, 655 
precisión, 106 
preorden, 544 
preprocesador, 67, 471 
printf, 102 

696

C/C++: CURSO DE PROGRAMACIÓN

prioridad de los operadores, 53 
programa, 2, 63 
programa compuesto por varios ficheros, 81 
prototipo de una función, 71 
puntero, 79, 267 
  a un puntero, 288 
  a una cadena de caracteres, 282 
  a una función, 369 
  como argumento, 352 
  como parámetro, 320 
  de lectura/escritura, 417 
  definir, 267 
  genérico, 274 
  nulo, 276 
punteros
  a estructuras, 317 
  asignación, 271 
  comparación, 274 
  const, 277 
  operaciones aritméticas, 272 
  operadores, 269 
  y matrices, 277 
putchar, 119 
puts, 203 
putw, 422 


quicksort, 602 


raíz de un árbol, 544 
rand, 656 
realloc, 302 
reasignar un bloque de memoria, 302 
recorrer un árbol, 544 
recursión, 591 
redireccionar la entrada o salida, 365 
redireccionar stdin, stdout o stderr, 411 
register, 86 
registro, 402 
registros, 427 
retornar la dirección de una v. static, 361 
retornar un puntero, 360 
retornar una copia de los datos, 359 
return, 74, 131 
return vs exit, 302 
rewind, 418 


scanf, 108, 123 
secuencia de escape, 25 
sentencia
  break, 163 
  compuesta, 70 
  continue, 164 
  de asignación, 100 
  do ... while, 157 
  for, 160 
  return, 74, 131 
  simple, 69 
  switch, 147 
  while, 151 
set, 668 
setvbuf, 438 
short, 28 
signed, 26 
sin, 653 
sinh, 653 
sinónimos de otro tipo, 33 
size_t, 300 
sizeof, 50 
sprintf, 208, 649 
sqrt, 655 
srand, 656 
static, 86 
stdaux, 405 
stderr, 405 
stdin, 102, 405 
stdout, 102, 405 
stdprn, 405 
strcat, 640 
strchr, 640 
strcmp, 208, 642 
strcpy, 208, 640 
strcspn, 643 
stream, 403 
strlen, 208, 644 
strlwr, 647 
strncat, 644 
strncmp, 645 
strncpy, 645 
strrchr, 641 
strspn, 645 
strstr, 646 
strtok, 646 
struct, 222 
strupr, 647 

ÍNDICE

tolower, 208, 650 
torres de Hanoi, 595 
toupper, 208, 650 
typedef, 33, 208, 223 

subíndice, 189 
switch, 147 
sys_errlist, 416 
sys_nerr, 416 
system, 128 


tan, 653 
tanh, 654 
temporal, fichero, 441 
tiempo de ejecución, 479 
time, 332, 657 
tipo, 104 
  abstracto de datos, 227 
  char, 27 
  double, 32 
  enumerado, 29 
  float, 31 
  int, 28 
  long, 28 
  long double, 32 
  short, 28 
tipos de datos, 26 
tipos derivados, 33 
tipos primitivos, 26 
tmpfile, 441 
toascii, 650 

 


UNICODE, 689 
unión, 234 
UNIX, 678 
unsigned, 26 


validar un dato de entrada, 124 
variable, 40 
  global, 84 
  iniciar, 41 
  local, 84 
Visual C++, 661 
void, 73 
void  , 274 


while, 151 
while, do, o for anidados, 154 

697

Del mismo autor
● Curso de programación con
PASCAL
● Curso de programación
GW BASIC/BASICA
● Manual para TURBO BASIC
Guía del programador
● Manual para Quick C 2
Guía del programador
● Manual para Quick BASIC 4.5
Guía del programador
● Curso de programación
Microsoft COBOL
● Enciclopedia del lenguaje
C
● Curso de programación
QBASIC y MS-DOS 5
● Curso de programación
RM/COBOL-85
● El abecé de
MS-DOS 6
● Microsoft Visual C ++ (ver. 1.5x de 16 bits)
Aplicaciones para Windows
● Microsoft Visual C ++
Aplicaciones para Win32 (2.ª edición)
● Microsoft Visual C ++
Programación avanzada en Win32
● Visual Basic 6
Curso de programación (2.ª edición)
● Enciclopedia de Microsoft
Visual Basic 6
● El lenguaje de programación
Java
● El lenguaje de programación
C#

ISBN: 978-84-86381-36-3
224 págs.
ISBN: 978-84-86381-87-5
320 págs.
ISBN: 978-84-86381-43-1
444 págs.
ISBN: 978-84-86381-65-3
540 págs.
ISBN: 978-84-86381-74-5
496 págs.
ISBN: 978-84-7897-001-8
480 págs.
ISBN: 978-84-7897-053-7
888 págs.
ISBN: 978-84-7897-059-9
384 págs.
ISBN: 978-84-7897-070-4
396 págs.
ISBN: 978-84-7897-114-5
224 págs.
ISBN: 978-84-7897-180-0
846 págs. + 2 disquetes
ISBN: 978-84-7897-561-7
792 págs. + disquete
ISBN: 978-84-7897-344-6
888 págs. + CD-ROM
ISBN: 978-84-7897-357-6
528 págs. + disquete
ISBN: 978-84-7897-386-6
1.072 págs. + CD-ROM
ISBN: 978-84-7897-485-6
320 págs. + CD-ROM
ISBN: 978-84-7897-500-6
320 págs. + CD-ROM

Del mismo autor
● El lenguaje de programación
Visual Basic.NET
● Java 2
Lenguaje y aplicaciones
● Programación orientada a objetos
con C ++ (4.ª edición)
● C/C++
Curso de programación (3.ª edición)
● Microsoft C#
Lenguaje y aplicaciones (2.ª edición)
● Aplicaciones .Net multiplataforma
(Proyecto Mono)
● Enciclopedia del lenguaje
C ++ (2.ª edición)
● Microsoft Visual Basic .NET
Lenguaje y aplicaciones (3.ª edición)
● Java 2
Curso de programación (4.ª edición)
● Microsoft C#
Curso de programación (2.ª edición)
● Visual C#. Interfaces gráficas y aplicaciones
para Internet con WPF, WCF y Silverlight
● Visual Basic. Interfaces gráficas y aplicaciones
para Internet con WPF, WCF y Silverlight
● Enciclopedia de Microsoft Visual C#.
Interfaces gráficas y aplicaciones para Internet
con Windows Forms y ASP.NET (4.ª edición)
● Enciclopedia de Microsoft Visual Basic.
Interfaces gráficas y aplicaciones para Internet
con Windows Forms y ASP.NET (3.ª edición)
● Java. Interfaces gráficas y aplicaciones para
Internet (4.ª edición)

ISBN: 978-84-7897-525-9
464 págs. + CD-ROM
ISBN: 978-84-7897-745-1
392 págs. + CD-ROM
ISBN: 978-84-7897-761-1
648 págs. + CD-ROM
ISBN: 978-84-7897-762-8
708 págs. + CD-ROM
ISBN: 978-84-7897-813-7
520 págs. + CD-ROM
ISBN: 978-84-7897-880-9
212 págs. + CD-ROM
ISBN: 978-84-7897-915-8
902 págs. + CD-ROM
ISBN: 978-84-9964-020-4
520 págs. + CD-ROM
ISBN: 978-84-9964-032-7
820 págs. + CD-ROM
ISBN: 978-84-9964-068-6
850 págs. + CD-ROM
ISBN: 978-84-9964-203-1
956 págs. + CD-ROM
ISBN: 978-84-9964-204-8
938 págs. + CD-ROM
ISBN: 978-84-7897-986-8
1.145 págs. + CD-ROM
ISBN: 978-84-7897-987-5
1.125 págs. + CD-ROM
ISBN: 978-84-9964-522-3
1.000 págs. + ZIP

INSTALACIÓN
Para instalar el kit de desarrollo de C/C++ y los ejemplos de este libro, descargue de Internet el paquete correspondiente al EDI preferido por usted (Microsoft Visual Studio, NetBeans, Code::Blocks, etc.) e instálelo. Después, proceda según se indica en el apéndice B.

SOBRE LOS EJEMPLOS DEL LIBRO
El material adicional de este libro, con las aplicaciones desarrolladas y el software para reproducirlas, puede descargarlo desde http://www.fjceballos.es (sección Mis publicaciones > C/C++ > Material adicional) o desde
http://www.ra-ma.com (en la página correspondiente al libro). La descarga consiste en un fichero ZIP con una
contraseña que encontrará en el libro.

LICENCIA
Los paquetes de software a los que se hace referencia en el material adicional del libro es propiedad de las firmas
que los representan. La inclusión en este libro se debe a su gentileza y es totalmente gratuita y con la finalidad de
apoyar el aprendizaje del software correspondiente. Para obtener más información y actualizaciones, visite las direcciones indicadas en dicho software.
Al realizar el proceso de instalación, haga el favor de consultar el acuerdo de licencia para cada uno de los productos.

WEB DEL AUTOR: http://www.fjceballos.es
En esta web podrá echar una ojeada a mis publicaciones más recientes y acceder a la descarga del software necesario para el estudio de esta obra, así como a otros recursos.

Sign up to vote on this title
UsefulNot useful