loliGothicK

template < class Iterator >
std::vector( Iterator, Iterator ) -> std::vector< typename Iterator::value_type >;

loliGothicK

#include <iostream>
#include <functional>

template <class F>
struct Fixed {
    F f;
    Fixed(F f): f{f} {}
    template <class... Args>
    decltype(auto) operator()(Args&&... args) const {
        return f(std::ref(*this), std::forward<Args>(args)...);

loliGothicK

template < class T >
struct X
{
    X( T t ) { }
};

int main()
{
    X x1(0); // X<int>.
    X x2(0.0); // X<double>.

loliGothicK

#include <array>
#include <utility>
#include <iostream>

template < std::size_t N >
constexpr auto ints = []{
    std::array<std::size_t, N> arr{};
    for( std::size_t i{}; i < N; ++i ) arr[i] = i;
    return arr;
}();

loliGothicK

#include <limits>
#include <utility>

template < class T >
constexpr
decltype(std::declval<T>()*2)
twice(T a) {
  return a*2;
}

loliGothicK

// エラー、SFINAEの文脈でconstexprラムダが使われている
template < typename T,
  bool b = []{
    T t;t.func();
    return true;
  }()>
void f() {
  T t;
  t.func();
}

loliGothicK

int main(){
auto twice = [](int n){ return n*2; };
constexpr int (*func_pointer_to_twice)(int) = twice;
static_assert(func_pointer_to_twice(2) == 4);
}

loliGothicK

int main(){
auto twice = [](int n){ return n*2; };
// twiceのoperator()は自動的にconstexpr指定されているのでOK
constexpr int x = twice(2);
}

loliGothicK

int main(){
// ラムダ式にconstexprをつけることができる
auto f1 = []() constexpr {};
// OK
auto f2 = []() mutable constexpr {};
// これもOK
auto f3 = []() constexpr mutable {};
}

loliGothicK

int main(){
constexpr auto add_one(int n){
// nがコンパイル時定数ならラムダ式はリテラル型
auto f = [n]{ return n + 1; };
// nがコンパイル時定数ならfはリテラル型なのでgもリテラル型
auto g = [f]{ return f(); };
return g;
}
static_assert( add_one(1)() == 2 );
}