17.cpp

Go to the documentation of this file.

 
static_assert(__cplusplus == 201703);
 
#include <bits/stdc++.h>
 
using namespace std;
 
constexpr pair deducted_pair(1, 2.3);
static_assert(deducted_pair.second == 2.3);
 
constexpr tuple deducted_tuple(4, 2, 2.5);
static_assert(get<2>(deducted_tuple) == 2.5);
 
template <typename T = float>
struct template_struct {
    T val;
    template_struct() : val() {}
    template_struct(T val) : val(val) {}
};
 
template_struct template_arg_deduction {1};
 
#if __cpp_deduction_guides > 201611
 
template_struct template_default_arg_deduction;
 
#endif
 
vector<int> int_vector = {1, 2, 3, 4};
 
 
deque deduction_guide1_queue(int_vector.begin(), int_vector.end());
 
deque deduction_guide2_queue {int_vector.cbegin(), int_vector.cend()};
 
array deduction_guide_array {1, 2, 3, 4};
 
vector deduction_guide1_vector(int_vector.begin(), int_vector.end());
vector deduction_guide2_vector {int_vector.begin(), int_vector.end()};
 
 
void deduction_guides_17()
{
    assert(deduction_guide1_queue[0] == 1);
    assert(*deduction_guide2_queue[0] == 1);
    assert(deduction_guide1_vector[0] == 1);
    assert(*deduction_guide2_vector[0] == 1);
}
 
template<auto n> struct B { /* ... */ };
 
B<5> b1; // OK: non-type template parameter type is int
 
B<'a'> b2;
 
// Error:
// B<2.5> b3;
 
tuple<int, int> foo_tuple()
{
    // return make_tuple(1, -1);
    return {1, -1};
}
 
template <auto... seq>
struct my_integer_sequence {
};
 
auto seq = my_integer_sequence<0, 1, 2>();
 
// explicit constexpr
auto identity = [](int n) constexpr { return n; };
static_assert(identity(1) == 1);
 
// lambda with auto argument actually is a template
 
// implicit auto constexpr:
 
auto can_be_constexpr1 = [](auto a) { return a; };
auto can_be_constexpr2 = [](int(*fp)(int), auto a) { return fp(a); };
 
static_assert(can_be_constexpr2(can_be_constexpr1, 3) == 3);
 
// error: non-constant condition for static assertion
// static int i=0;
// static_assert(can_be_constexpr2(can_be_constexpr1, i) == 0);
 
auto non_const = [](auto a) {static int s; return a; };
 
// error: no specialization can be constexpr because of s
// static_assert(can_be_constexpr(non_const, 3)==3);
 
constexpr int const_inc(int n)
{
    return [n] { return n + 1; }();
}
 
constexpr int(*inc)(int) = const_inc;
static_assert(const_inc(1) == 2);