#include <iostream>
#include <vector>
#include <stdlib.h>
#include <time.h>
/*
De pregunta 3 en C2 ELO329 2009
Se desea implementar la función genérica maximo(vec) la cual recibe un vector vec (no vacío)
de objetos y retorna una referencia constante (no un puntero) al mayor de ellos según el 
criterio de comparación que corresponda al objeto.    
a) Cree una plantilla (template) para la función global maximo(vec) de manera que se pueda invocar con
vectores de objetos, todos instancias de la misma clase. 
b) Complete e implemente la clase Dado para que podamos hacer:
const Dado &maxDado = maximo(v); // cuando v es un vector de Dados.
class Dado{ 
public: 
  Dado();  // por omisión el dado tiene 6 caras 
  Dado(int n_caras); // crea dado de  n_caras 
 :   // otros métodos que puedan ser requeridos para el uso pedido.
private:
      cont int numCaras; 
      int valor; 
} ;

*/
using namespace std;

template <class T>
const T& maximo(const vector<T> &v) {
  int max = 0;
  for (int i=1; i<v.size(); i++)
    if (v[i]>v[max])
      max=i;
  return v[max];
}

class Dado {
public:
  Dado();
  Dado(int n_caras);
  bool operator> (const Dado & d) const;  // Requerido por la platilla
    // otros métodos
  const Dado & operator=(const Dado&d);  // no se pedía.
                                         // Es requerido por vector.
                                         // La asignación por omisión
                                         // no sirve por tener atributo
                                         // constante.
  friend ostream& operator<<(ostream &os, const Dado&d); // no se pedía
private:
  const int numCaras;
  int valor;
};


Dado::Dado():numCaras(6)  {
  valor=random()%6+1;  // no importa para el problema
}
Dado::Dado(int n_caras):numCaras(n_caras) {
  valor=random()%n_caras+1;   // no importa para el problema
}
bool Dado::operator>(const Dado & d) const {
  return valor > d.valor;  // no importa su criterio de comparación
}

const Dado & Dado::operator=(const Dado&d){  // no se pedía
  valor=d.valor>numCaras?numCaras:d.valor;
  return *this;
}

ostream & operator<<(ostream & os, const Dado&d){ // no se pedía
  os << d.valor;
}

int main (void) {
  srandom(time(NULL)); // semilla números aleatorios
  vector<Dado> a;
  Dado d1(8);
  Dado d2, d3(10);
  a.push_back(d1);
  a.push_back(d2);
  a.push_back(d3);
  cout << maximo(a)<< endl;
  const Dado & d=maximo(a);
  cout << d << endl;
}