Мені кажуть, що система шаблонів у C ++ завершується Тьюрінгом під час компіляції. Про це йдеться у цій публікації, а також у вікіпедії .
Чи можете ви надати нетривіальний приклад обчислення, що експлуатує цю властивість?
Чи корисний цей факт на практиці?
Відповіді:
Приклад
#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 aka (Бібліотека програмування мета). Але спробуйте налагодити помилку компілятора у вашому коді шаблону, і ви будете тривалий важкий шлях.
Але хороший практичний приклад використання його для чогось корисного:
Скотт Мейєрс працював над розширенням мови С ++ (я терміново використовую цей термін), використовуючи шаблонні засоби. Про його роботу ви можете прочитати тут " Забезпечення функцій коду "
Я зробив машину для твердіння в С ++ 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!");
}" Шаблони C ++ завершуються завершеними " дає реалізацію машини Тьюрінга в шаблонах ..., що нетривіально і доводить суть дуже прямо. Звичайно, це також не дуже корисно!
Мій 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.Сенс полягає в тому, щоб продемонструвати, що компілятор повністю оцінює рекурсивне визначення, поки не досягне відповіді.
Навести нетривіальний приклад: http://gitorious.org/metatrace , відстежувач проміжок часу компіляції C ++.
Зауважте, що C ++ 0x додасть нешаблон, час компіляції, turing-завершений у вигляді constexpr:
constexpr unsigned int fac (unsigned int u) {
return (u<=1) ? (1) : (u*fac(u-1));
}Ви можете використовувати constexpr-expression скрізь, де потрібні константи часу компіляції, але ви також можете викликати constexpr-функції з параметрами non-const.
Хороша річ, що це, нарешті, дозволить скласти математику з плаваючою точкою часу компіляції, хоча стандарт прямо визначає, що арифметика з плаваючою точкою компіляції не повинна відповідати арифметиці з плаваючою точкою виконання:
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 () істинним чи хибним.
Книга Сучасний дизайн C ++ - Універсальне програмування та модель дизайну Андрія Олександреску - найкраще місце для досвіду корисних та потужних загальних моделей програмування.
Фактичний приклад насправді не показує, що шаблони Тьюрінга завершені, наскільки це показує, що вони підтримують примітивну рекурсію. Найпростіший спосіб довести, що шаблони закінчуються - це теза Церкви Тьюрінга, тобто реалізація або машини Тьюрінга (безладний і трохи безглуздий), або трьох правил (додаток, abs var) нетипізованого обчислення лямбда. Останнє набагато простіше і куди цікавіше.
Те, що обговорюється, є надзвичайно корисною функцією, коли ви розумієте, що шаблони C ++ дозволяють робити чисте функціональне програмування під час компіляції, формалізм, який є виразним, потужним та елегантним, але також дуже складним для написання, якщо у вас мало досвіду. Також зауважте, як багато людей вважають, що просто отримання сильно шаблонованого коду часто може вимагати великих зусиль: саме так трапляється з (чистими) функціональними мовами, які роблять компіляцію складнішою, але напрочуд вихідним кодом, який не потребує налагодження.
Я думаю, що це називається шаблонним метапрограмуванням .
Ну ось ось час компіляції Turing Machine, який працює з чотирма державними 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;
}Ідейний запуск: https://ideone.com/MvBU3Z
Пояснення: http://victorkomarov.blogspot.ru/2016/03/compile-time-turing-machine.html
Github з додатковими прикладами: https://github.com/fnz/CTTM
Ви можете перевірити цю статтю від доктора Доббса про реалізацію FFT із шаблонами, які, на мою думку, не такі тривіальні. Основний момент - дозволити компілятору провести кращу оптимізацію, ніж для реалізації не шаблонів, оскільки алгоритм FFT використовує багато констант (наприклад, таблиці sin)
Також цікаво зазначити, що це виключно функціональна мова, хоча її майже неможливо налагодити. Якщо ви подивитесь на пост Джеймса, ви побачите, що я маю на увазі під його функціональністю. Взагалі це не найкорисніша особливість C ++. Це не було призначено для цього. Це щось, що було виявлено.
Це може бути корисно, якщо ви хочете обчислити константи під час компіляції, принаймні теоретично. Перевірте метапрограмування шаблонів .
Приклад, який є корисним, - клас співвідношення. Є кілька варіантів, що плавають навколо. Ловити випадок D == 0 досить просто з частковими перевантаженнями. Реальна обчислення полягає в обчисленні GCD N і D та часу компіляції. Це важливо, коли ви використовуєте ці співвідношення для обчислень часу компіляції.
Приклад: Коли ви обчислюєте сантиметри (5) * кілометрів (5), під час компіляції ви будете множити коефіцієнт <1,100> і відношення <1000,1>. Щоб запобігти переповненню, потрібно співвідношення <10,1> замість співвідношення <1000,100>.
машина Тьюринга Тьюринг-повній, але це не означає , що ви повинні використовувати одну для виробництва коду.
Намагатися робити що-небудь нетривіальне з шаблонами, на мій досвід, безладний, потворний і безглуздий. У вас немає ніякого способу "налагодити" свій "код", повідомлення про помилки під час компіляції будуть криптовалютними і, як правило, в найбільш малоймовірних місцях, і ви можете досягти однакових переваг від продуктивності різними способами. (Підказка: 4! = 24). Гірше, що ваш код незрозумілий середньому програмісту на C ++ і, швидше за все, не переноситься через широкий діапазон підтримки в поточних компіляторах.
Шаблони чудово підходять для генерації загального коду (класи контейнерів, класові обгортки, суміші), але ні - на мою думку, Тюрінг повнота шаблонів НЕ ВИКОРИСТАН на практиці.
Ще один приклад того, як не програмувати:
шаблон <int Depth, int A, typename 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, ім'я типу>
структура K17 <16, A, B> {статичний const int x = 1; };
статичний const int z = K17 <0,0, int> :: x;
void main (пустота) {}
Повідомлення в шаблонах C ++ завершуються
K17<Depth+1>::x * 5.