Data member with reference type is not const inside a const member function due to C++'s type system.
i.e
c.v is decorated from right to left thus
int& const data_member;
is not valid.
struct Fun {
int &a;
void run() const { a += 1; }
};
int main() {
int a = 42;
[&a] { a += 1; }();
Fun f{a};
f.run();
}
template<typename T>
void f(T& t)
{
puts(__PRETTY_FUNCTION__);
}
int main() {
int i = 42;
f(static_cast<int&>(i)); // [with T=int]
f(static_cast<int&&>(i)); // ERROR (T=int)
f(static_cast<const int&>(i)); // [with T=const int]
f(static_cast<const int&&>(i)); // [with T=const int] (!)
}
template<typename R, typename A>
void foo(R (*fptr)(A))
{
puts(__PRETTY_FUNCTION__);
}
int main()
{
foo( [](double x) { return int(x); } ); // error
foo( +[](double x) { return int(x); } ); // compiles
}
void ContainingClass::SomeMethod()
{
class AnonymousClass$0
{
public:
AnonymousClass$0() { }
operator int (__cdecl *)(int k) { return cdecl_static_function; }
operator int (__stdcall *)(int k) { return stdcall_static_function; }
operator int (__fastcall *)(int k) { return fastcall_static_function; }
int operator(int k) { return cdecl_static_function(k); }
private:
static int __cdecl cdecl_static_function(int k) { return calc(k + 42); }
static int __stdcall stdcall_static_function(int k) { return calc(k + 42); }
static int __fastcall fastcall_static_function(int k) { return calc(k + 42); }
};
auto f = AnonymousClass$0();
...
}
template<typename T>
constexpr bool is_array = false;
template<typename Tp>
constexpr bool is_array<Tp[]> = true;
template<typename Tp, int N>
constexpr bool is_array<Tp[N]> = true;
template<> // this is a full specialization
constexpr bool is_array<void> = true;
template <typename T> T vt;
// GCC: this is a definition just as much as "int v;" would be
// Clang: this is just a declaration, akin to "extern int v;"
int i = vt<int>;
// GCC/MSVC reserve space for vt<int> here;
// Clang merely sets you up for a linker error
template<class T, class... Us, class V> void f();
f<int,char,int>(); // T=int; Us=<char,int>; V cannot be deduced
template<class... Ts, class U> void g(U);
g<int,char>(3.1); // Ts=<int,char>; U=double
template<class... Ts> void h(Ts...);
h<int,char>(0, 0, 3.1); // Ts=<int,char,double>
template<class... Ts, class U> void f(U, Ts...);
f('x', 1, 2); // U=char; Ts=<int,int>
template<class T, class... Us> void g(Us... us, T);
g('x', 1, 2); // us doesn’t contribute to deduction, so this fails
template<class T, class... Us> void h(Us... us, T);
h<int,int,int>('x', 1, 2); // us doesn’t contribute to deduction,
// but we explicitly stated T=int, Us=<int,int>, which happens to work!
template<class Ty, Ty Value>
struct integral_constant {
static constexpr auto value = Value;
};
template<auto Value>
struct new_integral_constant {
static constexpr auto value = Value;
};
template<typename T>
struct myvec {
explicit myvec(T t); // constructor
};
int main() {
myvec v(1);
}
template<typename T>
struct myvec {
myvec(T t); //choose
myvec(T *p);
};
int main() {
myvec v(1);
}
template<typename T>
struct myvec {
myvec(T t);
myvec(T *p); //choose
};
int main() {
int i;
myvec v(&i);
// OK in C++17
}
template<typename T>
struct myvec {
// But will having constructor overload error; i.e. myvec(double); myvec(double)
myvec(T t); // choose, since only by choosing this could the type T be deduced.
myvec(double d);
};
int main() {
myvec v(1.0); // OK in C++17
}
template<typename T>
struct myvec {
myvec(T t); // Choose, T = int*, int* matches below T*
};
template<typename T>
struct myvec<T*> {
myvec(T* t); // Match here!!!
};
int main() {
int i;
myvec v(&i); // OK in C++17, however, we have partial specialized myvec here...
}
template<typename T>
struct Base {
int data_base = 10;
};
struct Derived : Base {
int data_derived = 12;
};
template<typename T>
struct myvec {
myvec(T t) {
cout << t.data_base; // print 10;
}
myvec(float d) {
cout << "float\n";
}
};
myvec(Derived) -> myvec// declaration of the template
template<class T> struct container {
container(T t) {}
template<class Iter> container(Iter beg, Iter end);
};
// additional deduction guide
template<class Iter>
container(Iter b, Iter e) -> container<typename std::iterator_traits<Iter>::value_type>;
// uses
container c(7); // OK: deduces T=int using an automatic guide
std::vector<double> v = { /* ... */};
auto d = container(v.begin(), v.end()); // OK: deduces T=double
container e{5, 6}; // Error: there is no std::iterator_traits<int>::value_type
// Based on Richard Smith trick for constexpr lambda
// via Paul Fultz II (http://pfultz2.com/blog/2014/09/02/static-lambda/)
template<typename T>
auto addr(T &&t)
{
return &t;
}
static const constexpr auto odr_helper = true ? nullptr : addr([](){});
template <class T = decltype(odr_helper)>
inline void g() {
int arr[2] = {};
std::for_each(arr, arr+2, [] (int i) {std::cout << i << ' ';});
}