#include <iostream>
     
template<class T>
int len = 2;
     
template<class Fn>
const char* s_str = Fn();
     
//template<class Fn>
//auto x = Fn();
     
int main()
{
    class centimeter {};
    class meter {};
    class nothing {};
     
    len<centimeter> = 100 * len<meter>;
     
    std::cout << len<nothing> << ',' << len<centimeter> << std::endl;
     
    const char* str = "asdf";
     
    auto oGetStr = [str]()->const char* {return str;};
    //const char* p = s_str<decltype(oGetStr)>; // error
     
    auto o2and2 = []()->int{return 2 + 2;};
    //int n = x<decltype(o2and2)>; // error
     
    return 0;
}

void fun()
{
    std::cout << TT("asdf") << std::endl;
}

len<centimeter> = 100 * len<meter>;

BFE>len<centimeter> = 100 * len<meter>;
BFE>

len<   /* пишем пишем*/
   centimeter
  > = 0;

// Вместо
template <typename F>
struct pi_traits
{
  static F get() {return (F)3.1415...;}
};
// Получаем:
template <typename F>
static const pi<F> = (F)3.1415...;

#include <iostream>
     
     
template<class T>
T x = T{};

void f()
{
    class Test{ public: Test(){std::cout << "Test\n";} };

    Test t = x<Test>;
}


int main()
{
    std::cout << "start\n";

    return 0;
}

BFE>void fun()
BFE>{
BFE>    std::cout << TT("asdf") << std::endl;
BFE>}
BFE>

#include <iostream>
#include <vector>

using namespace std;

vector<const char *> strings;

template<class T>
T run_it = T{};

#define GETTEXT(x) \
    [] \
    { \
        struct Action { Action() { strings.push_back(x); } };\
        (void)run_it<Action>; \
        return x; \
    }() \
/**/

void not_used()
{
    const char *x = GETTEXT("first");
    auto y = GETTEXT("second");
}

int main()
{    
    for(auto x : strings)
        cout << x << endl;
}

first
second

BFE>>Какой, думаете, будет вывод такой программы?

Test
start

#include <iostream>
#include <vector>

std::vector<const char*> g_Strings;

const char* AddToGlobalArray(const char* pStr)
{
  g_Strings.push_back(pStr);
  return pStr;
}


template <class T>
class StrMap
{
  public:
    static const char* const m_p;
};

//static
template <class T>
const char* const StrMap<T>::m_p = AddToGlobalArray(T().get());

void fun()
{
    struct GetStr{ const char* get() { return "asdf"; } };

    const char* p = StrMap<GetStr>::m_p;
}


void fun2()
{
    struct GetStr{ const char* get() { return "qwerty"; } };

    const char* p = StrMap<GetStr>::m_p;
}


int main(int argc, char* argv[])
{
    for(auto x : g_Strings)
        std::cout << x << std::endl;

    return 0;
}

#include <cstdio>

using namespace std;

struct First
{
    First()
    {
        printf("first\n");
    }
} first;

template<class T>
T run_it = T{};

void not_used()
{
    struct Second
    {
        Second()
        {
            printf("second\n");
        }
    };
    Second t = run_it<Second>;
}

int main()
{
}

// GCC:
first
second

// Clang:
second
first

#ifndef CT_STRING_H_INCLUDED
#define CT_STRING_H_INCLUDED

namespace ct
{

template <char ...Chars>
struct string
{
    enum { length = sizeof...(Chars) - 1 };

    static char const value[];
};

template <char ...Chars>
char const string<Chars...>::value[] = { Chars... };

} // ct

#endif // CT_STRING_H_INCLUDED

#ifndef CT_INDICES_UTILS_H_INCLUDED
#define CT_INDICES_UTILS_H_INCLUDED

#include <cstddef>

namespace ct
{

template <size_t ...I>
struct indices
{ };

template <size_t Max, size_t ...Indices>
struct make_indices
    : make_indices<Max - 1, Max - 1, Indices...>
{ };

template <size_t ...Indices>
struct make_indices<0, Indices...>
    : indices<Indices...>
{
    using type = indices<Indices...>;
};

} // ct

#endif // CT_INDICES_UTILS_H_INCLUDED

#ifndef CT_STRING_UTILS_H_INCLUDED
#define CT_STRING_UTILS_H_INCLUDED

#include "ct_string.h"
#include "ct_indices_utils.h"

namespace ct
{

template <typename Str, typename I>
struct string_gen;

template <typename Str, size_t ...I>
struct string_gen<Str, ::ct::indices<I...>>
    : ::ct::string<Str{}.chars[I]...>
{ };

template <typename Str, size_t Len>
struct make_string
    : string_gen<Str, typename ::ct::make_indices<Len>::type>
{ };

} // ct

#endif // CT_STRING_UTILS_H_INCLUDED

#ifndef TRANSLATOR_H_INCLUDED
#define TRANSLATOR_H_INCLUDED

#include "ct_string.h"
#include "ct_indices_utils.h"
#include "ct_string_utils.h"

class Translator
{
public:
    enum { LangMax = 5 };

    struct Holder
    {
        char const * m_strings[LangMax];
    };

private:
    template <typename Value>
    struct Storage : Value, Holder
    {
        template <size_t ...I>
        Storage(Translator & self, ct::indices<I...>)
            : Holder{ { ((void)I, Value::value)... } }
        { }

        explicit Storage(Translator & self)
            : Storage(self, ct::make_indices<LangMax> {})
        { }
    };

    template <char ...Chars>
    Holder * addString(ct::string<Chars...> const &)
    {
        static Storage<ct::string<Chars...>> s(*this);
        return &s;
    }

public:
    static Translator & instance()
    {
        static Translator inst;
        return inst;
    }

    template <typename Original, typename Translated>
    void addTranslation(size_t lang)
    {
        Holder * h = this->addString(Original{});
        h->m_strings[lang] = Translated::value;
    }
    template <typename Original>
    char const * addString()
    {
        Holder * h = this->addString(Original{});
        return h->m_strings[m_lang];
    }

    static void setLang(size_t lang)
    {
        instance().m_lang = lang;
    }

private:
    size_t m_lang = 0;
};

#define TR(str) []() \
    {                                                                   \
        struct StringType1 { const char * chars = (str); };             \
        using type1 = ::ct::make_string<StringType1, sizeof((str))>;    \
        return Translator::instance().addString<type1>();               \
    }()

#define SETUP_TR(lang, orig, trans) []() \
    {                                                                   \
        struct StringType1 { const char * chars = (orig);  };           \
        using type1 = ::ct::make_string<StringType1, sizeof((orig))>;   \
        struct StringType2 { const char * chars = (trans); };           \
        using type2 = ::ct::make_string<StringType2, sizeof((trans))>;  \
        Translator::instance().addTranslation<type1, type2>(lang);      \
        return true;                                                    \
    }()

#endif // TRANSLATOR_H_INCLUDED

#include <cstdio>

#include "translator.h"

enum { RUS = 1 };

namespace {
bool f1 = SETUP_TR(RUS, "start", "старт");
bool f2 = SETUP_TR(RUS, "text", "текст");
}

int main()
{
    Translator::setLang(RUS);

    printf("%s\n", TR("start"));
    printf("%s\n", TR("start"));
    printf("%s\n", TR("text"));
}

int main()
{
    struct X
    {
        const char *chars = "abc";
    };
    static_assert(X{}.chars[0] == 'a', "");
    constexpr char x = X{}.chars[0];
}

#define CTTE_WRAP_STRING(x) \
    [] \
    { \
        struct { static constexpr auto value() { return x;} } str; \
        return str; \
    } \
/**/

EP>    struct X
EP>    {
EP>        const char *chars = "abc";
EP>    };
EP>

    struct X
    {
        const char *chars;
        
        constexpr X() : chars("abc") {}
    };

EP>>    struct X
EP>>    {
EP>>        const char *chars = "abc";
EP>>    };
EP>>

EP>    struct X
EP>    {
EP>        const char *chars;
        
EP>        constexpr X() : chars("abc") {}
EP>    };
EP>

struct X
{
    typedef decltype("abc") type;
    static constexpr type chars() { return "abc"; }
};

constexpr std::size_t c_str_length(const char *x)
{
    return find(x, '\0') - x;
}

W>struct X
W>{
W>    typedef decltype("abc") type;
W>    static constexpr type chars() { return "abc"; }
W>};
W>

struct X
{
    static constexpr auto chars() -> decltype("abc")
    {
        return "abc";
    }
};

    #define DECL_STR(str) \
        struct { char const * chars = (str); }

    using test = DECL_STR("test");

template <typename Str, size_t ...I>
struct string_gen<Str, ::ct::indices<I...>>
    : ::ct::string<Str().chars[I]...> // Str{} -> Str()
{ };