const Parameter<DcdTtg>& ttg = dcd.GetParameter<DcdTtg>();

char ttg = dcd.GetValue<DcdTtg>();

#include <boost/static_assert.hpp>

BOOST_STATIC_ASSERT(sizeof( typename Message<DcdId>::Parameter<DcdParameterIds, DcdTtg>::ValueType ) == 1);
char ttg = dcd.GetValue<DcdTtg>();

  unsigned char GetType() const { return _type; }
  unsigned char GetCount() const { return _count; }

  DcdMsgType,
  DcdConfigChangeCount,
  //for TVL parameters:
  DcdEirp = 2,
  DcdFrequency = 12

  public Parameter<DcdParameterIds, DcdMsgType>,
  public Parameter<DcdParameterIds, DcdConfigChangeCount>,
  public Parameter<DcdParameterIds, DcdEirp>,
  public Parameter<DcdParameterIds, DcdFrequency>

template <int>
class Storage;

Storage<1>

Storage<2>

P>  unsigned char GetType() const { return _type; }
P>  unsigned char GetCount() const { return _count; }
P>

P>  DcdMsgType,
P>  DcdConfigChangeCount,
P>  //for TVL parameters:
P>  DcdEirp = 2,
P>  DcdFrequency = 12

P>  public Parameter<DcdParameterIds, DcdMsgType>,
P>  public Parameter<DcdParameterIds, DcdConfigChangeCount>,
P>  public Parameter<DcdParameterIds, DcdEirp>,
P>  public Parameter<DcdParameterIds, DcdFrequency>
P>

enum DcdParameterIds
{
  DcdMsgType,
  DcdConfigChangeCount,
  //for TVL parameters:
  DcdEirp = 2,
  DcdFrequency = 12
  , DCD_ID_NR
};

template<>
class MessageSet<DcdId>:
public ParameterAutoAdd<DCD_ID_NR>
{};

template<DcdParameterIds _IdMax>
class ParameterAutoAdd :
public Parameter<DcdParameterIds, static_cast<DcdParameterIds>(_IdMax - 1)>,
public ParameterAutoAdd<static_cast<DcdParameterIds>(_IdMax - 1)>
{};

template<>
class ParameterAutoAdd<static_cast<DcdParameterIds>(0)>
public Parameter<DcdParameterIds, static_cast<DcdParameterIds>(0)>
{};

P>>  unsigned char GetType() const { return _type; }
P>>  unsigned char GetCount() const { return _count; }
P>>

Из пяти функций класса MessageDcd четыре функции относятся к интерфейсу доступа на чтение переменных класса. К ним еще необходимо добавить четыре функции доступа на запись переменных, которые реализуются по аналогии. Итого восемь функций интерфейса доступа.
:::
Другим недостатком явного объявления типа параметра является то, что изменение размера переменной или ее типа в исходном техническом задании влекут за собой соответствующие изменения в листингах 1 и 2, а именно: в объявлении переменной, в интерфейсах доступа к ней, и во всех местах кода, где она назначается.

P>>>>  unsigned char GetType() const { return _type; }
P>>>>  unsigned char GetCount() const { return _count; }
P>>>>

class MessageDcd
{
unsigned char _type;
unsigned char _count;
short _eirp;
unsigned int _frequency;

public:
  unsigned char GetType() const { return _type; }
  unsigned char GetCount() const { return _count; }
  short GetEirp() const { return _eirp; }
  unsigned int GetChannelFrequency() const { return _frequency; }
  void SetPdu(const Pdu& aPdu);
};

struct MessageDcd
{
   FieldType type;
   FieldSize count;
   SomeShit eirp;
   Freq frequency;
};
// non-member functions

P>>Код C++ можно генерировать программой/скриптом

С>Вам кажется, что так лучше и надёжней... Вероятно отпугивает не простой код, требующий квалификации для развития и поддержки... Но мы же не ищем лёгких путей!? ... Важны идеи!.. Прийдёт час и они окажутся востребованы... Всё новое рождается в муках... Методику генерации С++ кода из xml файлов с помощью xslt преобразования тоже применяем.

P>>>>>  unsigned char GetType() const { return _type; }
P>>>>>  unsigned char GetCount() const { return _count; }
P>>>>>

enum Ids
{
  ttt = 1,
  erwere = 3,
  DcdEirp,
  DcdTTG = DcdEirp+3,
  zzs = ttt + 8
};

P>А я ничего не говорил про время компиляции. я наоборот готов жертвовать временем компиляции ради надёжности

P>struct MessageDcd
P>{
P>   FieldType type;
P>   FieldSize count;
P>   SomeShit eirp;
P>   Freq frequency;
P>};
P>// non-member functions
P>

Frequency[10] channels;
//или сложные структуры:
std::vector<Frequency>channels(10);

P>>struct MessageDcd
P>>{
P>>   FieldType type;
P>>   FieldSize count;
P>>   SomeShit eirp;
P>>   Freq frequency;
P>>};
P>>// non-member functions
P>>

А главное вы не ответили чем это всё лучше простого аггрегирующего класса (с нормальной реализацией, а не как у вас с getters and setters).

template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
    ar & degrees;
    ar & minutes;
    ar & seconds;
}

std::cout << handlers['-'](20, 10) << std::endl;
std::cout << handlers['+'](20, 10) << std::endl;
std::cout << handlers['*'](20, 10) << std::endl;
std::cout << handlers['/'](20, 10) << std::endl;
std::cout << handlers[' '](20, 10) << std::endl;

Выдает нам:
10
30
200
2
Invalid operation
0

std::cout << 20 - 10 << std::endl;
std::cout << 20 + 10 << std::endl;
std::cout << 20 * 10 << std::endl;
std::cout << 20 / 10 << std::endl;
std::cout << 20   10 << std::endl;

template<>
class Message<UcdId> : public MessageInterface<MessageSet<UcdId>, UcdParameterIds>
{};

enum UcdParameterIds
{
  UcdMsgType,
  UcdConfigChangeCount,
  UcdRngBackoffStart,
  UcdRngBackoffSEnd,
  ...
  //for TVL parameters:
  ContentionTimeout,
  UcdFrequency,
  ULRadioResources
  ...
  ,UCD_ID_NR // может быть адаптирован под макрос, чтобы не определять его в классе ParameterAutoAdd<>
};

template <>
class Parameter<UcdId, UcdFrequency>
: public ParameterFactory<UcdId, UcdFrequency, Tlv, 4, Unsigned>
{};

template <>
class Parameter<UcdId, UcdFrequency>
: public ParameterFactory<UcdId, UcdFrequency, Tlv, 4, Unsigned>
  public Frequency
{
private:
    int get_frequency_Hz_units() 
    {
        // compiled/run time validation
        return GetValue() * 1000;
    }
    
    void set_frequency_Hz_units(int value){/* соответствующий код */}
};

class Radiohead
{
public:
  void SetSynthesizer(Frequency fq)
  {
     int driver_rg = fq.get_value<MHz_units>());
     ...
     io_ctl(IO_WR, ..., driver_rg);
  }
};

  ...
  Message<UcdId> ucd;
  ucd.SetPdu(pdu);

  Radiohead rh;
  rh.SetSynthesizer(ucd.GetParameter<UcdId, UcdFrequency>());
  ...

1. В boost::Serialization (обход полей runtime)

template<class Archive>
void serialize(Archive & ar, const unsigned int version)
{
    ar & degrees;
    ar & minutes;
    ar & seconds;
}

2. либо в стиле tuple, c возможным compile-time обходом полей.

и замете, везде статическая типизация
:::
3. вы слышали о технике X-Macros?
4. вы слышали о code generation?

С>>Надеюсь у Вас нет "аллергии" на шаблоны?

P>А с чего вы взяли, что у меня может быть аллергия на шаблоны?
P>То что я вам указал на то, что ваша реализация неадекватная (пусть она и использует шаблоны), разве говорит о том, что мне не нравятся шаблоны?
P>это похоже на:
P>(1): — Ты зачем бьёшь молотком себе по пальцам?
P>(2): — Надеюсь у тебя не аллергии на молоток?

С>enum UcdParameterIds
С>{
С>  UcdMsgType,
С>  UcdConfigChangeCount,
С>  UcdRngBackoffStart,
С>  UcdRngBackoffSEnd,
С>  ...
С>  //for TVL parameters:
С>  ContentionTimeout,
С>  UcdFrequency,
С>  ULRadioResources
С>  ...
С>  ,UCD_ID_NR // может быть адаптирован под макрос, чтобы не определять его в классе ParameterAutoAdd<>
С>};
С>

С>template <>
С>class Parameter<UcdId, UcdFrequency>
С>: public ParameterFactory<UcdId, UcdFrequency, Tlv, 4, Unsigned>
С>{};
С>

P>>>struct MessageDcd
P>>>{
P>>>   FieldType type;
P>>>   FieldSize count;
P>>>   SomeShit eirp;
P>>>   Freq frequency;
P>>>};
P>>>// non-member functions
P>>>

{
void update();
void reset();
...
};

Что эта структура может с ними делать? хранить их вместе, все алгоритмы прописываем вручную для каждого структуры.

P>>>>>struct MessageDcd
P>>>>>{
P>>>>>   FieldType type;
P>>>>>   FieldSize count;
P>>>>>   SomeShit eirp;
P>>>>>   Freq frequency;
P>>>>>};
P>>>>>// non-member functions
P>>>>>

С>>{
С>>void update();
С>>void reset();
С>>...
С>>};
С>>

int MessageDcd::update()
{
  ++m_update_call_count;
  int size = 0;
  ...
  if (eirp.is_relevant())
    size += eirp.calc_size();

  ...
  return size;
}

#include <iostream>
#include <ostream>

template<int Size>
struct CrapParam
{
    bool is_relevant()
    {
        return Size%2 == 0;
    }
    unsigned calc_size()
    {
        return Size;
    }
    void drop()
    {
        std::cout << "Dropped item with size="<< calc_size() << std::endl;
    }
};

struct Dropper
{
    template<class Item>
    void operator&(Item &item)
    {
        std::cout << "\t";
        item.drop();
    }
};

struct Updater
{
    unsigned size;
    Updater(): size(0) {}
    template<class Item>
    void operator&(Item &item)
    {
        std::cout << "\t";
        if(item.is_relevant())
        {
            std::cout << "Relevant item";
            size+=item.calc_size();
        }
        else
        {
            std::cout << "Irrelevant item";
        }
        std::cout << " with size=" << item.calc_size() << std::endl;
    }
};

struct ParamAggregator
{
    unsigned counter;
    ParamAggregator(): counter(0) {}

    CrapParam<1> p1;
    CrapParam<2> someShit2;
    CrapParam<5> superCrap3;
    CrapParam<4> crappyShit4;

    template<class Archive>
    void serialize(Archive & ar)
    {
        ar & p1;
        ar & someShit2;
        ar & superCrap3;
        ar & crappyShit4;
    }

    int update()
    {
        ++counter;
        std::cout << "Updating, counter=" << counter << std::endl;
        Updater updater;
        serialize(updater);
        std::cout << "Updated, size=" << updater.size << std::endl << std::endl;
        return updater.size;
    }

    void drop()
    {
        std::cout << "Dropping items" << std::endl;
        Dropper d;
        serialize(d);
        std::cout << "Items are droped" << std::endl << std::endl;
    }
};



int main(int argc,char *argv[])
{
    ParamAggregator pa;
    pa.update();
    pa.drop();
    pa.update();
    return 0;
}

С>Пока что не вижу (может туплю ), приведите, пожалуйста, Ваш код, чтобы был предмет обсуждения.

P>#include <iostream>
P>#include <ostream>

P>template<int Size>
P>struct CrapParam
P>{
P>    bool is_relevant(){return Size%2 == 0;}
P>    unsigned calc_size(){return Size;}
P>    void drop(){std::cout << "Dropped item with size="<< calc_size() << std::endl;}
P>};

P>struct Dropper
P>{
P>    template<class Item>
P>    void operator&(Item &item){std::cout << "\t";item.drop();}
P>};

P>struct Updater
P>{
P>    unsigned size;
P>    Updater(): size(0) {}
P>    template<class Item>
P>    void operator&(Item &item)
P>    {
P>        std::cout << "\t";
P>        if(item.is_relevant())
P>        {
P>            std::cout << "Relevant item";
P>            size+=item.calc_size();
P>        }
P>        else
P>        {
P>            std::cout << "Irrelevant item";
P>        }
P>        std::cout << " with size=" << item.calc_size() << std::endl;
P>    }
P>};

P>struct ParamAggregator
P>{
P>    unsigned counter;
P>    ParamAggregator(): counter(0) {}

P>    CrapParam<1> p1;
P>    CrapParam<2> someShit2;
P>    CrapParam<5> superCrap3;
P>    CrapParam<4> crappyShit4;

P>    template<class Archive>
P>    void serialize(Archive & ar)
P>    {
P>        ar & p1;
P>        ar & someShit2;
P>        ar & superCrap3;
P>        ar & crappyShit4;
P>    }

P>    int update()
P>    {
P>        ++counter;
P>        std::cout << "Updating, counter=" << counter << std::endl;
P>        Updater updater;
P>        serialize(updater);
P>        std::cout << "Updated, size=" << updater.size << std::endl << std::endl;
P>        return updater.size;
P>    }

P>    void drop()
P>    {
P>        std::cout << "Dropping items" << std::endl;
P>        Dropper d;
P>        serialize(d);
P>        std::cout << "Items are droped" << std::endl << std::endl;
P>    }
P>};



P>int main(int argc,char *argv[])
P>{
P>    ParamAggregator pa;
P>    pa.update();
P>    pa.drop();
P>    pa.update();
P>    return 0;
P>}
P>

Message<>::getParameter<frequency>() {onGet(); writeLog(); /* творим что хотим с классом или полем */; return ...;}
Message<>::setParameter<frequency>(Frequency fq) {onSet(); writeLog(fq); /* творим что хотим */; m_fq = fq;  /* творим что хотим */; postSet();}

С>Message<>::getParameter<frequency>() {onGet(); writeLog(); /* творим что хотим с классом или полем */; return ...;}
С>Message<>::setParameter<frequency>(Frequency fq) {onSet(); writeLog(fq); /* творим что хотим */; m_fq = fq;  /* творим что хотим */; postSet();}
С>

ar & p1;
ar & someShit2;
ar & superCrap3;
ar & crappyShit4;

ar(schema & p1 & someShit2 & superCrap3 & crappyShit4);