#include <iostream> // incluye la Biblioteca para usar cout y cin de C++

// cout es equivalente a printf y cin a scanf

#include <conio.h> // conio significa console input output, sirve para usar
// getche() que espera toquemos una tecla del teclado
// o sea lee un caracter del teclado

#include <stdio.h> // ya la conocen de Programación, es para usar printf

// y scanf
using namespace std; // Se usa para poder usar cout y cin de un modo más
// simple como lo vemos en este programa.
// Si esta sentencia no estuviera, se debería
// usar cout, endl y string de este modo: std::cout<<;
// std::endl y std::string

class Alumno //Declaración del la clase y su nombre

{
// Atributos de la clase: nombre, edad y promedio

string nombre; // al no tener public: o private: adelante seasume private

int edad; // Idem
double promedio; // Idem
//Fin de los atributos, comienzan los métodos o funciones
public: // Todos los métodos que estén debajo de este public:
// serán públicos.

// Función ó método Constructor Alumno()sin argumentos o parámetros

// entre paréntesis
Alumno()
{
this->nombre="Juan"; // this-> apunta al Objeto alu1 creado en main
// en la memoria con la sentencia en main()
// Alumno alu1=Alumno();
// Alumno alu1 crea el Objeto en la memoria con sus 3
// atributos pero vacíos, esto pasa con Alumno alu1.
// después la sentencia sigue con =Alumno(); esto invoca
// al constructor Alumno() que
// usando this-> pone datos en los atributos del Objeto
// alu1
// Guarda Juan en el atributo nombre del Objeto alu1
this->edad=23; // Idem para la edad, guarda 23
this->promedio=8.25; // Idem para el promedio,guarda 8.25

} // Fin método constructor Alumno()

// Método o Función Constructor Alumno Sobrecargado con
// argumentos o parámetros
// Función Constructor Sobrecargado, los parámetros o argumentos son
// string nom, int ed, double prom
Alumno(string nom, int ed, double prom)
{
this->nombre=nom;
this->edad=ed;
this->promedio=prom;
}
// Por ahora no lo necesitamos al Destructor
// Función Destructor
// ~Alumno() {cout<<" Ejecucion Destructor "<<endl;}

// Funciones getter
string getnombre()
{
cout<< "Nombre: " << this->nombre << endl; // Muestra el nombre en pantalla
return this->nombre; // retorna el nombre a main a la sentencia
// alu1.getnombre()
}
void getedad()
{
cout<< "Edad: " << this->edad << endl;
}
void getpromedio()
{
cout<< "Promedio: " << this->promedio << endl << endl;;
}
// Funciones setter
void setnombre(string nom)
{
this->nombre=nom;
}
void setedad(int ed)
{
this->edad=ed;
}
void setpromedio(double prom)
{
this->promedio=prom;
}
};

int main()
{
cout<< endl << "Vamos a crear"<<endl<<"al objeto alu1 usando el constructor
por defecto que no tiene argumentos"<<endl;
cout <<endl<<"Apriete cualquier tecla para continuar" << endl <<endl;
getche();
Alumno alu1=Alumno(); // La explicación de esta sentencia la hicimos
// en clase, pero les aclaro que después del signo =
// viene Alumno() que es un llamado al constructor que
// está más arriba.

// Estas tres sentencias comentadas más abajo se podrían usar si los atributos
// fueran públicos, pero como son privados el compilador no lo va a permitir
//cout<<"Nombre: "<<alu1.nombre<<endl; Esta y las dos de abajo dará error
// porque son privados
//cout<<"Edad: "<<alu1.edad<<endl;
//cout<<"Promedio: "<<alu1.promedio<<endl;
cout << "Datos del objeto alu1 recien creado e inicializao por el constructor por
defecto:" << endl;
alu1.getnombre(); // Como los atributos son privados, la única manera
// de accederlos es usando métodos públicos de la clase
// esos son getnombre, getedad y getpromedio.
// como se ve, se invocan poniendo alu1.getnombre()
// alu1.getedad() y alu1.getpromedio(). Estas sentencias
// significan lo siguiente: al objeto alu1 le pido
// que muestre su nombre, luego su edad y luego su promedio
// En otras palabras le pido al objeto alu1 que ejecute el
// método que está después del punto(alu1.getnombre).
// Un purista de Object Oriented va a decir que al objeto
// alu1 le enviamos un mensaje para que muestre su nombre
// o su edad o su promedio.
// ver más arriba lo que hacen getnombre, getedad y
// getpromedio.
alu1.getedad(); // Idem
alu1.getpromedio(); // Idem
cout << "Vamos a setear los datos edad y promedio de Juan que han
cambiado" << endl;
cout << "Apriete cualquier tecla para continuar" << endl <<endl;
getche();
alu1.setedad(26); // Le pido al objeto alu1 que setee su edad
// Ver más arriba lo que hace setedad.
alu1.setpromedio(9); // Idem para promedio
cout << "Datos del objeto alu1 modificados:" << endl;
//Las tres sentencias que siguen ya las explicamos más arriba
alu1.getnombre();
alu1.getedad();
alu1.getpromedio();
cout<< endl << "Vamos a crear al objeto alu2 usando el constructor
sobrecargado que tiene argumentos" <<endl;
cout << "Apriete cualquier tecla para continuar" << endl <<endl;
getche();
Alumno alu2=Alumno("Ana",22,9.25); // Alumno alu2 crea al objeto alu2 en
// memoria pero vacío, luego
// =Alumno("Ana",22,9.25) invocará al
// método sobrecargado y le mandalos datos
// para que los ponga en los atributos
// del objeto alu2.
cout << "Datos del objeto alu2:" << endl;
// Creo que a esta altura sabrán que hacen las tres sentencias que siguen
alu2.getnombre();
alu2.getedad();
alu2.getpromedio();
// Lo que viene que está comentado lo pueden probar, si tienen tiempo,
// por ahora no es obligatorio

/*cout << "Ejemplo para acceder a datos de los objetos alu1 y alu2 cuando son
declarados public" << endl;
cout << "Si no los hubiéramos declarados public en la clase Alumno hubiera
dado error por que por defecto son private" << endl;
cout << "Apriete cualquier tecla para continuar" << endl <<endl;
getche();
cout << alu2.nombre << endl;
cout << alu1.nombre << endl;
cout << "Edad de Juan: " << alu1.edad << endl;
cout << "Promedio de Ana: " <<alu2.promedio << endl;
*/
return 0;
}