Что-то вроде «если constexpr» но для определения класса

Тип индекса:

template<std::size_t I>
using index = std::integral_constant<std::size_t, I>;

first_truth берет набор bool во время компиляции и говорит, что индекс первого находится во время компиляции. Если вы передадите ему N bools во время компиляции, он вернет N, если все ложные:

constexpr index<0> first_truth() { return {}; }
template<class...Rest>
constexpr index<0> first_truth(std::true_type, Rest...) { return {}; }
template<class...Rest>
constexpr auto first_truth(std::false_type, Rest...rest) {
return index<first_truth( rest... )+1>{};
}

dispatch принимает набор bool-файлов времени компиляции и возвращает лямбду Эта лямбда-функция возвращается через совершенную пересылку первого элемента, который соответствует первому истинному времени компиляции bool:

template<class...Bools>
constexpr auto dispatch(Bools...bools) {
constexpr auto index = first_truth(bools...);

return [](auto&&...fs){
return std::get< decltype(index){} >(
std::forward_as_tuple( decltype(fs)(fs)... )
);
};
}

Тип bool времени компиляции:

template<bool b>
using bool_t = std::integral_constant<bool, b>;
template<bool b>
bool_t<b> bool_k{};

Теперь мы решаем вашу проблему:

const char* const osName =
dispatch(
bool_k<os == OS::Linux>,
bool_k<os == OS::MacOs>,
bool_k<os == OS::MsWindows>
)(
"Linux",
"MacOS",
"MS Windows",
"Unknown");

который должен приближаться к переключателю времени компиляции. Мы могли бы связать bools более близко к аргументам с немного большим количеством работы.

Код не скомпилирован, возможно, содержит tpyos.

Как определить различные типы на основе некоторой постоянной времени компиляции без специализации шаблона?

Вот:

constexpr auto osPropsCreate()
{
if constexpr (os == OS::Linux) {
struct Props { const char* name; int props1; using handle = int; };
return Props{"linux", 3};
} else if constexpr (os == OS::MacOs) {
struct Props { const char* name; using handle = float; };
return Props{"mac"};
} else if constexpr (os == OS::MsWindows) {
struct Props { const char* name; using handle = int; };
return Props{"win"};
} else
return;
}

using OsProps = decltype(osPropsCreate());
constexpr OsProps osProps = osPropsCreate();

Как видите — я использовал новую конструкцию if constexpr создать из некоторой функции «реализации» тип, который зависит от постоянной времени компиляции. Это не так просто в использовании, как static if на языке D — но это работает — я могу сделать это:

int linuxSpecific[osProps.props1];
int main() {
std::cout << osProps.name << std::endl;
OsProps::handle systemSpecificHandle;
}

Следующая вещь — определить различные функции в зависимости от постоянной времени компиляции:

constexpr auto osGetNameCreate() {
if constexpr (os == OS::Linux) {
struct Definition {
static constexpr auto getName() {
return "linux";
}
};
return Definition::getName;
} else if constexpr (os == OS::MacOs) {
// we might use lambda as well
return [] { return "mac"; };
} else if constexpr (os == OS::MsWindows) {
struct Definition {
static constexpr auto getName() {
return "win";
}
};
} else
return;
}constexpr auto osGetName = osGetNameCreate();

int main() {
std::cout << osGetName() << std::endl;
}

На самом деле они могут быть объектоподобными объектами (функторами) или статическими функциями-членами из вложенных классов. Это не имеет значения — у каждого есть полная свобода определять разные вещи для разных констант времени компиляции (тип ОС в данном случае). Обратите внимание, что для неизвестной системы мы просто возвращаем void — это приведет к ошибке компиляции для неизвестной системы …

Отвечая на второй вопрос:

Первый ответ приведите в комментариях (ссылка на сайт). Моя интерпретация заключается в том, что стандартный комитет C ++ не готов к этому изменению. Возможно, соревнование с D будет / будет хорошей причиной, чтобы поднять эту тему еще раз …