Capitulo 8: Programacion Orientada a Objetos.

Escribir programas en OOP implica pensar en nuestros programas a alto nivel.
Las clases en C++ nos permiten agrupar datos en forma de variables, y funciones conocidas
como metodos, que operan con los datos. Las clases nos permiten marcar variables y
metodos para ocultarlos al resto del programa.
Este concepto de ocultar datos se llama encapsulacion.
La interfaz pública que escribamos tendra en cierta manera un comportamiento predecible
para otras clases. Esta interfaz será consistente con el objetivo de crear programas
fácilmente mantenibles. En cambio los datos privados y metodos pueden ser modificados
tan frecuentemente como nosotros necesitemos. Por defecto los miembros y metodos de nuestra
clase seran privados.
Si tenemos variables miembro públicas, esto rompería la encapsulación.
La manera de solucionar este problema es utilizar metodos para acceder a las variables.

class Jugador
{

	private:
		std::string m_nombre;
	public:
		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}

		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};


string nombre;
cin >> nombre;
jugador.Nombrar(nombre);

Cuando usas la palabra clave class informas al compilador para que cree un nuevo tipo de
dato. Cuando se crea una variable, la primera tarea a ser realizada es inicializarla. C++
nos ofrece metodos denominados constructores que son llamados cuando nuestra clase
es inicializada. Ahora anhadiremos el constructor a la clase que creamos previamente:

class Jugador
{

	private:
		std::string m_nombre;
	public:
		Jugador(const std::string& nombre)
				: m_nombre(nombre)
		//En caso de querer anhadir mas variables a la lista de inicializacion,
	// usaremos la coma (,) en lugar de los dos puntos (:) para las siguientes variables.
		{
		}

		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}

		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};

Este codigo dara error si lo implementamos tal cual en nuestro programa debido a que
nuestro constructor tiene un parametro string, lo que implica que debemos pasar un
string a jugador.
 El problema estaria en:		 			Jugador jugador;
Para solucionarlo,
puedes pasar el string a jugador: 		  	Jugador jugador("NombrePorDefecto");
o anhadiendo tu propio constructor por defecto:

class Jugador
{

	private:
		std::string m_nombre;
	public:
		Jugador()
		{
		}

		Jugador(const std::string& nombre)
				: m_nombre(nombre)
		{
		}

		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}

		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};


Si anhades constructores por defecto a tus clases dependera principalmente de si hacerlo
es valido.
No todas las clases tienen sentido cuando no se les pasan valores para inicializarlos.
Los constructores de clase son llamados cuando objetos del tipo de nuestra clase son
creados.
Los destructores de clase son llamados cuando nuestros objetos estan siendo destruidos.
Los objetos pueden destruirse de diversas formas.
En el siguiente codigo de ejemplo, acutalmente solo se destruyen objetos cuando estos
se van fuera del dominio.

int main()
{
	Jugador jugador;
	BucleDelJuego::SaludarAlJugador(jugador);

	bool EstaJugando = true;
	while (EstaJugando)
	{
		EstaJugando = BucleDelJuego::IniciarPartida();
	}

	return 0;
}

El constructor de Jugador es llamado cuando se crea la variable jugador. Este codigo llama
al constructor por defecto. La variable jugador se va fuera de dominio cuando la funcion
que la contiene retorna (return). Entonces el destructor es llamado automaticamente tras
el return.

class Jugador
{

	private:
		std::string m_nombre;
	public:
		Jugador()
		{
		}

		Jugador(const std::string& nombre)
				: m_nombre(nombre)
		{
		}

		~Jugador() //Este es el destructor.
		{
		}

		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}

		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};


El destructor se crea con una funcion con el nombre de la clase, precedido este por el
simbolo ~
Todas las clases tienen metodos destructores. En caso de no tenerlo y al igual que con los
constructores, el compilador se encargara de crear unos por defecto.

Cuando nos referimos al codigo de una clase, nos referimos a el como clases.
Cuando nos referimos a variables que son del tipo de la clase, nos referimos a ellas como
objetos.
La clase es el tipo de dato, y los objetos una instancia de la clase.

Sobrecarga de metodos:
C++ nos permite crear distintos metodos compartiendo el mismo nombre pero que reciben
diferentes parametros de entrada. Ejemplo:

class Jugador
{
private:
		std::string m_nombre;
public:
		Jugador()
		{
		}

		Jugador(const std::string& nombre)
				: m_nombre(nombre)
		{
		}

		~Jugador()
		{
		}

		void Nombrar(const std::string& NombreDePila, const std::string& apellido)
		{
			m_nombre = NombreDePila;
			m_nombre.append(" ");
			m_nombre.append(apellido);
		}

		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}


		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};

Puedes llamar a los metodos Nombrar de la siguiente manera:

jugador.Nombrar("Manolo");
jugador.Nombrar("Manuel", "Perez")

El compilador trabaja automaticamente llamando al metodo correspondiente segun los
parametros de entrada.

Metodos que solo tienen valores de retorno diferente daran error de compilacion.

A parte de poder sobrecargar metodos, tambien podemos sobrecargar operadores:

class Jugador
{
private:
		std::string m_nombre;
public:
		Jugador()
		{
		}

		Jugador(const std::string& nombre)
				: m_nombre(nombre)
		{
		}

		~Jugador()
		{
		}

		void Nombrar(const std::string& NombreDePila, const std::string& apellido)
		{
			m_nombre = NombreDePila;
			m_nombre.append(" ");
			m_nombre.append(apellido);
		}

		void Nombrar(const std::string& nombre)
		{
			m_nombre = nombre;
		}

		void operator+=(const std::string& nombre) //Operador sobrecargado.
		{
			m_nombre.append(nombre);
		}


		const std::string& ObtenerNombre() const
		{
			return m_nombre;
		}

};


Haremos la llamada de la siguiente forma:

jugador.Nombrar("Manolo");
jugador += " Perez";

Algunas veces no vas a querer modificar el objeto pero te gustaria anhadir el nombre al
string pasado y almacenar un valor de retorno. Tendra mas sentido sobrecargar el operador
+ en ese caso:

std::string operator+(const std::string& nombre)
{
	std::string obtener(m_nombre);
	obtener.append(nombre);
	return obtener;
}
Esta funcion anhade el string pasado por parametro al miembro m_nombre y devuelve un nuevo
string creado para almacenar el resultado. Podremos usar el operador de la siguiente
manera:

jugador.Nombrar("Manolo");
string NombreCompleto = jugador + " Perez";

Los ejemplos que estamos viendo tienen una desventaja, no podemos encadenar los operadores
juntos.
Para eso tenemos el operador de asignacion que nos permite encadenar.

const Jugador& operator=(const Jugador& jugador)
{
	m_nombre = jugador.nombre;
	return this*;
}

El puntero this guarda la direccion en memoria para el objeto actual. Nuestro operador =
devuelve una referencia constante al objeto actual Jugador. Ejemplo:

void SaludarAlJugador(Jugador& jugador);
{
	cout << "Bienvenido!" << endl;
	cout << "Como te llamas?" << endl;

	string nombre;
	cin >> nombre;
	jugador.Nombrar("Manolo");
	Jugador jugador1, jugador2, jugador3, jugador4;
	jugador1 = jugador2 = jugador3 = jugador4 = jugador; //Cadena con el operador =

	cout << endl << "Hola " << jugador.ObtenerNombre() << endl;
}

El operador nos a permitido asignar el valor de jugador a todos los Objetos de Jugador
que acabamos de crear. El orden de asignaciones es el siguiente:
jugador4 = jugador;
jugador3 = jugador4;
jugador2 = jugador3;
jugador1 = jugador2;