copy-assignment.cpp [plain text]
struct A {
};
struct ConvertibleToA {
operator A();
};
struct ConvertibleToConstA {
operator const A();
};
struct B {
B& operator=(B&); };
struct ConvertibleToB {
operator B();
};
struct ConvertibleToBref {
operator B&();
};
struct ConvertibleToConstB {
operator const B();
};
struct ConvertibleToConstBref {
operator const B&();
};
struct C {
int operator=(int); long operator=(long); int operator+=(int); int operator+=(long); };
struct D {
D& operator+=(const D &);
};
struct ConvertibleToInt {
operator int();
};
void test() {
A a, na;
const A constA = A();
ConvertibleToA convertibleToA;
ConvertibleToConstA convertibleToConstA;
B b, nb;
const B constB = B();
ConvertibleToB convertibleToB;
ConvertibleToBref convertibleToBref;
ConvertibleToConstB convertibleToConstB;
ConvertibleToConstBref convertibleToConstBref;
C c, nc;
const C constC = C();
D d, nd;
const D constD = D();
ConvertibleToInt convertibleToInt;
na = a;
na = constA;
na = convertibleToA;
na = convertibleToConstA;
na += a;
nb = b;
nb = constB; nb = convertibleToB; nb = convertibleToBref;
nb = convertibleToConstB; nb = convertibleToConstBref;
nc = c;
nc = constC;
nc = 1;
nc = 1L;
nc = 1.0; nc += 1;
nc += 1L;
nc += 1.0;
nd = d;
nd += d;
nd += constD;
int i;
i = convertibleToInt;
i = a; }
namespace test1 {
template<typename T> class A : public unknown::X { A(UndeclaredType n) : X(n) {} };
template<typename T> class B : public A<T> {
virtual void foo() {}
};
extern template class A<char>;
extern template class B<char>;
}