How to map different C++ classes to enum class values

Question

I produce messages and each is receive by one object, chosen by an enum class member:

enum class ReceiverID
{
    R1,
    R2,
    MAX_NUM_RECEIVERS
};

struct Msg
{
    ReceiverID _receiverID;
    Data _data;
};

The receiving classes are stored in an array. The enum member indexes the array to access the receiving object:

void receive(const Msg& msg)
{
    const size_t arrIndex = static_cast<size_t>(msg._receiverID);
    
    if(nullptr == _array[arrIndex])
    {
        _array[arrIndex] = ???  // How do I associate the enum to the class?
    }
    
     _array[arrIndex].processMsg(msg);
}

It is possible the receiving object is missing. If this happens I'd like to use the enum to instantiate the missing object. However, this would require mapping the enum values to the receiving object type.

How can I map a class to each enum? (for all enums).

I'd like to generate a compiler error if a new enum is added but without a corresponding receiver class.

UPDATE

The receiving objects are polymorphic and so have a base class. The array is:

std::array<Base*, MAX_NUM_RECEIVERS> _array;

(removed unique_ptr to simplify question)

which is the enum member? What is the type of `_array`? It can only hold elements of one type, no? — 463035818_is_not_an_ai, Feb 08 '21 at 18:34
since you are storing the receiving objects in an array and did not mention using variants etc. Do all the classes inherit from a base class? Also do all the receiving classes share a signature for the constructor you want to use? — jwezorek, Feb 08 '21 at 18:36
We need to know `_array` type before the question would be answered. — SergeyA, Feb 08 '21 at 18:43
@jwezorek Yes they inherit from a base class and the array containers pointers to these. I have updated the question. — user997112, Feb 08 '21 at 19:19
I'm sorry, what is `Base` a base of? I'm having a very hard time to see why the answer isn't simply `_array[arrIndex] = &pMsg;`, but then again I'm having also having a very hard time to follow this rambling question format. — Blindy, Feb 08 '21 at 19:27
`_array[arrIndex].processMsg(msg);` should be `_array[arrIndex]->processMsg(msg);` — 463035818_is_not_an_ai, Feb 10 '21 at 07:39

bloody · Accepted Answer · 2021-02-10T08:11:52.067

3

For on-the-fly creation of objects we could go for some kind of a factory method, e.g.:

//In the Base class:
static Base* createReceiver(ReceiverID recvID) //static member function
{
    switch (recvID)
    {
        case ReceiverID::R1: return new R1Receiver();
        case ReceiverID::R2: return new R2Receiver();
        //...
        default: throw std::logic_error("Invalid ReceiverID");
    }
}

//...
void receive(const Msg& msg) except(true)
{
    const size_t arrIndex = static_cast<size_t>(msg._receiverID);
    if(nullptr == _array[arrIndex])
    {
        _array[arrIndex] = Base::createReceiver(msg._receiverID);
    }    
    _array[arrIndex]->processMsg(msg);
}

edited Feb 10 '21 at 08:11

answered Feb 08 '21 at 21:09

bloody

1,131
11
17

Thank you for this! – user997112 Feb 08 '21 at 23:47
@user997112 You're welcome :) You can adapt it to support `unique_ptr`s (as you mentioned you're using them). Change return type to `unique_ptr` and replace all `new` with `make_unique()`. – bloody Feb 09 '21 at 07:37
`_array[arrIndex].processMsg(msg);` should be `_array[arrIndex]->processMsg(msg);` – 463035818_is_not_an_ai Feb 10 '21 at 07:40
@largest_prime_is_463035818 Yea, copied from op's, thank you :) – bloody Feb 10 '21 at 08:12

score 1 · Answer 2 · answered Feb 08 '21 at 19:30

Instead of having a global std::array<Base*, MAX_NUM_RECEIVERS> _array; and then lazily filling it out on demand, I believe the normal thing to do is make it filled out at construction time:

std::array<Base*, MAX_NUM_RECEIVERS>& _array() {
    //use a method to bypass https://stackoverflow.com/questions/1005685/c-static-initialization-order
    static std::array<Base*, MAX_NUM_RECEIVERS> array = make_array();
    return array;
}
std::array<Base*, MAX_NUM_RECEIVERS> make_array() {
    std::array<Base*, MAX_NUM_RECEIVERS> array;
    array[static_cast<size_t>(R1)] = &myR1ProcessorObject();
    array[static_cast<size_t>(R2)] = &myR2ProcessorObject();
    return array;
}

Then your receive method is simple:

void receive(const Msg& msg)
{
    const size_t arrIndex = static_cast<size_t>(msg._receiverID);
    assert(arrIndex< MAX_NUM_RECEIVERS);
     _array()[arrIndex].processMsg(msg);
}

I appreciate your answer. I accepted the other one because I am receiving messages remotely, the objects are very expensive and whilst I will try to instantiate all that is needed, I wanted to check and create any which aren't, on-the-fly. This is why the question focused on the mapping. — user997112, Feb 08 '21 at 23:39

How to map different C++ classes to enum class values

2 Answers2