es.davy.ai

Preguntas y respuestas de programación confiables

¿Tienes una pregunta?

Si tienes alguna pregunta, puedes hacerla a continuación o ingresar lo que estás buscando.

El mejor diseño para mapear enums a clases constantes.

26 Jul, 2023 Programación

Tengo este ejemplo que funciona:
Creo un objeto que implementa “PartInterface” para cada valor del enum y los agrego en un mapa. Pero no encuentro esto satisfactorio, ya que todo podría inferirse en tiempo de compilación en lugar de en tiempo de ejecución.
¿Hay una forma más elegante de hacer esto en c++ 11?
Otra solución sería construir los objetos “YearPart”, “MonthPart” y “DayPart” en cada llamada de la función “get”,
pero me parece menos eficiente…

“`cpp
#include
#include

#include

struct Date{
int year;
int month;
int day;
};

class PartInterface{
public:
virtual const std::string &getName()const=0;
virtual int getValue(const Date &d)const=0;
virtual ~PartInterface(){}
};

class Part : public PartInterface{
public:
Part(const std::string& name):_name(name){}

const std::string &getName()const{
    return _name;
}
virtual int getValue(const Date& d)const=0;

private:
std::string _name;
};

class YearPart : public Part{
public:
YearPart():Part(“year”){}
int getValue(const Date& d)const{
return d.year;
}
};

class MonthPart : public Part{
public:
MonthPart():Part(“month”){}
int getValue(const Date& d)const{
return d.month;
}
};

class DayPart : public Part{
public:
DayPart():Part(“day”){}
int getValue(const Date& d)const{
return d.day;
}
};

enum DatePart{
Year,
Month,
Day
};

class Parts{
public:
Parts(){
_map[Year].reset(new YearPart());
_map[Month].reset(new MonthPart());
_map[Day].reset(new DayPart());
}

const PartInterface& get(const DatePart& date_part)const{
    return * (_map.find(date_part)->second);
}

private:
std::map<datepart,></datepart,>> _map;
};

int main() {
Date d({2016, 7, 23});
const Parts parts;
std::cout << “Date ”
<< parts.get(Year).getValue(d) << ” ”
<< parts.get(Month).getValue(d) << ” ”
<< parts.get(Day).getValue(d) << std::endl;
return 0;
}
“`

Tags:  , , , ,

Answer

  1. Avatar for davy.ai
    davy.ai

    Sí, hay una manera más elegante de lograr esto en C++11. Con el uso de funciones constexpr y declaraciones constexpr if, uno puede crear una función que compute el valor de una parte de la fecha en tiempo de compilación en lugar de en tiempo de ejecución.

    Aquí hay un ejemplo de implementación:

    “`c++
    #include

    struct Fecha{
    int año;
    int mes;
    int día;
    };

    enum ParteFecha{
    Año,
    Mes,
    Día
    };

    constexpr int obtener(const Fecha& f, ParteFecha parte){
    if(parte == Año){
    return f.año;
    }
    else if(parte == Mes){
    return f.mes;
    }
    else{
    return f.día;
    }
    }

    int main() {
    Fecha f({2016, 7, 23});
    std::cout << “Fecha ”
    << obtener(f, Año) << ” ”
    << obtener(f, Mes) << ” ”
    << obtener(f, Día) << std::endl;
    return 0;
    }
    “`

    En esta implementación, la función obtener ahora está marcada como constexpr, lo que significa que puede ser evaluada en tiempo de compilación si sus argumentos son conocidos en tiempo de compilación. La función utiliza una declaración constexpr if para elegir el valor a retornar según el argumento parte.

    Con esta implementación, el valor de las partes de la fecha ahora puede ser computado en tiempo de compilación, lo que resulta en un código más eficiente.

Comments are closed.