Modern C++ Design Chapter 2 Memo (1)

2.2 Partial Template Specialization

• クラスに対しての部分特殊化は通じるが、メンバー関数や一般関数での部分特殊化は出来ない。
• 関数をテンプレートに対して部分的に特殊化したい場合なら、以下のようにオーバーローディングをするしかない。

template <class T, class U> T Func(U obj);
template <class U> void Fun<void, U>(U obj); // Prohibited.
template <class T> T Fun(Window obj); // Legal (overloading)

2.3 Local Classes

void Func() {
  class Local {
    // ... Member variables ...
    // ... Member function definitions ...
  };
  // Code using local...
}

• 関数の中身にクラスの定義がある場合、このクラスはローカルクラスという。
• ローカルクラスは静的変数が定義出来ない。そして関数の外からはローカルクラスの変数には接近できない。
• ローカルクラスは関数の外からはローカルクラスを継承出来ない。

ローカルクラスを使用し、インタフェースを継承したクロージャーなどを実装することが出来る。

class Interface {
public:
  virtual void Fun() = 0;
};

template <class T, class P>
std::unique_ptr<Interface> MakeAdapter(const T& obj, const P& arg) {
  class Local : public Interface {
  public:
    Local(const T& obj, const P& arg) :
      obj_(obj), arg_(arg) {};

    virtual void Fun() { 
      obj_.Call(arg_);
    }
  private:
    T obj_;
    P arg_;
  };
  return std::make_unique<Local>(obj, arg);
}

2.5 Type-to-Type Mapping

#include <cstdint>
#include <vector>

template <typename TFrom, typename TTo>
class Conversion {
    using TSmall = char;
    class DBig { char dummy[2]; };

    static constexpr TSmall Test(const TTo&);
    static constexpr DBig Test(...);
    static constexpr TFrom MakeT();

public:
    static constexpr bool exists = sizeof(Conversion::Test(MakeT())) == sizeof(TSmall);
};

template <typename TFrom, typename TTo>
class ConversionExt : public Conversion<TFrom, TTo> {
public:
    static constexpr bool sameType = false;
};

template <typename TFrom>
class ConversionExt<TFrom, TFrom> : public Conversion<TFrom, TFrom> {
public:
    static constexpr bool sameType = true;
};

static_assert(Conversion<double, int>::exists, "");
static_assert(Conversion<char, char*>::exists, "");
static_assert(Conversion<std::size_t, std::vector<int>>::exists, "");

class Base {};
class Derived final : public Base {};
class NotDerived final {};

static_assert(Conversion<Derived, Base>::exists, "");
static_assert(Conversion<Base, Derived>::exists, "");
static_assert(Conversion<NotDerived, Base>::exists, "");

template <typename T, typename V>
constexpr bool IsSuperClass =
    (ConversionExt<T, V>::exists == true) && 
    (ConversionExt<T, const void*>::sameType == false);

static_assert(IsSuperClass<const Derived*, const Base*>, "");
static_assert(IsSuperClass<const NotDerived*, const Base*>, "");
static_assert(IsSuperClass<const Base*, const Base*>, "");

template <typename T, typename V>
constexpr bool IsSuperClassStrict = 
    IsSuperClass<T, V> && (ConversionExt<T, V>::sameType == false);

static_assert(IsSuperClassStrict<const Derived*, const Base*>, "");
static_assert(IsSuperClassStrict<const NotDerived*, const Base*>, "");
static_assert(IsSuperClassStrict<const Base*, const Base*>, "");