cursocpp.pdf

7/25/2019 cursoCpp.pdf

1/277

Autor: Salvador Pozo Coronado e-mail: [email protected]

Trascripcin del curso alojado en la pgina: http://c.conclase.net
http://c.conclase.net/http://c.conclase.net/http://c.conclase.net/


2/277

Curso C++ C con Clase Pg. 2

Salvador Pozo Coronado [email protected]

TABLA DE CONTENIDOTABLA DE CONTENIDO............................................................................................... 2

Introduccin...................................................................................................................... 9Proceso para la obtencin de un programa ejecutable................................................ 10Fichero fuente y programa o cdigo fuente: ...........................................................11Ficheros objeto, cdigo objeto y compiladores: ..................................................... 11Libreras:................................................................................................................. 11Ficheros ejecutables y enlazadores: ........................................................................ 11Errores:.................................................................................................................... 12

Propsito de C y C++.................................................................................................. 13CAPITULO 1 Toma de contacto ....................................................................................14CAPITULO 2 Tipos de variables I ................................................................................. 16

Tipos fundamentales................................................................................................... 16

Tipo "char" o carcter: ............................................................................................ 16Tipo "int" o entero: ................................................................................................. 17Tipo "float" o coma flotante: .................................................................................. 17Tipo "bool" o Booleana: .........................................................................................18Tipo "double" o coma flotante de doble precisin: ................................................ 18Tipo "void" o sin tipo:............................................................................................. 18Tipo "enum" o enumerado:.....................................................................................19Palabras reservadas usadas en este captulo............................................................19

CAPITULO 3 Funciones I: Declaracin y definicin .................................................... 21Prototipos de funciones...............................................................................................22Estructura de un programa C/C++: ............................................................................. 23

Palabras reservadas usadas en este captulo............................................................23CAPITULO 4 Operadores I ............................................................................................ 24

Operadores aritmticos ............................................................................................... 24Operadores de asignacin ........................................................................................... 26Operador coma............................................................................................................ 27Operadores de igualdad .............................................................................................. 27Operadores lgicos ..................................................................................................... 28Operadores relacionales.............................................................................................. 29

Nota:........................................................................................................................ 30CAPITULO 5 Sentencias................................................................................................ 31

Bloques ....................................................................................................................... 31Expresiones................................................................................................................. 31Llamadas a funcin................................................................................................. 32Asignacin ..............................................................................................................32

Nula.........................................................................................................................32Bucles.......................................................................................................................... 33

Bucles "while" ........................................................................................................ 33Bucle "do while" ..................................................................................................... 33Bucle "for" ..............................................................................................................34

Etiquetas...................................................................................................................... 34Etiquetas de identificacin...................................................................................... 34

Etiquetas "case" y "default" ....................................................................................35Seleccin..................................................................................................................... 35


3/277



Sentencia "if...else" ................................................................................................. 35Sentencia "switch" .................................................................................................. 35

Sentencias de salto ...................................................................................................... 37Sentencia de ruptura "break" ..................................................................................37Sentencia de "continue" .......................................................................................... 37

Sentencia de salto "goto" ........................................................................................38Sentencia de retorno "return"..................................................................................38Sobre las sentencias de salto y la programacin estructurada ................................ 38Comentarios............................................................................................................ 39Palabras reservadas usadas en este captulo............................................................39

CAPITULO 6 Declaracin de variables ......................................................................... 40Cmo se declaran las variables ...................................................................................40mbito de las variables: ............................................................................................. 40

Ejemplos captulos 1 a 6 ................................................................................................. 42Ejemplo 1.................................................................................................................... 42Ejemplo 2.................................................................................................................... 43

Ejemplo 3.................................................................................................................... 44Ejemplo 4.................................................................................................................... 45

CAPITULO 7 Normas para la notacin ......................................................................... 46Constantes "int" .......................................................................................................... 46Constantes "long"........................................................................................................ 47Constantes "unsigned" ................................................................................................ 47Constantes "float" ....................................................................................................... 47Constantes "char"........................................................................................................47Por qu es necesaria la notacin?.............................................................................. 49

CAPITULO 8 Cadenas de caracteres ............................................................................. 50CAPITULO 9 Libreras estndar ....................................................................................52

Librera de entrada y salida fluidas "iostream.h"........................................................52Librera de entrada y salida estndar "stdio.h" ........................................................... 53

Funcin "getchar()".................................................................................................54Funcin "putchar()" ................................................................................................ 54Funcin "gets()" ...................................................................................................... 55Funcin "puts()"...................................................................................................... 55Funcin "printf()".................................................................................................... 56

Librera de rutinas de conversin estndar "stdlib.h" ................................................. 61Funcin "atoi()" ...................................................................................................... 62Funcin "system()" ................................................................................................. 62

Funcin "max()"...................................................................................................... 63Funcin "min()" ...................................................................................................... 63Funcin "abs()" ....................................................................................................... 63Funcin "rand()" ..................................................................................................... 64Funcin "srand()".................................................................................................... 64

Librera rutinas de conversin y clasificacin de caracteres "ctype.h".......................64Funcin "toupper()" ................................................................................................ 64Funcin "tolower()" ................................................................................................ 65Macros "is()" ........................................................................................ 65

Ejemplos captulos 7 a 9 ................................................................................................. 67Ejemplo 5.................................................................................................................... 67

Ejemplo 6.................................................................................................................... 67Ejemplo 7.................................................................................................................... 68


4/277



Ejemplo 8.................................................................................................................... 69CAPITULO 10 Conversin de tipos...............................................................................71

"Casting", conversiones explcitas de tipo:............................................................. 72CAPITULO 11 Tipos de variables II: Arrays o Arreglos............................................... 73

Asignacin de arrays:.................................................................................................. 74

Algoritmos de ordenacin, mtodo de la burbuja:......................................................74Ejercicios (creo que ya podemos empezar con los ejercicios :-) : .............................. 75CAPITULO 12 Tipos de variables III: Estructuras ........................................................ 76

Funciones en el interior de estructuras: ...................................................................... 77Asignacin de estructuras: .......................................................................................... 79Arrays de estructuras: ................................................................................................. 79Estructuras anidadas: .................................................................................................. 80Campos de bits:........................................................................................................... 80

Palabras reservadas usadas en este captulo............................................................83Ejercicios: ................................................................................................................... 83

CAPITULO 13 Tipos de variables IV: Punteros 1 ......................................................... 84

Declaracin de punteros: ............................................................................................ 85Correspondencia entre arrays y punteros:...................................................................86Operaciones con punteros:.......................................................................................... 87

Asignacin. .............................................................................................................87Operaciones aritmticas. .........................................................................................87Comparacin entre punteros. .................................................................................. 88

Punteros genricos. ..................................................................................................... 88Punteros a estructuras: ................................................................................................ 89Ejemplos: .................................................................................................................... 90Variables dinmicas:................................................................................................... 91Ejercicios: ................................................................................................................... 92

CAPITULO 14 Operadores II: Ms operadores ............................................................. 94Operadores de Referencia (&) e Indireccin (*).........................................................94Operador "sizeof"........................................................................................................ 94Operadores . y -> ........................................................................................................94Operador de preprocesador......................................................................................... 95

Directiva define: .....................................................................................................95Directiva include:....................................................................................................96

Operadores de manejo de memoria "new" y "delete"................................................. 97Operador new:......................................................................................................... 97Operador delete:...................................................................................................... 97

Palabras reservadas usadas en este captulo............................................................98CAPITULO 15 Operadores III: Precedencia. ................................................................. 99Ejercicios: ................................................................................................................. 100

CAPITULO 16 Funciones II: Parmetros por valor y por referencia........................... 102Referencias a variables: ............................................................................................ 103Pasando parmetros por referencia: .......................................................................... 103Punteros como parmetros de funciones: .................................................................104Arrays como parmetros de funciones: .................................................................... 105Estructuras como parmetros de funciones: .............................................................105

CAPITULO 17 Ms libreras estndar: string.h ........................................................... 106Librera rutinas de manipulacin de cadenas "string.h" ........................................... 106

Funcin "strlen()".................................................................................................. 106Funcin "strcpy()".................................................................................................106


5/277



Funcin "strcmp()"................................................................................................ 107Funcin "strcat()".................................................................................................. 108Funcin "strncpy()"...............................................................................................108Funcin "strncmp()".............................................................................................. 109Funcin "strncat()"................................................................................................ 109

Funcin "strtok()" ................................................................................................. 110CAPITULO 18 Estructuras II: Uniones........................................................................112Estructuras annimas: ............................................................................................... 114

Palabras reservadas usadas en este captulo.......................................................... 114CAPITULO 19 Punteros II: Arrays dinmicos.............................................................115

Problema: .................................................................................................................. 118CAPITULO 20 Operadores IV: Ms operadores .........................................................119

Operadores de bits .................................................................................................... 119Ejemplos: ..............................................................................................................120

Operador condicional................................................................................................ 120CAPITULO 21 Definicin de tipos, tipos derivados....................................................122

Ejemplos: ..............................................................................................................122Palabras reservadas usadas en este captulo.......................................................... 123

CAPITULO 22 Funciones III .......................................................................................124Parmetros con valores por defecto .......................................................................... 124Funciones con nmero de argumentos variable........................................................125

Tipos: .................................................................................................................... 125Macros: ................................................................................................................. 125

Argumentos de main. ................................................................................................ 127Funciones inline ........................................................................................................ 128

Palabras reservadas usadas en este captulo.......................................................... 129Inline.CAPITULO 23 Funciones IV: Sobrecarga.........................................................129CAPITULO 23 Funciones IV: Sobrecarga................................................................... 130

Ejercicio:...............................................................................................................131CAPITULO 24 Operadores V: Operadores sobrecargados .......................................... 132

Palabras reservadas usadas en este captulo.......................................................... 133CAPITULO 25 El preprocesador.................................................................................. 134

Directiva #define: ................................................................................................. 134Directiva #undef: .................................................................................................. 135Directivas #if, #elif, #else y #endif ....................................................................... 135Directivas #ifdef e #ifndef: ...................................................................................136Directiva #error:....................................................................................................137

Directiva #include:................................................................................................137Directiva #line: ..................................................................................................... 138Directiva #pragma: ............................................................................................... 138

CAPITULO 26 Funciones V: Recursividad .................................................................139CAPITULO 27 Tipos de Variables V: tipos de almacenamiento.................................143

auto........................................................................................................................ 143register .................................................................................................................. 143static ...................................................................................................................... 143extern .................................................................................................................... 143Palabras reservadas usadas en este captulo.......................................................... 144

CAPITULO 28 Clases I: Definiciones ......................................................................... 145

POO: ......................................................................................................................... 145Objeto: ...................................................................................................................... 145


6/277



Mensaje:.................................................................................................................... 145Mtodo:..................................................................................................................... 145Clase: ........................................................................................................................ 146Interfaz: ..................................................................................................................... 146Herencia:................................................................................................................... 146

CAPITULO 29 Declaracin de una clase ..................................................................... 147Especificaciones de acceso: ...................................................................................... 148Acceso privado, private: ....................................................................................... 149Acceso pblico, public:.........................................................................................149Acceso protegido, protected: ................................................................................149Palabras reservadas usadas en este captulo.......................................................... 149

CAPITULO 30 Constructores ......................................................................................150Inicializacin de objetos: ..........................................................................................151Sobrecarga de constructores: .................................................................................... 152Constructores con argumentos por defecto:..............................................................152Asignacin de objetos:.............................................................................................. 153

Constructor copia:..................................................................................................... 153CAPITULO 31 Destructores ........................................................................................ 155CAPITULO 32 El puntero this ..................................................................................... 158

Palabras reservadas usadas en este captulo.......................................................... 159CAPITULO 33 Sistema de proteccin ......................................................................... 160

Declaraciones friend ................................................................................................. 160Funciones externas amigas ...................................................................................160Funciones amigas en otras clases..........................................................................161Clases amigas........................................................................................................ 162Palabras reservadas usadas en este captulo.......................................................... 163

CAPITULO 34 Modificadores para miembros ............................................................164Funciones en lnea (inline):....................................................................................... 164Funciones miembro constantes .................................................................................165Valores de retorno constantes ...................................................................................166Miembros estticos de una clase (Static) .................................................................. 167

Palabras reservadas usadas en este captulo.......................................................... 170CAPITULO 35 Ms sobre las funciones ...................................................................... 171

Funciones sobrecargadas: ......................................................................................... 171Funciones con argumentos con valores por defecto:................................................ 172

CAPITULO 36 Operadores sobrecargados: ................................................................. 173Sobrecarga de operadores binarios: .......................................................................... 173

Sobrecargar el operador de asignacin: por qu? ................................................... 175Operadores binarios que pueden sobrecargarse:.......................................................176Forma funcional de los operadores: .......................................................................... 178Sobrecarga el operadores para la clases con punteros: ............................................. 178Sobrecarga de operadores unitarios: ......................................................................... 180Operadores unitarios sufijos: ....................................................................................181Operadores unitarios que pueden sobrecargarse:...................................................... 182Operadores de conversin de tipo.............................................................................182Sobrecarga del operador de indexacin []: ............................................................... 183Sobrecarga del operador de llamada (): .................................................................... 185

CAPITULO 37 Herencia: ............................................................................................. 187

Jerarqua, clases base y clases derivadas: ................................................................. 187Derivar clases, sintaxis: ............................................................................................ 188


7/277



Constructores de clases derivadas: ........................................................................... 189Inicializacin de clases base en constructores: .........................................................190Inicializacin de objetos miembros de clases:.......................................................... 191Sobrecarga de constructores de clases derivadas:..................................................... 192Destructores de clases derivadas: .............................................................................193

CAPITULO 38 Funciones virtuales: ............................................................................ 194Redefinicin de funciones en clases derivadas:........................................................194Superposicin y sobrecarga: .....................................................................................195Polimorfismo: ........................................................................................................... 196Funciones virtuales: .................................................................................................. 197Destructores virtuales: .............................................................................................. 198Constructores virtuales: ............................................................................................ 198

Palabras reservadas usadas en este captulo.......................................................... 200CAPITULO 39 Derivacin mltiple: ........................................................................... 201

Constructores de clases con herencia mltiple: ........................................................202Herencia virtual: ....................................................................................................... 203

Funciones virtuales puras: ........................................................................................ 205Clases abstractas: ...................................................................................................... 205Uso de derivacin mltiple: ......................................................................................207

CAPITULO 40 Streams:............................................................................................... 208Clases predefinidas para streams: ............................................................................. 208Clase streambuf......................................................................................................... 209

Funciones protegidas: ........................................................................................... 210Funciones publicas:............................................................................................... 210

Clase ios.................................................................................................................... 212Enums: ..................................................................................................................212Funciones:.............................................................................................................213

Clase filebuf .............................................................................................................. 218Constructores: ....................................................................................................... 218Funciones:.............................................................................................................218

Clase istream.............................................................................................................220Constructor: .......................................................................................................... 221

Clase ostream............................................................................................................223Constructor: .......................................................................................................... 223

Clase iostream...........................................................................................................224Constructor: .......................................................................................................... 224

Clase fstreambase ..................................................................................................... 225

Constructores: ....................................................................................................... 225Clase ifstream ...........................................................................................................226Constructores: ....................................................................................................... 226

Clase ofstream...........................................................................................................227Constructores: ....................................................................................................... 227

Clase fstream.............................................................................................................228Constructores: ....................................................................................................... 228

Clase strstreambuf..................................................................................................... 229Constructores: ....................................................................................................... 229

Clase strstreambase...................................................................................................230Constructores: ....................................................................................................... 230

Clase istrstream.........................................................................................................230Constructores: ....................................................................................................... 230


8/277



Clase ostrfstream....................................................................................................... 231Constructores: ....................................................................................................... 231

Clase strstream..........................................................................................................231Constructores: ....................................................................................................... 231

Objetos predefinidos:................................................................................................ 232

Objeto cout................................................................................................................ 232El operador : .....................................................................................................241Funciones interesantes de cin: .............................................................................. 241

Trabajar con streams de ficheros. .............................................................................249Crear un fichero de salida, abrir un fichero de entrada............................................. 250Ficheros binarios....................................................................................................... 251Ficheros de acceso aleatorio. .................................................................................... 252Ficheros de entrada y salida. ..................................................................................... 253

Sobrecarga de operadores > ...........................................................................254Comprobar estado de un stream................................................................................255

CAPITULO 41 Plantillas:............................................................................................. 257Sintaxis...................................................................................................................... 258Plantillas de funciones. ............................................................................................. 259Plantilla para Tabla. .................................................................................................. 260Ejemplo de uso de plantilla Tabla............................................................................. 261

Posibles problemas: .............................................................................................. 263Tablas de cadenas. .................................................................................................... 264Funciones que usan plantillas como parmetros....................................................... 265

Pasar una instancia de una plantilla. ..................................................................... 265Pasar una plantilla genrica. .................................................................................266

Amigos de plantillas. ................................................................................................ 267Clase o funcin amiga de una plantilla:................................................................267Clase o funcin amiga de una instancia de una plantilla: .....................................269

Miembros estticos: datos y funciones. ....................................................................269Ejemplo de implementacin de una plantilla para una pila. .....................................271Libreras de plantillas................................................................................................ 275

Palabras reservadas usadas en este captulo.......................................................... 275


9/277



IntroduccinFinalmente me he decidido a escribir un curso de C++ en una pgina web.Probablemente estoy pecando de presuntuoso, y me est metiendo en camisa de once

varas. Pero, algunas veces hay que ser valiente.

El curso no est muy lejos de estar terminado, y no pretende ms que animar a losnuevos y futuros programadores autodidactas a incorporarse a esta gran y potenteherramienta que es el C++.

La idea es ir aadiendo los nuevos captulos a medida que los vaya escribiendo,dejando un margen de tiempo para incorporar las correcciones necesarias y lasmodificaciones que propongan los valientes que estn dispuestos a seguir el curso.Este margen de tiempo me permitir adems escribir los nuevos captulos con lacalma necesaria para que queden claros, y para que no me despidan de mi trabajo, ;-).

No pretendo ser original, (al menos no demasiado), consultar libros, tutoriales,revistas, listas de correo, news, pginas web... En fin, aprovechar cualquier fuente dedatos que pueda, con el fin de conseguir un buen nivel. Lo que s pretendo es serameno, no quiero que nadie se aburra leyendo el curso, y procurar que los ejemplossean divertidos.

Pretendo tambin (y me gustara muchsimo), que el curso sea interactivo, propondrproblemas, cuya resolucin pasar a ser parte del curso. Adems se aadirn laspreguntas que vaya recibiendo, as como sus respuestas. Y en la lista de correopodremos discutir sobre los temas del curso entre todos aquellos que lo sigan.

He intentado que los ejemplos que ilustran cada captulo corran en cualquier versinde compilador, sin embargo, he de decir que yo he usado el compilador Dev-C++ deBloodsheden modo consola. Este compilador, est pensado para hacer programas enWindows.

Aprovecho para aclarar que los programas de Windows tienen dos modos de cara alusuario:

El modo consola simula el funcionamiento de una ventana MS-DOS, trabaja en

modo de texto, es decir, la ventana es una especie de tabla en la que cada casillaslo puede contener un carcter. El modo consola de Windows no permite usargrficos de alta resolucin. Pero esto no es una gran prdida, pues como veremos,ni C ni C++ incluyen manejo de grficos de alta resolucin. Esto se hacemediante libreras externas no estndar.

El otro modo es el GUI, Interfaz Grfico de Usuario. Es el modo tradicional delos programas de Windows, con ventanas, mens, iconos, etc. La creacin de estetipo de programas se explica en otro curso de este mismo sitio, y requiere elconocimiento de la librera de funciones Win API32.

Para aquellos de vosotros que programis en otros entornos como Linux, Unix o Mac,

he de decir que no os servir el compilador Dev-C++, ya que est diseadoespecialmente para Windows. Pero esto no es un problema serio, todos los sistemas
http://www.bloodshed.net/http://www.bloodshed.net/http://www.bloodshed.net/http://winapi.conclase.net/http://winapi.conclase.net/http://winapi.conclase.net/http://www.bloodshed.net/http://www.bloodshed.net/


10/277



operativos disponen de compiladores de C++ que soportan la norma ANSI, slomenciono Dev-C++ y Windows porque es el entorno en el que yo, me muevoactualmente.

Adems intentar no salirme del ANSI, es decir del C++ estndar, as que no es

probable que surjan problemas con los compiladores.

De nuevo aprovecho para hacer una aclaracin. Resumidamente, el ANSI define unconjunto de reglas. Cualquier compilador de C o de C++ debe cumplir esas reglas, sino, no puede considerarse un compilador de C o C++. Estas reglas definen lascaractersticas de un compilador en cuanto a palabras reservadas del lenguaje,comportamiento de los elementos que lo componen, funciones externas que seincluyen, etc. Un programa escrito en ANSI C o en ANSI C++, podr compilarse concualquier compilador que cumpla la norma ANSI. Se puede considerar como unahomologacin o etiqueta de calidad de un compilador.

Todos los compiladores incluyen, adems del ANSI, ciertas caractersticas no ANSI,por ejemplo libreras para grficos. Pero mientras no usemos ninguna de esascaractersticas, sabremos que nuestros programas son transportables, es decir, que

podrn ejecutarse en cualquier ordenador y con cualquier sistema operativo.

Este curso es sobre C++, con respecto a las diferencias entre C y C++, habra muchoque hablar, pero no es este el momento adecuado. Si sientes curiosidad, consulta laseccin depreguntas frecuentes. Pero para comprender muchas de estas diferenciasnecesitars cierto nivel de conocimientos de C++.

Los programas de ejemplo que aparecen en el texto estn escritos con la fuentecourier y en color azul con el fin de mantener las tabulaciones y distinguirlos delresto del texto. Cuando sean largos se incluir tambin un fichero con el programa,que se podr descargar directamente.

Cuando se exponga la sintaxis de cada sentencia se adoptarn ciertas reglas, que porlo que s son de uso general en todas las publicaciones y ficheros de ayuda. Losvalores entre corchetes "[]" son opcionales, con una excepcin: cuando aparezcan ennegrita "[]", en ese caso indicarn que se deben escribir los corchetes. El separador "|"delimita las distintas opciones que pueden elegirse. Los valores entre "" se refierena nombres. Los textos sin delimitadores son de aparicin obligatoria.

Proceso para la obtencin de un programa ejecutable

Probablemente este es el lugar ms adecuado para explicar cmo se obtiene unfichero ejecutable a partir de un programa C++.

Para empezar necesitamos un poco de vocabulario tcnico. Veremos algunosconceptos que se manejan frecuentemente en cualquier curso de programacin ysobre todo en manuales de C y C++.


11/277



Fichero fuente y programa o cdigo fuente:

Los programas C y C++ se escriben con la ayuda de un editor de textos del mismomodo que cualquier texto corriente. Los ficheros que contiene programas en C o C++en forma de texto se conocen como ficheros fuente, y el texto del programa que

contiene se conoce como programa fuente. Nosotros siempreescribiremos programasfuente y los guardaremos en ficheros fuente.

Ficheros objeto, cdigo objeto y compiladores:

Los programas fuente no pueden ejecutarse. Son ficheros de texto, pensados para quelos comprendan los seres humanos, pero incomprensibles para los ordenadores.

Para conseguir un programa ejecutable hay que seguir algunos pasos. El primero escompilar o traducir el programa fuente a su cdigo objeto equivalente. Este es eltrabajo que hacen los compiladores de C y C++. Consiste en obtener un ficheroequivalente a nuestro programa fuente comprensible para el ordenador, este fichero seconoce como fichero objeto, y su contenido como cdigo objeto.

Los compiladores son programas que leen un fichero de texto que contiene elprograma fuente y generan un fichero que contiene el cdigo objeto.

El cdigo objeto no tiene ningn significado para los seres humanos, al menos nodirectamente. Adems es diferente para cada ordenador y para cada sistemaoperativo. Por lo tanto existen diferentes compiladores para diferentes sistemasoperativos y para cada tipo de ordenador.

Libreras:

Junto con los compiladores de C y C++, se incluyen ciertos ficheros llamadoslibreras. Las libreras contienen el cdigo objeto de muchos programas que permitenhacer cosas comunes, como leer el teclado, escribir en la pantalla, manejar nmeros,realizar funciones matemticas, etc. Las libreras estn clasificadas por el tipo detrabajos que hacen, hay libreras de entrada y salida, matemticas, de manejo dememoria, de manejo de textos, etc.

Hay un conjunto de libreras muy especiales, que se incluyen con todos los

compiladores de C y de C++. Son las libreras ANSI o estndar. Pero tambin haylibreras no estndar, y dentro de estas las hay pblicas y comerciales. En este cursoslo usaremos libreras ANSI.

Ficheros ejecutables y enlazadores:

Cuando obtenemos el fichero objeto, an no hemos terminado el proceso. El ficheroobjeto, a pesar de ser comprensible para el ordenador, no puede ser ejecutado. Hayvarias razones para eso:

1. Nuestros programas usaran, en general, funciones que estarn incluidas enlibreras externas, ya sean ANSI o no. Es necesario combinar nuestro ficheroobjeto con esas libreras para obtener un ejecutable.


12/277



2. Muy a menudo, nuestros programas estarn compuestos por varios ficherosfuente, y de cada uno de ellos se obtendr un fichero objeto. Es necesario unirtodos los ficheros objeto, ms las libreras en un nico fichero ejecutable.

3. Hay que dar ciertas instrucciones al ordenador para que cargue en memoria elprograma y los datos, y para que organice la memoria de modo que se

disponga de una pila de tamao adecuado, etc. La pila es una zona dememoria que se usa para que el programa intercambie datos con otrosprogramas o con otras partes del propio programa. Veremos esto con msdetalle durante el curso.

Existe un programa que hace todas estas cosas, se trata del "link", o enlazador. Elenlazador toma todos los ficheros objeto que componen nuestro programa, loscombina con los ficheros de librera que sea necesario y crea un fichero ejecutable.

Una vez terminada la fase de enlazado, ya podremos ejecutar nuestro programa.

Errores:

Por supuesto, somos humanos, y por lo tanto nos equivocamos. Los errores deprogramacin pueden clasificarse en varios tipos, dependiendo de la fase en que sepresenten.

Errores de sintaxis:son errores en el programa fuente. Pueden deberse a palabrasreservadas mal escritas, expresiones errneas o incompletas, variables que no existen,etc. Los errores de sintaxis se detectan en la fase de compilacin. El compilador,adems de generar el cdigo objeto, nos dar una lista de errores de sintaxis. De

hecho nos dar slo una cosa o la otra, ya que si hay errores no es posible generar uncdigo objeto.

Avisos:adems de errores, el compilador puede dar tambin avisos (warnings). Losavisos son errores, pero no lo suficientemente graves como para impedir lageneracin del cdigo objeto. No obstante, es importante corregir estos avisos, ya queel compilador tiene que decidir entre varias opciones, y sus decisiones no tienen porqu coincidir con lo que nosotros pretendemos, se basan en las directivas que loscreadores del compilador decidieron durante su creacin.

Errores de enlazado:el programa enlazador tambin puede encontrar errores.

Normalmente se refieren a funciones que no estn definidas en ninguno de losficheros objetos ni en las libreras. Puede que hayamos olvidado incluir algunalibrera, o algn fichero objeto, o puede que hayamos olvidado definir alguna funcino variable, o lo hayamos hecho mal.

Errores de ejecucin:incluso despus de obtener un fichero ejecutable, es posibleque se produzcan errores. En el caso de los errores de ejecucin normalmente noobtendremos mensajes de error, sino que simplemente el programa terminar

bruscamente. Estos errores son ms difciles de detectar y corregir. Existenprogramas auxiliares para buscar estos errores, son los llamados depuradores(debuggers). Estos programas permiten detener la ejecucin de nuestros programas,

inspeccionar variables y ejecutar nuestro programa paso a paso. Esto resulta til para


13/277



detectar excepciones, errores sutiles, y fallos que se presentan dependiendo decircunstancias distintas.

Errores de diseo:finalmente los errores ms difciles de corregir y prevenir. Si noshemos equivocado al disear nuestro algoritmo, no habr ningn programa que nos

pueda ayudar a corregir los nuestros. Contra estos errores slo cabe practicar ypensar.

Propsito de C y C++

Qu clase de programas y aplicaciones se pueden crear usando C y C++?

La respuesta es muy sencilla: TODOS.

Tanto C como C++ son lenguajes de programacin de propsito general. Todo puede

programarse con ellos, desde sistemas operativos y compiladores hasta aplicacionesde bases de datos y procesadores de texto, pasando por juegos, aplicaciones a medida,etc.

Oirs y leers mucho sobre este tema. Sobre todo diciendo que estos lenguajes soncomplicados y que requieren pginas y pginas de cdigo para hacer cosas que conotros lenguajes se hacen con pocas lneas. Esto es una verdad a medias. Es cierto queun listado completo de un programa en C o C++ para gestin de bases de datos (por

poner un ejemplo) puede requerir varios miles de lneas de cdigo, y que suequivalente en Visual Basic slo requiere unos pocos cientos. Pero detrs de cadalnea de estos compiladores de alto nivel hay cientos de lneas de cdigo en C, la

mayor parte de estos compiladores estn respaldados por enormes libreras escritas enC. Nada te impide a ti, como programador, usar libreras, e incluso crear las tuyaspropias.

Una de las propiedades de C y C++ es la reutilizacin del cdigo en forma delibreras de usuario. Despus de un tiempo trabajando, todos los programadoresdesarrollan sus propias libreras para aquellas cosas que hacen frecuentemente. Yadems, raramente piensan en ello, se limitan a usarlas.

Adems, los programas escritos en C o C++ tienen otras ventajas sobre el resto. Conla excepcin del ensamblador, generan los programas ms compactos y rpidos. El

cdigo es transportable, es decir, un programa ANSI en C o C++ podr ejecutarse encualquier mquina y bajo cualquier sistema operativo. Y si es necesario,

proporcionan un acceso a bajo nivel de hardware slo igualado por el ensamblador.

Otra ventaja importante, C tiene ms de 30 aos de vida, y C++ casi 20 y no pareceque su uso se debilite demasiado. No se trata de un lenguaje de moda, y

probablemente a ambos les quede an mucha vida por delante. Slo hay que pensarque sistemas operativos como Linux, Unix o incluso Windows se escriben casi porcompleto en C.

Por ltimo, existen varios compiladores de C y C++ gratuitos, o bajo la norma GNU, ascomo cientos de libreras de todo propsito y miles de programadores en todo el mundo,muchos de ellos dispuestos a compartir su experiencia y conocimientos.


14/277



CAPITULO 1 Toma de contactoMe parece que la forma ms rpida e interesante de empezar, y no perder potencialesseguidores de este curso, es con un ejemplo. Veamos nuestro primer programa C++.

Esto nos ayudar a sentar unas bases que resultarn muy tiles para los siguientesejemplos que irn apareciendo.

int main()

{

int numero;

numero = 2 + 2;

return 0;

}

No te preocupes demasiado si an no captas todos los matices de este pequeo

programa. Aprovecharemos la ocasin para explicar algunas de las peculiaridades deC++, aunque de hecho, este programa es casiun ejemplo de programa C. Pero eso esotro tema. En realidad C++ incluye a C. En general, un programa en C podrcompilarse usando un compilador de C++. Pero ya veremos este tema en otro lugar, ydescubriremos en qu consisten las diferencias.

Iremos repasando, muy someramente, el programa, lnea a lnea:

- Primera lnea: "int main()"

Se trata de una lnea muy especial, y la encontrars en todos los programas C y C++.

Es el principio de la definicin de una funcin. Todas las funciones C toman unosvalores de entrada, llamados parmetros o argumentos, y devuelven un valor deretorno. La primera palabra: "int", nos dice el tipo del valor de retorno de la funcin,en este caso un nmero entero. La funcin "main" siempre devuelve un entero. Lasegunda palabra es el nombre de la funcin, en general ser el nombre que usaremoscuando queramos usar o llamar a la funcin.

En este caso "main" es una funcin especial, ya que nosotros no la usaremos nuncaexplcitamente, es decir, nunca encontrars en ningn programa una lnea queinvoque a la funcin "main". Esta funcin ser la que tome el controlautomticamente cuando se ejecute nuestro programa. Otra pista por la que sabemosque se trata de una funcin son los parntesis, todas las definiciones de funcionesincluyen una lista de argumentos de entrada entre parntesis, en nuestro ejemplo esuna lista vaca, es decir, nuestra funcin no admite parmetros.

- Segunda lnea: "{"

Aparentemente es una lnea muy simple, las llaves encierran el cuerpo o definicin dela funcin. Ms adelante veremos que tambin tienen otros usos.

- Tercera lnea: "int numero;"


15/277



Esta es nuestra primera sentencia, todas las sentencias terminan con un punto y coma.Esta concretamente es una declaracin de variable. Una declaracin nos dice, anosotros y al compilador, que usaremos una variable "numero" de tipo entero. Estadeclaracin obliga al compilador a reservar un espacio de memoria para almacenar lavariable "numero", pero no le da ningn valor inicial. En general contendr "basura",

es decir, lo que hubiera en esa zona de memoria cuando se le reserv espacio. En C yC++ es obligatorio declarar las variables que usar el programa.

C y C++ distinguen entre maysculas y minsculas, as que "int numero;" es distintode "int NUMERO;", y tambin de "INT numero;".

- Cuarta lnea: ""

Una lnea vaca, no sirve para nada, al menos desde el punto de vista del compilador,pero sirve para separar visualmente la parte de declaracin de variables de la parte decdigo que va a continuacin. Se trata de una divisin arbitraria. Desde el punto de

vista del compilador, tanto las declaraciones de variables como el cdigo sonsentencias vlidas. La separacin nos ayudar a distinguir visualmente dnde terminala declaracin de variables. Una labor anloga la desempea el tabulado de las lneas:ayuda a hacer los programas ms fciles de leer.

- Quinta lnea: "numero = 2 + 2;"

Se trata de otra sentencia, ya que acaba con punto y coma. Esta es una sentencia deasignacin. Le asigna a la variable "numero" el valor resultante de la operacin "2 +2".

- Sexta lnea: "return 0;"

De nuevo una sentencia, "return" es una palabra reservada, propia de C y C++. Indicaal programa que debe abandonar la ejecucin de la funcin y continuar a partir del

punto en que se la llam. El 0 es el valor de retorno de nuestra funcin. Cuando"main" retorna con 0 indica que todo ha ido bien. Un valor distinto suele indicar unerror. Imagina que nuestro programa es llamado desde un fichero de comandos, unfichero "bat" o un "script". El valor de retorno de nuestro programa se puede usar

para tomar decisiones dentro de ese fichero. Pero somos nosotros, los programadores,los que decidiremos el significado de los valores de retorno.

- Sptima lnea: "}"

Esta es la llave que cierra el cuerpo o definicin de la funcin.

Lo malo de este programa, a pesar de sumar correctamente "2+2", es queaparentemente no hace nada. No acepta datos externos y no proporciona ningunasalida de ningn tipo. En realidad es absolutamente intil, salvo para fines didcticos,que es para lo que fue creado. Paciencia, iremos poco a poco. En los siguientescaptulos veremos tres conceptos bsicos: variables, funciones y operadores. Despusestaremos en disposicin de empezar a trabajar con ejemplos ms interactivos.


16/277



CAPITULO 2 Tipos de variables IUna variable es un espacio reservado en el ordenador para contener valores que

pueden cambiar durante la ejecucin de un programa. Los tipos determinan cmo se

manipular la informacin contenida en esas variables. No olvides, si es que ya losabas, que la informacin en el interior de la memoria del ordenador es siemprebinaria, al menos a un cierto nivel. El modo en que se interpreta la informacinalmacenada en la memoria de un ordenador es siempre arbitraria, es decir, el mismovalor puede usarse para codificar una letra, un nmero, una instruccin de programa,etc. El tipo nos dice a nosotros y al compilador cmo debe interpretarse ymanipularse la informacin binaria almacenada en la memoria de un ordenador.

De momento slo veremos los tipos fundamentales, que son: void, char, int, float ydouble, en C++ se incluye tambin el tipo bool. Tambin existen ciertosmodificadores, que permiten ajustar ligeramente ciertas propiedades de cada tipo; los

modificadores pueden ser: short, long, signed y unsigned o combinaciones de ellos.Tambin veremos en este captulo los tipos enumerados, enum.

Tipos fundamentales

En C slo existen cinco tipos fundamentales y los tipos enumerados, C++ aade unsptimo tipo, el bool, y el resto de los tipos son derivados de ellos. Los veremos uno

por uno, y veremos cmo les afectan cada uno de los modificadores.

Las definiciones de sintaxis de C++ se escribirn usando el color verde. Los valores

entre [] son opcionales, los valores separados con | indican que slo debe escogerseuno de los valores. Los valores entre indican que debe escribirse obligatoriamenteun texto que se usar como el concepto que se escribe en su interior.

[signed|unsigned] char significa que se puede usar signed o unsigned,o ninguna de las dos, ya que ambas estn entre []. Adems debe escribirse un texto,que debe ser una nica palabra que actuar como identificador o nombre de lavariable. Este identificador lo usaremos para referirnos a la variable durante el

programa. Sern vlidos estos ejemplos:

signed char Cuenta

unsigned char letraschar caracter

Tipo "char" o carcter:

[signed|unsigned] char

Es el tipo bsico alfanumrico, es decir que puede contener un carcter, un dgitonumrico o un signo de puntuacin. Desde el punto de vista del ordenador, todos esosvalores son caracteres. En C y C++ este tipo siempre contiene un nico carcter delcdigo ASCII. El tamao de memoria es de 1 byte u octeto. Hay que notar que en C

un carcter es tratado en todocomo un nmero, de hecho puede ser declarado cony sin signo. Y si no se especifica el modificador de signo, se asume que es con signo.


17/277



Este tipo de variables es apto para almacenar nmeros pequeos, como los dedos quetiene una persona, o letras, como la inicial de mi nombre de pila.

Tipo "int" o entero:

[signed|unsigned] [short|long] int [signed|unsigned] long [int]

[signed|unsigned] short [int]

Las variables enteras almacenan nmeros enteros dentro de los lmites de su tamao,a su vez, ese tamao depende de la plataforma del compilador, y del nmero de bitsque use por palabra de memoria: 8, 16, 23... No hay reglas fijas para saber el mayornmero que podemos almacenar en cada tipo: int, long int o short int; depende engran medida del compilador y del ordenador. Slo podemos estar seguros de que esenmero en short int es menor o igual que en int, y ste a su vez es menor o igual queen long int. Veremos cmo averiguar estos valores cuando estudiemos los

operadores.

Este tipo de variables es til para almacenar nmeros relativamente grandes, pero sindecimales, por ejemplo el dinero que tienes en el banco, salvo que seas Bill Gates, oel nmero de lentejas que hay en un kilo de lentejas.

Tipo "float" o coma flotante:

float

Las variables de este tipo almacenan nmeros en formato de coma flotante, mantisa y

exponente, para entendernos, son nmeros con decimales. Son aptos para variables detipo real, como por ejemplo el cambio entre euros y pesetas. O para nmeros muygrandes, como la produccin mundial de trigo, contada en granos. El fuerte de estosnmeros no es la precisin, sino el orden de magnitud, es decir lo grande o pequeoque es el nmero que contiene. Por ejemplo, la siguiente cadena de operaciones nodar el resultado correcto:

float a = 12335545621232154;

a = a + 1;

a = a - 12335545621232154;

Finalmente, "a" valdr 0 y no 1, como sera de esperar. Los formatos en coma flotantesacrifican precisin en favor de tamao. Sin embargo el ejemplo si funcionara connmeros ms pequeos. Esto hace que las variables de tipo float no sean muyadecuadas para los bucles, como veremos ms adelante.

Puede que te preguntes (alguien me lo ha preguntado), qu utilidad tiene algo tanimpreciso. La respuesta es: aquella que tu, como programador, le encuentres. Teaseguro que float se usa muy a menudo. Por ejemplo, para trabajar con temperaturas,la precisin es suficiente para el margen de temperaturas que normalmentemanejamos y para almacenar al menos tres decimales. Pero hay cientos de otrassituaciones en que resultan muy tiles.


18/277



Tipo "bool" o Booleana:

bool

Las variables de este tipo slo pueden tomar dos valores "true" o "false". Sirven para

evaluar expresiones lgicas. Este tipo de variables se puede usar para almacenarrespuestas, por ejemplo: Posees carn de conducir?. O para almacenar informacionesque slo pueden tomar dos valores, por ejemplo: qu mano usas para escribir. Enestos casos debemos acuar una regla, en este ejemplo, podra ser diestro->"true",zurdo->"false".

bool respuesta;

bool continuar;

Tipo "double" o coma flotante de doble precisin:

[long] double

Las variables de este tipo almacenan nmeros en formato de coma flotante, mantisa yexponente, al igual que float, pero usan mayor precisin. Son aptos para variables detipo real. Usaremos estas variables cuando trabajemos con nmeros grandes, perotambin necesitemos gran precisin. Lo siento, pero no se me ocurre ahora ningnejemplo.

Bueno, tambin me han preguntado por qu no usar siempre double o long double yolvidarnos de float. La respuesta es que C siempre ha estado orientado a la economade recursos, tanto en cuanto al uso de memoria como al uso de procesador. Si tu

problema no requiere la precisin de un double o long double, por qu derrocharrecursos?. Por ejemplo, en el compilador Dev-C++ float requiere 4 bytes, double 8 ylong double 12, por lo tanto, para manejar un nmero en formato de long double serequiere el triple de memoria y el triple o ms tiempo de procesador que para manejarun float.

Como programadores estamos en la obligacin de no desperdiciar nuestros recursos,y mucho ms los recursos de nuestros clientes, para los que haremos nuestros

programas. C y C++ nos dan un gran control sobre estas caractersticas, es nuestraresponsabilidad aprender a usarlos como es debido.

Tipo "void" o sin tipo:

void

Es un tipo especial que indica la ausencia de tipo. Se usa en funciones que nodevuelven ningn valor, tambin en funciones que no requieren parmetros, aunqueeste uso slo es obligatorio en C, y opcional en C++, tambin se usar en ladeclaracin de punteros genricos, lo veremos ms adelante.

Las funciones que no devuelven valores parecen una contradiccin. En lenguajescomo Pascal, estas funciones se llaman procedimientos. Simplemente hacen sutrabajo, y no revuelven valores. Por ejemplo, funciones como borrar la pantalla, notienen nada que devolver, hacen su trabajo y regresan. Lo mismo se aplica a


19/277



funciones sin parmetros de entrada, el mismo ejemplo de la funcin para borrar lapantalla, no requiere ninguna entrada para poder hacer su cometido.

Tipo "enum" o enumerado:

enum [] { [= ],...} [lista de variables];

Se trata de una sintaxis muy elaborada, pero no te asustes, cuando te acostumbres aver este tipo de cosas las comprenders mejor.

Este tipo nos permite definir conjuntos de constantes, normalmente de tipo int,llamados datos de tipo enumerado. Las variables declaradas de este tipo slo podrntomar valores entre los definidos.

El identificador de tipo es opcional, y nos permitir declarar ms variables del tipo

enumerado en otras partes del programa:

[enum] [,[...]];

La lista de variables tambin es opcional. Sin embargo, al menos uno de los doscomponentes opcionales debe aparecer en la definicin del tipo enumerado.

Varios identificadores pueden tomar el mismo valor, pero cada identificador slopuede usarse en un tipo enumerado. Por ejemplo:

enum tipohoras { una=1, dos, tres, cuatro, cinco, seis,

siete, ocho, nueve, diez, once, doce,trece=1, catorce, quince, dieciseis, diecisiete, dieciocho,

diecinueve, veinte, ventiuna, ventidos, ventitres, venticuatro =

0};

En este caso, una y trece valen 1, dos y catorce valen 2, etc. Y veinticuatro vale 0.Como se ve en el ejemplo, una vez se asigna un valor a un elemento de la lista, lossiguientes toman valores correlativos. Si no se asigna ningn valor, el primerelemento tomar el valor 0.

Los nombres de las constantes pueden utilizarse en el programa, pero no pueden serledos ni escritos. Por ejemplo, si el programa en un momento determinado nos

pregunta la hora, no podremos responder docey esperar que se almacene su valorcorrespondiente. Del mismo modo, si tenemos una variable enumerada con el valordocey la mostramos por pantalla, se mostrar 12, no doce. Deben considerarse como"etiquetas" que sustituyen a enteros, y que hacen ms comprensibles los programas.Insisto en que internamente, para el compilador, slo son enteros, en el rango devalores vlidos definidos en cada enum.

Palabras reservadas usadas en este captulo

Las palabras reservadas son palabras propias del lenguaje de programacin. Estn

reservadas en el sentido de que no podemos usarlas como identificadores de variableso de funciones.


20/277



char, int, float, double, bool, void, enum, unsigned, signed, long, short, true y false.


21/277



CAPITULO 3 Funciones I: Declaracin ydefinicin

Las funciones son un conjunto de instrucciones que realizan una tarea especfica. Engeneral toman unos valores de entrada, llamados parmetros y proporcionan un valorde salida o valor de retorno; aunque tanto unos como el otro pueden no existir.

Tal vez sorprenda que las introduzca tan pronto, pero como son una herramienta muyvaliosa, y se usan en todos los programas C++, creo que debemos tener, al menos,una primera nocin de su uso.

Al igual que con las variables, las funciones pueden declararse y definirse.

Una declaracin es simplemente una presentacin, una definicin contiene las

instrucciones con las que realizar su trabajo la funcin.

En general, la definicin de una funcin se compone de las siguientes secciones,aunque pueden complicarse en ciertos casos:

Opcionalmente, una palabra que especifique el tipo de almacenamiento, puede ser"extern" o "static". Si no se especifica es "extern". No te preocupes de estotodava, de momento slo usaremos funciones externas, slo lo menciono porquees parte de la declaracin. Una pista: las funciones declaradas como extern estndisponibles para todo el programa, las funciones static pueden no estarlo.

El tipo del valor de retorno, que puede ser "void", si no necesitamos valor deretorno. Si no se establece, por defecto ser "int". Aunque en general se considerade mal gusto omitir el tipo de valor de retorno.

Modificadores opcionales. Tienen un uso muy especfico, de momento noentraremos en este particular, lo veremos en captulos posteriores.

El nombre de la funcin. Es costumbre, muy til y muy recomendable, ponernombres que indiquen, lo ms claramente posible, qu es lo que hace la funcin, yque permitan interpretar qu hace el programa con slo leerlo. Cuando se precisenvarias palabras para conseguir este efecto existen varias reglas aplicables de usocomn. Una consiste en separar cada palabra con un "_", la otra, que yo prefiero,consiste en escribir la primera letra de cada palabra en mayscula y el resto en

minsculas. Por ejemplo, si hacemos una funcin que busque el nmero detelfono de una persona en una base de datos, podramos llamarla"busca_telefono" o "BuscaTelefono".

Una lista de declaraciones de parmetros entre parntesis. Los parmetros de unafuncin son los valores de entrada (y en ocasiones tambin de salida). Para lafuncin se comportan exactamente igual que variables, y de hecho cada parmetrose declara igual que una variable. Una lista de parmetros es un conjunto dedeclaraciones de parmetros separados con comas. Puede tratarse de una listavaca. En C es preferible usar la forma "func(void)" para listas de parmetrosvacas. En C++ este procedimiento se considera obsoleto, se usa simplemente"func()"..

Un cuerpo de funcin que representa el cdigo que ser ejecutado cuando sellame a la funcin. El cuerpo de la funcin se encierra entre llaves "{}"


22/277



Una funcin muy especial es la funcin "main". Se trata de la funcin de entrada, ydebe existir siempre, ser la que tome el control cuando se ejecute un programa en C.Los programas Windows usan la funcin WinMain() como funcin de entrada, peroesto se explica en otro lugar.

Existen reglas para el uso de los valores de retorno y de los parmetros de la funcin"main", pero de momento la usaremos como "int main()" o "int main(void)", con unentero como valor de retorno y sin parmetros de entrada. El valor de retorno indicarsi el programa ha terminado sin novedad ni errores retornando cero, cualquier otrovalor de retorno indicar un cdigo de error.

Prototipos de funciones

En C++ es obligatorio usar prototipos. Un prototipo es una declaracin de unafuncin. Consiste en una definicin de la funcin sin cuerpo y terminado con un ";".

La estructura de un prototipo es: func();

Por ejemplo:

int Mayor(int a, int b);

Sirve para indicar al compilador los tipos de retorno y los de los parmetros de unafuncin, de modo que compruebe si son del tipo correcto cada vez que se use estafuncin dentro del programa, o para hacer las conversiones de tipo cuando sea

necesario. Los nombres de los parmetros son opcionales, y se incluyen comodocumentacin y ayuda en la interpretacin y comprensin del programa. El ejemplode prototipo anterior sera igualmente vlido y se podra poner como:

int Mayor(int,int);

Esto slo indica que en algn lugar del programa se definir una funcin "Mayor"que admite dos parmetros de tipo "int" y que devolver un valor de tipo "int". No esnecesario escribir nombres para los parmetros, ya que el prototipo no los usa. Enotro lugar del programa habr una definicin completa de la funcin.

Normalmente, las funciones se declaran como prototipos dentro del programa, o seincluyen estos prototipos desde un fichero externo, (usando la directiva "#include",ver en el siguiente captulo el operador de preprocesador.)

Ya lo hemos dicho ms arriba, pero las funciones son "extern" por defecto. Estoquiere decir que son accesibles desde cualquier punto del programa, aunque seencuentren en otros ficheros fuente del mismo programa. En contraposicin lasfunciones declaradas "static" slo son accesibles dentro del fichero fuente donde sedefinen.

La definicin de la funcin se hace ms adelante o ms abajo, segn se mire. Lo

habitual es hacerlo despus de la funcin "main".


23/277



Estructura de un programa C/C++:

La estructura de un programa en C o C++ quedara as:

[directivas del pre-procesador: includes y defines]

[declaracin de variables globales][prototipos de funciones]

funcin main

[definiciones de funciones]

Una definicin de la funcin "Mayor" podra ser la siguiente:

int Mayor(int a, int b)

{

if(a > b) return a; else return b;

}

Los programas complejos se escriben normalmente usando varios ficheros fuente.Estos ficheros se compilan separadamente y se enlazan juntos. Esto es una granventaja durante el desarrollo y depuracin de grandes programas, ya que lasmodificaciones en un fichero fuente slo nos obligarn a compilar ese fichero fuente,y no el resto, con el consiguiente ahorro de tiempo.

La definicin de las funciones puede hacerse dentro de los ficheros fuente o enlazarsedesde libreras precompiladas. La diferencia entre una declaracin y una definicin esque la definicin posee un cuerpo de funcin.

En C++ es obligatorio el uso funciones prototipo, y aunque en C no lo es, resultaaltamente recomendable.

Palabras reservadas usadas en este captulo

extern y static.


24/277



CAPITULO 4 Operadores ILos operadores son elementos que disparan ciertos clculos cuando son aplicados avariables o a otros objetos en una expresin.

Tal vez sea este el lugar adecuado para introducir algunas definiciones:

Variable: es un valor que almacena nuestro programa que puede cambiar a lo largo desu ejecucin.

Expresin: segn el diccionario, "Conjunto de trminos que representan unacantidad", entre nosotros es cualquier conjunto de operadores y operandos, que dancomo resultado una cantidad.

Operando: cada una de las cantidades, constantes o variables o expresiones que

intervienen en una expresin

Existe una divisin en los operadores atendiendo al nmero de operandos queafectan. Segn esta clasificacin pueden ser unitarios, binarios o ternarios, los

primeros afectan a un solo operando, los segundos a dos y los ternarios a siete,perdn!, a tres.

Hay varios tipos de operadores, clasificados segn el tipo de objetos sobre los queactan.

Operadores aritmticosSon usados para crear expresiones matemticas. Existen dos operadores aritmticosunitarios, '+' y '-' que tienen la siguiente sintaxis:

+

-

Asignan valores positivos o negativos a la expresin a la que se aplican.

En cuanto a los operadores binarios existen varios. '+', '-', '*' y '/', tienen un

comportamiento anlogo, en cuanto a los operandos, ya que admiten enteros y decoma flotante. Sintaxis:

+

-

*

/

Evidentemente se trata de las conocidsimas operaciones aritmticas de suma, resta,multiplicacin y divisin, que espero que ya domines a su nivel tradicional, es decir,sobre el papel.


25/277



El operador de mdulo '%', devuelve el resto de la divisin entera del primeroperando entre el segundo. Por esta razn no puede ser aplicado a operandos en comaflotante.

%

Esto quizs requiera una explicacin:

Veamos, por ejemplo, la expresin 17 / 7, es decir 17 dividido entre 7.Cuando aprendimos a dividir, antes de que supiramos sacardecimales, nos ensearon que el resultado de esta operacin era 2, y elresto 3, es decir 2*7+3 = 17. Cuando las expresiones que intervienenen una de estas operaciones sean enteras, el resultado tambin serentero, es decir, si 17 y 7 se almacenan en variables enteras, elresultado ser entero, en este caso 2.

Por otro lado si las expresiones son en punto flotante, con decimales,el resultado ser en punto flotante, es decir, 2,428571. En este caso:7*2,428571=16.999997, o sea, que no hay resto, o es muy pequeo.

Por eso mismo, calcular el resto, usando el operador %, slo tienesentido si las expresiones implicadas son enteras, ya que en casocontrario se calcularn tantos decimales como permita la precisin detipo utilizado.

Siguiendo con el ejemplo, la expresin 17 % 7 dar como resultado 3,que es el resto de la divisin entera de 17 dividido entre 7.

Por ltimo otros dos operadores unitarios. Se trata de operadores un tanto especiales,ya que slo pueden trabajar sobre variables, pues implican una asignacin. Se trata delos operadores '++' y '--'. El primero incrementa el valor del operando y el segundo lodecrementa, ambos en una unidad. Existen dos modalidades, dependiendo de que seuse el operador en la forma de prefijo o de sufijo. Sintaxis:

++ (post-incremento)

++ (pre-incremento)

-- (post-decremento)

-- (pre-decremento)

En su forma de prefijo, el operador es aplicado antes de que se evale el resto de laexpresin; en la forma de sufijo, se aplica despus de que se evale el resto de laexpresin. Veamos un ejemplo, en las siguientes expresiones "a" vale 100 y "b" vale10:

c = a + + + b ;

En este primer ejemplo primero se aplica el pre-incremento, y b valdr 11 acontinuacin se evala la expresin "a+b", que dar como resultado 111, y por ltimose asignar este valor a c, que valdr 111.

c = a + b + + ;


26/277



En este segundo ejemplo primero se avala la expresin "a+b", que dar comoresultado 110, y se asignar este valor a c, que valdr 110. Finalmente se aplica en

post-incremento, y b valdr 11.

Los operadores unitarios sufijos (post-incremento y post-decremento) se evalan

despus de que se han evaluado el resto de las expresiones. En el primer ejemploprimero se evala ++b, despus a+b y finalmente c =. En el segundoejemplo, primero se evala a+b, despus c = y finalmente b++.

Es muy importante no pensar o resolver las expresiones C como ecuacionesmatemticas, NO SON EXPRESIONES MATEMATICAS. No veas estasexpresiones como ecuaciones, NO SON ECUACIONES. Esto es algo que se tarda encomprender al principio, y que despus aprendes y dominas hasta el punto que no tedas cuenta.

Por ejemplo, piensa en esta expresin:

b = b + 1;

Supongamos que inicialmente "b" vale 10, esta expresin asignar a "b" el valor 11.Veremos el operador "=" ms adelante, pero por ahora no lo confundas con unaigualdad matemtica. En matemticas la expresin anterior no tiene sentido, en

programacin s lo tiene.

La primera expresin equivale a:

b = b+1;

c = a + b;

La segunda expresin equivale a:

c = a + b;

b = b+1;

Esto tambin proporciona una explicacin de por qu la versin mejorada del lenguajeC se llama C++, es simplemente el C mejorado o incrementado. Y ya que estamos, ellenguaje C se llama as porque las personas que lo desarrollaron crearon dos prototiposde lenguajes de programacin con anterioridad a los que llamaron B y BCPL.

Operadores de asignacin

Existen varios operadores de asignacin, el ms evidente y el ms usado es el "=",pero no es el nico.

Aqu hay una lista: "=", "*=", "/=", "%=", "+=", "-=", "=", "&=", " ^=" y"|=". Y la sintaxis es:

En general, para todos los operadores mixtos la expresin


27/277



E1 op= E2

Tiene el mismo efecto que la expresin

E1 = E1 op E2

El funcionamiento es siempre el mismo, primero se evala la expresin de la derecha,se aplica el operador mixto, si existe y se asigna el valor obtenido a la variable de laizquierda.

Operador coma

La coma tiene una doble funcin, por una parte separa elementos de una lista deargumentos de una funcin. Por otra, puede ser usado como separador en expresiones"de coma". Ambas funciones pueden ser mezcladas, pero hay que aadir parntesis

para resolver las ambigedades. Sintaxis:E1, E2, ..., En

En una expresin "de coma", cada operando es evaluado como una expresin, perolos resultados obtenidos anteriormente se tienen en cuenta en las subsiguientesevaluaciones. Por ejemplo:

func(i, (j = 1, j + 4), k);

Llamar a la funcin con tres argumentos: (i, 5, k). La expresin de coma (j = 1, j+4),

se evala de izquierda a derecha, y el resultado se pasar como argumento a lafuncin.

Operadores de igualdad

Los operadores de igualdad son "==", (dos signos = seguidos) y "!=", quecomprueban la igualdad o desigualdad entre dos valores aritmticos. Sintaxis:

==

!=

Se trata de operadores de expresiones lgicas, es decir, el resultado es "true" o"false". En el primer caso, si las expresiones 1 y 2 son iguales el resultado es "true",en el segundo, si las expresiones son diferentes, el resultado es "true".

Nota: Cuando se hacen comparaciones entre una constante y una variable, esrecomendable poner en primer lugar la constante, por ejemplo:

if(123 == a) ...

if(a == 123) ...

Si nos equivocamos al escribir estas expresiones, y ponemos slo un signo '=', en el

primer caso obtendremos un error del compilador, ya que estaremos intentandocambiar el valor de una constante, lo cual no es posible. En el segundo caso, el valor


28/277



de la variable cambia, y adems el resultado de evaluar la expresin no depender deuna comparacin, sino de una asignacin, y siempre ser "true", salvo que el valorasignado sea 0.

Por ejemplo:

if(a = 0) ... // siempre ser "false"

if(a = 123)... // siempre ser "true", ya que 123 es distinto de 0

El resultado de evaluar la expresin no depende de "a" en ninguno de los dos casos,como puedes ver.

En estos casos, el compilador, en el mejor de los casos, nos dar un "warning", o seaun aviso, pero compilar el programa.

Nota: los compiladores clasifican los errores en dos tipos, dependiendo de lo serios

que sean:

"Errores": son errores que impiden que el programa pueda ejecutarse, los programascon "errores" no pueden pasar de la fase de compilacin a la de enlazado, que es lafase en que se obtiene el programa ejecutable.

"Warnings": son errores de poca entidad, (segn el compilador que, por supuesto, notiene ni idea de lo que intentamos hacer). Estos errores no impiden pasar a la fase deenlazado, y por lo tanto es posible ejecutarlos. Debes tener cuidado si tu compilador deda una lista de "warnings", eso significa que has cometido algn error, en cualquier casorepasa esta lista e intenta corregir los "warnings".

Operadores lgicos

Los operadores "&&", "||" y "!" relacionan expresiones lgicas, formando a su veznuevas expresiones lgicas. Sintaxis:

&&

||

!

El operador "&&" equivale al "AND" o "Y"; devuelve "true" slo si las dosexpresiones evaluadas son "true" o distintas de cero, en caso contrario devuelve"false" o cero. Si la primera expresin evaluada es "false", la segunda no se evala.

Generalizando, con expresiones AND con ms de dos expresiones, la primeraexpresin falsa interrumpe el proceso e impide que se contine la evaluacin del restode las expresiones. Esto es lo que se conoce como "cortocircuito", y es muyimportante, como veremos posteriormente.


29/277



A continuacin se muestra la tabla de verdad del operador &&:

Expresin1 Expresin2

Expresin1 &&

Expresin2false ignorada false

true false false

true true true

El operador "||" equivale al "OR" u "O inclusivo"; devuelve "true" si cualquiera de lasexpresiones evaluadas es "true" o distinta de cero, en caso contrario devuelve "false"o cero. Si la primera expresin evaluada es "true", la segunda no se evala.

Expresin1 Expresin2 Expresin1 ||Expresin2

false false false

false true true

true ignorada true

El operador "!" es equivalente al "NOT", o "NO", y devuelve "true" slo si laexpresin evaluada es "false" o cero, en caso contrario devuelve "false".

La expresin "!E" es equivalente a (0 == E).

Expresin !Expresin

false true

true false

Operadores relacionales

Los operadores son "", "=", que comprueban relaciones de igualdad odesigualdad entre dos valores aritmticos. Sintaxis:

<

<

=

Si el resultado de la comparacin resulta ser verdadero, se retorna

"true", en caso contrario "false". El significado de cada

operador es evidente:

> mayor que

< menor que

>= mayor o igual que


30/277


Salvador Pozo

cursocpp.pdf

Documents