Как создать массив с различным количеством и типом параметров элементов?

Question

Возможно изобретаю велосипед. Нужен массив соответствия.

Структура элемента:

using collation_t = struct collation {
    wchar_t l; //символ в нижнем регистре
    wchar_t u; //символ в верхнем регистре
    int flags; //флаги, определяющие тип символа.
};

Вспомогательное перечисление:

using WCHAR_FLAGS = enum collation_char_flags:int{
    IS_WHITESPACE = 1,
    IS_CTRL = 2,
    IS_ALPHA = 4,
    IS_NUMBER = 8,
    IS_PUNKTUM =16,
    IS_SPEC =32,
    IS_CURRENCY = 64,
    IS_SCOPE =128,
    IS_PRINTABLE = 256,
};

Поле flags определяет, что за символ: контрольный вроде '\7', или пробельный как '\t', или цифра, или буква ...

Большая часть массива - символы без разделения на нижний (поле l) и верхний (поле u) регистр и относятся к видимым (IS_PRINTABLE).

То есть нужно иметь возможность легко определять:

символы без разделения на регистр и с флагами по умолчанию:

COLLATE('!') == { '!', '!', IS_PRINTABLE}

символы без разделения по регистру и с конкретными флагами:

COLLATE('\n', IS_WHITESPACE) == {'\n', '\n', IS_WHITESPACE}

символы с разделением по регистру и флагами по умолчанию:

COLLATE('a', 'A') == {'a', 'A', IS_PRINTABLE}

Вариант с разделением по регистру и конкретными флагами может быть побочным эффектом, но не обязателен.

Желательно получит способ с минимум кода, чтобы минимизировать ошибки.

Пример кода, что не подходит для решения.

#ifndef _COLLATION_H
#define _COLLATION_H

using collation_t = struct _collation {
    wchar_t l; 
    wchar_t u;
};
template<const size_t normal>
constexpr collation_t COLLATION() {
    return { normal, normal };
}
 
#define COLLATE(normal, lower, upper) \
template<> \
constexpr collation_t COLLATION<(normal)>(){ \
    return {(lower), (upper)}; \
}
 
template<size_t S>
struct CollationArray{
    static constexpr int size = S;
    collation_t array[size];
    const collation_t operator[](size_t index){
        return array[index];
    }
};
 
template<wchar_t size, wchar_t... indexes>
struct MakeCollationIndexes : MakeCollationIndexes<size - 1, size - 1, indexes...>{};

template<wchar_t... indexes>
struct CollationIndexes{};

template<wchar_t... indexes>
struct MakeCollationIndexes<0, indexes...> : CollationIndexes<indexes...>{};

template<size_t S, wchar_t... indexes>
constexpr CollationArray<S> createCollationArrayImpl(CollationIndexes<indexes...>){
    return CollationArray<S>{ COLLATION<indexes>()... };
}
 
template<size_t S>
constexpr CollationArray<S> createCollationArray(){
    return createCollationArrayImpl<S>(MakeCollationIndexes<S>());
}
//Стандартные сиволы в начале ASCII
COLLATE('A','a', 'A')
COLLATE('B','b', 'B')
COLLATE('C','c', 'C')
COLLATE('D','d', 'D')
COLLATE('E','e', 'E')
COLLATE('F','f', 'F')
COLLATE('G','g', 'G')
COLLATE('H','h', 'H')
COLLATE('I','i', 'I')
COLLATE('J','j', 'J')
COLLATE('K','k', 'K')
COLLATE('L','l', 'L')
COLLATE('M','m', 'M')
COLLATE('N','n', 'N')
COLLATE('O','o', 'O')
COLLATE('P','p', 'P')
COLLATE('Q','q', 'Q')
COLLATE('R','r', 'R')
COLLATE('S','s', 'S')
COLLATE('T','t', 'T')
COLLATE('U','u', 'U')
COLLATE('V','v', 'V')
COLLATE('W','w', 'W')
COLLATE('X','x', 'X')
COLLATE('Y','y', 'Y')
COLLATE('Z','z', 'Z')

COLLATE('a','a', 'A')
COLLATE('b','b', 'B')
COLLATE('c','c', 'C')
COLLATE('d','d', 'D')
COLLATE('e','e', 'E')
COLLATE('f','f', 'F')
COLLATE('g','g', 'G')
COLLATE('h','h', 'H')
COLLATE('i','i', 'I')
COLLATE('j','j', 'J')
COLLATE('k','k', 'K')
COLLATE('l','l', 'L')
COLLATE('m','m', 'M')
COLLATE('n','n', 'N')
COLLATE('o','o', 'O')
COLLATE('p','p', 'P')
COLLATE('q','q', 'Q')
COLLATE('r','r', 'R')
COLLATE('s','s', 'S')
COLLATE('t','t', 'T')
COLLATE('u','u', 'U')
COLLATE('v','v', 'V')
COLLATE('w','w', 'W')
COLLATE('x','x', 'X')
COLLATE('y','y', 'Y')
COLLATE('z','z', 'Z')

#endif //_COLLATION_H

Добавление поля в структуру и дополнительного параметра в шаблон приводит к ошибкам компиляции.

БЛОГ НА HUSL

Как создать массив с различным количеством и типом параметров элементов?

Ответы (0 шт):