default-expr-arguments.cpp [plain text]
template<typename T>
class C { C(int a0 = 0); };
template<>
C<char>::C(int a0);
struct S { };
template<typename T> void f1(T a, T b = 10) { }
template<typename T> void f2(T a, T b = T()) { }
template<typename T> void f3(T a, T b = T() + T());
void g() {
f1(10);
f1(S());
f2(10);
f2(S());
f3(10);
f3(S()); }
template<typename T> struct F {
F(T t = 10); void f(T t = 10); };
struct FD : F<int> { };
void g2() {
F<int> f;
FD fd;
}
void g3(F<int> f, F<struct S> s) {
f.f();
s.f();
F<int> f2;
F<S> s2; }
template<typename T> struct G {
G(T) {}
};
void s(G<int> flags = 10) { }
template<typename T>
struct X0 {
void f(T = T()); };
template<typename U>
void X0<U>::f(U) { }
void test_x0(X0<int> xi) {
xi.f();
xi.f(17);
}
struct NotDefaultConstructible { NotDefaultConstructible(int); };
void test_x0_not_default_constructible(X0<NotDefaultConstructible> xn) {
xn.f(NotDefaultConstructible(17));
xn.f(42);
xn.f(); }
template<typename T>
struct X1 {
typedef T value_type;
X1(const value_type& value = value_type());
};
void test_X1() {
X1<int> x1;
}
template<typename T>
struct X2 {
void operator()(T = T()); };
void test_x2(X2<int> x2i, X2<NotDefaultConstructible> x2n) {
x2i();
x2i(17);
x2n(NotDefaultConstructible(17));
x2n(); }
namespace PR5283 {
template<typename T> struct A {
A(T = 1); };
struct B : A<int*> {
B();
};
B::B() { }
struct C : virtual A<int*> {
C();
};
C::C() { }
struct D {
D();
A<int*> a;
};
D::D() { } }
namespace pr5301 {
void f(int, int = 0);
template <typename T>
void g(T, T = 0);
template <int I>
void i(int a = I);
template <typename T>
void h(T t) {
f(0);
g(1);
g(t);
i<2>();
}
void test() {
h(0);
}
}
namespace PR5810 {
template<typename T>
struct allocator {
allocator() { int a[sizeof(T) ? -1 : -1]; } };
template<typename T>
struct vector {
vector(const allocator<T>& = allocator<T>()) {} };
struct A { };
struct B { };
template<typename>
void FilterVTs() {
vector<A> Result;
}
void f() {
vector<A> Result;
}
template<typename T>
struct X {
vector<B> bs;
X() { }
};
void f2() {
X<float> x; }
}
template<typename T> void f4(T, int = 17);
template<> void f4<int>(int, int);
void f4_test(int i) {
f4(i);
}
namespace InstForInit {
template<typename T>
struct Ptr {
typedef T* type;
Ptr(type);
};
template<typename T>
struct Holder {
Holder(int i, Ptr<T> ptr = 0);
};
void test_holder(int i) {
Holder<int> h(i);
}
};
namespace PR5810b {
template<typename T>
T broken() {
T t;
double**** not_it = t;
}
void f(int = broken<int>());
void g() { f(17); }
}
namespace PR5810c {
template<typename T>
struct X {
X() {
T t;
double *****p = t; }
X(const X&) { }
};
struct Y : X<int> { };
void f(Y y = Y());
void g() { f(); }
}
namespace PR8127 {
template< typename T > class PointerClass {
public:
PointerClass( T * object_p ) : p_( object_p ) {
p_->acquire();
}
private:
T * p_;
};
class ExternallyImplementedClass;
class MyClass {
void foo( PointerClass<ExternallyImplementedClass> = 0 );
};
}
namespace rdar8427926 {
template<typename T>
struct Boom {
~Boom() {
T t;
double *******ptr = t; }
};
Boom<float> *bfp;
struct X {
void f(Boom<int> = Boom<int>()) { } void g(int x = (delete bfp, 0)); };
void test(X *x) {
x->f();
x->g();
}
}
namespace PR8401 {
template<typename T>
struct A {
A() { T* x = 1; } };
template<typename T>
struct B {
B(const A<T>& a = A<T>()); };
void f(B<int> b = B<int>());
void g() {
f();
}
}
namespace PR12581 {
const int a = 0;
template < typename > struct A;
template < typename MatrixType, int =
A < MatrixType >::Flags ? : A < MatrixType >::Flags & a > class B;
void
fn1 ()
{
}
}