Manual básico de programación en c++ prev

M anual básico
de
Pr ogr amación en
C++

Apoyo a la Investigación C.P.D.
Servicios Informáticos U.C.M.

INDICE

PROGRAMACION ORIENTADA A OBJETOS

1. INTRODUCCION.....................................................................................................4

2. TIPOS DE DATOS ABSTRACTOS ( T.D.A. ).......................................................6

3. CONCEPTOS DE ORIENTACION A OBJETOS................................................7
3.1. Clases y métodos.................................................................................................7
3.1.1. Tipos de clases............................................................................................7
3.2. Objetos.................................................................................................................7
3.3. Mens ajes..............................................................................................................8
3.3.1. Semejanzas entre programación en lenguajes convencionales y P.O.O..8
3.3.2. Diferencias entre programación en lenguajes convencionales y P.O.O..8
3.4. Herencia...............................................................................................................9
3.5. Herencia múltiple.............................................................................................10
3.6. Enlace de métodos............................................................................................10
3.7. Tipos genéricos..................................................................................................10
3.8. Asignación estática y dinámica de memoria..................................................11
3.9. Polimorfismo.....................................................................................................11
3.10. Reutilización.....................................................................................................11

PROGRAMACION EN C++

INTRODUCCION...................................................................................................13

C++ COMO UN ''C MEJORADO''......................................................................15
2.1. Comentarios y declaraciones en C++...............................................................15
2.2. Flujo de entrada/salida de C++........................................................................15
2.3. Cómo crear nuevos tipos de datos en C++......................................................15
2.4. Prototipos de función y verificación de tipo....................................................16
2.5. Funciones en línea..............................................................................................16
2.6. Parámetros por refere ncia................................................................................16
2.7. El calificador const.............................................................................................17
2.8. Asignación dinámica de memoria mediante new y delete..............................18
2.9. Operador de resolución de alcance unario......................................................18
2.10. Homonimia de funciones..................................................................................18
2.11. Plantillas de función.........................................................................................20

PRIMERAS EXTENSIONES ORIENTADAS A OBJETOS.............................21
3.1. Cómo poner en práctica un TDA con una clase.............................................21
3.2. Alcance de clase y acceso a miembros de clase...............................................22
3.3. Cómo controlar el acceso a miembros.............................................................23
3.4. Cómo inicializar objetos de clase: constructores............................................24
3.5. Destructores.......................................................................................................25

3.6. Cuándo son llamados los destructores y constructores.................................26
3.7. Asignación por omisión en copia a nivel de miembro....................................26

CLASES....................................................................................................................27
4.1. Objetos constantes y funciones miembro const...............................................27
4.2. Composición: clases como miembros de otras clases.....................................28
4.3. Funciones amigo y clases amigo.......................................................................28
4.4. Cómo utilizar un apuntador this......................................................................29
4.5. Asignación dinámica de memoria mediante new y delete..............................30
4.6. Miembros de clase estáticos..............................................................................30
4.7. Clases contenedor e iteradores.........................................................................30
4.8. Clases plant illa...................................................................................................31
4.9. Clases abstractas................................................................................................32

HOMONIMIA DE OPERADORES......................................................................33
5.1. Fundamentos de la homonimia de operadores...............................................33
5.2. Restricciones sobre la homonimia de operadores..........................................33
5.3. Homonimia de operadores de inserción y de extracción de flujo..................34
5.4. Homonimia de operadores unarios..................................................................34
5.5. Homonimia de operadores binarios.................................................................34
5.6. Estudio de caso: una clase array......................................................................35
5.7. Conversión entre tipos......................................................................................35

6. HERENCIA..............................................................................................................36
6.1. Tipos de here ncia...............................................................................................37
6.2. Clases base públicas, protegidas y privadas....................................................37
6.3. Construcción y destrucción...............................................................................38
6.4. Herencia múltiple..............................................................................................38

7. POLIMORFISMO...................................................................................................39

8. PLANTILLAS PARA LOS NODOS.....................................................................40

9. COMPILAMOS UN PROGRAMA.......................................................................43
9.1. Pasos de la compilación.....................................................................................43

10. FLUJO DE ENTRADA/SALIDA DE C++..........................................................45
10.1. Archivos de cabecera de biblioteca iostream.................................................45
10.2. Funciones miembro get y getline....................................................................45
10.3. Entradas/salidas sin formato utilizando read, gcount y write......................46
10.4. Manipuladores de flujo...................................................................................46

11. EJERCICIOS.........................................................................................................47

12. BIBLIOGR AFIA...................................................................................................59

1. INTRODUCCION

C++ es una mejoría sobre muchas de las características de C, y proporciona
capacidades de P.O.O. que promete mucho para incrementar la productividad, calidad y
reutilización del software.

En C, la unidad de programación es la función, con lo cual, se trata de una
programación orientada a la acción.

En C++, la unidad de programación es la clase a partir de la cual, los objetos son
producidos. Se trata, pues, de una programación orientada al objeto.

Las bibliotecas estándar de C++ proporcionan un conjunto extenso de capacidades de
entrada/salida. C++ usa entradas/salidas de tipo seguro; no podrán introducirse datos
equivocados dentro del sistema.

Se pueden especificar entradas/salidas de tipos definidos por el usuario, así como de
tipos estándar. Esta extensibilidad es una de las características más valiosas de este
lenguaje de programación.

C++ permite un tratamiento común de entradas/salidas de tipos definidos por usuario.
Este tipo de estado común facilita el desarrollo de software en general y de la
reutilización de software en particular.

La salida de flujo puede ser ejecutada mediante el operador de inserción de flujo : <<.
Se hace la homonimia del operador << para extraer elementos de datos de tipos
incorporados, para extraer cadenas y para extraer valores de apuntadores.

Ejemplo:

// Programa que muestra mensaje de bienvenida a C++.
// Salida de una cadena usando inserción de flujo.

# include <iostream.h>
main( )
{
cout <<''¡ Bienvenido a C++! n'';
return 0;
}

Dichos operadores se pueden concatenar.

Todas las palabras claves de C++ están en minúsculas. En C++, las mayúsculas y
minúsculas son diferentes.

A continuación se muestra dos tablas de palabras reservadas en C++ :

C y C++
auto break case char const
continue default do double else
enum extern float for goto
if int long register return
short signed sizeof static struct
switch typedef union unsigned void
volatile while

C++ únicamente
asm Medio definido por la puesta en práctica de lenguaje de ensamble a lo
largo de C++. ( Vea los manuales correspondientes a su sistema).
catch Maneja una excepción generada por un throw.
class Define una nueva clase. Pueden crearse objetos de esta clase.
delete Destruye un objeto de memoria creado con new.
friend Declara una función o una clase que sea un ''amigo'' de otra clase. Los
amigos pueden tener acceso a todos los miembros de datos y a todas las
funciones miembro de una clase.
inline Avisa al compilador que una función particular deberá ser generada en
línea, en vez de requerir de una llamada de función.
new Asigna dinámicamente un objeto de memoria en la memoria adicional
disponible para el programa en tiempo de ejecución. Determina
automáticamente el tamaño del objeto.
operator Declara un operador ''homónimo''.
private Un miembro de clase accesible a funciones miembro y a funciones
friend de la clase de miembros private.
protected Una forma extendida de acceso private; también se puede tener acceso a
los miembros protected por funciones miembro de clases derivadas y
amigos de clases derivadas.
public Un miembro de clase accesible a cualquier función.
template Declara cómo construir una clase o una función, usando una variedad de
tipos.
this Un apuntador declarado en forma implícita en toda función de miembro
no static de una clase. Señala al objeto al cual esta función miembro ha
sido invocada.
throw Transfiere control a un manejador de excepción o termina la ejecución
del programa si no puede ser localizado un manejador apropiado.
try Crea un bloque que contiene un conjunto de números que pudieran
generar excepciones, y habilita el manejo de excepciones para cualquier
excepción generada.
virtual Declara una función virtual.

2. C++ COMO UN ''C MEJORADO''

2.1. COMENTARIOS Y DECLARACIONES EN C++

C++ permite empezar un comentario con // y usar el resto de la línea para texto del
comentario; el fin de la línea da de manera automática por terminado el comentario.
También es aceptable la forma de C : /* */.

En C++, a diferencia de C, las declaraciones pueden ser colocadas en cualquier parte
de un enunciado ejecutable, siempre y cuando las declaraciones antecedan el uso de lo
que se está declarando. También, las variables pueden ser declaradas en la sección de
inicialización de una estructura for; dichas variables se mantienen en alcance hasta el
final del bloque en el cual la estructura for está definida.

El alcance de una variable local C++ empieza en su declaración y se extiende hasta la
llave derecha de cierre. Las declaraciones de variables no pueden ser colocadas en la
condición de una estructura while, do/while, for o if.

2.2. FLUJO DE ENTRADA/SALIDA DE C++

C++ ofrece una alternativa a las llamadas de función printf y scanf para manejar la
entrada/salida de los tipos y cadenas de datos estándar. Así, en lugar de printf usamos el
flujo estándar de salida cout y el operador << (''colocar en''); y en lugar de scanf
usamos el flujo de entrada estándar cin y el operador >> (''obtener de''). Estos
operadores de inserción y extracción de flujo, a diferencia de printf y scanf, no
requieren de cadenas de formato y de especificadores de conversión para indicar los
tipos de datos que son extraídos o introducidos.

Para utilizar entradas/salidas de flujo, se debe incluir el archivo de cabecera
iostream.h.

2.3. COMO CREAR NUEVOS TIPOS DE DATOS EN C++

C++ proporciona la capacidad de crear tipos definidos por el usuario mediante el uso
de las palabras reservadas enum, struct, union y la nueva palabra reservada class. A
diferencia de C, una enumeración ( enum ) en C++, cuando se declara, se convierte en
un tipo nuevo. Para declarar la variable del nuevo tipo, la palabra reservada enum no es
requerida. Lo mismo para struct, union y class. Los nombres de etiqueta pueden ser
utilizados para declarar variables. Las enumeraciones por omisión son evaluadas
iniciándose en cero.

2.4. PROTOTIPOS DE FUNCION Y VERIFICACION DE TIPO

C++ requiere que se declaren todos los parámetros de función en los paréntesis de la
definición de función y del prototipo. Una lista vacía de parámetros se especifica
escribiendo void o absolutamente nada en los paréntesis.

2.5. FUNCIONES EN LINEA

Existen funciones en línea que ayudan a reducir la sobrecarga por llamadas de función
especial para pequeñas funciones. El compilador puede ignorar el calificador inline y
típicamente así lo hará para todo, a excepción de las funciones más pequeñas. El
calificador inline deberá ser utilizado sólo tratándose de funciones pequeñas, de uso
frecuente. Usa funciones inline puede reducir el tiempo de ejecución, pero puede
aumentar el tamaño del programa.

Ejemplo:

// Usamos la función inline para calcular el volumen de un cubo.

#include <iostream.h>

inline float cubo( const float s ) { return s * s * s; }

main( )
{
cout << ''Introduce la longitud del lado de tu cubo: '';
float lado;
cin >> lado;
cout << ''El volumen del cubo de lado ''
<< lado << ''es'' << cubo( lado ) << 'n';

return 0;
}

2.6. PARAMETROS POR REFERENCIA

C++ ofrece parámetros por referencia. Un parámetro de referencia es un seudónimo
(''alias'') de su argumento correspondiente. Para indicar que un parámetro de función es
pasado por referencia, sólo hay que colocar un ampersand (&) después del tipo del
parámetro en el prototipo de función.

Debemos usar apuntadores para pasar argumentos que pudieran ser modificados por la
función llamada, y usar referencias a constantes para pasar argumentos extensos, que no
serán modificados.

Las variables de referencia deben ser inicializadas en sus declaraciones, y no pueden
ser reasignadas como seudónimos a otras variables.

Cuando se regresa un apuntador o una referencia a una variable declarada en la función
llamada, la variable deberá ser declarada static dentro de dicha función.

Las referencias pueden ser usadas como argumentos de funciones y regresar valores.

Ejemplo:

int ix; /* ix es la variable ''real'' */
int &rx = ix; /* rx es el ''alias'' de ix */
ix = 1; /* también rx == 1 */
rx = 2; /* también ix == 2 */

2.7. EL CALIFICADOR CONST

El calificador const se usa en la lista de parámetros de una función para especificar que
un argumento pasado a la función no es modificable en dicha función. También puede
ser utilizado para declarar las llamadas ''variables constantes''. Estas pueden ser
colocadas en cualquier parte en que se espere una expresión constante. También en
archivos de cabecera.

La variable constante debe ser inicializada al declararse.

Otro uso común para el calificador const es para poder declarar un apuntador
constante.

Tabla con expresiones de declaración de constantes:

DECLARACION NOMBRE ES...
const tipo nombre = valor; Tipo constante.

tipo *const nombre = valor; Apuntador constante a tipo.
const tipo *nombre = valor; (Variable) apuntador a la constante
tipo.
const tipo *const nombre = valor; Apuntador constante a tipo
constante.

2.8. ASIGNACION DINAMICA DE MEMORIA MEDIANTE NEW Y DELETE

En C++, el enunciado
ptr = new typeName;
asigna memoria para un objeto del tipo typeName. El operador new crea
automáticamente un objeto del tamaño apropiado, y regresa un apuntador (ptr)del tipo
apropiado. Si mediante new no se puede asignar memoria, se regresa un apuntador nulo.

Para liberar el espacio para este objeto se usa delete ptr;

El operador delete sólo puede ser utilizado para desasignar memoria ya asignada
mediante el operando new.

2.9. OPERADOR DE RESOLUCION DE ALCANCE UNARIO

Es posible declarar variables locales y globales con un mismo nombre. C++ dispone
del operador de resolución de alcance unario ( :: ) para tener acceso a una variable
global cuando está en alcance una variable local con el mismo nombre. No puede ser
utilizado para tener acceso a una variable del mismo nombre en un bloque externo.

Ejemplo:

#include <iostream.h>
float v;
int main( )
{
int v = 7;
::v = 10.5; // Utilizar la variable global v
cout << ''variable local v = '' << v << ''n'';
cout << ''variable global v = '' << ::v << ''n'';
return 0;
}

2.10. HOMONIMIA DE FUNCIONES

C++ permite que sean definidas varias funciones del mismo nombre (sobrecarga de
funciones), siempre que estos nombres indiquen distintos conjuntos de parámetros. Esta
capacidad se llama homonimia de funciones. La homonimia de la función se utiliza por
lo común para crear varias funciones del mismo nombre, que ejecuten tareas similares,
sobre tipos de datos distintos.

Las funciones homónimas deben tener distintas listas de parámetros.

La homonimia ayuda a eliminar el uso de las macros #define de C.

Ejemplo:

// Definimos dos funciones distintas max( ), una que regrese el mayor de
// dos enteros y otra que regrese el mayor de dos strings.

#include <stdio.h>
int max( int a, int b )
{
if ( a > b ) return a;
return b;
}
char *max( char *a, char *b )
{
if ( strcmp (a,b) > 0 ) return a;
return b;
}
int main( )
{
printf ( ''max( 19, 69 ) = %dn'', max( 19, 69 ) );
printf ( ''max( abc,def ) = %sn'', max( ''abc'',''def'' ) );
return 0;
}

El programa del ejemplo define dos funciones que difieren en su lista de parámetros,
de ahí que defina dos funciones distintas.

Las referencias se pueden usar para proveer una función con un alias de un argumento
real de llamada de función. Esto permite cambiar el valor del argumento de llamada de
función tal como se conoce de otros lenguajes de programación de llamada-por-
referencia:

void mira( int porValor, int &porReferencia )
{
porValor = 42;
porReferencia = 42;
}
void mar( )
{
int ix, jx;
ix = jx = 1;
mira( ix, jx );
// ix == 1, jx == 42
}

Manual básico de programación en c++ prev

Más contenido relacionado

La actualidad más candente (7)

Similar a Manual básico de programación en c++ prev (20)

Más de jtk1 (20)

Manual básico de programación en c++ prev