instantiate-init.cpp [plain text]
struct X0 { X0(int*, float*); };
template<typename T, typename U>
X0 f0(T t, U u) {
X0 x0(t, u); return X0(t, u); }
void test_f0(int *ip, float *fp, double *dp) {
f0(ip, fp);
f0(ip, dp); }
template<typename Ret, typename T, typename U>
Ret f1(Ret *retty, T t, U u) {
Ret r0(t, u); return Ret(t, u); }
void test_f1(X0 *x0, int *ip, float *fp, double *dp) {
f1(x0, ip, fp);
f1(x0, ip, dp); }
namespace PR6457 {
template <typename T> struct X { explicit X(T* p = 0) { }; };
template <typename T> struct Y { Y(int, const T& x); };
struct A { };
template <typename T>
struct B {
B() : y(0, X<A>()) { }
Y<X<A> > y;
};
B<int> b;
}
namespace PR6657 {
struct X
{
X (int, int) { }
};
template <typename>
void f0()
{
X x = X(0, 0);
}
void f1()
{
f0<int>();
}
}
namespace PR10001 {
template <typename T> struct S {
static const int arr[];
static const int x;
static int f();
};
template <typename T> const int S<T>::arr[] = { 1, 2, 3 };
template <typename T> const int S<T>::x = sizeof(arr) / sizeof(arr[0]);
template <typename T> int S<T>::f() { return x; }
int x = S<int>::f();
}
namespace PR7985 {
template<int N> struct integral_c { };
template <typename T, int N>
integral_c<N> array_lengthof(T (&x)[N]) { return integral_c<N>(); }
template<typename T>
struct Data {
T x;
};
template<typename T>
struct Description {
static const Data<T> data[];
};
template<typename T>
const Data<T> Description<T>::data[] = {{ 1 }};
template<>
Data<float*> Description<float*>::data[];
void test() {
integral_c<1> ic1 = array_lengthof(Description<int>::data);
(void)sizeof(array_lengthof(Description<float>::data));
sizeof(array_lengthof( Description<int*>::data ));
array_lengthof(Description<float*>::data); }
}
namespace PR13064 {
struct A { explicit A(int); }; template<typename T> struct B { T a { 0 }; };
B<A> b;
template<typename T> struct C { T a = { 0 }; }; C<A> c; }