Is C Template Metaprogramming Turing-Complete?

Is C Templates Turing-complete?

A widely circulated claim is that C templates are Turing-complete at compile time. This means that templates can be used to represent and execute any computable function.

Example of a Computation

Here's a non-trivial example of a turing machine implemented in C 11 using templates:

#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>

The above is the detailed content of Is C Template Metaprogramming Turing-Complete?. For more information, please follow other related articles on the PHP Chinese website!