C++
Concepto de clase.
Los objetos en C++ son abstraídos mediante una clase. Según el paradigma de la programación orientada a objetos un objeto consta de:
Identidad, que lo diferencia de otros objetos (Nombre que llevara la clase a la que pertenece dicho objeto).
Métodos o funciones miembro
Atributos o variables miembro
Un ejemplo de clase que podemos tomar es la clase perro. Cada perro comparte unas características (atributos). Su número de patas, el color de su pelaje o su tamaño son algunos de sus atributos. Las funciones que lo hagan ladrar, cambiar su comportamiento... esas son las funciones de la clase.
Este es otro ejemplo de una clase:
class Punto
{
//por omisión los miembros son 'private' para que sólo 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
Son unos métodos especiales que se ejecutan automáticamente al crear un objeto de la clase. En su declaración no se especifica el tipo de dato que devuelven, y poseen el mismo nombre que la clase a la que pertenecen. Al igual que otros métodos, puede haber varios constructores sobrecargados, aunque no pueden existir constructores virtuales.
Como característica especial a la hora de implementar un constructor, justo después de la declaración de los parámetros, se encuentra lo que se llama "lista de inicializadores". Su objetivo es llamar a los constructores de los atributos que conforman el objeto a construir.
Cabe destacar que no es necesario declarar un constructor al igual que un destructor, pues el compilador lo puede hacer, aunque no es la mejor forma de programar.
Tomando el ejemplo de la Clase Punto, si deseamos que cada vez que se cree un objeto de esta clase las coordenadas del punto sean igual a cero podemos agregar un constructor como se muestra a continuación:
class Punto
{
public:
float x; // Coordenadas del punto
float y;
// Constructor
Punto() : x(0), y(0){ // Inicializamos las variables "x" e "y"
}
};
// Main para demostrar el funcionamiento de la clase
# include <iostream> // Esto nos permite utilizar "cout"
using namespace std;
int main () {
Punto MiPunto; // creamos un elemento de la clase Punto llamado MiPunto
cout << "Coordenada X: " << MiPunto.x << endl; // mostramos el valor acumulado en la variable x
cout << "Coordenada Y: " << MiPunto.y << endl; // mostramos el valor acumulado en la variable y
getchar(); // le indicamos al programa que espere al buffer de entrada (detenerse)
return 0;
}
Si compilamos y ejecutamos el anterior programa, obtenemos una salida que debe ser similar a la siguiente:
Coordenada X: 0 Coordenada Y: 0
Existen varios tipos de constructores en C++:
- Constructor predeterminado. Es el constructor que no recibe ningún parámetro en la función. Si no se definiera ningún constructor, el sistema proporcionaría uno predeterminado. Es necesario para la construcción de estructuras y contenedores de la STL.
- Constructor de copia. Es un constructor que recibe un objeto de la misma clase, y realiza una copia de los atributos del mismo. Al igual que el predeterminado, si no se define, el sistema proporciona uno.
- Constructor de conversión. Este constructor, recibe como único parámetro, un objeto o variable de otro tipo distinto al suyo propio. Es decir, convierte un objeto de un tipo determinado a otro objeto del tipo que estamos generando.
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 además llama a su constructor(por lo que se le pueden enviar parámetros). El operador new se utiliza de la siguiente manera:
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;
}
Además, con el operador new[] se pueden crear arrays (colecciones o listas ordenadas) de tamaño dinámico:
Punto *asignar(int cuantos) {
return new Punto[cuantos]; //asigna un array de 'cuantos' puntos(se llama el constructor que se muestra más arriba), y se retorna.
}
Destructores
Los destructores son funciones miembro especiales llamadas automáticamente en la ejecución del programa, y por tanto no tienen por qué ser llamadas explícitamente por el programador. Sus principales cometidos son:
- Liberar los recursos computacionales que el objeto de dicha clase haya adquirido en tiempo de ejecución al expirar éste.
- Quitar los vínculos que pudiesen tener otros recursos u objetos con éste.
Los destructores son invocados automáticamente al alcanzar el flujo del programa el fin del ámbito en el que está declarado el objeto. El único caso en el que se debe invocar explícitamente al destructor de un objeto, es cuando éste fue creado mediante el operador new, es decir, que éste vive en memoria heap, y no en la pila de ejecución del programa. La invocación del destructor de un objeto que vive en heap se realiza a través del operador delete o delete[] para arrays. Ejemplo:
int main() {
int *unEntero = new int(12); //asignamos un entero en memoria heap con el valor 12
int *arrayDeEnteros = new int[25]; //asignamos memoria para 25 enteros(no estan inicializados)
delete unEntero; //liberamos la memoria que ocupaba unEntero
delete[] arrayDeEnteros; //liberamos la memoria ocupada por arrayDeEnteros
return 0;
}
Si no se utilizara el operador delete y delete[] en ese caso, la memoria ocupada por unEntero y arrayDeEnteros respectivamente, quedaría ocupada sin sentido. Cuando una porción de memoria queda ocupada por una variable que ya no se utiliza, y no hay forma de acceder a ella, se denomina un 'memory leak'. En aplicaciones grandes, si ocurren muchos memory leaks, el programa puede terminar ocupando bastante más memoria RAM de la que debería, lo que no es para nada conveniente. Es por esto, que el manejo de memoria heap debe usarse conscientemente.
Existen dos tipos de destructores pueden ser públicos o privados, según si se declaran:
- Si es público se llama desde cualquier parte del programa para destruir el objeto.
- Si es privado no se permite la destrucción del objeto por el usuario.
El uso de destructores es clave en el concepto de Adquirir Recursos es Inicializa.
C#
using System;
public class Ejemplo {
public static void Main(string[] args) {
Console.WriteLine("Hola mundo");
}
}
Suma y concatenación:
using System;
public class Ejemplo {
public static void Main(string[] args) {
int x = 10;
int y = 20;
Console.WriteLine("El resultado es: " + (x + y)); // Imprimirá en pantalla: "El resultado es: 30"
}
}
Uso de clases, métodos, propiedades y sobrecarga:
using System;
public class Coche {
private int numPuertas;
public int NumPuertas {
get {
return this.numPuertas;
}
set {
this.numPuertas = value; // 'value' es una variable que se asigna automáticamente al asignar un valor a la propiedad, para poder trabajar con dicho valor.
}
}
public Coche(int numPuertas) {
this.NumPuertas = numPuertas;
}
// Sobrecarga: si se instancia la clase sin indicar ningún parámetro, se inicializa 'numPuertas' con el valor '2'
public Coche() : this(2) {
}
}
public class Ejemplo {
public static void Main(string[] args) {
Coche coche = new Coche(); // Se usa el segundo constructor
coche.NumPuertas = 4;
Console.WriteLine("El número de puertas es: " + coche.NumPuertas);
}
}
