C++: используйте #if std::is_fundamental‹T›::value для условной компиляции в MSVC 2010

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

template <typename T, bool is_fundamental>
struct Foo_impl {
   void foo() {
   }
};
template <typename T>
struct Foo_impl<T,true>
{
   void foo() {              // is fundamental version
   }
};
template <typename T>
class Foo : public Foo_impl<T, std::is_fundamental_type<T>::value> {
   // ...
};

Другой подход состоит в том, чтобы реализовать их как частные функции в вашем классе и отправлять их внутренне из foo на основе признака. Это действительно простое и более чистое решение, но оно не работает, если одна из двух версий foo_impl не скомпилируется. В этом случае вы можете использовать, как другие предложили функцию-член шаблона для разрешения, но я бы все же предложил нешаблонный foo в качестве общедоступного интерфейса, перенаправляя его в частный шаблон foo_impl. Причина в том, что template здесь является деталью реализации для взлома условной компиляции, а не частью интерфейса. Вы не хотите, чтобы пользовательский код вызывал эту функцию-член с аргументами шаблона, отличными от типа вашего собственного класса. Заимствование из ответа pmr:

template <typename T>
struct Foo
{
  template <typename U = T, 
            typename std::enable_if< 
              std::is_fundamental<U>::value, int >::type* _ = 0
           >
  void foo() {
    std::cout << "is fundamental" << std::endl;
  }
//...

Это решение позволяет использовать пользовательский код, например:

Foo<int> f;
f.foo<std::string>();

Который создаст экземпляр функции, которая вам не нужна и не нужна, и выполнит логику, которая вам не нужна. Даже если пользователи не пытаются обмануть ваш класс, тот факт, что он является шаблоном в интерфейсе, может сбить с толку и заставить пользователей думать, что его можно вызывать для разных типов.

Препроцессор запускается на ранней стадии компиляции, до того, как компилятор проанализирует типы и узнает значение std::is_fundamental<T>::value, поэтому он не может работать таким образом.

Вместо этого используйте специализацию:

template<bool> void f();

template<> void f<true>() {
    if(m_buf[j] < m_buf[idx_min])
        idx_min = j;
}

template<> void f<false>() {
    const ASSortable& curr = dynamic_cast<ASSortable&>(m_buf[j]);
    const ASSortable& curr_min = dynamic_cast<ASSortable&>(m_buf[idx_min]);
    // error checking removed for simplicity
    if(curr.before(curr_min))
        idx_min = j;
}

template <typename T>
void MyClass<T>::foo()
{
// ... some code here
    f<std::is_fundamental<T>::value>();
}

EDIT: вам, вероятно, потребуется сделать f функцией-членом, однако это невозможно напрямую, поскольку MyClass<T> не является специализированным шаблоном. Вы можете сделать f глобальным, который делегирует вызов правильному члену MyClass. Однако есть и другой подход.

Используя перегрузку, это становится:

void MyClass<T>::f(const true_type&) {
    if(m_buf[j] < m_buf[idx_min])
        idx_min = j;
}

void MyClass<T>::f(const false_type&) {
    const ASSortable& curr = dynamic_cast<ASSortable&>(m_buf[j]);
    const ASSortable& curr_min = dynamic_cast<ASSortable&>(m_buf[idx_min]);
    // error checking removed for simplicity
    if(curr.before(curr_min))
        idx_min = j;
}

template <typename T>
void MyClass<T>::foo()
{
// ... some code here
    f(std::is_fundamental<T>::type());
}

Вы путаете состояния компиляции. Препроцессор запускается до фактического компилятора и ничего не знает о типах или шаблонах. Он просто выполняет (очень) сложную замену текста.

В текущем C++ нет ничего подобного static if¹, поэтому вам придется прибегнуть к другому методу, чтобы включить условную компиляцию. Для функций я бы предпочел enable_if.

#include <type_traits>
#include <iostream>

template <typename T>
struct Foo
{
  template <typename U = T, 
            typename std::enable_if< 
              std::is_fundamental<U>::value, int >::type = 0
           >
  void foo() {
    std::cout << "is fundamental" << std::endl;
  }

  template <typename U = T, 
            typename std::enable_if< 
              !(std::is_fundamental<U>::value), int >::type = 0
           >
  void foo() {
    std::cout << "is not fundamental" << std::endl;
  }
};


struct x {};

int main()
{
  Foo<int> f; f.foo();
  Foo<x> f2; f2.foo();
  return 0;
}

¹ Ссылки:

Видео: статично, если показано Александреску в Going Native.

n3322: предложение Уолтера Э. Брауна для static if

n3329: Саттер, Брайт и Александреску предложение для static if

Это почти то, что он говорит, вы не можете использовать :: в директивах препроцессора. На самом деле, единственное, что вы можете использовать после #if, это выражение-константа, которое определено до времени компиляции. Некоторую информацию можно найти здесь

std::is_fundamental<T>::value == true нельзя использовать во время предварительной обработки. Я думаю, вам придется использовать какой-то трюк SFINAE с std::enable_if:

template <typename T>
typename std::enable_if<std::is_fundamental<T>::value, void>::type 
MyClass<T>::foo()
{
    // ... some code here

    if(m_buf[j] < m_buf[idx_min])
        idx_min = j;
}


template <typename T>
typename std::enable_if<!std::is_fundamental<T>::value, void>::type 
MyClass<T>::foo()
{
    // ... some code here

    const ASSortable& curr = dynamic_cast<ASSortable&>(m_buf[j]);
    const ASSortable& curr_min = dynamic_cast<ASSortable&>(m_buf[idx_min]);
    // error checking removed for simplicity
    if(curr.before(curr_min))
        idx_min = j;
}