Home
#C++
C++ es un lenguaje de programación diseñado en 1979 por Bjarne Stroustrup. La intención de su creación fue extender al lenguaje de programación C mecanismos que permiten la manipulación de objetos. En ese sentido, desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje híbrido.
Posteriormente se añadieron facilidades de programación genérica, que se sumaron a los paradigmas de programación estructurada y programación orientada a objetos. Por esto se suele decir que el C++ es un lenguaje de programación multiparadigma.
Actualmente existe un estándar, denominado ISO C++, al que se han adherido la mayoría de los fabricantes de compiladores más modernos. Existen también algunos intérpretes, tales como ROOT.
El nombre "C++" fue propuesto por Rick Mascitti en el año 1983, cuando el lenguaje fue utilizado por primera vez fuera de un laboratorio científico. Antes se había usado el nombre "C con clases". En C++, la expresión "C++" significa "incremento de C" y se refiere a que C++ es una extensión de C.
C ++ development environment
- Su sintaxis es heredada del lenguaje C.
- Programa orientado a objetos (POO).
- Permite la agrupación de instrucciones.
- Lenguaje muy didáctico, con este lenguaje puedes aprender muchos otros lenguajes con gran facilidad.
- Es portátil y tiene un gran número de compiladores en diferentes plataformas y sistemas operativos.
- Permite la separación de un programa en módulos que admiten compilación independiente.
- Es un lenguaje de alto nivel.
El siguiente programa lee por teclado un año y calcula y muestra si es bisiesto. Para realizar el cálculo utiliza una función llamada bisiesto. La función bisiesto recibe el año leído por teclado, comprueba si es o no bisiesto y devuelve 1 si lo es ó 0 si no lo es.
#include <iostream>
using namespace std;
int bisiesto(int); //declaración o prototipo de la función
int main()
{
int anio;
cout<<"Introduce a"<<(char)164<<"o: "; //164 ascii de ñ
cin >> anio;
if(bisiesto(anio)) //llamada a la función
cout << "Bisiesto" << endl;
else
cout << "No es bisiesto" << endl;
system("pause");
}
int bisiesto(int a) //definición de la función
{
if(a%4==0 and a%100!=0 or a%400==0)
return 1;
else
return 0;
}
| Types | Description |
|---|---|
char |
Caracteres. |
short, int, long, long long
|
Enteros. |
float, double, long double
|
Números en coma flotante. |
bool |
Booleanos. |
void |
Vacío. |
El modificador unsigned se puede aplicar a enteros para obtener números sin signo (por omisión los enteros contienen signo), con lo que se consigue un rango mayor de números naturales.
Según la máquina y el compilador que se utilice los tipos primitivos pueden ocupar un determinado tamaño en memoria. La siguiente lista ilustra el número de bits que ocupan los distintos tipos primitivos en la arquitectura x86
Otras arquitecturas pueden requerir distintos tamaños de tipos de datos primitivos. C++ no dice nada acerca de cuál es el número de bits en un byte, ni del tamaño de estos tipos; más bien, ofrece solamente las siguientes "garantías de tipos"
Tamaños de tipos primitivos bajo i386 (GCC)
| Types | number of bits |
|---|---|
char |
Caracteres. |
int |
Enteros. |
float |
Números en coma flotante. |
double |
Booleanos. |
Para la versión del estándar que se publicó en 1998, se decidió añadir el tipo de dato wchar_t, que permite el uso de caracteres UNICODE, a diferencia del tradicional char, que contempla simplemente al código de caracteres ASCII extendido. A su vez, se ha definido para la mayoría de las funciones y clases, tanto de C como de C++, una versión para trabajar con wchar_t, donde usualmente se prefija el carácter w al nombre de la función (en ocasiones el carácter es un infijo). Por ejemplo:
strcpy - wstrcpystd::string - std::wstringstd::cout - std::wcout
Cabe resaltar que en C se define wchar_t como:
typedef unsigned short wchar_t;
La palabra reservada void define en C++ el concepto de no existencia o no atribución de un tipo en una variable o declaración. Es decir, una función declarada como void no devolverá ningún valor. Esta palabra reservada también puede usarse para indicar que una función no recibe parámetros, como en la siguiente declaración:
int funcion (void);
Aunque la tendencia actual es la de no colocar la palabra "void". Además se utiliza para determinar que una función no retorna un valor, como en:
void funcion (int parametro);
Cabe destacar que void no es un tipo. Una función como la declarada anteriormente no puede retornar un valor por medio de return: la palabra clave va sola. No es posible una declaración del tipo:
void t; //Está mal
En este sentido, void se comporta de forma ligeramente diferente a como lo hace en C, especialmente en cuanto a su significado en declaraciones y prototipos de funciones. Sin embargo, la forma especial void * indica que el tipo de datos es un puntero. Por ejemplo:
void *memoria;
Indica que memoria es un puntero a alguna parte, donde se guarda información de algún tipo. El programador es responsable de definir estos "algún", eliminando toda ambigüedad. Una ventaja de la declaración "void *" es que puede representar a la vez varios tipos de datos, dependiendo de la operación de cast escogida. La memoria que hemos apuntado en alguna parte, en el ejemplo anterior, bien podría almacenar un entero, un flotante, una cadena de texto o un programa, o combinaciones de estos. Es responsabilidad del programador recordar qué tipo de datos hay y garantizar el acceso adecuado.
Además de los valores que pueden tomar los tipos anteriormente mencionados, existe un valor llamado NULL, sea el caso numérico para los enteros, carácter para el tipo char, cadena de texto para el tipo string, etc. El valor NULL, expresa, por lo regular, la representación de una Macro, asignada al valor "0".
Tenemos entonces que:
void* puntero = NULL;
int entero = NULL;
bool boleana = NULL;
char caracter = NULL;
Todo programa en C++ debe tener la función principal main() (a no ser que se especifique en tiempo de compilación otro punto de entrada, que en realidad es la función que tiene el main())
int main()
{}
La función principal del código fuente main debe tener uno de los siguientes prototipos: int main() int main(int argc, char** argv)
Aunque no es estándar algunas implementaciones permiten int main(int argc, char** argv, char** env)
Los objetos en C++ son abstraídos mediante una clase. Según el paradigma de la programación orientada a objetos un objeto consta de:
- Identidad, que lo diferencia de otros objetos (Nombre que llevará la clase a la que pertenece dicho objeto).
- Métodos o funciones miembro.
- Atributos o variables miembro.
Un ejemplo de clase que podemos tomar es la clase perro. Cada perro comparte unas características (atributos). Su número de patas, el color de su pelaje o su tamaño son algunos de sus atributos. Las funciones que lo hagan ladrar, cambiar su comportamiento... esas son las funciones de la clase.
class Punto
{
//por omisión, los miembros son 'private' para que solo se puedan modificar desde la propia clase.
private:
// Variable miembro privada
int id;
protected:
// Variables miembro protegidas
int x;
int y;
public:
// Constructor
Punto();
// Destructor
~Punto();
// Funciones miembro o métodos
int ObtenerX();
int ObtenerY();
};
Son unos métodos especiales que se ejecutan automáticamente al crear un objeto de la clase. En su declaración no se especifica el tipo de dato que devuelven, y poseen el mismo nombre que la clase a la que pertenecen. Al igual que otros métodos, puede haber varios constructores sobrecargados, aunque no pueden existir constructores virtuales.
Como característica especial a la hora de implementar un constructor, justo después de la declaración de los parámetros, se encuentra lo que se llama "lista de inicializadores". Su objetivo es llamar a los constructores de los atributos que conforman el objeto a construir.
Cabe destacar que no es necesario declarar un constructor al igual que un destructor, pues el compilador lo puede hacer, aunque no es la mejor forma de programar.
Tomando el ejemplo de la Clase Punto, si deseamos que cada vez que se cree un objeto de esta clase las coordenadas del punto sean igual a cero podemos agregar un constructor como se muestra a continuación:
class Punto
{
public:
float x; // Coordenadas del punto
float y;
// Constructor
Punto() : x(0), y(0){ // Inicializamos las variables "x" e "y"
}
};
// Main para demostrar el funcionamiento de la clase
# include <iostream> // Esto nos permite utilizar "cout"
using namespace std;
int main () {
Punto MiPunto; // creamos un elemento de la clase Punto llamado MiPunto
cout << "Coordenada X: " << MiPunto.x << endl; // mostramos el valor acumulado en la variable x
cout << "Coordenada Y: " << MiPunto.y << endl; // mostramos el valor acumulado en la variable y
getchar(); // le indicamos al programa que espere al buffer de entrada (detenerse)
return 0;
}
Si compilamos y ejecutamos el anterior programa, obtenemos una salida que debe ser similar a la siguiente:
Coordenada X: 0 Coordenada Y: 0
Existen varios tipos de constructores en C++:
- Constructor predeterminado. Es el constructor que no recibe ningún parámetro en la función. Si no se definiera ningún constructor, el sistema proporcionaría uno predeterminado. Es necesario para la construcción de estructuras y contenedores de la STL.
- Constructor de copia. Es un constructor que recibe un objeto de la misma clase, y realiza una copia de los atributos del mismo. Al igual que el predeterminado, si no se define, el sistema proporciona uno.
- Constructor de conversión. Este constructor, recibe como único parámetro, un objeto o variable de otro tipo distinto al suyo propio. Es decir, convierte un objeto de un tipo determinado a otro objeto del tipo que estamos generando.
Los destructores son funciones miembro especiales llamadas automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas explícitamente por el programador. Sus principales cometidos son:
- Liberar los recursos computacionales que el objeto de dicha clase haya adquirido en tiempo de ejecución al expirar este.
- Quitar los vínculos que pudiesen tener otros recursos u objetos con este.
Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito en el que está declarado el objeto. El único caso en el que se debe invocar explícitamente al destructor de un objeto, es cuando este fue creado mediante el operador new, es decir, que este vive en memoria heap, y no en la pila de ejecución del programa. La invocación del destructor de un objeto que vive en heap se realiza a través del operador delete o delete[] para arrays. Ejemplo:
int main() {
int *unEntero = new int(12); //asignamos un entero en memoria heap con el valor 12
int *arrayDeEnteros = new int[25]; //asignamos memoria para 25 enteros(no están inicializados)
delete unEntero; //liberamos la memoria que ocupaba unEntero
delete[] arrayDeEnteros; //liberamos la memoria ocupada por arrayDeEnteros
return 0;
}
Si no se utilizara el operador delete y delete[] en ese caso, la memoria ocupada por unEntero y arrayDeEnteros respectivamente, quedaría ocupada sin sentido. Cuando una porción de memoria queda ocupada por una variable que ya no se utiliza, y no hay forma de acceder a ella, se denomina un 'memory leak'. En aplicaciones grandes, si ocurren muchos memory leaks, el programa puede terminar ocupando bastante más memoria RAM de la que debería, lo que no es para nada conveniente. Es por esto, que el manejo de memoria heap debe usarse conscientemente.
Existen dos tipos de destructores pueden ser públicos o privados, según si se declaran:
- Si es público se llama desde cualquier parte del programa para destruir el objeto.
- Si es privado no se permite la destrucción del objeto por el usuario.
Función miembro es aquella que está declarada en ámbito de clase. Son similares a las funciones habituales, con la salvedad de que el compilador realizara el proceso de Decoración de nombre (Name Mangling en inglés): Cambiará el nombre de la función añadiendo un identificador de la clase en la que está declarada, pudiendo incluir caracteres especiales o identificadores numéricos. Este proceso es invisible al programador. Además, las funciones miembro reciben implícitamente un parámetro adicional: El puntero this, que referencia al objeto que ejecuta la función.
Las funciones miembro se invocan accediendo primero al objeto al cual refieren, con la sintaxis: myobject.mymemberfunction(), esto es un claro ejemplo de una función miembro.
Caso especial es el de las funciones miembro estáticas. A pesar de que son declaradas dentro de la clase, con el uso de la palabra clave static no recibirán el puntero this. Gracias a esto no es necesario crear ninguna instancia de la clase para llamar a esta función, sin embargo, solo se podrá acceder a los miembros estáticos de la clase dado que estos no están asociados al objeto sino al tipo. La sintaxis para llamar a esta función estática es _mytype::mystaticmember(). _
Las plantillas son el mecanismo de C++ para implantar el paradigma de la programación genérica. Permiten que una clase o función trabaje con tipos de datos abstractos, especificándose más adelante cuales son los que se quieren usar. Por ejemplo, es posible construir un vector genérico que pueda contener cualquier tipo de estructura de datos. De esta forma se pueden declarar objetos de la clase de este vector que contengan enteros, flotantes, polígonos, figuras, fichas de personal, etc
La declaración de una plantilla se realiza anteponiendo la declaración template <typename A,....> a la declaración de la estructura (clase, estructura o función) desead
template <typename T>
T max(const T &x, const T &y) {
return (x > y) ? x : y; //si x > y, retorna x, sino retorna y
}
La función max() es un ejemplo de programación genérica, y dados dos parámetros de un tipo T (que puede ser int, long, float, double, etc.) devolverá el mayor de ellos (usando el operador >). Al ejecutar la función con parámetros de un cierto tipo, el compilador intentará "calzar" la plantilla a ese tipo de datos, o bien generará un mensaje de error si fracasa en ese proceso.
Existen varios tipos de herencia entre clases en el lenguaje de programación C++. Estos son:
Herencia simple La herencia en C++ es un mecanismo de abstracción creado para poder facilitar y mejorar el diseño de las clases de un programa. Con ella se pueden crear nuevas clases a partir de clases ya hechas, siempre y cuando tengan un tipo de relación especial.
En la herencia, las clases derivadas "heredan" los datos y las funciones miembro de las clases base, pudiendo las clases derivadas redefinir estos comportamientos (polimorfismo) y añadir comportamientos nuevos propios de las clases derivadas. Para no romper el principio de encapsulamiento (ocultar datos cuyo conocimiento no es necesario para el uso de las clases), se proporciona un nuevo modo de visibilidad de los datos/funciones: "protected". Cualquier cosa que tenga visibilidad protected se comportará como pública en la clase Base y en las que componen la jerarquía de herencia, y como privada en las clases que NO sean de la jerarquía de la herencia.
Antes de utilizar la herencia, nos tenemos que hacer una pregunta, y si tiene sentido, podemos intentar usar esta jerarquía: Si la frase ES-UN tiene sentido, entonces estamos ante un posible caso de herencia donde clase A será la clase base y clase B la derivada.
Ejemplo: clases Barco, Acorazado, Carguero, etc. Un Acorazado ES-UN Barco, un Carguero ES-UN Barco, un Trasatlántico ES-UN Barco, etc.
En este ejemplo tendríamos las cosas generales de un Barco (en C++)
class Barco {
protected:
char* nombre;
float peso;
public:
//Constructores y demás funciones básicas de barco
};
y ahora las características de las clases derivadas, podrían (a la vez que heredan las de barco) añadir cosas propias del subtipo de barco que vamos a crear, por ejemplo:
class Carguero: public Barco { // Esta es la manera de especificar que hereda de Barco
private:
float carga;
//El resto de cosas
};
class Acorazado: public Barco {
private:
int numeroArmas;
int Soldados;
// El resto de cosas
};
Herencia múltiple
La herencia múltiple es el mecanismo que permite al programador hacer clases derivadas a partir, no de una sola clase base, sino de varias. Para entender esto mejor, pongamos un ejemplo: Cuando ves a quien te atiende en una tienda, como persona que es, podrás suponer que puede hablar, comer, andar, pero, por otro lado, como empleado que es, también podrás suponer que tiene un jefe, que puede cobrarte dinero por la compra, que puede devolverte el cambio, etc. Si esto lo trasladamos a la programación sería herencia múltiple (clase empleado_tienda):
class Persona {
...
Hablar();
Caminar();
...
};
class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
};
class EmpleadoTienda: public Persona, Empleado {
...
AlmacenarStock();
ComprobarExistencias();
...
};