C++
Na Galipedia, a wikipedia en galego.
C++ (pronunciado /ce mais mais/, ou /ce plus plus/, maioritariamente) é unha linguaxe de programación, deseñada a mediados dos oitenta, por Bjarne Stroustrup, como extensión da linguaxe de programación C.
É unha linguaxe híbrida, que se pode compilar e resulta máis sinxela de aprender para os programadores que xa coñecen C. Actualmente existe un estándar, denominado ISO C++, ó que se adheriron a maioría dos fabricantes de compiladores máis modernos. Existen tamén algúns intérpretes como ROOT (enlace externo). As principais características do C++ son abstracción (encapsulación), o soporte para programación orientada a obxectos (polimorfismo) e o soporte para modelos de programación xenérica (templates). Aínda máis, podése dicir que C++ é unha linguaxe que abrangue tres paradigmas da programación: a programación estruturada, a programación xenérica e a programación orientada a obxetos. Os modelos defínense da manera seguinte:
template <parámetros> declaración X
e se as instancia con
X<parámetros>.
Ademais engade unha serie de propiedades que se atopan máis dificilmente noutras linguaxe de alto nivel:
- Posibilidade de redefinir os operadores
- Identificación de tipos en tempo de execución (RTTI)
C++ está considerado por moitos como a linguaxe máis potente debido a que permite traballar tanto a alto como a baixo nivel. Non obstante, é a súa vez un dos que menos automatismos trae (obriga a face-lo case todo manualmente, ó igual que C) o que dificulta moito a súa aprendizaxe.
O nome C++ foi proposto por Rick Masciatti no ano 1983, cando a linguaxe se empregou por vez primeira fóra dun laboratorio científico. Antes usárase o nome de "C con clases". En C++, "C++" significa "C máis un" e refírese a que C++ é unha extensión de C.
Algúns din que "C++" todavía significa "C", porque "++" neste caso é o operador da postincrementación, é dicir, aumenta o valor da expresión á que se refire, despois, nas instrucións seguintes. Por isto o valor da expresión neste momento permanece orixinal.
Índice |
[editar] Un exemplo
A continuación cítase un programa de exemplo escrito en C++:
#include <iostream> int main() { std::cout << "¡Ola mundo!" << std::endl; }
[editar] Conceptos xerais da programación orientada a obxectos
- Clase: É un modelo do que se poden sacar varios obxectos. Estes conteñen prototipos de atributos e métodos que pode herdar cada unha das súas instancias. De forma xeral pode definirse como a representación que fai a programación orientada a obxectos dun obxecto matemático.
- Obxecto: É a instanciación dunha clase, é dicir, un exemplo concreto das propiedades que pode ter unha clase. Unha clase define una idea, así como un obxecto é a súa representación.
- Identidade: Permite ó obxecto diferenciarse dos demais.
[editar] Tipos Primitivos en C++
En C e máis en C++ exiten dúas clases de tipos primitivos: enteiros e flotantes, que se poden clasificar da seguinte forma:
- Enteiros
- integer (enteiro)
- long integer (enteiro largo)
- long long integer (enteiro extralargo, lit. "enteiro largo largo")
- short integer (enteiro corto)
- character string (cadena de caracteres ou alfanumérica)
- Frotantes
- float (IEEE754 Simple) (frotante)
- double float (IEEE754 Normal) (dobre frotante)
- long double float (IEEE754 Extendido) (frotante largo dobre)
O modificador unsigned pódese aplicar a enteiros para obter números sen signo (por defecto os enteiros conteñen signo), co que se permite usar un rango de positivos maior. Segundo a máquina e o compilador usado os tipos primitivos poden ocupar un determinado tamaño en memoria. A seguinte lista ilustra o número de bits que ocupan os distintos tipos primitivos nun PC da familia 386 con gcc.
Tipo | Número de Bits |
char | 8 |
short | 16 |
int | 32 |
float | 32 |
double | 64 |
[editar] Principios
Todo programa en C++ debe ter a función main() :
int main() { return 0; }
[editar] O Concepto de Clase
Os obxetos en C++ son abstraídos mediante unha Clase. Segundo o paradigma da programación orientada a obxetos un obxeto consta de:
- Métodos ou funcións
- Variables Membro
Un exemplo dunha clase
class Punto { // Opcional pero recomendado, xa que por defecto os membros son 'private'. private: // Variable membro privada int id; protected: // Variables membro protexidas int x; int y; public: // Constructor Punto(); // Destructor ~Punto(); // Funcións membro ou metodos int ObterX(); int ObterY(); };
[editar] Constructores
Son uns métodos especiais que se executan automaticamente ó crear un obxeto da clase. Na súa declaración non se especifica o tipo de dato que devolven, e poseen o mesmo nome que a clase á que pertencen. De igual forma que outros métodos, pode haber varios constructores sobrecargados, aínda uqe non poden existir constructores virtuales.
Como característica especial á hora de implementar un constructor, xusto despois da declaración dos parámetros, atópase a chamada "lista de inicializadores". O seu obxetivo é chamar ós constructores dos atributos que conforman o obxeto a construir.
Tomando o exemplo da Clase Punto, se desexamos que cada vez que se cree un obxeto desta clase as coordenadas do punto sexan igual a cero podemos agregar un construtor como se amosa a continuación:
// Clase Punto //----------------------------------------------------------------------- class Punto { public: // Constructor Punto()// Inicializar as variables membro : x ( 0 ) : y ( 0 ) { } // Coordenadas do punto float x; float y; }; //----------------------------------------------------------------------- // Main para demostrar o funcionamiento da clase #include <iostream> using namespace std; int main() { Punto OMeuPunto; cout<<"Coordenada X:"<<OMeuPunto.x<<endl; cout<<"Coordenada Y:"<<OMeuPunto.y<<endl; return 0; }
Se compilamos e executamos o anterior programa, obteremos una saída que debe ser similar á seguinte: \\ Coordenada X:0 \\ Coordenada Y:0 \\
[editar] Destructores
Os destructores son funcións membro especiais chamadas automaticamente na execución do programa, e que por tanto non deben ser chamadas explicitamente polo programador. O seu cometido: liberar os recursos computacionais que o obxeto de tal clase adquirira en tempo de execución ó expirar este. Os destructores desaparecen da memoria ó acadaren o fin do ámbito no que está declarado o obxeto.
[editar] Funciós Membro
Función membro é aquela que está declarada en ámbito de clase. Son similares ás funcións habituais, coa salvedade de que o compilador realizase o denominado Name Mangling: cambiase o nome da función engadindo un identificador da clase na que está declarada. Ademáis, as funcións membro reciben implícitamente un parámetro adicional: O puntero this, que referencia ó objeto que executa a función.
[editar] Modelos
Os modelos son o mecanismo de C++ para implantar o paradigma da Programación xenérica. Permiten que una clase ou función traballe con tipos de datos abstractos, especificando máis adiante cales son os que se queren usar. Por exemplo, é posible construir un vector xenérico que poda conter calquera tipo de estrutura de datos. Desta forma pódense declarar obxetos da clase deste vector que conteñan enteiros, flotantes, polígonos, figuras, fichas de persoal, etc. Anteponse template <typename A[=tipo_por_defecto], typename B[=tipo_por_defecto],...>
á estrutura de programación (clase, función, etc.).
[editar] Espazos de nomes
[editar] Excepcións
=== Herdanza ===
- Herdanza Simple
- Herdanza Múltiple
[editar] Sobrecarga de Operadores
É posible definir o comportamento dun operador da linguaxe para que traballe con tipos de datos definidos polo usuario. Estes comportamentos impleméntanse do mexmo xeito que una función, salvo que esta terá un nome especial: Tipo de dato de devolución operator<token del operador> (parámetros)
- Operador +
- Operador ++
- Operador -
- Operador --
- Operador =
- Operador ==
- Operador *
- Operador /
- Operador %
- Operador new
- Operador delete
- Operador ()
- Operador []
[editar] Biblioteca Estándar de Modelos(STL)
As linguaxes de programación adoitan ter unha serie de bibliotecas integradas para a manipulación de datos a nivel máis básico. En C++, ademáis de poder usar as bibliotecas de C, pódese usar a nativa STL (Standard Template Library), propia da linguaxe. Proporciona unha serie de clases parametrizadas (véxase más arriba modelos) que permite efectuar operacións sobre o almacenado de datos, procesado e fluxos de entrada/saída. A STL é máis un conxunto de bibliotecas ca unha soa. Desta forma únicamente inclúense no fichero executable final aquelas que sexan necesarias para a aplicación que se esté programando, reducindo drásticamente o uso innecesario de memoria.
[editar] ostreams / istreams
Cabe destacar as clases basic_ostream ebasic_stream, e os obxectos cout e cin, pertencentes a estas clases, respectivamente. Proporcionan a entrada e saída estándar de datos (teclado/pantalla). Tamén está disponible cerr, similar a cout, usado para a salida estándar de errores. Estas clases teñen sobrecargados os operadores << e >>, respectivamente, có obxeto de seren útiles na inserción/extracción de datos a dichos flujos. Son operadores intelixentes, xa que son capaces de adaptarse ó tipo de datos que reciben, aunque teremos que definir o comportamento de dicha entrada/saída para clases/tipos de datos definidos polo usuario. Por exemplo:
ostream& operator<<(ostream& fs,const Punto& punto) { fs << punto.x << "," << punto.y; return fs; }
Desta forma, para mostrar un punto, só teríamos que executar a seguinte expresión:
//... Punto p(4,5); //... cout << "As coordenadas son: " << p << endl; //...
É posible formatear a entrada/saída, indicando o número de díxitos decimais a mostrar, se os textos se pasarán a minúsculas ou maiúsculas, se os números recibidos están en formato octal ou hexadecimal, etc.
[editar] fstreams
Tipo de fluxo para o manexo de ficheros. A definición previa de ostreams/istreams é aplicable a este apartado. Existen tres clases): ifstream (só lectura), ofstream (só escritura) e fstream (lectura/escritura).
Poden abrirse pasando ó constructor os parámetros relativos á ubicación do fichero e o modo de apertura:
ios::ate ao abrir o ficheiro, posicionarase ó final | ios::trunc Ó abrir, bórrase o contido | ios::app Modo "append": abrirase o ficheiro en modo de anexo | ios::binary Apertura dun fichero binario (isto é un concepto relativo ó sistema operativo en cuestión, logo en moitas ocasións, non é necesario) |
Para pechar un fichero, pode usarse o método close, ou agardar a que o destructor das clases o peche automáticamente.
[editar] sstreams
Se destacan dúas clases, ostringstream e istringstream. Todo o anteriormente dito é aplicable a estas clases. Tratan a una cadena como se dun fluxo de datos se tratase. ostringstream permite elaborar unha cadena de texto insertando datos cual fluxo, e istringstream pode extraer a información contida nunha cadena (pasada como parámetro no seu constructor) có operador >>. Ejemplos:
ostringstream s; s << nome << "," << idade << "," << estatura << "," << punto(5,6) << endl; cout << s.str();
istringstream s(cadena); s >> nome >> idade >> estatura >> p;
[editar] Contenedores
Son clases modelos especiais utilizados para almacenar tipos de datos xenéricos, sexan cales sexan. Segundo a natureza do almacenado, disponemos de varios tipos:
- Vectores: Defínense por
vector<tipo_de_dato> nome_do_vector;
Equivalen ós array de calquera linguaxe, con diversas salvedades. Teñen tamaño dinámico, có que se pode insertar elementos aínda que o vector estea cheo. A diferenza dos vectores clásicos a baixo nivel de C, tamén poden lanzar excepcións se se accede a un elemento có rango fóra do vector en cuestión, usando, en vez do operador [], o método at().
- Colas dobres.
- Listas.
- Adaptadores de secuencia.
- Contenedores asociativos: map e multimap.
- Contenedores asociativos: set e multiset.
Métodos comúns e non comúns entre os contenedores da STL.
[editar] Iteradores
Poden considerarse como unha xeralización da clase de "punteiro". Un iterador é un tipo de dato que permite o recorrido e a busca de elementos nos contenedores. Como as estruturas de datos (contenedores) son clases xenéricas, e os operadores (algoritmos) que deben operar sobre elas son tamén xenéricos (funcións xenéricas), Stepanov e os seus colaboradores tiveron que desenvolver o concepto de iterador como elemento ou nexo de conexión entre ambos os dous. O novo concepto resulta ser unha especie de punteiros que sinalan ós diversos membros do contenedor (punteiros xenéricos que como tales non existen na linguaxe).
[editar] Compiladores
Un dos mellores compiladores de C++ é o de GNU, o compilador G++ (parte do proxecto Gcc, que engloba varios compiladores para distintas linguaxes), descargable dende a dirección http://www.gnu.org
Actualmente os compiladores máis comúns que se poden atopar para C++ no sistema operativo Windows son Visual C++ e MinGW. Visual C++ pertence a Microsoft e é de pago, mentres que MinGW é unha versión do compilador de GNU adaptada para este sistema operativo. Dev-C++ é un IDE de libre distribución para este compilador e pode ser descargado da súa web oficial Bloodshed gratuitamente. Tamén existe DJGPP, aínda que actualmente está en desuso.
[editar] Ligazóns externas
- cplusplus resources (inglés)