Имеется ли число в enum

enum BoardType {
    Classic = 0,
    Static = 1,
    Smart = 2
}
BoardType t = (BoardType)getBoardType();

Я бы предложил, коль речь идет о быстродействии и небольшом количестве команд - использовать просто табличные преобразования. Да и таблица не будет чрезмерно большой.

Пример кода (ссылка на ideone):

#include <iostream>
enum class BoardType : uint8_t { 
  Classic = 0,
  Static = 1,
  Smart = 2,
  Bad = 255  
};
BoardType Cast[UINT8_MAX];     // <- сюда просто забить константы -++
                                                                   //
inline BoardType ToEnum(const uint8_t i) {                         //
  BoardType Ret = Cast[i];                                         //
  if (Ret == BoardType::Bad) throw std::range_error("Беда");       //
  return Ret;                                                      //
}                                                                  //
                                                                   //
int main () {                                                      //
  ////// вместо  инициализации ниже - ///////////////////////////////  
  for(auto i=0; i<UINT8_MAX; i++) Cast[i] = BoardType::Bad;
  Cast[0] = BoardType::Classic;
  Cast[1] = BoardType::Static;
  Cast[2] = BoardType::Smart; 
  //////////////////////////////////////////////////////////////////  
  try {  
    std::cout << static_cast<int>(ToEnum(0)) << std::endl;  
    std::cout << static_cast<int>(ToEnum(1)) << std::endl;
    std::cout << static_cast<int>(ToEnum(2)) << std::endl;
    std::cout << static_cast<int>(ToEnum(3)) << std::endl;  
  } catch(std::range_error &e) {
    std::cout << "range_error: " << e.what() << std::endl;  
  } catch(...) {
    std::cout << "что-то совсем пошло не так" << std::endl;  
  }    
  return 0;        
}

Вывод:

0
1
2
range_error: Беда

Во-первых, можно с помощью функции ToEnum() "неправильные" значения отлавливать в блоках обработки исключений.

Во-вторых, используя таблицу Cast, просто сравнивать с BoardType::Bad, если обработка исключений "напрягает".

В-третьих, если "команд" будет несколько десятков - switch будет хуже читаем, а возможно и медленнее обрабатываем.

По большому счету, никак. Потому что это просто условные обозначения для целочисленных значений.
Так что если уж очень нужно - то либо проверять диапазон (если перечисления без "просветов", либо иметь отдельное множество значений и проверять на присутствие в нем.

По-моему, так. (с) Пух

Конкретно для вашего примера можно так:

enum BoardType{
    Classic = 0,
    Static = 1,
    Smart = 2,
    NumberOfBoardTypes
};
bool isCorrect(BoardType t){
    return t >= 0 && t < NumberOfBoardTypes;
}

Или так:

enum BoardType{
    Classic = 0,
    Static = 1,
    Smart = 2,
    Unknown
};
BoardType getBoardType(){
    BoardType t = static_cast<BoardType>(42);
    if(t < 0 || t > Unknown){
        t = Unknown;
    }
    return t;
}

UPD: для случая с "дырами" в enum можно сделать так:

enum BoardType{
    Classic = 0,
    Static = 1,
    Smart = 2
};
std::set<BoardType> boardTypes(){
    std::set<BoardType> types;
    types.insert(Classic);
    types.insert(Static);
    types.insert(Smart);
    return types;
}
bool isCorrect(BoardType t){
    static const std::set<BoardType> types = boardTypes();
    return types.count(t);
}