Guia para programacion en cpp, Apuntes de Programación C

¡Descarga Guia para programacion en cpp y más Apuntes en PDF de Programación C solo en Docsity!

Curso de programación en C++

EUI (UPV)

Valencia, 17 al 28 de Julio de 1995

Apuntes de clase

Sergio Talens Oliag

• BASES TEÓRICAS. INTRODUCCIÓN A LA POO.. Contenidos
• INTRODUCCIÓN...............................................................................................................................
• PARADIGMAS DE PROGRAMACIÓN.....................................................................................................
• PROGRAMACIÓN IMPERATIVA ..........................................................................................................
  • Tipos de datos .............................................................................................................................
  • Operadores y expresiones...............................................................................................................
  • Algoritmos y estructuras de control .................................................................................................
  • Funciones y procedimientos...........................................................................................................
  • Constantes y variables
• PROGRAMACIÓN MODULAR .............................................................................................................
• TIPOS ABSTRACTOS DE DATOS..........................................................................................................
• PROGRAMACIÓN ORIENTADA A OBJETOS ...........................................................................................
  • Objetos y mensajes
  • Clases........................................................................................................................................
  • Herencia y polimorfismo...............................................................................................................
  • Programación con objetos..............................................................................................................
• EL LENGUAJE C++.
• INTRODUCCIÓN...............................................................................................................................
• CONCEPTOS BÁSICOS......................................................................................................................
  • Estructura de los programas............................................................................................................
  • Tipos de datos y operadores..........................................................................................................
  • Estructuras de control..................................................................................................................
  • Funciones.................................................................................................................................
  • Soporte a la programación modular................................................................................................
  • Soporte a los Tipos de Datos Abstractos.........................................................................................
  • Soporte a la programación Orientada a Objetos
• TIPOS DE DATOS, OPERADORES Y EXPRESIONES.................................................................................
  • Tipos de datos
  • Tipos elementales
  • Tipos enumerados
  • Tipos derivados..........................................................................................................................
  • Tipos compuestos......................................................................................................................
  • Constantes (literales)
  • Variables..................................................................................................................................
  • Conversiones de tipos.................................................................................................................
  • Operadores y expresiones.............................................................................................................
• ESTRUCTURAS DE CONTROL
  • Estructuras de selección...............................................................................................................
  • Estructuras de repetición..............................................................................................................
  • Estructuras de salto.....................................................................................................................
• FUNCIONES
  • Declaración de funciones..............................................................................................................
  • Definición de funciones...............................................................................................................
  • Paso de parámetros.....................................................................................................................
  • Parámetros array
  • Retorno de valores......................................................................................................................
  • Sobrecarga de funciones...............................................................................................................
  • Parámetros por defecto
  • Parámetros indefinidos
  • Recursividad..............................................................................................................................
  • Punteros a funciones...................................................................................................................
  • La función main()
• VARIABLES DINÁMICAS.................................................................................................................
  • Punteros y direcciones.................................................................................................................
  • El puntero NULL.......................................................................................................................
  • Punteros void............................................................................................................................
  • Aritmética con punteros
  • Punteros y parámetros de funciones
  • Punteros y arrays........................................................................................................................ iv
  • Operadores new y delete...............................................................................................................
  • Punteros y estructuras
  • Punteros a punteros
• PROGRAMACIÓN EFICIENTE............................................................................................................
  • Estructura de los programas..........................................................................................................
  • El preprocesador.........................................................................................................................
  • Funciones inline ........................................................................................................................
  • Inclusión de rutinas en ensamblador
  • Eficiencia y claridad de los programas.............................................................................................
• CLASES........................................................................................................................................
  • Introducción ..............................................................................................................................
  • Clases y miembros
  • Métodos estáticos y funciones amigas
  • Construcción y destrucción...........................................................................................................
• HERENCIA Y POLIMORFISMO...........................................................................................................
  • Clases derivadas o subclases .........................................................................................................
  • Clases abstractas ........................................................................................................................
  • Herencia múltiple.......................................................................................................................
  • Control de acceso
  • Gestión de memoria....................................................................................................................
• SOBRECARGA DE OPERADORES .......................................................................................................
  • Funciones operador.....................................................................................................................
  • Conversiones de tipos
  • Operadores y objetos grandes ........................................................................................................
  • Asignación e inicialización...........................................................................................................
  • Subíndices ................................................................................................................................
  • Llamadas a función.....................................................................................................................
  • Dereferencia...............................................................................................................................
  • Incremento y decremento..............................................................................................................
  • Sobrecarga de new y delete ...........................................................................................................
  • Funciones amigas o métodos........................................................................................................
• TEMPLATES ..................................................................................................................................
  • Genericidad................................................................................................................................
  • Funciones genéricas....................................................................................................................
  • Clases genéricas.........................................................................................................................
• MANEJO DE EXCEPCIONES ..............................................................................................................
  • Programación y errores................................................................................................................
  • Tratamiento de excepciones en C++ (throw - catch - try)....................................................................
• ENTRADA Y SALIDA
  • Introducción ..............................................................................................................................
  • Objetos Stream ..........................................................................................................................
  • Entrada y salida..........................................................................................................................
  • Ficheros ...................................................................................................................................
• PROGRAMACIÓN EN C++................................................................................................................
  • El proceso de desarrollo ...............................................................................................................
  • Mantenibilidad y documentación....................................................................................................
  • Diseño e implementación.............................................................................................................
  • Elección de clases.......................................................................................................................
  • Interfaces e implementación..........................................................................................................
• LIBRERÍAS DE CLASES....................................................................................................................
  • Diseño de librerías......................................................................................................................
  • Clases Contenedor......................................................................................................................
  • Clases para aplicaciones...............................................................................................................
  • Clases de Interface
  • Eficiencia temporal y gestión de memoria .......................................................................................
  • Estandarización ..........................................................................................................................
• RELACIÓN C/C++..........................................................................................................................
  • No se puede usar en ANSI C ........................................................................................................
  • Diferencias entre C y C++ ...........................................................................................................

Bibliografía básica

— Brian W. Kernighan, Dennis M. Ritchie, The C Programming Language, Second Edition , Prentice Hall, 1988

— Bjarne Stroustrup, The C++ Programming Language, Second Edition , Addison-Wesley, 1991

— Enrique Hernández Orallo, José Hernández Orallo, Programación en C++ , Paraninfo, 1993

Bases teóricas. Introducción a la POO.

INTRODUCCIÓN

Para comenzar a estudiar cualquier lenguaje de programación se debe conocer cuales son los conceptos que soporta, es decir, el tipo de programación que vamos a poder realizar con él. Como el C++ incorpora características nuevas respecto a lenguajes como Pascal o C, en primer lugar daremos una descripción a los conceptos a los que este lenguaje da soporte, repasando los paradigmas de programación y centrándonos en la evolución desde la programación Funcional a la programación Orientada a Objetos. Más adelante estudiaremos el lenguaje de la misma manera, primero veremos sus características funcionales (realmente la parte que el lenguaje hereda de C) y después estudiaremos las extensiones que dan soporte a la programación orientada a objetos (el ++ de C++).

PARADIGMAS DE PROGRAMACIÓN

Según los conceptos en que se basa un lenguaje de programación tenemos distintas maneras de aproximarnos a la resolución de los problemas y diferentes estilos de programación. Podemos clasificar los lenguajes de programación en varios tipos:

— Imperativos

— Orientados a Objetos

— Funcionales

— Lógicos

Las dos primeras opciones se basan en la abstracción de los tipos de datos. Básicamente se trata de representar las características variables de los objetos mediante tipos que el ordenador pueda tratar, como por ejemplo números enteros o caracteres alfanuméricos. Nuestro programa será una colección de algoritmos que opere sobre los datos que hemos modelado. La diferencia entre las dos aproximaciones se verá en puntos posteriores.

Los lenguajes funcionales, al contrario que los imperativos, eliminan totalmente la idea de tipo de datos, se limitan a tratar todos los datos como símbolos y hacen hincapié en las operaciones que podemos aplicar sobre estos símbolos, agrupados en listas o árboles. Es importante indicar que en estos lenguajes se emplea únicamente el concepto de función aplicado a símbolos, siendo una de sus características principales el empleo de las funciones recursivas. Como ejemplo de este tipo de lenguajes podríamos citar el LISP.

Los lenguajes lógicos son los que trabajan directamente con la lógica formal, se trata de representar relaciones entre conjuntos, para luego poder determinar si se verifican determinados predicados. El lenguaje lógico más extendido es el Prolog.

PROGRAMACIÓN IMPERATIVA

Como ya hemos mencionado anteriormente, la programación imperativa trata con tipos de datos y algoritmos, los primeros representan la información utilizada por los programas, mientras que los segundos se refieren a la manera en que tratamos esa información.

En los puntos que siguen revisaremos de forma breve los conceptos fundamentales de la programación imperativa clásica, también llamada programación procedural. La idea básica de esta aproximación es la de definir los algoritmos o procedimientos más eficaces para tratar los datos de nuestro problema.

Tipos de datos

Cuando nos planteamos la resolución de problemas mediante computador lo más usual es que queramos tratar con datos que son variables y cuantificables, es decir, que toman un conjunto de valores distintos entre un conjunto de valores posibles, además de poder almacenar los valores de estos datos en alguna forma aceptable para el computador (ya sea en la memoria o en periféricos de almacenamiento externo).

En un lenguaje de programación el concepto de tipo de datos se refiere al conjunto de valores que puede tomar una variable. Esta idea es similar a la que se emplea en matemáticas, donde clasificamos las variables en función de determinadas características, distinguiendo entre números enteros, reales o complejos. Sin embargo, en matemáticas, nosotros somos capaces de diferenciar el tipo de las variables en función del contexto, pero para los compiladores esto resulta mucho más difícil. Por este motivo debemos declarar explícitamente cada variable como perteneciente a un tipo. Este mecanismo es útil para que el computador almacene la variable de la forma más adecuada, además de permitir verificar que tipo de operaciones se pueden realizar con ella.

Se suelen diferenciar los tipos de datos en varias categorías:

— Tipos elementales , que son aquellos cuyos valores son atómicos y, por tanto, no pueden ser descompuestos en valores más simples. Entre las variables de estos tipos siempre encontramos definidas una serie de operaciones básicas: asignación de un valor, copia de valores entre variables y operaciones relacionales de igualdad o de orden (por lo tanto, un tipo debe ser un conjunto ordenado ).

Los tipos más característicos son:

booleanos = {verdadero, falso}

enteros = {… -2, -1, 0, +1, +2, …}

reales = {… -1.0, …, 0.0, …, +1.0, …}

caracteres = {… 'a', 'b', …, 'Z', …}

Generalmente existen mecanismos para que el usuario defina nuevos tipos elementales por enumeración , es decir, definiendo el conjunto de valores explícitamente. Por ejemplo podríamos definir el tipo día como {lunes, martes, miércoles, jueves, viernes, sábado, domingo}, las variables definidas como día sólo podrían tomar estos valores.

Por último mencionaremos otro tipo de datos elemental de características especiales, el puntero , que es el tipo que almacena las direcciones de las variables (la dirección de memoria en la que se almacena su valor). Analizaremos este tipo más adelante.

Los operadores están directamente relacionados con los tipos de datos, puesto que se definen en función del tipo de operandos que aceptan y el tipo del valor que devuelven. En algunos casos es fácil olvidar esto, ya que llamamos igual a operadores que realizan operaciones distintas en función de los valores a los que se apliquen, por ejemplo, la división de enteros no es igual que la de reales, ya que la primera retorna un valor entero y se olvida del resto, mientras que la otra devuelve un real, que tiene decimales.

Un programa completo está compuesto por una serie de sentencias , que pueden ser de distintos tipos:

— declarativas , que son las que empleamos para definir los tipos de datos, declarar las variables o las funciones, etc., es decir, son aquellas que se emplean para definir de forma explícita los elementos que intervienen en nuestro programa,

— ejecutables , que son aquellas que se transforman en código ejecutable, y

— compuestas , que son aquellas formadas de la unión de sentencias de los tipos anteriores.

Llamaremos expresión a cualquier sentencia del programa que puede ser evaluada y devuelve un valor. Las expresiones más simples son los literales , que expresan un valor fijo explícitamente, como por ejemplo un número o una cadena de caracteres. Las expresiones compuestas son aquellas formadas por una secuencia de términos separados por operadores, donde los términos pueden ser literales, variables o llamadas a funciones (ya que devuelven un resultado).

Algoritmos y estructuras de control

Podemos definir un algoritmo de manera general como un conjunto de operaciones o reglas bien definidas que, aplicadas a un problema, lo resuelven en un número finito de pasos. Si nos referimos sólo a la informática podemos dar la siguiente definición:

Un procedimiento es una secuencia de instrucciones que pueden realizarse mecánicamente. Un procedimiento que siempre termina se llama algoritmo.

Al diseñar algoritmos que resuelvan problemas complejos debemos emplear algún método de diseño, la aproximación más sencilla es la del diseño descendente (top-down). El método consiste en ir descomponiendo un problema en otros más sencillos (subproblemas) hasta llegar a una secuencia de instrucciones que se pueda expresar en un lenguaje de alto nivel. Lo que haremos será definir una serie de acciones complejas y dividiremos cada una en otras más simples. Para controlar el orden en que se van desarrollando las acciones, utilizaremos las estructuras de control , que pueden ser de distintos tipos:

— condicionales o de selección , que nos permiten elegir entre varias posibilidades en función de una o varias condiciones,

— de repetición (bucles) , que nos permiten repetir una serie de operaciones hasta que se verifique una condición o hayamos dado un número concreto de vueltas, y

— de salto , que nos permiten ir a una determinada línea de nuestro algoritmo directamente.

Funciones y procedimientos

En el punto anterior hemos definido los algoritmos como procedimientos que siempre terminan, y procedimiento como una secuencia de instrucciones que pueden realizarse mecánicamente, aquí consideraremos que un procedimiento es un algoritmo que recibe unos parámetros de entrada , y una función un procedimiento que, además de recibir unos parámetros, devuelve un valor de un tipo concreto. En lo que sigue emplearé los términos procedimiento y función indistintamente.

Lo más importante de estas abstracciones es saber como se pasan los parámetros, ya que según el mecanismo que se emplee se podrá o no modificar sus valores. Si los parámetros se pasan por valor , el procedimiento recibe una copia del valor que tiene la variable parámetro y por lo tanto no puede modificarla, sin embargo, si el parámetro se pasa por referencia , el procedimiento recibe una referencia a la variable que se le pasa como parámetro, no el valor que contiene, por lo que cualquier consulta o cambio que se haga al parámetro afectará directamente a la variable.

¿Por qué surgieron los procedimientos y las funciones? Sabemos que un programa según el paradigma clásico es una colección de algoritmos pero, si los escribiéramos todos seguidos, nuestro programa sería ilegible. Los procedimientos son un método para ordenar estos algoritmos de alguna manera, separando las tareas que realiza un programa. El hecho de escribir los algoritmos de manera independiente nos ayuda a aplicar el diseño descendente; podemos expresar cada subproblema como un procedimiento distinto, viendo en el programa cual ha sido el refinamiento realizado. Además algunos procedimientos se podrán reutilizar en problemas distintos.

Por último indicaremos que el concepto de procedimiento introduce un nivel de abstracción importante en la programación ya que, si queremos utilizar un procedimiento ya implementado para resolver un problema, sólo necesitamos saber cuáles son sus parámetros y cuál es el resultado que devuelve. De esta manera podemos mejorar o cambiar un procedimiento sin afectar a nuestro programa, siempre y cuando no cambie sus parámetros, haciendo mucho más fácil la verificación de los programas, ya que cuando sabemos que un procedimiento funciona correctamente no nos debemos volver a preocupar por él.

Constantes y variables

En los puntos anteriores hemos tratado las variables como algo que tiene un tipo y puede ser pasado como parámetro pero no hemos hablado de cómo o dónde se declaran, de cómo se almacenan en memoria o de si son accesibles desde cualquier punto de nuestro programa.

Podemos decir que un programa está compuesto por distintos bloques, uno de los cuales será el principal y que contendrá el procedimiento que será llamado al comenzar la ejecución del programa. Serán bloques el interior de las funciones, el interior de las estructuras de control, etc.

Diremos que el campo o ámbito de un identificador es el bloque en el que ha sido definido. Si el bloque contiene otros bloques también en estos el identificador será válido. Cuando hablo de identificador me refiero a su sentido más amplio: variables, constantes, funciones, tipos, etc. Fuera del ámbito de su definición ningún identificador tiene validez.

Clasificaremos las variables en función de su ámbito de definición en globales y locales. Dentro de un bloque una variable es local si ha sido definida en el interior del mismo, y es global si se ha definido fuera de el bloque pero podemos acceder a ella.

Como es lógico las variables ocupan memoria pero, como sólo son necesarias en el interior de los bloques donde se definen, durante la ejecución del programa serán creadas al entrar en su ámbito y eliminadas al salir de él. Así, habrá variables que existirán durante todo el programa (si son globales para todos los bloques) y otras que sólo existan en momentos muy concretos. Este mecanismo de creación y destrucción de variables permite que los programas aprovechen al máximo la memoria que les ha sido asignada.

Todo lo dicho anteriormente es válido para las variables declaradas estáticamente, pero existe otro tipo de variables cuya existencia es controlada por el programador, las denominadas variables dinámicas. Ya hablamos anteriormente de los punteros y dijimos entonces que eran las variables empleadas para apuntar a otras variables, pero ¿a qué nos referimos con apuntar? Sabemos que las variables se almacenan en memoria, luego habrá alguna dirección de memoria en la que encontremos su valor (que puede ocupar uno o varios bytes). Los punteros no son más que variables cuyo contenido es una dirección de memoria, que puede ser la de la posición del valor de otra variable.

variables del tipo únicamente se podrán declarar como estructuras, por lo que los procedimientos necesitarán que las incluyamos como parámetro. La solución adoptada por los nuevos lenguajes es incorporar mecanismos de definición de tipos de usuario que se comportan casi igual que los tipos del lenguaje.

PROGRAMACIÓN ORIENTADA A OBJETOS

La diferencia fundamental entre la programación pocedural y la orientada a objetos está en la forma de tratar los datos y las acciones. En la primera aproximación ambos conceptos son cosas distintas, se definen unas estructuras de datos y luego se define una serie de rutinas que operan sobre ellas. Para cada estructura de datos se necesita un nuevo conjunto de rutinas. En la programación orientada a objetos los datos y las acciones están muy relacionadas. Cuando definimos los datos ( objetos ) también definimos sus acciones. En lugar de un conjunto de rutinas que operan sobre unos datos tenemos objetos que interactuan entre sí.

Objetos y mensajes

Un Objeto es una entidad que contiene información y un conjunto de acciones que operan sobre los datos. Para que un objeto realice una de sus acciones se le manda un mensaje. Por tanto, la primera ventaja de la programación orientada a objetos es la encapsulación de datos y operaciones, es decir, la posibilidad de definir Tipos Abstractos de Datos.

De cualquier forma la encapsulación es una ventaja mínima de la programación orientada a objetos. Una característica mucho más importante es la posibilidad de que los objetos puedan heredar características de otros objetos. Este concepto se incorpora gracias a la idea de clase.

Clases

Cada objeto pertenece a una clase , que define la implementación de un tipo concreto de objetos. Una clase describe la información de un objeto y los mensajes a los que responde. La declaración de una clase es muy parecida a la definición de un registro, pero aquí los campos se llaman instancias de variables o datos miembro (aunque utilizaré el término atributo, que no suena tan mal en castellano). Cuando le mandamos un mensaje a un objeto, este invoca una rutina que implementa las acciones relacionadas con el mensaje. Estas rutinas se denominan métodos o funciones miembro. La definición de la clase también incluye las implementaciones de los métodos.

Se puede pensar en las clases como plantillas para crear objetos. Se dice que un objeto es una instancia de una clase. También se puede decir que un objeto es miembro de una clase.

Herencia y polimorfismo

Podemos definir clases en base a otra clase ya existente. La nueva clase se dice que es una subclase o clase derivada , mientras que la que ya existía se denomina superclase o clase base. Una clase que no tiene superclase se denomina clase raíz.

Una subclase hereda todos los métodos y atributos de su superclase, además de poder definir miembros adicionales (ya sean datos o funciones). Las subclases también pueden redefinir (override) métodos definidos por su superclase. Redefinir se refiere a que las subclase responde al mismo mensaje que su superclase, pero utiliza su propio método para hacerlo.

Gracias al mecanismo de redefinición podremos mandar el mismo mensaje a objetos de diferentes clases, esta capacidad se denomina polimorfismo.

Programación con objetos

A la hora de programar con objetos nos enfrentamos a una serie de problemas: ¿Qué clases debo crear?, ¿Cuándo debo crear una subclase? ¿Qué debe ser un método o un atributo?

Lo usual es crear una jerarquía de clases, definiendo una clase raíz que da a todos los objetos un comportamiento común. La clase raíz será una clase abstracta , ya que no crearemos instancias de la misma. En general se debe definir una clase (o subclase de la clase raíz) para cada concepto tratado en la aplicación. Cuando necesitemos añadir atributos o métodos a una clase definimos una subclase. Los atributos deben ser siempre privados, y deberemos proporcionar métodos para acceder a ellos desde el exterior. Todo lo que se pueda hacer con un objeto debe ser un método.

Los comentarios se introducirán en el programa separados por /* y / o comenzándolos con //. Los comentarios entre / y / pueden tener la longitud que queramos, pero no se anidan, es decir, si escribimos / hola /* amigo */ mío */, el compilador interpretará que el comentario termina antes de mío, y dará un error. Los comentarios que comienzan por // sólo son válidos hasta el final de la línea en la que aparecen.

Un programa simple que muestra todo lo que hemos visto puede ser el siguiente:

/* Este es un programa mínimo en C++, lo único que hace es escribir una frase en la pantalla */

#include <iostream.h>

int main() { cout << "Hola guapo\n"; // imprime en la pantalla la frase "hola guapo" }

La primera parte separada entre /* y */ es un comentario. Es recomendable que se comenten los programas, explicando que es lo que estamos haciendo en cada caso, para que cuando se lean sean más comprensibles.

La línea que empieza por # es una directiva. En este caso indica que se incluya el fichero "iostream.h", que contiene las definiciones para entrada/salida de datos en C++.

En la declaración de main() hemos incluido la palabra int, que indica que la función devuelve un entero. Este valor se le entrega al sistema operativo al terminar el programa. Si no se devuelve ningún valor el sistema recibe un valor aleatorio.

La sentencia separada ente llaves indica que se escriba la frase "Hola guapo". El operador << ("poner en") escribe el segundo argumento en el primero. En este caso la cadena "Hola guapo\n" se escribe en la salida estándar (cout). El carácter \ seguido de otro carácter indica un solo carácter especial, en este caso el salto de línea (\n).

Veremos el tema de la entrada salida estándar más adelante. Hay que indicar que las operaciones de E/S se gestionan de forma diferente en C y C++, mientras que el C proporciona una serie de funciones (declaradas en el fichero "stdio.h"), el C++ utiliza el concepto de stream , que se refiere al flujo de la información (tenemos un flujo de entrada que proviene de cin y uno de salida que se dirige a cout) que se maneja mediante operadores de E/S.

Por último señalar que debemos seguir ciertas reglas al nombrar tipos de datos, variables, funciones, etc. Los identificadores válidos del C++ son los formados a partir de los caracteres del alfabeto (el inglés, no podemos usar ni la ñ ni palabras acentuadas), los dígitos (0..9) y el subrayado ( _ ), la única restricción es que no podemos comenzar un identificador con un dígito (es así porque se podrían confundir con literales numéricos). Hay que señalar que el C++ distingue entre mayúsculas y minúsculas, por lo que Hola y hola representan dos cosas diferentes. Hay que evitar el uso de identificadores que sólo difieran en letras mayúsculas y minúsculas, porque inducen a error.

Tipos de datos y operadores

Los tipos elementales definidos en C++ son:

char, short, int, long, que representan enteros de distintos tamaños (los caracteres son enteros de 8 bits)

float, double y long double, que representan números reales (en coma flotante).

Para declarar variables de un tipo determinado escribimos el nombre del tipo seguido del de la variable. Por ejemplo:

int i; double d; char c;

Sobre los tipos elementales se pueden emplear los siguientes operadores aritméticos:

• (más, como signo o como operación suma)

• (menos, como signo o como operación resta)

• (multiplicación) / (división) % (resto)

Y los siguientes operadores relacionales:

== (igual) != (distinto) < (menor que)

(mayor que) <= (menor o igual que) = (mayor o igual que)

El operador de asignación se representa por =.

En la bibliografía del C++ se suelen considerar como tipos derivados los construidos mediante la aplicación de un operador a un tipo elemental o compuesto en su declaración. Estos operadores son:

• Puntero & Referencia [] Vector (Array) () Función

Los tipos compuestos son las estructuras (struct), las uniones (unión) y las clases (class).

Estructuras de control

Como estructuras de control el C++ incluye las siguientes construcciones:

condicionales:

if instrucción de selección simple

switch instrucción de selección múltiple

bucles:

do-while instrucción de iteración con condición final

while instrucción de iteración con condición inicial

for instrucción de iteración especial (similar a las de repetición con contador)

de salto:

break instrucción de ruptura de secuencia (sale del bloque de un bucle o instrucción condicional)

continue instrucción de salto a la siguiente iteración (se emplea en bucles para saltar a la posición donde se comprueban las condiciones)

goto instrucción de salto incondicional (salta a una etiqueta)

return instrucción de retorno de un valor (se emplea en las funciones)

Soporte a los Tipos de Datos Abstractos

Para soportar los tipos de datos se proporcionan mecanismos para definir operadores y funciones sobre un tipo definido por nosotros y para restringir el acceso a las operaciones a los objetos de este tipo. Además se proporcionan mecanismos para redefinir operadores e incluso se soporta el concepto de tipos genéricos mediante las templates (plantillas).

También se define un mecanismo para manejo de excepciones que permite que controlemos de forma explícita los errores de nuestro programa.

Soporte a la programación Orientada a Objetos

Para soportar el concepto de programación orientada a objetos se incluyen diversos mecanismos:

— declaración de clases (usando la palabra class)

— de paso de mensajes a los objetos (realmente son llamadas a funciones)

— protección de los métodos y atributos de las clases (definición de métodos privados, protegidos y públicos)

— soporte a la herencia y polimorfismo (incluso se permite la herencia múltiple, es decir, la definición de una clase que herede características de dos clases distintas)

Es interesante señalar que el soporte a objetos complementa a los mecanismos de programación modular, encapsulando aun más los programas.

TIPOS DE DATOS, OPERADORES Y EXPRESIONES

Tipos de datos

Para declarar una variable ponemos el nombre del tipo seguido del de la variable. Podemos declarar varias variables de un mismo tipo poniendo el nombre del tipo y las variables a declarar separadas por comas:

int i, j,k;

Además podemos inicializar una variable a un valor en el momento de su declaración:

int i=100;

Cada tipo definido en el lenguaje (o definido por el usuario) tiene un nombre sobre el que se pueden emplear dos operadores:

sizeof, que nos indica la memoria necesaria para almacenar un objeto del tipo, y

new, que reserva espacio para almacenar un valor del tipo en memoria.

Tipos elementales

El C++ tiene un conjunto de tipos elementales correspondientes a las unidades de almacenamiento típicas de un computador y a las distintas maneras de utilizarlos:

— enteros:

char short int int long int

— reales (números en coma flotante):

float double long double

La diferencia entre los distintos tipos enteros (o entre los tipos reales) está en la memoria que ocupan las variables de ese tipo y en los rangos que pueden representar. A mayor tamaño, mayor cantidad de valores podemos representar. Con el operador sizeof podemos saber cuanto ocupa cada tipo en memoria.

Para especificar si los valores a los que se refieren tienen o no signo empleamos las palabras signed y unsigned delante del nombre del tipo (por ejemplo unsigned int para enteros sin signo).

Para tener una notación más compacta la palabra int se puede eliminar de un nombre de tipo de más de una palabra, por ejemplo short int se puede escribir como short, unsigned es equivalente a unsigned int, etc.

El tipo entero char es el que se utiliza normalmente para almacenar y manipular caracteres en la mayoría de los computadores, generalmente ocupa 8 bits (1byte), y es el tipo que se utiliza como base para medir el tamaño de los demás tipos del C++.

Un tipo especial del C++ es el denominado void (vacío). Este tipo tiene características muy peculiares, ya que es sintácticamente igual a los tipos elementales pero sólo se emplea junto a los derivados, es decir, no hay objetos del tipo void Se emplea para especificar que una función no devuelve nada o como base para punteros a objetos de tipo desconocido (esto lo veremos al estudiar los punteros). Por ejemplo:

void BorraPantalla (void);

indica que la función BorraPantalla no tiene parámetros y no retorna nada.

Tipos enumerados

Un tipo especial de tipos enteros son los tipos enumerados. Estos tipos sirven para definir un tipo que sólo puede tomar valores dentro de un conjunto limitado de valores. Estos valores tienen nombre, luego lo que hacemos es dar una lista de constantes asociadas a un tipo.

La sintaxis es:

enum booleano {FALSE, TRUE}; // definimos el tipo booleano

Aquí hemos definido el tipo booleano que puede tomar los valores FALSE o TRUE. En realidad hemos asociado la constante FALSE con el número 0, la constante TRUE con 1, y si hubiera más constantes seguiríamos con 2, 3, etc. Si por alguna razón nos interesa dar un número concreto a cada valor podemos hacerlo en la declaración:

enum colores {rojo = 4, azul, verde = 3, negro = 1};

azul tomará el valor 5 (4+1), ya que no hemos puesto nada. También se pueden usar números negativos o constantes ya definidas.

Para declarar un variable de un tipo enumerado hacemos:

enum booleano test; // sintaxis de ANSI C booleano test; // sintaxis de C++

En ANSI C los enumerados son compatibles con los enteros, en C++ hay que convertir los enteros a enumerado:

booleano test = (booleano) 1; // asigna TRUE a test (valor 1)