C テンプレートのメタプログラミングはチューリング完全ですか?

C テンプレートはチューリング完全ですか?

広く広まっている主張は、C テンプレートはコンパイル時にチューリング完全であるというものです。これは、テンプレートを使用して計算可能な関数を表現および実行できることを意味します。

計算の例

これは、C で実装されたチューリング マシンの重要な例です。 11 テンプレートの使用:

#include <iostream>

template<bool c typename a b>
struct Conditional {
    typedef A type;
};

template<typename a typename b>
struct Conditional<false a b> {
    typedef B type;
};

template<typename...>
struct ParameterPack;

template<bool c typename="void">
struct EnableIf { };

template<typename type>
struct EnableIf<true type> {
    typedef Type type;
};

template<typename t>
struct Identity {
    typedef T type;
};

// define a type list 
template<typename...>
struct TypeList;

template<typename t typename... tt>
struct TypeList<t tt...>  {
    typedef T type;
    typedef TypeList<tt...> tail;
};

template
struct TypeList> {

};

template<typename list>
struct GetSize;

template<typename... items>
struct GetSize<typelist>> {
    enum { value = sizeof...(Items) };
};

template<typename... t>
struct ConcatList;

template<typename... first typename... second tail>
struct ConcatList<typelist>, TypeList<second...>, Tail...> {
    typedef typename ConcatList<typelist second...>, 
                                Tail...>::type type;
};

template<typename t>
struct ConcatList<t> {
    typedef T type;
};

template<typename newitem typename list>
struct AppendItem;

template<typename newitem typename...items>
struct AppendItem<newitem typelist>> {
    typedef TypeList<items... newitem> type;
};

template<typename newitem typename list>
struct PrependItem;

template<typename newitem typename...items>
struct PrependItem<newitem typelist>> {
    typedef TypeList<newitem items...> type;
};

template<typename list int n typename="void">
struct GetItem {
    static_assert(N > 0, "index cannot be negative");
    static_assert(GetSize<list>::value > 0, "index too high");
    typedef typename GetItem<typename list::tail n-1>::type type;
};

template<typename list>
struct GetItem<list> {
    static_assert(GetSize<list>::value > 0, "index too high");
    typedef typename List::type type;
};

template<typename list template typename...> class Matcher, typename... Keys>
struct FindItem {
    static_assert(GetSize<list>::value > 0, "Could not match any item.");
    typedef typename List::type current_type;
    typedef typename Conditional<matcher keys...>::value, 
                                 Identity<current_type>, 
                                 FindItem<typename list::tail matcher keys...>>
        ::type::type type;
};

template<typename list int i typename newitem>
struct ReplaceItem {
    static_assert(I > 0, "index cannot be negative");
    static_assert(GetSize<list>::value > 0, "index too high");
    typedef typename PrependItem<typename list::type typename replaceitem list::tail i-1 newitem>::type>
        ::type type;
};

template<typename newitem typename type typename... t>
struct ReplaceItem<typelist t...>, 0, NewItem> {
    typedef TypeList<newitem t...> type;
};

enum Direction {
    Left = -1,
    Right = 1
};

template<typename oldstate typename input newstate output direction move>
struct Rule {
    typedef OldState old_state;
    typedef Input input;
    typedef NewState new_state;
    typedef Output output;
    static Direction const direction = Move;
};

template<typename a typename b>
struct IsSame {
    enum { value = false }; 
};

template<typename a>
struct IsSame<a a> {
    enum { value = true };
};

template<typename input typename state int position>
struct Configuration {
    typedef Input input;
    typedef State state;
    enum { position = Position };
};

template<int a int b>
struct Max {
    enum { value = A > B ? A : B };
};

template<int n>
struct State {
    enum { value = n };
    static char const * name;
};

template<int n>
char const* State<n>::name = "unnamed";

struct QAccept {
    enum { value = -1 };
    static char const* name;
};

struct QReject {
    enum { value = -2 };
    static char const* name; 
};

#define DEF_STATE(ID, NAME) \
    typedef State<id> NAME ; \
    NAME :: name = #NAME ;

template<int n>
struct Input {
    enum { value = n };
    static char const * name;

    template<int... i>
    struct Generate {
        typedef TypeList<input>...> type;
    };
};

template<int n>
char const* Input<n>::name = "unnamed";

typedef Input InputBlank;

#define DEF_INPUT(ID, NAME) \
    typedef Input<id> NAME ; \
    NAME :: name = #NAME ;

template<typename config typename transitions> 
struct Controller {
    typedef Config config;
    enum { position = config::position };

    typedef typename Conditional(GetSize<typename config::input>::value) 
            (position),
        AppendItem<inputblank typename config::input>,
        Identity<typename config::input>>::type::type input;
    typedef typename config::state state;

    typedef typename GetItem<input position>::type cell;

    template<typename item typename state cell>
    struct Matcher {
        typedef typename Item::old_state checking_state;
        typedef typename Item::input checking_input;
        enum { value = IsSame<state checking_state>::value && 
                       IsSame<cell checking_input>::value
        };
    };
    typedef typename FindItem<transitions matcher state cell>::type rule;

    typedef typename ReplaceItem<input position typename rule::output>::type new_input;
    typedef typename rule::new_state new_state;
    typedef Configuration<new_input new_state max rule::direction>::value> new_config;

    typedef Controller<new_config transitions> next_step;
    typedef typename next_step::end_config end_config;
    typedef typename next_step::end_input end_input;
    typedef typename next_step::end_state end_state;
    enum { end_position = next_step::position };
};

template<typename input typename state int position transitions>
struct Controller<configuration state position>, Transitions, 
                  typename EnableIf<issame qaccept>::value || 
                                    IsSame<state qreject>::value>::type> {
    typedef Configuration<input state position> config;
    enum { position = config::position };
    typedef typename Conditional(GetSize<typename config::input>::value) 
            (position),
        AppendItem<inputblank typename config::input>,
        Identity<typename config::input>>::type::type input;
    typedef typename config::state state;

    typedef config end_config;
    typedef input end_input;
    typedef state end_state;
    enum { end_position = position };
};

template<typename input typename transitions startstate>
struct TuringMachine {
    typedef Input input;
    typedef Transitions transitions;
    typedef StartState start_state;
</typename></typename></inputblank></typename></state></issame></configuration></typename></new_config></new_input></transitions></cell></state></typename></typename></inputblank></typename></typename></id></n></int></int...></int></id></n></int></int></int></typename></a></typename></typename></typename></newitem></typelist></typename></typename></list></typename></typename></current_type></matcher></list></typename></list></list></typename></typename></list></typename></newitem></newitem></typename></typename></items...></newitem></typename></typename></t></typename></typelist></second...></typelist></typename...></typename...></typelist></typename...></typename></tt...></t></typename></typename...></typename></true></typename></bool></typename...></false></typename></bool></iostream>

以上がC テンプレートのメタプログラミングはチューリング完全ですか?の詳細内容です。詳細については、PHP 中国語 Web サイトの他の関連記事を参照してください。