本文介紹一種簡單的C++ Concept實現：給模板引數加限制。


1.背景

#include <iostream>
using namespace std;
typedef long long int64;


struct BigInteger {
  BigInteger(int64 v): value(v) {}
  int64 value;
};


template<typename T>
BigInteger operator * (T v, const BigInteger& x) {
  return BigInteger((int64)v * x.value);
}


struct Matrix {
};


int main() {
  Matrix a;
  BigInteger b(1);
  a * b;
  return 0;
}
 

這裡使用BigInteger作為例子（並未真正實現），其中提供了operator *，期望支援和所有基礎的int型別相乘（當然，有其它方法實現，為了和本文配合而使用了程式碼中的實現）。但是，有可能對於非int型別也匹配了該函式模板，進而導致錯誤：

concept.c: In instantiation of 'BigInteger operator*(T, const BigInteger&) [with T = Matrix]':
concept.c:21:7:   required from here
concept.c:12:21: error: invalid cast from type 'Matrix' to type 'int64 {aka long long int}'
   return BigInteger((int64)v * x.value);
 

然而，該錯誤並不是錯誤的根源所在，所以看上去有點莫名其妙。另外，根據BigInteger的設計，只應該匹配所有基礎的int型別，而程式碼中並沒有這樣的保證，只能通過文件說明和使用者的小心翼翼來保證正確性。


2.實現
所以本文基於SAFINAE，利用c++模板的一些技巧，在一定程度上對模板引數加以限制，避免這種情況出現。

#include <iostream>
#include <type_traits>
using namespace std;
typedef long long int64;


template<int ok>
struct CheckConditionThen{};


template<>
struct CheckConditionThen<true>{
  template<typename U>
  struct IdenticalType {
    typedef U type;
  };
};


#define REQUIRES(...) typename CheckConditionThen<__VA_ARGS__>::
#define RETURN(...) template IdenticalType<__VA_ARGS__>::type


struct BigInteger {
  BigInteger(int64 v): value(v) {}
  int64 value;
};


template<typename T>
REQUIRES(is_integral<T>::value)
RETURN(BigInteger)
operator * (T v, const BigInteger& x) {
  return BigInteger((int64)v * x.value);
}


struct Matrix {
};


int main() {
  Matrix a;
  BigInteger b(1);
  a * b;
  return 0;
}
 

對於該程式碼，錯誤資訊為:

concept1.c: In function 'int main()':
concept1.c:38:5: error: no match for 'operator*' (operand types are 'Matrix' and 'BigInteger')
   a * b;
   ~~^~~
concept1.c:28:1: note: candidate: template<class T> typename CheckConditionThen<std::is_integral<_Tp>::value>::IdenticalType<BigInteger>::type operator*(T, const BigInteger&)
 operator * (T v, const BigInteger& x) {
 ^~~~~~~~
concept1.c:28:1: note:   template argument deduction/substitution failed:
concept1.c: In substitution of 'template<class T> typename CheckConditionThen<std::is_integral<_Tp>::value>::IdenticalType<BigInteger>::type operator*(T, const BigInteger&) [with T = Matrix]':
concept1.c:38:7:   required from here
concept1.c:28:1: error: no class template named 'IdenticalType' in 'struct CheckConditionThen<0>'

從中可以看到，明確指出了是a * b導致的。


3.分析
將整個巨集展開，可以看出首先利用type_trait對T進行限制，當條件滿足時返回true，否則返回false。其次，將這個返回值放到某個類模板中，該類模板對於true值時擁有一個IdenticalType的類模板，而對於false值時沒有。所以在條件不滿足時，這裡會出現錯誤，導致模板匹配失敗。對於true值時，IdenticalType用來接收函式的返回型別再把該返回型別返回作為一個型別表示式。


該實現是為了配合REQUIRES 在前 RETURN在後的巨集的使用，在邏輯結構上並不美妙。如果我們從資料流處理的角度來看：
input T => filter T => output T會更加優美:

template<typename T>
struct IdenticalType {
  typedef T type;
};


template<int v>
struct IdenticalValue {
  enum {value = v};
};


template<typename T, int ok>
struct CheckCondition {
};


template<typename T>
struct CheckCondition<T, 1> {
  typedef T type;
};


#define RETURN(...) typename CheckCondition<typename IdenticalType<__VA_ARGS__>::type,
#define WHEN(...) IdenticalValue<__VA_ARGS__>::value >::type

其中IdenticalType和IdenticalValue是為了避免在巨集展開的時候的一些問題。在大多數情況下，兩個Identical是不需要的。


另一個實現是：

template<int ok, typename T>
struct IdenticalIfTrue {
};


template<typename T>
struct IdenticalIfTrue<1, T> {
  template<typename U>
  struct IdenticalType {
    typedef U type;
  };
};


template<typename T>
struct CheckCondition {
  template<int ok>
  struct IdenticalIfTrueWrapper {
    typedef typename IdenticalIfTrue<ok, T>::template IdenticalType<T>::type type;
  };
};


#define RETURN(...) typename CheckCondition<__VA_ARGS__>::


#define WHEN(...) IdenticalIfTrueWrapper<__VA_ARGS__>::type

該實現將T和ok分兩次傳入，目的是避免前一個實現所說的巨集展開的問題。但是，對於CheckCondition的匹配總是成功的，然後內層的IdenticalIfTrueWrapper也是成功的，最後到IdenticalIfTrue才失敗。這樣的問題是：編譯器首先給出了上述匹配失敗的錯誤資訊，再給出a * b的失敗。而之前的錯誤資訊是首先指出a * b失敗，再列出所有的候選函式模板。當然，哪種錯誤更友好沒有定論。


4.不足
對於背景和實現中的錯誤資訊，可以看出，由於匹配失敗，列出了所有candidate導致過多的錯誤資訊。