Diferencies ente revisiones de «C++»

Cabo resaltar qu'en C se define <code>wchar_t</code> como:

 

typedef unsigned short wchar_t;

 

Ente qu'en C++ ye en sí mesmu un tipu de datu.

La pallabra reservada <code>void</code> define en C++ el conceutu de non esistencia o non atribución d'un tipu nuna variable o declaración. Esto ye, una función declarada como <code>void</code> nun va devolver nengún valor. Esta pallabra reservada tamién puede usase pa indicar qu'una función nun recibe parámetros, como na siguiente declaración:

 

int funcion (void);

Anque l'enclín actual ye la de nun asitiar la pallabra "void".

 

Amás utilízase pa determinar qu'una función nun retorna un valor, como en:

void funcion (int parametro);

 

Cabo destacar que '''<code>void</code> nun ye un tipu'''. Una función como la declarada enantes nun puede retornar un valor per mediu de <tt>return</tt>: la pallabra clave va sola. Nun ye posible una declaración del tipu:

void t; //Ta mal

 

Nesti sentíu, <code>void</code> portar de forma llixeramente distinta a como lo fai en C, especialmente tocantes al so significáu en declaraciones y prototipos de funciones.

Sicasí, la forma especial <tt>void *</tt> indica que'l tipu de datos ye un punteru. Por casu:

 

void *memoria;

 

Indica que <tt>memoria</tt> ye un punteru a ''dalguna parte'', onde se guarda información de ''dalgún tipu''. El [[programador]] ye responsable de definir estos "dalgún", esaniciando toa ambigüedá. Una ventaya de la declaración "''void *''" ye que puede representar al empar dellos tipos de datos, dependiendo de la [[Conversión de tipo|operación de ''cast'']] escoyida. La memoria qu'apuntemos ayundes, nel exemplu anterior, bien podría almacenar un enteru, un flotante, una cadena de testu o un programa, o combinaciones d'estos. Ye responsabilidá del programador recordar qué tipu de datos hai y garantizar l'accesu fayadizu.

Tenemos entós que:

 

void* piqueru = NULL;

int enteru = NULL;

bool boleana = NULL;

char caracter = NULL;

 

El valor de les variables anteriores daríanos 0. A diferencia de la variable "caracter", que nos daría l'equivalente a NULL, '\0', pa calteres.

 

Tou programa en C++ tien de tener la función principal <code>main()</code> (sacantes que se especifique en tiempu de compilación otru puntu d'entrada, qu'en realidá ye la función que tien el <code>main()</code>)

int main()

{}

 

La función principal del códigu fonte <tt>main</tt> tien de tener unu de los siguientes prototipos:<br />

Este ye otru exemplu d'una clase:

 

class Puntu {

 

int ObtenerY();

};

 

=== Constructores ===

 

 

class Puntu {

 

return 0;

}

 

Si compilamos y executamos l'anterior programa, llogramos una salida que tien de ser similar a la siguiente:

Un oxetu creáu de la forma que se vio hasta agora, ye un oxetu que vive dientro del scope(les llaves { }) nel que foi creáu. Por que un oxetu pueda siguir viviendo cuando se saque del scope nel que se creó, tien de crear en memoria heap. Pa esto, utilízase l'operador new, que asigna memoria p'almacenar al oxetu creáu, y amás llama al so constructor(polo que se-y pueden unviar parámetros). L'operador new utilizar de la siguiente manera:

 

int main() {

Puntu *unPunto = new Puntu(); //esto llapada al constructor que se describe más arriba

return 0;

}

 

Amás, col operador new[] pueden crease arrays (colecciones o llistes ordenaes) de tamañu dinámicu:

 

Puntu *asignar(int cuantos) {

return new Puntu[cuantos]; //asigna un array de 'cuantos' puntos(llámase'l constructor que s'amuesa más arriba), y retornar.

}

 

=== Destructores ===

Los destructores son invocaos automáticamente al algamar el fluxu del programa'l fin del ámbitu nel que ta declaráu l'oxetu. L'únicu casu nel que se debe '''invocar explícitamente al destructor d'un oxetu''', ye cuando esti foi creáu por aciu l'operador new, esto ye, qu'esti vive en memoria heap, y non na pila d'execución del programa. La invocación del destructor d'un oxetu que vive en heap realízase al traviés del operador delete o delete[] pa arrays. Exemplu:

 

int main() {

int *unEntero = new int(12); //asignamos un enteru en memoria heap col valor 12

return 0;

}

 

Si nun s'utilizara l'operador delete y delete[] nesi casu, la memoria ocupada por unEntero y arrayDeEnteros respeutivamente, quedaría ocupada ensin sentíu. Cuando una porción de memoria queda ocupada por una variable que yá non s'utiliza, y nun hai forma d'aportar a ella, denominar un 'memory leak'. N'aplicaciones grandes, si asoceden munchos memory leaks, el programa puede terminar ocupando abondo más memoria RAM de la que debería, lo que nun ye pa nada conveniente. Ye por esto, que'l manexu de memoria heap tien d'usase conscientemente.

Por casu:

 

template <typename T>

T max(const T &x, const T &y) {

return (x > y) ? x : y; //si x > y, retorna x, sinón retorna y }

 

 

La función <tt>max()</tt> ye un exemplu de programación xenérica, y daos dos parámetros d'un tipu T (que puede ser <tt>int</tt>, <tt>long</tt>, <tt>float</tt>, <tt>double</tt>, etc.) va devolver el mayor d'ellos (usando l'operador <tt>></tt>). Al executar la función con parámetros d'un ciertu tipu, el compilador va intentar "calzar" la plantía a esi tipu de datos, o bien va xenerar un mensaxe d'error si fracasa nesi procesu.

El siguiente exemplu:

 

template <typename A> int myfunction(A a);

 

crea una plantía so la cual pueden ser definíes nel códigu de cabecera cualesquier funciones especializaes pa un tipu de datos como <tt>int myfunction(int), int myfunction(std::string), int myfunction(bool)</tt>, etcétera:

 

int myfunction (int a) {

return a + 5;

return (a & rand()); //Si a ye verdaderu, devuelve un númberu aleatoriu; en casu contrariu devuelve 0

};

 

Caúna d'estes funciones tien la so propia definición (cuerpu). Cada cuerpu distintu, non equivalente ("non convertible") correspuende a una '''especialización'''. Si una d'estes funciones nun fuera definida, el compilador va tratar d'aplicar les conversiones de tipos de datos que-y fueren dexaes pa "calzar" una de les plantíes, o va xenerar un mensaxe d'error si fracasa nesi procesu.

En C++ los métodos de les clases astractes defínense como [[función virtual|funciones virtuales]] pures.

 

class Astracta {

 

}

};

Nel exemplu, la clase <tt>ConcretaA</tt> ye una implementación de la clase <tt>Astracta</tt>, y la clase <tt>ConcretaB</tt> ye otra implementación.

Tien De notase qu'el <tt>= 0</tt> ye la notación qu'emplega C++ pa definir funciones virtuales pures.

Por casu:

 

# include <iostream>

// Les funciones nesta cabecera esisten dientro del espaciu de nomes std::

return 0;

}

 

Como puede trate, les invocaciones direutes a ''el mio_valor'' van dar accesu solamente a la variable descrita llocalmente; p'aportar a la variable del espaciu de nomes ''el mio_paquete'' ye necesariu aportar específicamente l'espaciu de nomes. Un atayu encamentáu pa programes senciellos ye la direutiva <tt>using namespace</tt>, que dexa aportar a los nomes de variables del paquete deseyáu en forma direuta, siempres y cuando nun se produza dalguna ambigüedá o conflictu de nomes.

 

Nesti exemplu tendríamos les coses xenerales d'un Barcu (en C++)

class Barcu {

protected:

//Constructores y demás funciones básiques de barcu };

 

y agora les carauterístiques de les clases derivaes, podríen (al empar qu'herieden les de barcu) añedir coses propies del subtipo de barcu que vamos crear, por casu:

 

class Cargueru: public Barcu { // Esta ye la manera d'especificar qu'herieda de Barcu private:

// El restu de coses

};

 

A lo último, hai que mentar qu'esisten 3 clases d'heriedu que s'estremen na manera de remanar la visibilidá de los componentes de la clase resultante:

Cuando ves a quien te atiende nuna tienda, como persona que ye, vas poder suponer que puede falar, comer, andar, pero, per otru llau, como emplegáu que ye, tamién vas poder suponer que tien un xefe, que puede cobrate dineru pola compra, que puede devolvete'l cambéu, etc. Si esto treslladar a la programación sería heriedu múltiple (clase emplegáu_tienda):

 

class Persona {

...

...

};

 

Por tanto, ye posible utilizar más d'una clase por qu'otra heriede les sos carauterístiques.

** Operador +

** Operador -

* ** Operador /

** Operador %

Estes clases tienen sobrecargados el operadores << y >>, respeutivamente, al envís de ser útiles nel insertamientu/estracción de datos a dichos fluxos. Son operadores intelixentes, yá que son capaces d'afaese al tipu de datos que reciben, anque vamos tener que definir el comportamientu de felicidá entrada/salida pa clases/tipo de datos definíos pol usuariu. Por casu:

 

ostream& operator<<(ostream& fs, const Puntu& puntu)

{

return fs << puntu.x << "," << puntu.y;

}

 

D'esta forma, p'amosar un puntu, solo habría que realizar la siguiente espresión:

//...

Puntu p(4,5);

cout << "Les coordenaes son: " << p << endl;

//...

 

Ye posible formatear la entrada salida, indicando'l númberu de díxitos decimales a amosar, si los testos van pasar a minúscules o mayúscules, si los númberos recibíos tán en formatu [[sistema octal|octal]] o [[sistema hexadecimal|hexadecimal]], etc.

Lleer un ficheru:

1-Si ye ficheru de testu planu:

#include <fstream>

#include <string>

return 0;

}

 

2-Si ye un ficheru binariu(.dat);

Exemplos:

 

ostringstream s;

s << nome << "," << edá << "," << estatura << "," << puntu(5,6) << endl;

istringstream s(cadena);

s >> nome >> edá >> estatura >> p;

 

=== Contenedores ===

* Vectores: Definir por <pre>vector<tipu_de_datu> nome_del vector;</pre> Son arrays (o llistes ordenaes) que se redimensionan automáticamente al amestar nuevos elementos, polo que se-y pueden amestar "teóricamente", infinitos elementos. Los vectores déxennos aportar a cualquier elementu que contenga, por aciu l'operador[]. Tien De tenese en cuenta que si s'intenta aportar a una posición qu'entepasa les llendes del vector, esti nun va faer nengún chequeo, polo que se debe ser cuidadosu al utilizar esti operador. P'asegurar un accesu seguru al vector, puede utilizase el métodu at(int), que llanza una esceición de tipu std::out_of_range en casu de qu'esto asoceda.

P'añedir elementos a la fin del vector, utilízase'l métodu push_back(const T&). Per otru llau, pa esaniciar un elementu del final del vector, tien d'usase'l métodu pop_back().

#include <vector> //llibrería que contién a la clase vector

#include <iostream>

return 0;

}

* Coles dobles: son paecíes a los vectores, pero tienen meyor eficiencia p'amestar o esaniciar elementos nes "puntes".<pre>deque<tipu_de_datu> nome_de_la cola;</pre>

Amás de los métodos push_back(const T&) y pop_back(), amiéstense los métodos push_front(const T&) y pop_front(), que realicen lo mesmo que los yá esplicaos, pero nel empiezu de la cola.

 

#include <deque> //llibrería de deques

 

return 0;

}

* Llistes: Son eficientes a la d'amestar elementos. La diferencia coles coles dobles, ye que son más eficientes pa esaniciar elementos que nun tean en dalguna de les "puntes"<pre>list<tipu_de_datu> nome_de_la llista;</pre>

* Adaptadores de secuencia.

</pre>

 

#include <map> //llibrería que contién a map y multimap

#include <string> //llibrería de strings

return 0;

}

* Contenedores asociativos: set y multiset, qu'ufierten solamente la condición de "pertenencia", ensin la necesidá de garantizar un ordenamientu particular de los elementos que contienen.

 

Un algoritmu bien importante que vien implementáu na biblioteca STL, ye'l sort. L'algoritmu sort, ordena cualquier tipu de contenedor, siempres y cuando se-y pasen como argumentos, dende onde y hasta onde quier ordenar lo.

 

#include <vector>

#include <deque>

/*Notar que si en cuenta de un vector, fuera una deque, ordenar de la mesma manera. */

}

 

Ente les funciones más conocíes tán <tt>swap (variable1, variable2)</tt>, qu'a cencielles intercambia los valores de variable1 y variable2; <tt>max (variable1, variable2)</tt> y el so símil <tt>min (variable1, variable2)</tt>, que retornen el máximu o mínimu ente dos valores; <tt>find (entamu, fin, valor)</tt> que busca valor nel espaciu de variables ente entamu y fin; etcétera.

=== Usu ===

 

#include <cstdlib>

using namespace std;

system("color 45");

 

 

Nesti casu definióse'l fondu de pantalla de color coloráu y les lletres rosadas.

* [[wxDev-C++]]

* [[Zinjai]]

* [[CodeLite]]

 

* [[Zinjai]]

* [[Kdevelop]]

* [[CodeLite]]

* [[Clion (software)]]

Pa evitar los problemes qu'esisten en C ++, y p'aumentar la productividá,<ref>[https://www.technologyreview.com/s/419956/new-languages-and-why-we-need-them/ New Languages, and Why We Need Them], [[MIT Technology Review]]</ref> delles persones suxuren llinguaxes alternativos más recién que C ++, como [[D (llinguaxe de programación)|D]], [[Go (llinguaxe de programación)|Go]], [[Rust (llinguaxe de programación)|Rust]] y [[Vala (llinguaxe de programación)|Vala]].<ref>[http://www.drdobbs.com/architecture-and-design/the-new-native-languages/232901652 The New Native Languages | Dr Dobb's]</ref>

 

 

* [[A++]]