C ++模板图灵完成?


Answers:


110

#include <iostream>

template <int N> struct Factorial
{
    enum { val = Factorial<N-1>::val * N };
};

template<>
struct Factorial<0>
{
    enum { val = 1 };
};

int main()
{
    // Note this value is generated at compile time.
    // Also note that most compilers have a limit on the depth of the recursion available.
    std::cout << Factorial<4>::val << "\n";
}

那有点有趣,但不是很实用。

要回答问题的第二部分:
这个事实在实践中有用吗?

简短的回答:有点。

长答案:是的,但是仅当您是模板守护程序时才可以。

要使用对其他人(例如库)确实有用的模板元编程来产生好的编程,确实非常困难(尽管可行)。为了帮助提高甚至有MPL(元编程库)。但是,尝试在模板代码中调试编译器错误,您将需要花费很长时间。

但是它被用于有用的东西的一个很好的实际例子:

Scott Meyers一直在使用模板工具来扩展C ++语言(我宽松地使用该术语)。您可以在此处阅读有关他的工作的“ 执行代码功能


36
当当去了概念(欺骗)
马丁·约克

5
我提供的示例只有一个小问题-它没有利用C ++模板系统的(完整)图灵完整性。阶乘也可以使用原始递归函数找到,这些函数不具有图灵完备性
Dalibor Frivaldsky

4
现在,我们有了精简概念
nurettin

1
在2017年,我们将概念进一步推向前进。这是2020
。– DeiDei

2
@MarkKegel 12年后:D
Victor

181

我用C ++ 11做过图灵机。C ++ 11添加的功能对于图灵机确实并不重要。它只是使用可变参数模板提供任意长度的规则列表,而不是使用不正确的宏元编程:)。条件的名称用于在stdout上输出图表。我删除了该代码以使样本简短。

#include <iostream>

template<bool C, typename A, typename 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<Items...>> {
    enum { value = sizeof...(Items) };
};

template<typename... T>
struct ConcatList;

template<typename... First, typename... Second, typename... Tail>
struct ConcatList<TypeList<First...>, TypeList<Second...>, Tail...> {
    typedef typename ConcatList<TypeList<First..., 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<Items...>> {
    typedef TypeList<Items..., NewItem> type;
};

template<typename NewItem, typename List>
struct PrependItem;

template<typename NewItem, typename...Items>
struct PrependItem<NewItem, TypeList<Items...>> {
    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, 0> {
    static_assert(GetSize<List>::value > 0, "index too high");
    typedef typename List::type type;
};

template<typename List, template<typename, 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<current_type, Keys...>::value, 
                                 Identity<current_type>, // found!
                                 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<typename List::tail, I-1,
                                                  NewItem>::type>
        ::type type;
};

template<typename NewItem, typename Type, typename... T>
struct ReplaceItem<TypeList<Type, T...>, 0, NewItem> {
    typedef TypeList<NewItem, T...> type;
};

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

template<typename OldState, typename Input, typename NewState, 
         typename 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<I>...> type;
    };
};

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

typedef Input<-1> InputBlank;

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

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

    typedef typename Conditional<
        static_cast<int>(GetSize<typename config::input>::value) 
            <= static_cast<int>(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, typename 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<position + rule::direction, 0>::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, typename Transitions>
struct Controller<Configuration<Input, State, Position>, Transitions, 
                  typename EnableIf<IsSame<State, QAccept>::value || 
                                    IsSame<State, QReject>::value>::type> {
    typedef Configuration<Input, State, Position> config;
    enum { position = config::position };
    typedef typename Conditional<
        static_cast<int>(GetSize<typename config::input>::value) 
            <= static_cast<int>(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, typename StartState>
struct TuringMachine {
    typedef Input input;
    typedef Transitions transitions;
    typedef StartState start_state;

    typedef Controller<Configuration<Input, StartState, 0>, Transitions> controller;
    typedef typename controller::end_config end_config;
    typedef typename controller::end_input end_input;
    typedef typename controller::end_state end_state;
    enum { end_position = controller::end_position };
};

#include <ostream>

template<>
char const* Input<-1>::name = "_";

char const* QAccept::name = "qaccept";
char const* QReject::name = "qreject";

int main() {
    DEF_INPUT(1, x);
    DEF_INPUT(2, x_mark);
    DEF_INPUT(3, split);

    DEF_STATE(0, start);
    DEF_STATE(1, find_blank);
    DEF_STATE(2, go_back);

    /* syntax:  State, Input, NewState, Output, Move */
    typedef TypeList< 
        Rule<start, x, find_blank, x_mark, Right>,
        Rule<find_blank, x, find_blank, x, Right>,
        Rule<find_blank, split, find_blank, split, Right>,
        Rule<find_blank, InputBlank, go_back, x, Left>,
        Rule<go_back, x, go_back, x, Left>,
        Rule<go_back, split, go_back, split, Left>,
        Rule<go_back, x_mark, start, x, Right>,
        Rule<start, split, QAccept, split, Left>> rules;

    /* syntax: initial input, rules, start state */
    typedef TuringMachine<TypeList<x, x, x, x, split>, rules, start> double_it;
    static_assert(IsSame<double_it::end_input, 
                         TypeList<x, x, x, x, split, x, x, x, x>>::value, 
                "Hmm... This is borky!");
}

131
您手上的时间太多了。
马克·凯格尔

2
看起来像Lisp,除了用certin词代替所有这些括号。
Simon Kuang

1
好奇的读者可以在某个地方公开获得完整的源代码吗?:)
OJFord 2015年

1
只是尝试值得得到更多的荣誉:-)这段代码可以编译(gcc-4.9),但是没有输出-像博客文章一样多一点的信息将是很棒的。
Alfred Bratterud'3

2
@OllieFord我在pastebin页面上找到了它的一个版本,并在这里对其进行了批注:coliru.stacked-crooked.com/a/de06f2f63f905b7e
Johannes Schaub-litb


13

我的C ++有点生锈,因此可能并不完美,但是已经接近了。

template <int N> struct Factorial
{
    enum { val = Factorial<N-1>::val * N };
};

template <> struct Factorial<0>
{
    enum { val = 1 };
}

const int num = Factorial<10>::val;    // num set to 10! at compile time.

关键是要证明编译器将完全评估递归定义,直到获得答案为止。


1
嗯...您是否不需要在struct Factorial <0>之前的行上使用“ template <>”来指示模板的专业化?
paxos1977

11

举一个简单的例子:http : //gitorious.org/metatrace,一个C ++编译时光线跟踪器。

请注意,C ++ 0x将以以下形式添加非模板的,编译时的,图灵完整的工具constexpr

constexpr unsigned int fac (unsigned int u) {
        return (u<=1) ? (1) : (u*fac(u-1));
}

您可以constexpr在需要编译时间常数的任何地方使用-expression,但也可以constexpr使用具有非const参数的-functions 来调用。

一件很酷的事情是,尽管标准明确指出编译时浮点算术不必与运行时浮点算术相匹配,但这最终将启用编译时浮点算术:

bool f(){
    char array[1+int(1+0.2-0.1-0.1)]; //Must be evaluated during translation
    int  size=1+int(1+0.2-0.1-0.1); //May be evaluated at runtime
    return sizeof(array)==size;
}

f()的值是true还是false尚不确定。



8

阶乘示例实际上并未显示模板是图灵完整的,而是显示它们支持原始递归。证明模板是完整的最简单的方法是由Church-Turing论文完成的,即通过实现未类型化lambda演算的Turing机器(凌乱而又毫无意义的)或三个规则(app,abs var)。后者更简单,也更有趣。

当您了解C ++模板允许在编译时进行纯函数式编程时,所讨论的内容是一个非常有用的功能,这种形式化具有表现力,功能强大且优雅,但如果您经验不足,编写起来也会非常复杂。还要注意,有很多人发现仅获得大量的模板化代码通常需要付出很大的努力:(纯)功能语言就是这种情况,这使得编译更加困难,但令人惊讶地产生了不需要调试的代码。


嘿,我想知道“ app,abs,var”指的是哪三个规则?我假设前两个分别是函数应用程序和抽象(lambda definition(?))。是这样吗?第三是什么?与变量有关吗?
维泽克

我个人认为,在编译器中支持原语递归的语言通常比图灵完备更好,因为针对支持编译时原语递归的语言的编译器可以保证任何构建都会完成或失败,但是构建过程为Turing Complete的人不能这样做,除非人为地限制构建,使其不是Turing Complete。
超级猫

5

我认为这称为模板元编程


2
这是有用的一面。不利的一面是,我怀疑大多数人(当然不是我)是否会真正理解大多数东西中发生的一小部分。这是非常难以理解,无法维护的东西。
Michael Burr

3
我认为这就是整个C ++语言的缺点。它正在变成一个怪物……
Federico A. Ramponi

C ++ 0x有望使其变得更容易(根据我的经验,最大的问题是编译器不完全支持它,而C ++ 0x则无济于事)。尤其是概念看起来会清除所有内容,例如摆脱很多SFINAE的东西,这很难看懂。
coppro

@MichaelBurr C ++委员会不在乎那些不可读,无法维护的东西。他们只是喜欢添加功能。
Sapphire_Brick

4

好吧,这是运行4状态2符号繁忙海狸的图灵机实现的编译时实现

#include <iostream>

#pragma mark - Tape

constexpr int Blank = -1;

template<int... xs>
class Tape {
public:
    using type = Tape<xs...>;
    constexpr static int length = sizeof...(xs);
};

#pragma mark - Print

template<class T>
void print(T);

template<>
void print(Tape<>) {
    std::cout << std::endl;
}

template<int x, int... xs>
void print(Tape<x, xs...>) {
    if (x == Blank) {
        std::cout << "_ ";
    } else {
        std::cout << x << " ";
    }
    print(Tape<xs...>());
}

#pragma mark - Concatenate

template<class, class>
class Concatenate;

template<int... xs, int... ys>
class Concatenate<Tape<xs...>, Tape<ys...>> {
public:
    using type = Tape<xs..., ys...>;
};

#pragma mark - Invert

template<class>
class Invert;

template<>
class Invert<Tape<>> {
public:
    using type = Tape<>;
};

template<int x, int... xs>
class Invert<Tape<x, xs...>> {
public:
    using type = typename Concatenate<
        typename Invert<Tape<xs...>>::type,
        Tape<x>
    >::type;
};

#pragma mark - Read

template<int, class>
class Read;

template<int n, int x, int... xs>
class Read<n, Tape<x, xs...>> {
public:
    using type = typename std::conditional<
        (n == 0),
        std::integral_constant<int, x>,
        Read<n - 1, Tape<xs...>>
    >::type::type;
};

#pragma mark - N first and N last

template<int, class>
class NLast;

template<int n, int x, int... xs>
class NLast<n, Tape<x, xs...>> {
public:
    using type = typename std::conditional<
        (n == sizeof...(xs)),
        Tape<xs...>,
        NLast<n, Tape<xs...>>
    >::type::type;
};

template<int, class>
class NFirst;

template<int n, int... xs>
class NFirst<n, Tape<xs...>> {
public:
    using type = typename Invert<
        typename NLast<
            n, typename Invert<Tape<xs...>>::type
        >::type
    >::type;
};

#pragma mark - Write

template<int, int, class>
class Write;

template<int pos, int x, int... xs>
class Write<pos, x, Tape<xs...>> {
public:
    using type = typename Concatenate<
        typename Concatenate<
            typename NFirst<pos, Tape<xs...>>::type,
            Tape<x>
        >::type,
        typename NLast<(sizeof...(xs) - pos - 1), Tape<xs...>>::type
    >::type;
};

#pragma mark - Move

template<int, class>
class Hold;

template<int pos, int... xs>
class Hold<pos, Tape<xs...>> {
public:
    constexpr static int position = pos;
    using tape = Tape<xs...>;
};

template<int, class>
class Left;

template<int pos, int... xs>
class Left<pos, Tape<xs...>> {
public:
    constexpr static int position = typename std::conditional<
        (pos > 0),
        std::integral_constant<int, pos - 1>,
        std::integral_constant<int, 0>
    >::type();

    using tape = typename std::conditional<
        (pos > 0),
        Tape<xs...>,
        Tape<Blank, xs...>
    >::type;
};

template<int, class>
class Right;

template<int pos, int... xs>
class Right<pos, Tape<xs...>> {
public:
    constexpr static int position = pos + 1;

    using tape = typename std::conditional<
        (pos < sizeof...(xs) - 1),
        Tape<xs...>,
        Tape<xs..., Blank>
    >::type;
};

#pragma mark - States

template <int>
class Stop {
public:
    constexpr static int write = -1;
    template<int pos, class tape> using move = Hold<pos, tape>;
    template<int x> using next = Stop<x>;
};

#define ADD_STATE(_state_)      \
template<int>                   \
class _state_ { };

#define ADD_RULE(_state_, _read_, _write_, _move_, _next_)          \
template<>                                                          \
class _state_<_read_> {                                             \
public:                                                             \
    constexpr static int write = _write_;                           \
    template<int pos, class tape> using move = _move_<pos, tape>;   \
    template<int x> using next = _next_<x>;                         \
};

#pragma mark - Machine

template<template<int> class, int, class>
class Machine;

template<template<int> class State, int pos, int... xs>
class Machine<State, pos, Tape<xs...>> {
    constexpr static int symbol = typename Read<pos, Tape<xs...>>::type();
    using state = State<symbol>;

    template<int x>
    using nextState = typename State<symbol>::template next<x>;

    using modifiedTape = typename Write<pos, state::write, Tape<xs...>>::type;
    using move = typename state::template move<pos, modifiedTape>;

    constexpr static int nextPos = move::position;
    using nextTape = typename move::tape;

public:
    using step = Machine<nextState, nextPos, nextTape>;
};

#pragma mark - Run

template<class>
class Run;

template<template<int> class State, int pos, int... xs>
class Run<Machine<State, pos, Tape<xs...>>> {
    using step = typename Machine<State, pos, Tape<xs...>>::step;

public:
    using type = typename std::conditional<
        std::is_same<State<0>, Stop<0>>::value,
        Tape<xs...>,
        Run<step>
    >::type::type;
};

ADD_STATE(A);
ADD_STATE(B);
ADD_STATE(C);
ADD_STATE(D);

ADD_RULE(A, Blank, 1, Right, B);
ADD_RULE(A, 1, 1, Left, B);

ADD_RULE(B, Blank, 1, Left, A);
ADD_RULE(B, 1, Blank, Left, C);

ADD_RULE(C, Blank, 1, Right, Stop);
ADD_RULE(C, 1, 1, Left, D);

ADD_RULE(D, Blank, 1, Right, D);
ADD_RULE(D, 1, Blank, Right, A);

using tape = Tape<Blank>;
using machine = Machine<A, 0, tape>;
using result = Run<machine>::type;

int main() {
    print(result());
    return 0;
}

Ideone证明运行:https ://ideone.com/MvBU3Z

说明: http //victorkomarov.blogspot.ru/2016/03/compile-time-turing-machine.html

GitHub上有更多示例:https : //github.com/fnz/CTTM


3

您可以从Dobbs博士那里查看有关使用模板实现FFT的文章,我认为这不是那么简单。重点是允许编译器执行比非模板实现更好的优化,因为FFT算法使用很多常量(例如sin表)

第一部分

第二部分


2

指出这是一种纯粹的功能语言,尽管几乎无法调试,这也很有趣。如果您查看James post,您会明白我的意思是功能正常。通常,它不是C ++最有用的功能。它并非旨在执行此操作。这是被发现的东西。


2

如果您想至少在理论上在编译时计算常量,这可能会很有用。查看模板元编程


1

一个合理有用的例子是比率类。周围有一些变体。使用部分重载来捕获D == 0情况非常简单。真正的计算是在计算N和D的GCD和编译时间。当您在编译时计算中使用这些比率时,这是必不可少的。

示例:当您计算厘米(5)*公里(5)时,在编译时您将把ratio <1,100>与ratio <1000,1>相乘。为了防止溢出,您需要使用比率<10,1>而不是比率<1000,100>。


0

一个图灵机是图灵完备的,但是,这并不意味着你应该要使用一个产品代码。

以我的经验,尝试对模板进行任何琐碎的工作都是混乱,丑陋且毫无意义的。您没有办法“调试”您的“代码”,编译时错误消息将是晦涩的,通常在最不可能的地方,并且您可以通过不同的方式获得相同的性能优势。(提示:4!= 24)。更糟糕的是,您的代码对于一般的C ++程序员来说是难以理解的,并且由于当前编译器的广泛支持水平,可能无法移植。

模板非常适合用于通用代码生成(容器类,类包装器,混入),但不能-在我看来,模板的图灵完整性在实践中并不有用


4!可能是24岁,但MY_FAVORITE_MACRO_VALUE是多少!?好的,我也不认为这是个好主意。
Jeffrey L Whitledge,

0

另一个不编程的例子:

template <int深度,int A,类型名B>
结构K17 {
    静态const int x =
    K17 <深度+1,0,K17 <深度,A,B>> :: x
    + K17 <深度+1,1,K17 <深度,A,B>> :: x
    + K17 <深度+1,2,K17 <深度,A,B>> :: x
    + K17 <深度+1,3,K17 <深度,A,B>> :: x
    + K17 <深度+1,4,K17 <深度,A,B>> :: x;
};
模板<int A,类型名B>
结构K17 <16,A,B> {static const int x = 1; };
静态常量int z = K17 <0,0,int> :: x;
void main(void){}

发表于C ++模板图灵完备


出于好奇,x的答案是pow(5,17-depth);
10年

当您意识到模板参数A和B不执行任何操作并删除它们,然后将所有附加值替换为时,这很容易看到K17<Depth+1>::x * 5
大卫·斯通
By using our site, you acknowledge that you have read and understand our Cookie Policy and Privacy Policy.
Licensed under cc by-sa 3.0 with attribution required.