Académique Documents
Professionnel Documents
Culture Documents
Desarrollador(es)
Bjarne Stroustrup, Laboratorios Bell
https://isocpp.org/ y http://www.open-
std.org/jtc1/sc22/wg21/
Información general
Extensiones comunes .h .hh .hpp .hxx
.h++ .cc .cpp
.cxx .c++
Paradigma Multiparadigma:
Programación
Estructurada,
imperativo,
programación genérica
Apareció en 1983
Diseñado por Bjarne Stroustrup
Última versión estable ISO/IEC 14882:2017
(C++17) (1 de
diciembre de 2017)
Última versión en C++20 (2020)
pruebas
Sistema de tipos Fuerte, estático,
nominativo
Implementaciones C++ Builder, clang,
Comeau C/C++, GCC,
Intel C++ Compiler,
Microsoft Visual C++,
Sun Studio,
Code::Blocks, Zinjai
Dialectos ISO/IEC C++ 1998,
ISO/IEC C++ 2003,
ISO/IEC C++ 2011
Influido por C, Simula, Ada 83,
ALGOL 68, CLU, ML[1]
Ha influido a Perl, LPC, Lua, Pike, Ada
95, Java, PHP, D, C99,
C#, Falcon
Si i M li l f
Ejemplos
A continuación 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>
int main()
{
cout << "Hola mundo" <<
endl;
return 0;
}
Tipos de datos
C++ tiene los siguientes tipos
fundamentales:
Tamaños asociados
char 8
short 16
int 32
float 32
double 64
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":
Wchar_t
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 - wstrcpy
std::string - std::wstring
std::cout - std::wcout
void *memoria;
La palabra "NULL"
int main()
{}
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();
};
Constructores
class Punto
{
public:
float x; // Coordenadas
del punto
float y;
//
Constructor
Punto() : x(0), y(0){ //
Inicializamos las variables
"x" e "y"
}
};
int main () {
Punto MiPunto; //
creamos un elemento de la
clase Punto llamado MiPunto
Coordenada X: 0 Coordenada Y: 0
1. 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.
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 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.
int main() {
Punto *unPunto = new
Punto(); //esto llama al
constructor que se describe
más arriba
delete unPunto;
//no hay que olvidarse de
liberar la memoria ocupada
por el objeto(ver la sección
destructores, más abajo)
return 0;
}
Destructores
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;
}
Funciones miembro
Plantillas
Especialización
El siguiente ejemplo:
Clases abstractas
En C++ es posible definir clases
abstractas. Una clase abstracta, o clase
base abstracta (ABC), es una que está
diseñada solo como clase padre de las
cuales se deben derivar clases hijas. Una
clase abstracta se usa para representar
aquellas entidades o métodos que
después se implementarán en las clases
derivadas, pero la clase abstracta en sí no
contiene ninguna implementación --
solamente representa los métodos que se
deben implementar. Por ello, no es posible
instanciar una clase abstracta, pero sí una
clase concreta que implemente los
métodos definidos en ella.
Las clases abstractas son útiles para
definir interfaces, es decir, un conjunto de
métodos que definen el comportamiento
de un módulo determinado. Estas
definiciones pueden utilizarse sin tener en
cuenta la implementación que se hará de
ellos.
class Abstracta
{
public:
virtual int metodo() =
0;
}
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;
return 0;
}
Herencia
class Barco {
protected:
char* nombre;
float peso;
public:
//Constructores y demás
funciones básicas de barco
};
Herencia múltiple
class Persona {
...
Hablar();
Caminar();
...
};
class Empleado {
Persona jefe;
int sueldo;
Cobrar();
...
};
Operadores Unarios
Operador * (de indirección)
Operador -> (de indirección)
Operador & (de dirección)
Operador +
Operador -
Operador ++
Operador --
Operadores Binarios
Operador ==
Operador +
Operador -
Operador *
Operador /
Operador %
Operador <<
Operador >>
Operador &
Operador ^
Operador |
Operador []
Operador ()
Operadores de Asignación
Operador =
Operador +=
Operador -=
Operador *=
Operador /=
Operador %=
Operador <<=
Operador >>=
Operador &=
Operador ^=
Operador |=
//...
Punto p(4,5);
//...
cout << "Las coordenadas
son: " << p << endl;
//...
Fstreams
Ejemplo: f.close();
Leer un fichero:
#include <fstream>
#include <string>
#include <iostream>
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
también una variable de
cualquier tipo primitivo, o
un string.
Ejemplo: f<<HOLA;
2-Si es un fichero
binario(.dat);
nombre_variable_fichero.writ
e((char*)&nombre_variable,
sizeof(tipo_variable));
Ejemplo:
f.write((char*)&e,
sizeof(int));
Pueden abrirse pasando al constructor los
parámetros relativos a la ubicación del
fichero y el modo de apertura:
Sstreams
ostringstream s;
s << nombre << "," << edad
<< "," << estatura << "," <<
punto(5,6) << endl;
cout << s.str();
istringstream s(cadena);
s >> nombre >> edad >>
estatura >> p;
Contenedores
vector<tipo_de_dato>
nombre_del_vector;
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
método 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 (i. e. 32)
cout << "Ahora tengo: " <<
intVector.size() << "
elementos." << endl;
//imprimirá 1
return 0;
}
deque<tipo_de_dato>
nombre_de_la_cola;
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;
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;
}
Iteradores
Algoritmos
copy (inicio_origen,
fin_origen, inicio_destino);
#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 ordenaría de la misma
manera. */
}
Entre las funciones más conocidas están
swap (variable1, variable2), que
simplemente intercambia los valores de
variable1 y variable2; max (variable1,
variable2) y su símil min (variable1,
variable2), que retornan el máximo o
mínimo entre dos valores; find (inicio, fin,
valor) que busca valor en el espacio de
variables entre inicio y fin; etcétera.
C++11
El 12 de agosto de 2011, Herb Sutter,
presidente del comité de estándares de
C++, informó la aprobación unánime del
nuevo estándar.[2] La publicación del
mismo se realizó en algún momento del
2011.
Funciones lambda;
Referencias rvalue;
La palabra reservada auto;
Inicialización uniforme;
Plantillas con número variable de
argumentos.
Actualidad y futuro
La continuidad de C++14 es C++17, que es
la versión actual, y en el futuro, se estima
que en 2020, será C++20
Compiladores
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.
#include <cstdlib>
using namespace std;
system("color 45");
Entornos de desarrollo
Véase también: Entorno de desarrollo integrado
Bajo MacOS
Xcode
Zinjai
CodeLite
Geany
Bajo DOS
Turbo C, reemplazado por C++Builder
Bajo GNU/Linux
Code::Blocks
NetBeans
Eclipse
Geany
Emacs
Zinjai
Kdevelop
Open Watcom (IDE y Dialog Editor)
CodeLite
Clion (software)
Críticas
A pesar de su adopción generalizada,
muchos programadores han criticado el
lenguaje C ++, incluyendo Linus Torvalds,[3]
Richard Stallman,[4] y Ken Thompson.[5]
Los problemas incluyen una falta de
reflexión o recolector de basura, tiempos
de compilación lentos, perceived feature
creep,[6] y mensajes de error detallados,
particularmente de la metaprogramación
de plantilla.[7]
Referencias
1. Stroustrup, Bjarne (1997). «1». The C++
Programming Language (Third edición).
ISBN 0201889544. OCLC 59193992 .
2. http://herbsutter.com/2011/08/12/we-
have-an-international-standard-c0x-is-
unanimously-approved/
3. «Re: [RFC Convert builin-mailinfo.c to
use The Better String Library]», 6 de
septiembre de 2007,
https://lwn.net/Articles/249460/ ,
consultado el 31 de marzo de 2015.
4. «Re: Efforts to attract more users? », 12
de julio de 2010, http://harmful.cat-
v.org/software/c++/rms , consultado el 31
de marzo de 2015.
5. Andrew Binstock (18 de mayo de 2011).
«Dr. Dobb's: Interview with Ken
Thompson» . Consultado el 7 de febrero de
2014.
6. Pike, Rob (2012). «Less is exponentially
more» .
7. Kreinin, Yossi (13 de octubre de 2009).
«Defective C++» . Consultado el 3 de
febrero de 2016.
8. New Languages, and Why We Need
Them , MIT Technology Review
9. The New Native Languages | Dr Dobb's
Bibliografía
Enlaces externos
Wikimedia Commons alberga una
categoría multimedia sobre C++.
«Cplusplus resources» (en inglés).
Consultado el 10 de abril de 2015.
«C/C++ Reference=C Programming and
C++ Programming» (en inglés).
Consultado el 10 de abril de 2015.
Obtenido de
«https://es.wikipedia.org/w/index.php?
title=C%2B%2B&oldid=115237367»