Los tipos de datos en C++ se clasifican en primitivos y derivados.

Los tipos de datos primitivos son los que estn definidos dentro del lenguaje.
Los tipos de datos derivados se forman a partir de los tipos primitivos.
En este tema veremos los tipos primitivos y en temas siguientes estudiaremos los
tipos derivados.
Los tipos de datos primitivos en C++ son: numricos enteros, numricos reales,
tipo lgico y tipo carcter ampliado.

Tipos de datos C++ numricos enteros

El tipo de dato numrico entero es un subconjunto finito de los nmeros enteros del
mundo real. Pueden ser positivos o negativos.
En C++ los tipos de datos numricos enteros son los siguientes:
Tipo de Dato

Descripcin

Nmero de
bytes tpico

Rango

short

Entero corto

-32768 a 32767

int

Entero

long

Entero largo

char

Carcter

-2147483648
a +2147483647
-2147483648
a +2147483647
-128 a 127

Con los tipos enteros pueden utilizarse los calificadores signed y unsigned.
Estos calificadores indican si el nmero tiene signo o no. Si se usan solos, sin
indicar el tipo de dato se asume int.
Por ejemplo, las siguientes declaraciones son equivalentes:
unsigned int x;
equivale a:
unsigned x;
Usando estos calificadores podemos tener los siguientes tipos enteros:
Tipo de Dato

Descripcin

Nmero de
bytes tpico

Rango

signed short

Entero corto

-32768 a 32767

unsigned short

Entero corto sin

signo

0 a 65535

signed int

Entero

-2147483648 a +2147483647

unsigned int

Entero sin signo

0 a 4294967295

signed long

Entero largo

-2147483648 a +2147483647

unsigned long

Entero largo sin

signo

0 a 4294967295

signed char

Carcter

-128 a 127

unsigned char

Carcter sin signo

0 a 255

Podemos ver que los datos enteros de tipo signed son equivalentes a los enteros sin
utilizar el calificador:
signed int a;

es equivalente a escribir

int a;

Tipos de datos numricos reales

El tipo de dato numrico real es un subconjunto finito de los nmeros reales.
Pueden ser positivos o negativos.
En C++ los tipos de datos numricos reales son los siguientes:
Tipo de
Dato
float
double

Descripcin
Real (Nmero en
coma flotante)
Real doble(Nmero
en coma flotante de
doble precisin)

long
double

Real doble largo

Nmero de
bytes tpico

Rango

Positivos: 3.4E-38 a 3.4E38

Negativos: -3.4E-38 a -3.4E38

Positivos: 1.7E-308 a 1.7E308

Negativos: -1.7E-308 a -1.7E308

10

Positivos: 3.4E-4932 a 1.1E4932

Negativos: -3.4E-4932 a -1.1E4932

Tipo lgico
Los datos de este tipo slo pueden contener dos valores: true false (verdadero
falso).
Si se muestran como enteros, el valor true toma el valor 1 y false el valor 0.
Tipo de
Dato

Descripcin

Nmero de
bytes tpico

Rango

bool

Dato de tipo lgico

0, 1

Tipo carcter extendido

Este tipo se utiliza para representar caracteres UNICODE. Utiliza 2 bytes a
diferencia del tipo char que solo utiliza 1.
Tipo de
Dato

Descripcin

Nmero de
bytes tpico

Rango

wchar_t

Carcter Unicode

0 a 65535

C++ es un lenguaje de programacin diseado a mediados de los aos 1980 por Bjarne
Stroustrup. La intencin de su creacin fue el extender al lenguaje de
programacin C mecanismos que permiten la manipulacin de objetos. En ese sentido,
desde el punto de vista de los lenguajes orientados a objetos, el C++ es un lenguaje
hbrido.
Posteriormente se aadieron facilidades de programacin genrica, que se sumaron a los
paradigmas de programacin estructurada y programacin orientada a objetos. Por esto se
suele decir que el C++ es un lenguaje de programacin multiparadigma.
Actualmente existe un estndar, denominado ISO C++, al que se han adherido la mayora
de los fabricantes de compiladores ms modernos. Existen tambin algunos intrpretes,
tales como ROOT.
Una particularidad del C++ es la posibilidad de redefinir los operadores, y de poder crear
nuevos tipos que se comporten como tipos fundamentales.
El nombre C++ fue propuesto por Rick Mascitti en el ao 1983, cuando el lenguaje fue
utilizado por primera vez fuera de un laboratorio cientfico. Antes se haba usado el nombre
"C con clases". En C++, la expresin "C++" significa "incremento de C" y se refiere a que
C++ es una extensin de C.

ndice

1Ejemplos

2Tipos de datos
o

2.1Tamaos asociados

2.2Wchar_t

2.3La palabra reservada "void"

2.4La palabra "NULL"

3Principios

4El concepto de clase

o

4.1Constructores

4.2Destructores

4.3Funciones miembro

4.4EJEMPLOS

4.4.1Especializacin

4.5Clases o tipos

4.6Espacios de nombres

4.7Herencia

4.7.1Herencia simple

4.7.2Herencia mltiple
4.8Sobrecarga de operadores

5Standard Template Library (STL)

6Biblioteca de entrada y salida

o

6.1Fstreams

6.2Sstreams

6.3Contenedores

6.4Iteradores

6.5Algoritmos

7C++11

8Actualidad y futuro

9Diferencias de tipos respecto a C

10Compiladores

11Ejemplo: Cmd con colores

11.1Uso

12Entornos de desarrollo
o

12.1Bajo Microsoft Windows

12.2Bajo MacOS

12.3Bajo DOS

12.4Bajo GNU/Linux

13Vase tambin

14Referencias
14.1Bibliografa

15Enlaces externos

Ejemplos[editar]
A continuacin se cita un programa de ejemplo Hola mundo escrito en C++:
/* Esta cabecera permite usar los objetos que encapsulan los
descriptores stdout
y stdin: cout(<<) y cin(>>)*/
#include <iostream>
using namespace std;
int main()
{
cout << "Hola mundo" << endl;
cin.get();
return 0;

Al usar la directiva #include se le dice al compilador que busque e interprete todos los
elementos definidos en el archivo que acompaa la directiva (en este caso, iostream ).
Para evitar sobrescribir los elementos ya definidos al ponerles igual nombre, se crearon los
espacios de nombres o namespace del singular en ingls. En este caso hay un espacio
de nombres llamado std , que es donde se incluyen las definiciones de todas las
funciones y clases que conforman la biblioteca estndar de C++. Al incluir la
sentencia using namespace std le estamos diciendo al compilador que usaremos el
espacio de nombres std por lo que no tendremos que incluirlo cuando usemos elementos
de este espacio de nombres, como pueden ser los objetos cout y cin , que representan
el flujo de salida estndar (tpicamente la pantalla o una ventana de texto) y el flujo de
entrada estndar (tpicamente el teclado).
La definicin de funciones es igual que en C, salvo por la caracterstica de que si main no
va a recoger argumentos, no tenemos por qu ponrselos, a diferencia de C, donde haba
que ponerlos explcitamente, aunque no se fueran a usar. Queda solo comentar que el
smbolo << se conoce como operador de insercin, y grosso modo est enviando
a cout lo que queremos mostrar por pantalla para que lo pinte, en este caso la
cadena "Hola mundo" . El mismo operador << se puede usar varias veces en la misma
sentencia, de forma que gracias a esta caracterstica podremos concatenar el
objeto endl al final, cuyo resultado ser imprimir un retorno de lnea.
Por ltimo tomaremos una secuencia de caracteres del teclado hasta el retorno de lnea
(presionando ENTER), llamando al mtodo get del objeto cin .

Tipos de datos[editar]
C++ tiene los siguientes tipos fundamentales:

Caracteres: char (tambin es un entero), wchar_t

Enteros: short , int , long , long long

Nmeros en coma flotante: float , double , long double

Booleanos: bool

Vaco: void

El modificador unsigned se puede aplicar a enteros para obtener nmeros sin signo (por
omisin los enteros contienen signo), con lo que se consigue un rango mayor de nmeros
naturales.

Tamaos asociados[editar]

Tamaos de tipos primitivos bajo i386 (GCC)

Nmero de Bits
8

Tipo
char
short

16

int

32

float

32

64
Segn la mquina y el compilador que se utilice los tipos primitivos pueden ocupar un
determinado tamao en memoria. La siguiente lista ilustra el nmero de bits que ocupan
los distintos tipos primitivos en la arquitectura x86.
double

Otras arquitecturas pueden requerir distintos tamaos de tipos de datos primitivos. C++ no
dice nada acerca de cul es el nmero de bits en un byte, ni del tamao de estos tipos;
ms bien, ofrece solamente las siguientes "garantas de tipos":

De acuerdo al estndar C99, un tipo char debe ocupar exactamente

un byte compuesto de un mnimo de 8 bits independientemente de la arquitectura de la
mquina.

El tamao reconocido de char es de 1. Es decir, sizeof(char) siempre

devuelve 1.

Un tipo short tiene al menos el mismo tamao que un tipo char .

Un tipo long tiene al menos el doble tamao en bytes que un tipo short .

Un tipo int tiene un tamao entre el de short y el de long , ambos inclusive,

preferentemente el tamao de un apuntador de memoria de la mquina. Su valor
mximo es 2147488281, usando 32 bits.
Un tipo unsigned tiene el mismo tamao que su versin signed .

Wchar_t[editar]
Para la versin del estndar que se public en 1998, se decidi aadir el tipo de
dato wchar_t , que permite el uso de caracteres UNICODE, a diferencia del
tradicional char , que contempla simplemente al cdigo de caracteres ASCII extendido. A
su vez, se ha definido para la mayora de las funciones y clases, tanto de C como de C++,
una versin para trabajar con wchar_t , donde usualmente se prefija el carcter w al
nombre de la funcin (en ocasiones el carcter es un infijo). Por ejemplo:

strcpy - wstrcpy

std::string - std::wstring

std::cout - std::wcout

Cabe resaltar que en C se define wchar_t como:

typedef unsigned short wchar_t;

Mientras que en C++ es en s mismo un tipo de dato.

La palabra reservada "void"[editar]

La palabra reservada void define en C++ el concepto de no existencia o no atribucin de

un tipo en una variable o declaracin. Es decir, una funcin declarada como void no
devolver ningn valor. Esta palabra reservada tambin puede usarse para indicar que una
funcin no recibe parmetros, como en la siguiente declaracin:
int funcion (void);

Aunque la tendencia actual es la de no colocar la palabra "void".

Adems se utiliza para determinar que una funcin no retorna un valor, como en:
void funcion (int parametro);

Cabe destacar que void no es un tipo. Una funcin como la declarada anteriormente no
puede retornar un valor por medio de return: la palabra clave va sola. No es posible una
declaracin 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 informacin de algn
tipo. El programador es responsable de definir estos "algn", eliminando toda ambigedad.
Una ventaja de la declaracin "void *" es que puede representar a la vez varios tipos de
datos, dependiendo de la operacin de cast escogida. La memoria que hemos apuntado
en alguna parte, en el ejemplo anterior, bien podra almacenar un entero, un flotante, una
cadena de texto o un programa, o combinaciones de stos. Es responsabilidad del
programador recordar qu tipo de datos hay y garantizar el acceso adecuado.

La palabra "NULL"[editar]
Adems de los valores que pueden tomar los tipos anteriormente mencionados, existe un
valor llamado NULL, sea el caso numrico para los enteros, carcter para el tipo char,
cadena de texto para el tipo string, etc. El valor NULL, expresa, por lo regular, la
representacin de una Macro, asignada al valor "0".
Tenemos entonces que:
void* puntero = NULL;
int entero = NULL;
bool boleana = NULL;
char caracter = NULL;

El valor de las variables anteriores nos dara 0. A diferencia de la variable "caracter", que
nos dara el equivalente a NULL, '\0', para caracteres.

Principios[editar]
Todo programa en C++ debe tener la funcin principal main() (a no ser que se
especifique en tiempo de compilacin otro punto de entrada, que en realidad es la funcin
que tiene el main() )
int main()
{}

La funcin principal del cdigo fuente main debe tener uno de los siguientes prototipos:
int main()
int main(int argc, char** argv)
Aunque no es estndar algunas implementaciones permiten
int main(int argc, char** argv, char** env)
La primera es la forma por omisin de un programa que no recibe parmetros ni
argumentos. La segunda forma tiene dos parmetros: argc, un nmero que describe el
nmero de argumentos del programa (incluyendo el nombre del programa mismo), y argv,
un puntero a un array de punteros, de argc elementos, donde el
elemento argv[i]representa el i-simo argumento entregado al programa. En el tercer
caso se aade la posibilidad de poder acceder a las variables de entorno de ejecucin de
la misma forma que se accede a los argumentos del programa, pero reflejados sobre la
variable env.
El tipo de retorno de main es un valor entero int. Al finalizar la funcin main , debe
incluirse el valor de retorno (por ejemplo, return 0;, aunque el estndar prev solamente
dos posibles valores de retorno: EXIT_SUCCESS y EXIT_FAILURE, definidas en el
archivo cstdlib), o salir por medio de la funcin exit. Alternativamente puede dejarse en
blanco, en cuyo caso el compilador es responsable de agregar la salida adecuada.

El concepto de clase[editar]
Vase tambin: Clase (informtica)

Los objetos en C++ son abstrados mediante una clase. Segn el paradigma de la
programacin orientada a objetos un objeto consta de:
1. Identidad, que lo diferencia de otros objetos (Nombre que llevar la clase a la que
pertenece dicho objeto).
2. Mtodos o funciones miembro
3. Atributos o variables miembro
Un ejemplo de clase que podemos tomar es la clase perro. Cada perro comparte unas
caractersticas (atributos). Su nmero de patas, el color de su pelaje o su tamao son
algunos de sus atributos. Las funciones que lo hagan ladrar, cambiar su comportamiento...
esas son las funciones de la clase.
Este es otro ejemplo de una clase:
class Punto
{

//por omisin, los miembros son 'private' para que slo 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 mtodos
int ObtenerX();
int ObtenerY();
};

Constructores[editar]
Vase tambin: Constructor (informtica)

Son unos mtodos especiales que se ejecutan automticamente al crear un objeto de la

clase. En su declaracin 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 mtodos, puede haber
varios constructores sobrecargados, aunque no pueden existir constructores virtuales.
Como caracterstica especial a la hora de implementar un constructor, justo despus de la
declaracin de los parmetros, 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 continuacin:
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++:
1. Constructor predeterminado. Es el constructor que no recibe ningn parmetro
en la funcin. Si no se definiera ningn constructor, el sistema proporcionara uno
predeterminado. Es necesario para la construccin de estructuras y contenedores
de la STL.
2. 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.
3. Constructor de conversin. Este constructor, recibe como nico parmetro, 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.
Constructores + Memoria heap Un objeto creado de la forma que se vio hasta ahora, es
un objeto que vive dentro del scope(las llaves { }) en el que fue creado. Para que un objeto
pueda seguir viviendo cuando se saque de el scope en el que se cre, se lo debe crear en
memoria heap. Para esto, se utiliza el operador new, el cual asigna memoria para
almacenar al objeto creado, y adems llama a su constructor(por lo que se le pueden
enviar parmetros). El operador new se utiliza de la siguiente manera:
int main() {

Punto *unPunto = new Punto(); //esto llama al constructor que se

describe ms arriba
delete unPunto;

//no hay que olvidarse de liberar la

memoria ocupada por el objeto(ver la seccin destructores, ms abajo)

return 0;
}

Adems, con el operador new[] se pueden crear arrays (colecciones o listas ordenadas) de
tamao dinmico:
Punto *asignar(int cuantos) {
return new Punto[cuantos]; //asigna un array de 'cuantos' puntos(se
llama el constructor que se muestra ms arriba), y se retorna.
}

Destructores[editar]
Vase tambin: Destructor (informtica)

Los destructores son funciones miembro especiales llamadas automticamente en la

ejecucin del programa, y por tanto no tienen por qu ser llamadas explcitamente por
el programador. Sus principales cometidos son:

Liberar los recursos computacionales que el objeto de dicha clase haya adquirido
en tiempo de ejecucin al expirar ste.
Quitar los vnculos que pudiesen tener otros recursos u objetos con ste.

Los destructores son invocados automticamente al alcanzar el flujo del programa el fin del
mbito en el que est declarado el objeto. El nico caso en el que se debeinvocar
explcitamente al destructor de un objeto, es cuando ste fue creado mediante el
operador new, es decir, que ste vive en memoria heap, y no en la pila de ejecucin del
programa. La invocacin del destructor de un objeto que vive en heap se realiza a travs
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 estn inicializados)
delete unEntero;

//liberamos la memoria que

ocupaba unEntero
delete[] arrayDeEnteros;
por arrayDeEnteros
return 0;
}

//liberamos la memoria ocupada

Si no se utilizara el operador delete y delete[] en ese caso, la memoria ocupada por

unEntero y arrayDeEnteros respectivamente, quedara ocupada sin sentido. Cuando una
porcin 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 ms memoria
RAM de la que debera, 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 pblicos o privados, segn si se declaran:

Si es pblico se llama desde cualquier parte del programa para destruir el objeto.

Si es privado no se permite la destruccin del objeto por el usuario.

El uso de destructores es clave en el concepto de Adquirir Recursos es Inicializar.

Funciones miembro[editar]
Funcin 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
deDecoracin de nombre (Name Mangling en ingls): Cambiar el nombre de la funcin
aadiendo un identificador de la clase en la que est declarada, pudiendo incluir
caracteres especiales o identificadores numricos. Este proceso es invisible al
programador. Adems, las funciones miembro reciben implcitamente un parmetro
adicional: El puntero this, que referencia al objeto que ejecuta la funcin.
Las funciones miembro se invocan accediendo primero al objeto al cual refieren, con la
sintaxis: myobject.mymemberfunction(), esto es un claro ejemplo de una funcin
miembro.
Caso especial es el de las funciones miembro estticas. A pesar de que son declaradas
dentro de la clase, con el uso de la palabra clave static no recibirn el puntero this.
Gracias a esto no es necesario crear ninguna instancia de la clase para llamar a esta
funcin, sin embargo, slo se podr acceder a los miembros estticos de la clase dado que
estos no estn asociados al objeto sino al tipo. La sintaxis para llamar a esta funcin
esttica es mytype::mystaticmember().

EJEMPLOS[editar]
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 funcin max() es un ejemplo de programacin genrica, y dados dos parmetros de un

tipo T (que puede ser int, long, float, double, etc.) devolver el mayor de ellos
(usando el operador >). Al ejecutar la funcin con parmetros 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.
Especializacin[editar]

Clases o tipos[editar]
En C++ es posible definir clases abstractas. Una clase abstracta, o clase base abstracta
(ABC), es una que est diseada slo como clase padre de las cuales se deben derivar
clases hijas. Una clase abstracta se usa para representar aquellas entidades o mtodos
que despus se implementarn en las clases derivadas, pero la clase abstracta en s no

contiene ninguna implementacin -- solamente representa los mtodos que se deben

implementar. Por ello, no es posible instanciar una clase abstracta, pero s una clase
concreta que implemente los mtodos definidos en ella.
Las clases abstractas son tiles para definir interfaces, es decir, un conjunto de mtodos
que definen el comportamiento de un mdulo determinado. Estas definiciones pueden
utilizarse sin tener en cuenta la implementacin que se har de ellos.
En C++ los mtodos de las clases abstractas se definen como funciones virtuales puras.
class Abstracta
{
public:
virtual int metodo() = 0;
}
class ConcretaA : public Abstracta
{
public:
int metodo()
{
//haz algo
return foo () + 2;
}
};
class ConcretaB : public Abstracta
{
public:
int metodo()
{
//otra implementacin
return baz () - 5;
}
};

En el ejemplo, la clase ConcretaA es una implementacin de la clase Abstracta, y la

clase ConcretaB es otra implementacin. Debe notarse que el = 0 es la notacin que
emplea C++ para definir funciones virtuales puras.

Espacios de nombres[editar]
Una adicin a las caractersticas de C son los espacios de nombre (namespace en
ingls), los cuales pueden describirse como reas virtuales bajo las cuales ciertos nombres
de variable o tipos tienen validez. Esto permite evitar las ocurrencias de conflictos entre
nombres de funciones, variables o clases.
El ejemplo ms conocido en C++ es el espacio de nombres std::, el cual almacena todas
las definiciones nuevas en C++ que difieren de C (algunas estructuras y funciones), as
como las funcionalidades propias de C++ (streams) y los componentes de la biblioteca
STL.

Por ejemplo:
# include <iostream>
// Las funciones en esta cabecera existen dentro del espacio de
nombres std::
namespace mi_paquete{
int mi_valor;
};
int main()
{
int mi_valor = 3;
mi_paquete::mi_valor = 4;
std::cout << mi_valor << '\n'; // imprime '3'
std::cout << mi_paquete::mi_valor << '\n'; // imprime '4'
return 0;
}

Como puede verse, las invocaciones directas a mi_valor darn acceso solamente a la
variable descrita localmente; para acceder a la variable del espacio de
nombresmi_paquete es necesario acceder especficamente el espacio de nombres. Un
atajo recomendado para programas sencillos es la directiva using namespace, que
permite acceder a los nombres de variables del paquete deseado en forma directa,
siempre y cuando no se produzca alguna ambigedad o conflicto de nombres.

Herencia[editar]
Existen varios tipos de herencia entre clases en el lenguaje de programacin C++. Estos
son:
Herencia simple[editar]
La herencia en C++ es un mecanismo de abstraccin creado para poder facilitar y mejorar
el diseo 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 relacin 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 aadir 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 pblica en
la clase Base y en las que componen la jerarqua de herencia, y como privada en las
clases que NO sean de la jerarqua de la herencia.
Antes de utilizar la herencia, nos tenemos que hacer una pregunta, y si tiene sentido,
podemos intentar usar esta jerarqua: Si la frase <claseB> ES-UN <claseA> 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 Trasatlntico ES-UN Barco, etc.
En este ejemplo tendramos las cosas generales de un Barco (en C++)
class Barco {
protected:
char* nombre;
float peso;
public:
//Constructores y dems funciones bsicas de barco
};

y ahora las caractersticas de las clases derivadas, podran (a la vez que heredan las de
barco) aadir 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
};

Por ltimo, hay que mencionar que existen 3 clases de herencia que se diferencian en el
modo de manejar la visibilidad de los componentes de la clase resultante:

Herencia pblica (class Derivada: public Base ): Con este tipo de herencia se
respetan los comportamientos originales de las visibilidades de la clase Base en la
clase Derivada.

Herencia privada (clase Derivada: private Base): Con este tipo de herencia todo
componente de la clase Base, ser privado en la clase Derivada (las propiedades
heredadas sern privadas aunque estas sean pblicas en la clase Base)

Herencia protegida (clase Derivada: protected Base): Con este tipo de herencia,
todo componente pblico y protegido de la clase Base, ser protegido en la clase
Derivada, y los componentes privados, siguen siendo privados.

Herencia mltiple[editar]
La herencia mltiple 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, podrs

suponer que puede hablar, comer, andar, pero, por otro lado, como empleado que es,
tambin podrs suponer que tiene un jefe, que puede cobrarte dinero por la compra, que
puede devolverte el cambio, etc. Si esto lo trasladamos a la programacin sera herencia
mltiple (clase empleado_tienda):
class Persona {
...
Hablar();
Caminar();
...
};
class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
};
class EmpleadoTienda: public Persona, Empleado {
...
AlmacenarStock();
ComprobarExistencias();
...
};

Por tanto, es posible utilizar ms de una clase para que otra herede sus caractersticas.

Sobrecarga de operadores[editar]
La sobrecarga de operadores es una forma de hacer polimorfismo. Es posible definir el
comportamiento de un operador del lenguaje para que trabaje con tipos de datos definidos
por el usuario. No todos los operadores de C++ son factibles de sobrecargar, y, entre
aquellos que pueden ser sobrecargados, se deben cumplir condiciones especiales. En
particular, los operadores sizeof y :: no son sobrecargables.
No es posible en C++ crear un operador nuevo.
Los comportamientos de los operadores sobrecargados se implementan de la misma
manera que una funcin, salvo que esta tendr un nombre especial: Tipo de dato de
devolucin operator<token del operador>(parmetros)
Los siguientes operadores pueden ser sobrecargados:

Operadores Unarios

Operador * (de indireccin)

Operador -> (de indireccin)

Operador & (de direccin)

Operador +

Operador -

Operador ++

Operador --

Operadores Binarios

Operador ==

Operador +

Operador -

Operador *

Operador /

Operador %

Operador <<

Operador >>

Operador &

Operador ^

Operador |

Operador []

Operador ()

Operadores de Asignacin

Operador =

Operador +=

Operador -=

Operador *=

Operador /=

Operador %=

Operador <<=

Operador >>=

Operador &=

Operador ^=

Operador |=

Dado que estos operadores son definidos para un tipo de datos definido por el usuario,
ste es libre de asignarles cualquiera semntica que desee. Sin embargo, se considera de
primera importancia que las semnticas sean tan parecidas al comportamiento natural de
los operadores como para que el uso de los operadores sobrecargados sea intuitivo. Por
ejemplo, el uso del operador unario - debiera cambiar el "signo" de un "valor".
Los operadores sobrecargados no dejan de ser funciones, por lo que pueden devolver un
valor, si este valor es del tipo de datos con el que trabaja el operador, permite el
encadenamiento de sentencias. Por ejemplo, si tenemos 3 variables A, B y C de un tipo T y
sobrecargamos el operador = para que trabaje con el tipo de datos T, hay dos opciones: si
el operador no devuelve nada una sentencia como "A=B=C;" (sin las comillas) dara error,
pero si se devuelve un tipo de datos T al implementar el operador, permitira concatenar
cuantos elementos se quisieran, permitiendo algo como "A=B=C=D=...;"

Standard Template Library (STL)[editar]

Artculo principal: Standard Template Library

Los lenguajes de programacin suelen tener una serie de bibliotecas de funciones

integradas para la manipulacin de datos a nivel ms bsico. En C++, adems de poder
usar las bibliotecas de C, se puede usar la nativa STL (Standard Template Library), propia
del lenguaje. Proporciona una serie plantillas (templates) que permiten efectuar
operaciones sobre el almacenado de datos, procesado de entrada/salida.

Biblioteca de entrada y salida[editar]

Las clases basic_ostream y basic_stream, y los objetos cout y cin, proporcionan la
entrada y salida estndar de datos (teclado/pantalla). Tambin est disponible cerr, similar
a cout, usado para la salida estndar de errores. Estas clases tienen sobrecargados los
operadores << y >>, respectivamente, con el objeto de ser tiles en la insercin/extraccin
de datos a dichos flujos. Son operadores inteligentes, ya que son capaces de adaptarse al
tipo de datos que reciben, aunque tendremos que definir el comportamiento de dicha
entrada/salida para clases/tipos de datos definidos por el usuario. Por ejemplo:
ostream& operator<<(ostream& fs, const Punto& punto)
{
return fs << punto.x << "," << punto.y;
}

De esta forma, para mostrar un punto, solo habra que realizar la siguiente expresin:
//...
Punto p(4,5);

//...
cout << "Las coordenadas son: " << p << endl;
//...

Es posible formatear la entrada/salida, indicando el nmero de dgitos decimales a mostrar,

si los textos se pasarn a minsculas o maysculas, si los nmeros recibidos estn en
formato octal o hexadecimal, etc.

Fstreams[editar]
Tipo de flujo para el manejo de ficheros. La definicin previa de ostreams/istreams es
aplicable a este apartado. Existen tres clases (ficheros de lectura, de escritura o de
lectura/escritura): ifstream,ofstream y fstream.
Como abrir un fichero: (nombre_variable_fichero).open("nombre_fichero.dat/txt", ios::in);
para abrirlo en modo lectura. (nombrevariablefichero).open("nombre_fichero.dat/txt",
ios::out); para abrirlo en modo escritura.
Ejemplo: f.open("datos.txt", ios::in);
Como cerrar el fichero: nombre_variable_fichero.close();
Ejemplo: f.close();
Leer un fichero:
1-Si es fichero de texto plano:
#include <fstream>
#include <string>
#include <iostream>
using namespace std;
int main() {
ifstream entrada;
entrada.open("textoPlano.txt");
string unString;
while(entrada >> unString)
cout << "Lei: " << unString << endl;
return 0;
}

2-Si es un fichero binario(.dat);

nombre_variable_fichero.read((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.read((char*)&e, sizeof(int));
Escribir un fichero:

1-Si es fichero de texto(.txt):

nombrevariable<<"texto"; donde "texto" puede ser tambin una
variable de cualquier tipo primitivo, o un string.
Ejemplo: f<<HOLA;
2-Si es un fichero binario(.dat);
nombre_variable_fichero.write((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.write((char*)&e, sizeof(int));
Pueden abrirse pasando al constructor los parmetros relativos a la ubicacin del fichero y
el modo de apertura:

Sstreams[editar]
Se destacan dos clases, ostringstream e istringstream. Todo lo anteriormente dicho es
aplicable a estas clases. Tratan a una cadena como si de un flujo de datos se tratase.
ostringstream permite elaborar una cadena de texto insertando datos cual flujo, e
istringstream puede extraer la informacin contenida en una cadena (pasada como
parmetro en su constructor) con el operador >> . Ejemplos:
ostringstream s;
s << nombre << "," << edad << "," << estatura << "," << punto(5,6) <<
endl;
cout << s.str();
istringstream s(cadena);
s >> nombre >> edad >> estatura >> p;

Contenedores[editar]
Son clases plantillas especiales utilizadas para almacenar tipos de datos genricos, sean
cuales sean. Todos los contenedores son homogneos, es decir, una vez que se declaran
para contener un tipo de dato determinado, en ese contenedor, solo se podrn meter
elementos de ese tipo. Segn la naturaleza del almacenado, disponemos de varios tipos:

Vectores: Se definen por

vector<tipo_de_dato> nombre_del_vector;

Son arrays (o listas ordenadas) que se redimensionan automticamente al agregar

nuevos elementos, por lo que se le pueden agregar "tericamente", infinitos
elementos. Los vectores nos permiten acceder a cualquier elemento que contenga,
mediante el operador[]. Debe tenerse en cuenta que si se intenta acceder a una
posicin que excede los lmites del vector, este no har ningn chequeo, por lo que se
debe ser cuidadoso al utilizar este operador. Para asegurar un acceso seguro al
vector, se puede utilizar el mtodo at(int), que lanza una excepcin de tipo
std::out_of_range en caso de que esto ocurra.

Para aadir elementos al final del vector, se utiliza el mtodo push_back(const T&). Por
otro lado, para eliminar un elemento del final del vector, se debe usar el mtodo
pop_back().
#include <vector> //librera que contiene a la clase vector
#include <iostream>
using namespace std;
int main() {
vector<int> intVector;

//crea un vector de enteros(sin elementos)

intVector.push_back(25); //agrega el entero 25 al vector

cout << "El primer elemento es: " << intVector.front() <<
" y mi vector tiene " << intVector.size() << " elementos." <<
endl; //imprime el primer elemento(retornado por el mtodo front()
intVector.push_back(32); //agrego el entero 32 al vector
cout << "El primer elemento es: " << intVector[0] << endl; //imprime
25
intVector.pop_back();

//elimina el ltimo elemento del

vector(osea 32)
cout << "Ahora tengo: " << intVector.size() << " elementos." <<
endl; //imprimir 1
return 0;
}

Colas dobles: son parecidas a los vectores, pero tienen mejor eficiencia para
agregar o eliminar elementos en las "puntas".
deque<tipo_de_dato> nombre_de_la_cola;

Adems de los mtodos push_back(const T&) y pop_back(), se agregan los mtodos

push_front(const T&) y pop_front(), que realizan lo mismo que los ya explicados, pero en el
comienzo de la cola.
#include <deque> //librera de deques
using namespace std;
int main() {
deque<int> intDeque;
intDeque.push_front(25);
intDeque.push_back(12);
while(intDeque.size())

intDeque.pop_back(); //borra todos los elementos

return 0;
}

Listas: Son eficientes a la hora de agregar elementos. La diferencia con las colas
dobles, es que son ms eficientes para eliminar elementos que no estn en alguna de
las "puntas"

list<tipo_de_dato> nombre_de_la_lista;

Adaptadores de secuencia.

Contenedores asociativos: map y multimap, que permiten asociar una "clave" con
un "valor". map no permite valores repetidos, mientras que multimap si.

map<tipo_de_llave, tipo_de_dato> nombre_del_map;

multimap<tipo_de_llave, tipo_de_dato> nombre_del_multimap;
#include <map> //librera que contiene a map y multimap
#include <string> //librera de strings
#include <iostream> //librera de entrada/salida
using namespace std;
int main() {
map<int, string> intAString;
intAString[1] = "uno";
intAString[10] = "diez";
cout << "En intAString[1]: " << intAString[1] << endl;
cout << "En intAString[10]: " << intAString[10] << endl;
return 0;
}

Contenedores asociativos: set y multiset, que ofrecen solamente la condicin de

"pertenencia", sin la necesidad de garantizar un ordenamiento particular de los
elementos que contienen.

Iteradores[editar]
Pueden considerarse como una generalizacin de la clase de "puntero". Un iterador es un
tipo de dato que permite el recorrido y la bsqueda de elementos en los contenedores.
Como las estructuras de datos (contenedores) son clases genricas, y los operadores
(algoritmos) que deben operar sobre ellas son tambin genricos (funciones genricas),
Stepanov y sus colaboradores tuvieron que desarrollar el concepto de iterador como
elemento o nexo de conexin entre ambos. El nuevo concepto resulta ser una especie de
punteros que sealan a los diversos miembros del contenedor (punteros genricos que
como tales no existen en el lenguaje).

Algoritmos[editar]
Combinando la utilizacin de templates y un estilo especfico para denotar tipos y
variables, la STL ofrece una serie de funciones que representan operaciones comunes, y
cuyo objetivo es "parametrizar" las operaciones en que estas funciones se ven
involucradas de modo que su lectura, comprensin y mantenimiento, sean ms fciles de
realizar.
Un ejemplo es la funcin copy, la cual simplemente copia variables desde un lugar a otro.
Ms estrictamente, copia los contenidos cuyas ubicaciones estn delimitadas por dos
iteradores, al espacio indicado por un tercer iterador. La sintaxis es:
copy (inicio_origen, fin_origen, inicio_destino);
De este modo, todos los datos que estn entre inicio_origen y fin_origen, excluyendo el
dato ubicado en este ltimo, son copiados a un lugar descrito o apuntado por
inicio_destino.
Un algoritmo muy importante que viene implementado en la biblioteca STL, es el sort. El
algoritmo sort, ordena cualquier tipo de contenedor, siempre y cuando se le pasen como
argumentos, desde donde y hasta donde se quiere ordenarlo.
#include <vector>
#include <deque>
#include <algorithm>
int main() {
vector<int> intVector;
intVector.push_back(60);
intVector.push_back(12);
intVector.push_back(54); //para este momento, el vector tiene
60,12,54
sort(intVector.begin(), intVector.end()); //listo, array ordenado,
ahora tiene 12,54,60
/*Notar que si en vez de un vector, fuese una deque, se ordenara de
la misma manera. */
}

Entre las funciones ms conocidas estn swap (variable1, variable2), que

simplemente intercambia los valores de variable1 y variable2; max (variable1,
variable2) y su smilmin (variable1, variable2), que retornan el mximo o mnimo
entre dos valores; find (inicio, fin, valor) que busca valor en el espacio de
variables entre inicio y fin; etctera.
Los algoritmos son muy variados, algunos incluso tienen versiones especficas para operar
con ciertos iteradores o contenedores, y proveen un nivel de abstraccin extra que permite
obtener un cdigo ms "limpio", que "describe" lo que se est haciendo, en vez de hacerlo
paso a paso explcitamente.

C++11[editar]
Artculo principal: C++11

El 12 de agosto de 2011, Herb Sutter, presidente del comit de estndares de C++,

inform la aprobacin unnime del nuevo estndar.2 La publicacin del mismo se realiz
en algn momento del 2011.
Entre las caractersticas del nuevo estndar se pueden destacar:

Funciones lambda;

Referencias rvalue;

La palabra reservada auto;

Inicializacin uniforme;

Plantillas con nmero variable de argumentos.

Adems se ha actualizado la biblioteca estndar del lenguaje.

Actualidad y futuro[editar]
La continuidad del C++11 es C++14, que es la versin actual, y en el futuro, se estima que
a finales de 2017, ser C++17

Diferencias de tipos respecto a C[editar]

En C++, cualquier tipo de datos que sea declarado completo (fully qualified, en ingls) se
convierte en un tipo de datos nico. Las condiciones para que un tipo de
datos T seadeclarado completo son a grandes rasgos las siguientes:

Es posible al momento de compilacin conocer el espacio asociado al tipo de datos

(es decir, el compilador debe conocer el resultado de sizeof(T)).
T Tiene al menos un constructor, y un destructor, bien declarados.

Si T es un tipo compuesto, o es una clase derivada, o es la especificacin de una

plantilla, o cualquier combinacin de las anteriores, entonces las dos condiciones
establecidas previamente deben aplicar para cada tipo de dato constituyente.

En general, esto significa que cualquier tipo de datos definido haciendo uso de las
cabeceras completas, es un tipo de datos completo.
En particular, y, a diferencia de lo que ocurra en C, los tipos definidos por medio
de struct o enum son tipos completos. Como tales, ahora son sujetos a sobrecarga,
conversiones implcitas, etctera.
Los tipos enumerados, entonces, ya no son simplemente alias para tipos enteros, sino
que son tipos de datos nicos en C++. El tipo de datos bool, igualmente, pasa a ser un
tipo de datos nico, mientras que en C funcionaba en algunos casos como un alias para
alguna clase de dato de tipo entero.

Compiladores[editar]
Uno de los compiladores libres de C++ es el de GNU, el compilador G++ (parte del
proyecto GCC, que engloba varios compiladores para distintos lenguajes). Otros
compiladores comunes son Intel C++ Compiler, el compilador de Xcode, el compilador
de Borland C++, el compilador de CodeWarrior C++, el compilador g++ de Cygwin, el
compilador g++ de MinGW, el compilador de Visual C++, Carbide.c++, entre otros.

Ejemplo: Cmd con colores[editar]

Para cambiar el color de la interfaz del programa se necesita la librera "stdlib.h". su
aplicacin sirve para cambiar el color de fondo del cmd y el color de las letras. Nota: Esto
nicamente funciona en sistemas Windows,
Uso[editar]
#include <stdlib.h>
using namespace std;
system("color 45");

En este caso se ha definido el fondo de pantalla de color rojo y las letras rosadas.

Entornos de desarrollo[editar]
Vase tambin: Entorno de desarrollo integrado

Bajo Microsoft Windows[editar]

Visual Studio Code

Code::Blocks

Dev-C++

Visual C++

wxDev-C++

Zinjai

Open Watcom (IDE y Dialog Editor)

CodeLite

Bajo MacOS[editar]

Xcode

Zinjai

CodeLite

Bajo DOS[editar]

Turbo C, reemplazado por C++Builder

Bajo GNU/Linux[editar]

Code::Blocks

NetBeans

Eclipse

Geany

Emacs

Zinjai

Kdevelop

Open Watcom (IDE y Dialog Editor)

CodeLite

Variables y constantes en C++.

Asignacin de valores, uso de
#define y const en C++
Secciones C++
Introduccin a C++
Entornos de Desarrollo
o

Comentarios en C++
Estructura de un Programa

 Tipos de Datos
o
o

Entrada y Salida de Datos

Condicionales
o
o
o

Ciclos o Bucles
o
o
o
o

Estructuras de Datos
o
o
o

Libreras o Bibliotecas
Funciones

Las variables son altamente imprescindibles al

momento de programar, de hecho sera imposible
conseguir una aplicacin con una funcionalidad
bsica sin usar variables; por esta misma razn es
necesario aprender a usarlas bien y lo tenemos muy

fcil, pues su uso es bastante sencillo e intuitivo,

tanto para declararlas como para asignarles valores.
Las variables son posiciones en memoria donde
estarn guardados los diferentes valores que le
damos o que toman duranet ejecucin los datos que
usamos y normalmente estarn disponibles a lo
largo de la ejecucin de nuestro programa. Para
asignar valores a una variable en una gran variedad
de lenguajes que incluye a C++ se usa el
operador "=" seguido del valor que le daremos a la
variable (no todos usan el "=" para esto). Veamos un
ejemplo completo con todos los posibles usos que le
damos a una variable.
#include <iostream>
using namespace std;
int main()
{
char x = 'a'; // Declaramos y asignamos en la misma lnea
int num; //Declaramos el entero en una lnea
num = 5; //Le asignamos un valor en otra lnea
int num2 = 8; //Asignacion y declaracion al tiempo
float numero; //Un numero decimal
numero = 3.5; //Le asignamos un valor al decimal
float res = numero + num2; //Sumamos dos variables y las asignamos a res
//3.5 + 8 = 11.5
res = res + num; //Al valor actual de res le sumamos el valor de num
//11.5 + 5 = 16.5
bool valor = false; //Variable booleana
valor = true; // Pueden ser true o false
res = res*2; //Duplicamos el valor de res 16.5*2 = 33
cout << res << endl; //Mostramos el valor de res por pantalla
return 0;
}

En el cdigo anterior hemos visto las multiples

formas en que se puede declarar una variable, cmo
asignarle un valor, incluso vimos que es posible
asignarle el valor de una variable a otra, o realizar
operaciones entre los valores de variables y asignar
el resultado a una variable nueva, vimos que es
posible usar el valor de una misma variable y
cambiar su propio valor (res = res*2).
Ahora hablemos de las constantes en C++.
Constantes en C++, const y #define

Las datos constantes, mal llamadas por algunos

"variables constantes" (realmente no son variables)
tienen un valor fijo durante toda la ejecucin del
programa, es decir, este valor no cambia ni puede
ser cambiado a lo largo de la ejecucin de nuestro
programa. Las constantes son muy tiles para
especificar el tamao de un vector y para algunas
otras cosas, como facilidad de uso y confiabilidad del
cdigo. Para declarar una constante, se hace
despues de declarar las libreras y antes de las
funciones, la sintaxis es la siguiente: #define
nombre_constante valor. Veamos algunos detalles y
luego unos ejemplos sencillos del uso de las
constantes en C++
En C++ se pueden definir constantes de dos forma,
ambas vlidas para nosotros. La primera es por
medio del comando #define nombre_constante
valor y la segunda es usando la palabra clave const,
veamos ahora cada una de estas formas en detalle.
Uso de #define para declarar constantes en C++

La instruccin #define nos permite declarar

constantes (y algunas cosas ms) de una manera
rpida y sencilla. Hay que tener en cuenta que al
declarar constantes con #define debemos hacerlo
despues de los #include para importar libreras pero
antes de declarar nuestras funciones y dems.
Veamos un ejemplo:
Ejemplo de uso de #define en C++ para declarar constantes
#include <iostream>
using namespace std;
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI;
return 0;
}

Notemos que ha sido bastante fcil, sin embargo no

todo es bueno. Realmente al usar la
instruccin#define en C++ no estmos creando una
constante realmente, estamos creando una
expresin y por tal motivo hay algunas cosas que se
complican, veamos:
#include <iostream>
using namespace std;
#define PI 3.1416; //Definimos una constante llamada PI
int main()
{
cout << "Mostrando el valor de PI: " << PI << endl;
return 0;
}

Si intentamos ejecutar el cdigo anterior

obtendremos un error al haber usado el

operador << justo despues de PI, esto sucede

porque PI no es tratado exactamente como una
variable cualquiera sino como una expresin, as que
realmente aunque podemos usar #define para
declarar constantes no es la mejor opcin.
Veamos ahora cual es realmente la forma ms
adecuada de declarar constantes en C++, esto se
hace por medio de la instruccin const, veamos:
Uso de const para declarar constantes en C++

La instruccin const nos permite declarar constantes

de una manera ms adecuada y acorde. Las
constantes declaradas con const poseen un tipo de
dato asociado (como debera ser siempre) y se
declaran al interior de nuestro cdigo como un tipo
cualquiera. Veamos un ejemplo:
Ejemplo de uso de const en C++ para declarar constantes
#include <iostream>
using namespace std;
int main()
{
const float PI = 3.1416; //Definimos una constante llamada PI
cout << "Mostrando el valor de PI: " << PI << endl;
return 0;
}

Notemos que de igual forma ha sido bastante fcil y

mejor an ha sido mucho ms intuitivo y sencillo
para nosotros. Se puede ver que la declaracin es
muy similar a la de una variable cualquiera y que ya
no tenemos complicaciones al intentar aadir la
instruccin endl para agregar el salto de lnea.
Veamos que realmente la variable no puede
cambiar:

#include <iostream>
using namespace std;
int main()
{
const float PI = 3.1416; //Definimos una constante llamada PI
cout << "Mostrando el valor de PI: " << PI << endl;
PI = 2; //Esto generar un error pues PI es de solo lectura (constante)
return 0;
}

Si intentamos ejecutar el cdigo anterior

obtendremos un error al intentar cambiarle el valor a
PI, pues lo hemos definido como una constante y el
lenguaje no nos permitir cambiarle en ningn
momento el valor.
Muy bien eso ha sido todo en esta seccin, espero
haber sido lo ms claro posible y que se haya
entendido a la perfeccin. No olvides dejar tus
comentarios en la seccin de comentarios.

Bibliotecas o libreras en C++.

Declaracin y uso de libreras.
Include en C++
Secciones C++
Introduccin a C++
Entornos de Desarrollo
o

Comentarios en C++
Estructura de un Programa
Tipos de Datos
o
o

Entrada y Salida de Datos

Condicionales
o
o
o

Ciclos o Bucles
o
o
o
o

Estructuras de Datos

o
o
o

Libreras o Bibliotecas
Funciones

Junto con los compiladores de C y C++, se incluyen

ciertos archivos llamados bibliotecas mas
comnmente libreras. Las bibliotecas contienen el
cdigo objeto de muchos programas que permiten
hacer cosas comunes, como leer el teclado, escribir
en la pantalla, manejar nmeros, realizar funciones
matemticas, etc.
Las bibliotecas estn clasificadas por el tipo de
trabajos que hacen, hay bibliotecas de entrada y
salida, matemticas, de manejo de memoria, de
manejo de textos y como imaginars existen
muchsimas libreras disponibles y todas con una
funcin especifica.
Nota: Existe una discusin sobre el nombre de estos
archivos. Muchos personas consideran que el
nombre adecuado es archivos de biblioteca, y estan
en lo correcto. Sin embargo, la mayora llamamos a
estos archivos libreras, y tambin me incluyo entre
estos. El error proviene del nombre en ingls, que es
library. Este trmino se traduce como biblioteca, y no
como librera. De este modo a lo largo de esta
seccin las llamar de cualquiera de las dos formas,
para estr mas claros.

Hay un conjunto de bibliotecas (o libreras) muy

especiales, que se incluyen con todos los
compiladores de C y de C++. Son las libreras (o
bibliotecas) ANSI o estndar. Tambin hay libreras
que no son parte del estndar pero en esta seccin
slo usaremos algunas bibliotecas (o libreras) ANSI.
Nota 2: S que esto pinta aburrido, pero es muy til
y realmente las libreras nos facilitan enormemente
el trabajo de programar. Recuerda que antes de
hablar libreras y dems es necesario dominar
algunos conceptos de fundamentacin en general
y otros temas importantes
(ciclos, condicionales y dems) Ahora veamos
algunas libreras y como es su sintaxis.
Qu son exactamente las libreras?

En C++, se conoce como libreras (o bibliotecas) a

cierto tipo de archivos que podemos importar o
incluir en nuestro programa. Estos archivos
contienen las especificaciones de diferentes
funcionalidades ya construidas y utilizables que
podremos agregar a nuestro programa, como por
ejemplo leer del teclado o mostrar algo por pantalla
entre muchas otras ms.
Al poder incluir estas libreras con definiciones de
diferentes funcionalidades podremos ahorrarnos
gran cantidad de cosas, imaginemos por ejemplo
que cada vez que necesitemos leer por teclado,
debamos entonces crear una funcin que lo haga
(algo realmente complejo), al poder contar con las
libreras en C++, podremos hacer uso de una gran

variedad de funciones que nos facilitaran la vida y

aumentarn la modularidad de nuestros cdigos.
Las libreras no son nicamente archivos externos
creados por otros, tambin es posible crear nuestras
propias libreras y utilizarlas en nuestros programas.
Las libreras pueden tener varias extensiones
diferentes, las ms comunes son: .lib, .bpl, .a, .dll, .h
y algunas ms ya no tan comunes.
En conclusin: Las librearas son archivos (no
siempre externos) que nos permiten llevar a cabo
diferentes tareas sin necesidad de preocuparnos por
cmo se hacen sino simplemente entender cmo
usarlas. Las librearas en C++ permiten hacer
nuestros programas ms modulares y reutilizables,
facilitando adems crear programas con
funcionalidades bastante complejas en unas pocas
lneas de cdigo.
Sintaxis para declarar Libreras en C++

La declaracin de libreras, tanto en C como en C++,

se debe hacer al principio de todo nuestro cdigo,
antes de la declaracin de cualquier funcin o lnea
de cdigo, debemos indicarle al compilador que
libreras usar, para el saber que trminos estaran
correctos en la escritura de nuestro cdigo y cules
no. La sintaxis es la siguiente: #include <nombre de
la librera> o alternativamente #include "nombre de
la librera". Cualquiera de las 2 formas es vlida en
C++ (no estoy seguro si en C sea vlido), ten en
cuenta que siempre el nombre de la librera debe ir
entre " y " o entre < y >. En tu cdigo puedes
declarar todas las libreras que quieras aunque en

realidad no tienen sentido declarar una librera que

no vas a usar en tu programa, sin embargo no existe
lmite para esto.
Libreras Estandar de C++ (Standar Template Library
o STL)

A continuacin pondr algunas de las libreras de

uso ms comn de C++ y que forman parte de las
libreras estandar de este lenguaje.
o fstream:
Flujos hacia/desde ficheros. Permite la manipulacin
de archivos desde el programar, tanto leer como
escribir en ellos.
o iosfwd:
Contiene declaraciones adelantadas de todas las
plantillas de flujos y sus typedefs estndar. Por
ejemplo ostream.
o iostream:
Parte del a STL que contiene los algoritmos
estndar, es quiz la ms usada e importante
(aunque no indispensable).
o La biblioteca list:
Parte de la STL relativa a contenedores tipo list;
listas doblemente enlazadas
o math:

Contiene los prototipos de las funciones y otras

definiciones para el uso y manipulacin de funciones
matemticas.
o memory:
Utilidades relativas a la gestin de memoria,
incluyendo asignadores y punteros inteligentes
(auto_ptr).
"auto_ptr" es una clase que conforma la librera
memory y permite un fcil manejo de punteros y su
destruccin automaticamente.
o Biblioteca new:
Manejo de memoria dinmica
o numeric:
Parte de la librera numrica de la STL relativa a
operaciones numricas.
o ostream:
Algoritmos estndar para los flujos de salida.
o queue:
Parte de la STL relativa a contenedores tipo queue
(colas de objetos).
o Librera stdio:
Contiene los prototipos de las funciones, macros, y
tipos para manipular datos de entrada y salida.

o Librera stdlib:
Contiene los prototipos de las funciones, macros, y
tipos para utilidades de uso general.
o string:
Parte de la STL relativa a contenedores tipo string;
una generalizacin de las cadenas alfanumricas
para albergar cadenas de objetos. Muy til para el
fcil uso de las cadenas de caracteres, pues elimina
muchas d elas dificultades que generan los char
o typeinfo:
Mecanismo de identificacin de tipos en tiempo de
ejecucin
o vector:
Parte de la STL relativa a los contenedores tipo
vector; una generalizacin de las matrices
unidimensionales C/C++
o forward_list
Esta librera es til para implementar con gran
facilidad listas enlazadas simples.
o list
Permite implementar listas doblemente enlzadas
(listas enlazadas dobles) facilmente.
o iterator

Proporciona un conjunto de clases para iterar

elementos.
o regex
Proporciona fcil acceso al uso de expresiones
regulares para la comparacin de patrones.
o thread
til para trabajar programacin multihilos y crear
mltiples hilos en nuestra aplicacin.
Nota: Para ms informacin sobre las libreras
estandar de C++ y STL puedes ingresar aqu
Cmo declarar una librera en C++?

Veamos a continuacin como se hara la declaracin

de unas cuantas libreras conocidas, recuerda que
ese pueden declarar todas las libreras necesarias y
siempre debe hacerse al comienzo del cdigo fuente
#include "iostream"
#include "string"
#include <math.h>
#include <conio.h>
using namespace std;

Con esto debi quedar claro, como declarar libreras

C++ al interior de un cdigo fuente. Lo nico
adicional, es la lnea que dice using namespace
std; esta lnea nos ayuda a declarar un espacio de
nombre que evita tener que usarlo cada que
accedemos a alguna funcin especifica de una
librera. Teniendo este namespace declarado
podemos llamar por ejemplo el comando cout >>,

que pertenece a la librera iostream, sin embargo sin

este namespace sera std::cout >>, imagina tener
que hacer esto cada vez que uses algn comando o
funcin de las libreras, sera bastante tedioso.
Acerca del namespace std

Todas las libreras estndar de C++ contienen una

declaracin del espacio de nombre std, es decir que
todas las libreras que hacen parte del estndar de
C++ colocan entidades dentro de este espacio de
nombre.
Por esta razn cuando declaramos el uso del
espacio de nombre std por medio de "using
namespace std;", podemos evitar estar escribiendo
std::cout o std::cin, etc en nuestro cdigo.
El espacio de nombre std como tal no es una librera
sino simplemente un namespace, por esta razn no
reemplaza la declaracin de las libreras del cdigo,
simplemente facilita la escritura de ste al momento
de usar las entidades de las libreras estndar. Sin
embargo si vamos a hacer uso de una o varias
libreras estndar de C++ es recomendable que
declaremos el namespace std, para no tener que
estar constantemente escribiendo cosas similares a
las que puse hace unas lneas como std::cin o
similares, dado que nicamente se puede acceder a
la entidades de las libreras estndar por medio del
espacio nombre std.
Muy bien, ahora veamos algunos ejemplos simples
del uso de libreras o bibliotecas en C++
Ejemplo 1 de libreras en C++

En el siguiente ejemplo veremos el uso de la librera

stdlib.h que posee una gran variedad de
funcionalidades, para este ejemplo usaremos la
funcin rand que nos permite generar un nmero
aleatorio.
#include <stdlib.h>
#include <iostream>
using namespace std;
int main ()
{
cout << ("Se va a generar un numero aleatorio ....\n");
cout << ("El numero generado es : ");
cout << rand(); //Se genera el nmero con rand y se muestra en pantalla
return 0;
}

En el anterior cdigo hemos hecho uso de dos

libreras: iostream y stdlib. La librera o biblioteca
iostream, nos permitir hacer uso del cin y el cout
para obtener o imprimir valores por pantalla,
respectivamente mientras stdlib nos dar acceso a la
funcin rand que generar por nosotros un nmero
cualquiera.
Ejemplo 2 de libreras en C++

En el siguiente ejemplo veremos el uso de la librera

string.h que nos permite bsicamente crear y
manipular muy fcilmente cadenas de caracteres
#include <string.h>
#include <iostream>
using namespace std;
int main ()
{
cout << ("Hola! Por favor ingrese su nombre ....\n");
string cadena = "Hola "; //Se le da un valor inicial al string

string nombre; //Esta cadena contendr el nombre

cin >> nombre; //Se lee el nombre
cadena = cadena + nombre; //Se juntan el saludo con el nombre usando "+"
cout << (cadena); //Se muestra el resultado final.
return 0;
}

Aqu hemos mostrado un mensaje solicitando el

nombre al usuario y luego usando string, hemos
creado un saludo que incluya el nombre del usuario.
"Hola Juan".
Ejemplo 3 para bibliotecas en C++

En este ejemplo usaremos la biblioteca vector,

iterator y list, para crear un lista doblemente
enlazada, agregar algunos elementos en ella
(incluido un vector) y recorrerla.
#include <iostream>
#include <list>
#include <vector>
using namespace std;
int main ()
{
list<int> miLista; //Creamos
list<int>::iterator it;
for (int i=10; i<=50; i = i+10)
{
miLista.push_back(i);
}
//Se agrega un 10 20 30 40 50 a la lista
it = miLista.begin(); //Se estabelce el iterador al comienzo de la lista
it++; //Movemos el iterador una posicin (ahora estamos en 20)
//Se inserta un 11 en la posicin del 10 11 20 30 40 50
miLista.insert (it,11);
miLista.insert (it,3,18);
//En la actual posicin del 20 insertamos un 18 tres veces
//10 11 18 18 18 20 30 40 50

//Creamos un vector que poseer dos elementos con valor de 19

vector<int> myvector (2,19);
//Insertamos ese vector en la lista, enviando los iteradores del propio vector
miLista.insert (it,myvector.begin(),myvector.end());
//10 11 18 18 18 19 19 20 30 40 50
cout << "Mi lista contiene lo siguiente:";
for (it=miLista.begin(); it!=miLista.end(); it++)
{
cout << ' ' << *it; //Se muestra el valor al cual est antando el
iterador
}
return 0;
}

El resultado final de la ejecucin de este cdigo

debera mostrar por pantalla "Mi lista contiene lo
siguiente: 10 11 18 18 18 19 19 20 30 40 50" que es
el resultado final de la insercin.
Muy bien. He aadido este par de ejemplo a peticin
de algunos visitantes del sitio y creo que s eran muy
necesarios, espero que con esto hayas clarificado
dudas y afianzado el concepto.
Bueno!!! Es todo lo que necesitas saber sobre
libreras, al menos en la lista que te he puesto, estn
las que vamos a usar para ejemplos y ejercicios y
algunas otras de mas. Si deseas informacin sobre
alguna otra o que ample la informacin sobre alguna
que ya esta aqu, hzmelo saber por medio de
la seccin de comentarios
Ahora vamos a la siguiente seccin y metamosle
mano a algunos cdigos y cmo es su estructura. Da
clic en el siguiente contenido llamado Funciones en
C++.

Iostream
iostream es un componente de la biblioteca estndar (STL) del lenguaje de
programacin C++ que es utilizado para operaciones de entrada/salida. Su nombre es
un acrnimode Input/Output Stream. El flujo de entrada y salida de datos en C++ (y su
predecesor C) no se encuentra definida dentro de la sintaxis bsica y se provee por medio
de libreras de funciones especializadas como iostream. iostream define los siguientes
objetos:

cin : Flujo de entrada (que entra)

cout : Flujo de salida (que sale)

cerr : Flujo de error no almacenado.

clog : Flujo de error almacenado.

Todos los objetos derivados de iostream hacen parte del espacio de nombres std.

Ejemplo[editar]
El clsico programa Hola Mundo puede ser expresado en C++ utilizando iostream:
#include <iostream> // biblioteca que contiene las funciones de
entrada y salida de c++ . Viene Input/Output Stream
#include <cstdlib>
using namespace std;
int main()
{
cout << "Hola, mundo!" << endl;
system("pause");
return 0;
}