How far can you push c++11 templates?

>this much bullshit to generate a fucking triangle at compile time
>needing templates

import std.stdio;

string stars(int x)
{   char[] ret;
    int y = 0;
    while (y <= x)
    {   for (int m = 0; m < y; ++m)
            ret ~= "*";
        ret ~= "\n";
        ++y;
    }
    return ret.idup;
}

void main()
{  pragma(msg, stars(12));
   writeln(stars(12));
}

>>61546464
>enum
>typedef
>constexpr constructor
You call that C++11 template metaprogramming? Absolutely disgusting.

#include <utility>
#include <iostream>

template<char...>
struct static_string;

template<typename...>
struct static_string_cat;

template<char... C, typename... A>
struct static_string_cat<static_string<C...>, A...>
{
  using value = typename static_string_cat<
    static_string<C...>, typename static_string_cat<A...>::value
  >::value;
};

template<char... L, char... R>
struct static_string_cat<static_string<L...>, static_string<R...>>
{
  using value = static_string<L..., R...>;
};

template<>
struct static_string_cat<>
{
  using value = static_string<>;
};

template<typename>
struct static_string_cstr;

template<char... C>
struct static_string_cstr<static_string<C...>>
{
  static constexpr char value[] = { C..., '\0' };
};

template<char... C>
constexpr char static_string_cstr<static_string<C...>>::value[];

template<std::size_t N, char C>
struct char_repeat
{
  using value = typename static_string_cat<
    static_string<C>, typename char_repeat<N - 1, C>::value
  >::value;
};

template<char C>
struct char_repeat<1, C>
{
  using value = static_string<C>;
};

template<unsigned N>
struct stars
  : public static_string_cat<
      typename char_repeat<N, '*'>::value, static_string<'\n'>
    >
{
};

template<typename>
struct triangle_aux;

template<std::size_t... I>
struct triangle_aux<std::index_sequence<I...>>
{
  using value = typename static_string_cat<
    typename stars<I + 1>::value...
  >::value;
};

template<std::size_t N>
struct triangle
{
  using value = typename triangle_aux<std::make_index_sequence<N - 1>>::value;
};

int main(void)
{
  static constexpr std::size_t TRIANGLE_SIZE = 20;
  std::cout
    << static_string_cstr<typename triangle<TRIANGLE_SIZE>::value>::value;
}

>>61547692
Please help I ran that and it formated my computer

>>61547692
Impressive

#include <iostream>

template<char... chars>
struct char_list
    {
    char value[sizeof...(chars)+1];
    constexpr char_list(): value{chars..., '\0'}{}
    };

template<size_t line, size_t tri_size, size_t row_size, char... collect>
struct _make_row
    { typedef typename _make_row<line, tri_size, row_size - 1, collect..., '*'>::type type; };

template<size_t line, size_t size, char... chars>
struct _make_tri
    { 
    typedef typename _make_row<line, size, size - line + 1, chars...>::type type;
    };

template<size_t line, size_t tri_size, char... collect>
struct _make_row<line, tri_size, 0, collect...>
    { typedef typename _make_tri<line - 1, tri_size, collect..., '\n'>::type type; };

template<size_t size, char... chars>
struct _make_tri<0, size, chars...>
    { typedef typename char_list<chars...> type; };


template<size_t size>
struct triangle
    { typedef typename _make_tri<size, size>::type type ; };

int main()
    {
    std::cout << triangle<10>::type().value << std::endl;
    return 0;
    }

pls rate

>>61547110
BTFO

>>61548033
Needs more templates.

>>61548033
btw, don't know why but this code doesn't work with gcc, it runs fine on msvc 2017 tho so you can run it on this site if your interested. http://webcompiler.cloudapp.net/

>>61548120
but it does everything at compile time and isn't cluttered

>>61547692
we're on the verge of getting c++17 and you're still doing c++11? pathetic

>>61548033
>using _ as a prefix for variable and type names
0/10 see me after class

>>61548234
can I still get half credit professor anon?

#include <iostream>

template<char... chars>
struct char_list
    {
    char value[sizeof...(chars)+1];
    constexpr char_list(): value{chars..., '\0'}{}
    };

template<size_t line, size_t tri_size, size_t row_size, char... collect>
struct _make_row
    { using type = typename _make_row<line, tri_size, row_size - 1, collect..., '*'>::type; };

template<size_t line, size_t size, char... chars>
struct _make_tri
    { using type = typename _make_row<line, size, size - line + 1, chars...>::type; };

template<size_t line, size_t tri_size, char... collect>
struct _make_row<line, tri_size, 0, collect...>
    { using type = typename _make_tri<line - 1, tri_size, collect..., '\n'>::type; };

template<size_t size, char... chars>
struct _make_tri<0, size, chars...>
    { using type = typename char_list<chars...>; };


template<size_t size>
struct triangle
    { using type = typename _make_tri<size, size>::type; };

int main()
    {
    std::cout << triangle<10>::type().value << std::endl;
    return 0;
    }

>>61548310
no
https://stackoverflow.com/questions/228783/what-are-the-rules-about-using-an-underscore-in-a-c-identifier

File: 1498774314426.jpg (146KB, 682x1082px) Image search: [Google]

146KB, 682x1082px

>>61546464
>this thread
OOP was a mistake.

>outputs 1.5MB executable

Brilliant.

How cant Rustfags even compete?