#include <iostream>

bool fermat()
{
    constexpr int threshold = 100;
    int a = 1, b = 1, c = 1;
    while(true)
    {
        if( a*a*a + b*b*b == c*c*c )
            return true;
        ++a;
        if(a > threshold)
        {
            a = 1;
            ++b;
        }
        if(b > threshold)
        {
            b = 1;
            ++c;
        }
        if(c > threshold)
            c = 1;
    }
    return false;
}

int main()
{
    using namespace std;
    cout << boolalpha << fermat() << endl;
}

clang++ -std=c++1z -O3 -Wall main.cpp && ./a.out
true

1.10/24 The implementation may assume that any thread will eventually do one of the following:
— terminate,
— make a call to a library I/O function,
— access or modify a volatile object, or
— perform a synchronization operation or an atomic operation.
[ Note: This is intended to allow compiler transformations such as removal of empty loops, even when termination cannot be proven. —end note ]

struct A
{
    template <int n>
    A() { }
                                   
    A(int) : A::A<2>() {}
};

BFE>? Вроде же нет прямого запрета.

[Note: Because the explicit template argument list follows the function template name, and because conversion member function templates and constructor member function templates are called without using a function name, there is no way to provide an explicit template argument list for these function templates. —end note]

BFE>>? Вроде же нет прямого запрета.

A a<2>();// так нельзя.

A mem-initializer-list can delegate to another constructor of the constructor’s class using any class-ordecltype
that denotes the constructor’s class itself. If a mem-initializer-id designates the constructor’s class,
it shall be the only mem-initializer; the constructor is a delegating constructor, and the constructor selected
by the mem-initializer is the target constructor.

	Скрытый текст
	mem-initializer: mem-initializer-id ( expression-listopt) mem-initializer-id braced-init-list mem-initializer-id: class-or-decltype identifier class-or-decltype: nested-name-specifieropt class-name decltype-specifier nested-name-specifier: :: type-name :: namespace-name :: decltype-specifier :: nested-name-specifier identifier :: nested-name-specifier templateopt simple-template-id :: simple-template-id: template-name < template-argument-listopt> class-name: identifier simple-template-id template-name: identifier по синтаксису, вроде, подходит

struct A
{
    A() { }
    A(int) : A::A() {}
};

struct A
{
    template <int n> A(){}                               
    A(int) : A::template A<2>(){}
    
};

struct A
{
    template <int n> A(){} // OK
};

_NN>struct A
_NN>{
_NN>    template <int n> A(){} // OK
_NN>};
_NN>

_NN>Только вызвать его нельзя никак

struct A
{
    template <int n> A(){} // OK
    A(int) : A::A<2>() {} // call of template <int n> A(){}
};

Я нашёл этому поистине чудесное доказательство, но оно в процессе сохранения форматирует носитель, на который его сохраняют.