TEMA DE CLASES Y OBJETOS

EJERCICIOS:
#include<iostream>
using namespace std;
class rectangulo {//esta es la clase rectangulo, en su juridiccion las variables base y altura estan definidas.
private:
int base;//sus atributos son base y altura
int altura;
public:
void cargar_datos(int, int);
int calcular_area();
};
void rectangulo::cargar_datos(int xbase, int xaltura) {
base = xbase;
altura = xaltura;
}
int rectangulo::calcular_area() {
int area;
area = base * altura;//AQUI LOS VALORES DE LAS VARIABLES ESTAN DEFINIDAS YA QUE BASE Y
ALTURA PERTENECEN A LA CLASE RECTANGULO.
return area;
}
int main(){
rectangulo cuadro, papel, cuaderno, regla;
cuadro.cargar_datos(5, 10);
cout << cuadro.calcular_area() << endl;
return 0;
}

Con punteros:

#include<iostream>
using namespace std;
class rectangulo {//esta es la clase rectangulo, en su juridiccion las variables base y altura estan definidas.
private:
int base;//sus atributos son base y altura
int altura;
public:
void leer_datos(int*, int*) ;
void cargar_datos(int*, int*);
int calcular_area();
};
void rectangulo :: leer_datos( int *aux_altura,int *aux_base) {
cout << "Ingrese la base"; cin >> *aux_base;
cout << "Ingrese la altura"; cin >> *aux_altura;
}
void rectangulo::cargar_datos(int *aux_base, int *aux_altura) {
base = *aux_base;
altura = *aux_altura;
}
int rectangulo::calcular_area() {
int area;
 area = base * altura;//AQUI LOS VALORES DE LAS VARIABLES ESTAN DEFINIDAS YA QUE BASE Y
ALTURA PERTENECEN A LA CLASE RECTANGULO.
return area;
}
int main(){
rectangulo cuadro, papel, cuaderno, regla;
int aux_altura, aux_base;
cuadro.leer_datos(&aux_altura, &aux_base);
cuadro.cargar_datos(&aux_base,&aux_altura );
cout << cuadro.calcular_area() << endl;
return 0;
}

Con patrones de referencia:

#include<iostream>
using namespace std;
class rectangulo {//esta es la clase rectangulo, en su juridiccion las variables base y altura estan definidas.
private:
int base;//sus atributos son base y altura
int altura;
public:
void leer_datos(int&, int&) ;
void cargar_datos(int&, int&);
int calcular_area();
void imprimir(int );
};
void rectangulo :: leer_datos( int &aux_altura,int &aux_base) {
cout << "Ingrese la base"; cin >> aux_base;
cout << "Ingrese la altura"; cin >> aux_altura;
}
void rectangulo::cargar_datos(int &aux_base, int &aux_altura) {
base = aux_base;
altura = aux_altura;
}
int rectangulo::calcular_area() {//ESTAMOS EN LA CLASE RECTANGULO
int area;
area = base * altura;//AQUI LOS VALORES DE LAS VARIABLES ESTAN DEFINIDAS YA QUE BASE Y
ALTURA PERTENECEN A LA CLASE RECTANGULO.
return area;
}
void rectangulo::imprimir(int aux_area) {
cout << aux_area << endl;
}
int main(){
rectangulo cuadro, papel, cuaderno, regla;
int aux_altura=0, aux_base=0, aux_area=0;
cuadro.leer_datos(aux_altura, aux_base);
cuadro.cargar_datos(aux_base,aux_altura );
aux_area = cuadro.calcular_area();
cuadro.imprimir(aux_area);
return 0;
}

Lo mismo pero para dos objetos CUADERNO Y REGLA:

#include<iostream>
using namespace std;
class rectangulo {//esta es la clase rectangulo, en su juridiccion las variables base y altura estan definidas.
private:
int base;//sus atributos son base y altura
int altura;
public:
void leer_datos(int&, int&) ;
void cargar_datos(int&, int&);
int calcular_area();
void imprimir(int );
};
void rectangulo :: leer_datos( int &aux_altura,int &aux_base) {
cout << "Ingrese la base"; cin >> aux_base;
cout << "Ingrese la altura"; cin >> aux_altura;
}
void rectangulo::cargar_datos(int &aux_base, int &aux_altura) {
base = aux_base;
altura = aux_altura;
}
int rectangulo::calcular_area() {//ESTAMOS EN LA CLASE RECTANGULO
int area;
area = base * altura;//AQUI LOS VALORES DE LAS VARIABLES ESTAN DEFINIDAS YA QUE BASE Y
ALTURA PERTENECEN A LA CLASE RECTANGULO.
return area;
}
void rectangulo::imprimir(int aux_area) {
cout << aux_area << endl;
}
int main(){
rectangulo cuadro, papel, cuaderno, regla;
int aux_altura=0, aux_base=0, aux_area=0;
cuadro.leer_datos(aux_altura, aux_base);
cuadro.cargar_datos(aux_base,aux_altura );
aux_area = cuadro.calcular_area();
cuadro.imprimir(aux_area);
cout << "REGLA" << endl;
regla.leer_datos(aux_altura, aux_base);
regla.cargar_datos(aux_base, aux_altura);
aux_area = regla.calcular_area();
regla.imprimir(aux_area);
return 0;
}

CONSTRUCTOR:

Caracerisiticas:

1. Que el método se llame igual que la CLASE.

2. Que a su lado no vaya ni void, int …. Nada tiene que ir
3. //USO DEL CONSTRUCTOR, SE DEBE INICIALIZAR CON LOS VALORES EN LA FUNCION
PRINCIPAL INT MAIN()
4. #include<iostream>
5. using namespace std;
6. class rectangulo {//esta es la clase rectangulo, en su juridiccion las variables base y altura estan definidas.
7. private:
 8. int base;//sus atributos son base y altura
9. int altura;
10. public:
11. void leer_datos(int&, int&);
12. rectangulo(int, int);//<---------constructor
13. int calcular_area();
14. void imprimir(int);
15. };
16. void rectangulo::leer_datos(int& aux_altura, int& aux_base) {
17. cout << "Ingrese la base"; cin >> aux_base;
18. cout << "Ingrese la altura"; cin >> aux_altura;
19. }
20. rectangulo::rectangulo(int x_base, int x_altura) {//me servira para cargar los datos
21. int aux_altura = 0, aux_base = 0;
22. leer_datos(aux_altura, aux_base);
23. base = aux_base;
24. altura = aux_altura;
25. }
26. int rectangulo::calcular_area() {//ESTAMOS EN LA CLASE RECTANGULO
27. int area;
28. area = base * altura;//AQUI LOS VALORES DE LAS VARIABLES ESTAN DEFINIDAS YA QUE
BASE Y ALTURA PERTENECEN A LA CLASE RECTANGULO.
29. return area;
30. }
31. void rectangulo::imprimir(int aux_area) {
32. cout << aux_area << endl;
33. }
34. int main() {
35. //rectangulo cuadro, papel, cuaderno, regla;
36. int aux_altura = 0, aux_base = 0, aux_area = 0;
37. rectangulo cuadro(aux_base, aux_altura);//se inicializa al principio el CONSTRUCTOR , en este
caso hace la simulacion de cargar datos
38. aux_area = cuadro.calcular_area();
39. cuadro.imprimir(aux_area);
40. cout << "REGLA" << endl;
41. rectangulo regla(aux_base, aux_altura);
42. aux_area = regla.calcular_area();
43. regla.imprimir(aux_area);
44. return 0;
45. }

EL CONSNTRUCTOR SU FINALIDAD ES INICIALIZAR LOS VALORES///

///////////////////////////
#include<iostream>
using namespace std;
class producto {
private:
string descripcion;
int precio;
 int cantidad;
public:
const float IGV = 0.18;
void cargar_datos(string,int,int);
int calcular_precio_deventa();
void imprimir();

};
void producto::cargar_datos(string _descr , int pre, int cant) {
descripcion = _descr;
precio=pre;
cantidad = cant;
}
int producto::calcular_precio_deventa() {
double preciodeventa;
preciodeventa = precio * (1+IGV);
return preciodeventa;
}
void producto::imprimir() {

}
int main() {
producto televisor, cocina, plancha;
televisor.cargar_datos("tv 50pulgadas", 50, 2);
televisor.imprimir();
return 0;
}

A partir de una clase sacamos dos objetos

#include<iostream>
using namespace std;
class producto {
private:
string descripcion;
int precio;
int cantidad;
int precio_de_venta=0;
public:
const float IGV = 18;
void cargar_datos(string ,int, int);
int calcular_precio_deventa();
void imprimir();
};
void producto::cargar_datos(string descri,int pre,int cant) {
precio = pre;
descripcion = descri;
cantidad = cant;
}
int producto::calcular_precio_deventa() {
precio_de_venta = precio * (1 + IGV);
return precio_de_venta;
}
void producto::imprimir() {
cout << "DESCRIPCION: " << descripcion << endl;
 cout << "PRECIO: " << precio << endl;
cout << "CANTIDAD: " << cantidad << endl;
cout << "PRECIO DE VENTA: " << calcular_precio_deventa() << endl;
}
int main() {
producto televisor, cocina, plancha;
televisor.cargar_datos("tv 50pulg",2000,3);//TODAS LAS FUNCIONES QUE LLAMEN SE REALIZARAN,
SINO IRAN DE FRENTE DE CARGAR_DATOS A IMPRIMIR
//SIN
REALIZARSE LA FUNCION CALCULAR_PRECIO_DE_VENTA.
televisor.imprimir();
cocina.cargar_datos("estufa", 200, 10);
cocina.imprimir();
return 0;
}

Cuando lo hacemos en tres ventanas diferentes:

1. Se comienza primero llamando al nombre de tu archivo como la clase, en este caso CUBO.h//
Aquí se procedera a crear la clase y sus atributos.
2. Segundo crearemos otro archivo donde tendrá el nombre de la clase CUBO.cpp, este contendrá
el desarrollo de los métodos aquí se inciara con el #include “CUBO.h”.
3. Por último se creara un archivo llamado Principal.cpp, en el cual #include<iostream> y #include
“CUBO.h” además del using namespace std. Aquí el int main() es el personaje principal y aquí se
llaman solo a los métodos.