Определить разрядность процессора во время компиляции / Detect CPU bit capacity during compiling

Если, например, у нас есть две версии функции: одна для 32-разрадных процессоров и вторая для 64-разрядных процессоров. И мы хотим использовать ту, которая подходит для нашей архитектуры процессора.
Первый путь это использовать директивы препроцессора (дефайны):

void do_some()
{
#if defined(_IS_64_BIT_CPU)
    do_some_64();
#endif

#if defined(_IS_32_BIT_CPU)
    do_some_32();
#endif
}

Иногда, когда мы не имеем таких директив, можно определить разрядность процесора по размеру указателя (у 64-битных процессоров он очевидно равен 8 байтам, и соотсвественно у 32-разрядных процессоров он равен 4 байтам):

void do_some()
{
if(sizeof(void*) == 8)
    do_some_64();

if(sizeof(void*) == 4)
    do_some_32();
}

Это работающее решение, но нам не нужна одна из веток, т.е. мы хотим ее исключить на этапе компиляции. Можно с помощью C++11 написать такой код:

template<typename T = void*>
std::enable_if_t<sizeof(T) == 8, void> do_some()
{
    do_some_64();
}

template<typename T = void*>
std::enable_if_t<sizeof(T) == 4, void> do_some()
{
    do_some_32();
}

Теперь на этапе компиляции будет включено только одно из определений функции - то, которое нам нужно.
Хотя, проще для чтения все же вариант с дефайнами, но второй вариант более универсален.

Использование is_base_of и enable_if и детектирование типов во время компиляции

Допустим у нас есть некая функция, которая должна быть определена только для наследников определенного класса. Можно сделать это в рантайме, но детектирование типов в рантайме это дорого и к тому же некрасиво. C++11 предлагает более красивое решение.

#include <iostream> #include <type_traits>   class A { public: virtual void do_work() = 0; };   class B : public A { public: void do_work() override { std::cout << "B::do_work()" << std::endl; }; };   class C { public: void do_work() { std::cout << "C::do_work()" << std::endl; }; };   template<typename T> typename std::enable_if<std::is_base_of<A, T>::value, void>::type execute_work(T &t) { t.do_work(); } UPD 03.12.2016: можно сделать это гораздо проще: //... template<typename T> bool execute_work(T &t) { static_assert(std::is_base_of<A, T>::value, "T must be subclass of A"); t.do_work(); }   int main() { B b; C c; execute_work(b); //OK execute_work(c); //compile error } И теперь у нас компилятор будет выдавать именно то сообщение, которое мы указали в static_assert