Composición de clases

Por composición se entiende la capacidad que presenta la POO de ensamblar una nueva clase
cuyos elementos o piezas son otras clases, es decir que una clase esta dentro de otra, esta
relación es conocida como composición o contención. Por ejemplo la clase AUTO contiene
RUEDAS o contiene SILLAS que a su vez pueden ser otras clases.

En el siguiente ejemplo se creará un reloj, con atributos como: marca, color, tamaño, etc. Y
atributos como hora de de Alarma y hora Actual del reloj. Para esto aprovechamos la
composición entre clases y utilizamos la clase HORA que ya se implementó previamente:

#ifndef HORA_H
#define HORA_H

class hora
{ private:
int hor;
int min;
int seg;
public:
hora();
hora(int h, int m, int s);
virtual ~hora();
hora SiguienteSegundo();
void mostrar();
int GetHora();
int GetMin();
int GetSeg();
};
#endif // HORA_H
La implementación de la clase hora es:

#include "hora.h"
#include <iostream>
using namespace std;
hora::hora()
{ hor=0;
min=0;
seg=0;
}
hora::hora(int h, int m, int s)
{ hor=h;
min=m;
seg=s;
}
hora::~hora() { }

hora hora::SiguienteSegundo()
{ hora sig;
sig.hor=hor;
sig.min=min;
sig.seg=seg+1;
if(seg==59)
{ sig.seg=0;
sig.min++;
if(min==59)
{ sig.min=0;
sig.hor++;
if(hor==24)
{ sig.hor=0;
sig.min=0;
sig.seg=0;
}
}
}
return sig;
}
void hora::mostrar()
{ cout<<hor<<" : "<<min<<" : "<<seg<<endl;
}
int hora::GetHora()
{ return hor;
}
int hora::GetMin()
{ return min;
}
int hora::GetSeg()
{ return seg;
}
En la clase Reloj se debe incluir hora.h por que contiene alarma y actual que son de tipo
HORA.

#include "hora.h"
#include <string>
using namespace std;
#ifndef RELOJ_H
#define RELOJ_H

class reloj
{
private:
string marca;
hora alarma;
hora actual;
public:
reloj();
virtual ~reloj();
void funcionar();
void SetAlarma(hora al);
hora GetAlarma();
};
#endif // RELOJ_H

La Implementación de RELOJ muestra como en el método FUNCIONAR se incrementa la hora

actual segundo a segundo, llamando al método SiguienteSegundo() de la clase Hora.

#include "reloj.h"
#include <iostream>
#include <windows>
using namespace std;

reloj::reloj(){}

reloj::~reloj(){}

void reloj::funcionar()
{ system("cls");
for (int x=1;x<4600;x++)
{ actual = actual.SiguienteSegundo();
actual.mostrar();
Sleep(1000);
system("cls");
}
}
hora reloj::GetAlarma()
{ return alarma;
}

void reloj::SetAlarma(hora al)

{ alarma=al;
}
Desde el programa principal, creamos un reloj y lo ponemos a funcionar

#include "reloj.h"
#include "hora.h"
#include <iostream>
#include <string>
using namespace std;

int main()
{
reloj clock;

clock.funcionar();

system("pause");
}