void test() { // This function tests C++0x 5.16 // p1 (contextually convert to bool) int i1 = ToBool() ? 0 : 1; // p2 (one or both void, and throwing) Fields flds; i1 ? throw 0 : throw 1; i1 ? test() : throw 1; i1 ? throw 0 : test(); i1 ? test() : test(); i1 = i1 ? throw 0 : 0; i1 = i1 ? 0 : throw 0; i1 = i1 ? (throw 0) : 0; i1 = i1 ? 0 : (throw 0); i1 ? 0 : test(); // expected-error {{right operand to ? is void, but left operand is of type 'int'}} i1 ? test() : 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}} (i1 ? throw 0 : i1) = 0; (i1 ? i1 : throw 0) = 0; (i1 ? (throw 0) : i1) = 0; (i1 ? i1 : (throw 0)) = 0; (i1 ? (void)(throw 0) : i1) = 0; // expected-error {{left operand to ? is void, but right operand is of type 'int'}} (i1 ? i1 : (void)(throw 0)) = 0; // expected-error {{right operand to ? is void, but left operand is of type 'int'}} int &throwRef1 = (i1 ? flds.i1 : throw 0); int &throwRef2 = (i1 ? throw 0 : flds.i1); int &throwRef3 = (i1 ? flds.b1 : throw 0); // expected-error {{non-const reference cannot bind to bit-field}} int &throwRef4 = (i1 ? throw 0 : flds.b1); // expected-error {{non-const reference cannot bind to bit-field}} // p3 (one or both class type, convert to each other) // b1 (lvalues) Base base; Derived derived; Convertible conv; Base &bar1 = i1 ? base : derived; Base &bar2 = i1 ? derived : base; Base &bar3 = i1 ? base : conv; Base &bar4 = i1 ? conv : base; // these are ambiguous BadBase bb; BadDerived bd; (void)(i1 ? bb : bd); // expected-error {{conditional expression is ambiguous; 'BadBase' can be converted to 'BadDerived' and vice versa}} (void)(i1 ? bd : bb); // expected-error {{conditional expression is ambiguous}} // curiously enough (and a defect?), these are not // for rvalues, hierarchy takes precedence over other conversions (void)(i1 ? BadBase() : BadDerived()); (void)(i1 ? BadDerived() : BadBase()); // b2.1 (hierarchy stuff) extern const Base constret(); extern const Derived constder(); // should use const overload A a1((i1 ? constret() : Base()).trick()); A a2((i1 ? Base() : constret()).trick()); A a3((i1 ? constret() : Derived()).trick()); A a4((i1 ? Derived() : constret()).trick()); // should use non-const overload i1 = (i1 ? Base() : Base()).trick(); i1 = (i1 ? Base() : Base()).trick(); i1 = (i1 ? Base() : Derived()).trick(); i1 = (i1 ? Derived() : Base()).trick(); // should fail: const lost (void)(i1 ? Base() : constder()); // expected-error {{incompatible operand types ('Base' and 'const Derived')}} (void)(i1 ? constder() : Base()); // expected-error {{incompatible operand types ('const Derived' and 'Base')}} Priv priv; Fin fin; (void)(i1 ? Base() : Priv()); // expected-error{{private base class}} (void)(i1 ? Priv() : Base()); // expected-error{{private base class}} (void)(i1 ? Base() : Fin()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}} (void)(i1 ? Fin() : Base()); // expected-error{{ambiguous conversion from derived class 'Fin' to base class 'Base':}} (void)(i1 ? base : priv); // expected-error {{private base class}} (void)(i1 ? priv : base); // expected-error {{private base class}} (void)(i1 ? base : fin); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} (void)(i1 ? fin : base); // expected-error {{ambiguous conversion from derived class 'Fin' to base class 'Base':}} // b2.2 (non-hierarchy) i1 = i1 ? I() : i1; i1 = i1 ? i1 : I(); I i2(i1 ? I() : J()); I i3(i1 ? J() : I()); // "the type [it] woud have if E2 were converted to an rvalue" vfn pfn = i1 ? F() : test; pfn = i1 ? test : F(); (void)(i1 ? A() : B()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} (void)(i1 ? B() : A()); // expected-error {{conversion from 'B' to 'A' is ambiguous}} (void)(i1 ? 1 : Ambig()); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} (void)(i1 ? Ambig() : 1); // expected-error {{conversion from 'Ambig' to 'int' is ambiguous}} // By the way, this isn't an lvalue: &(i1 ? i1 : i2); // expected-error {{cannot take the address of an rvalue}} // p4 (lvalue, same type) int &ir1 = i1 ? flds.i1 : flds.i2; (i1 ? flds.b1 : flds.i2) = 0; (i1 ? flds.i1 : flds.b2) = 0; (i1 ? flds.b1 : flds.b2) = 0; // p5 (conversion to built-in types) // GCC 4.3 fails these double d1 = i1 ? I() : K(); pfn = i1 ? F() : G(); DFnPtr pfm; pfm = i1 ? DFnPtr() : &Base::fn1; pfm = i1 ? &Base::fn1 : DFnPtr(); // p6 (final conversions) i1 = i1 ? i1 : ir1; int *pi1 = i1 ? &i1 : 0; pi1 = i1 ? 0 : &i1; i1 = i1 ? i1 : EVal; i1 = i1 ? EVal : i1; d1 = i1 ? 'c' : 4.0; d1 = i1 ? 4.0 : 'c'; Base *pb = i1 ? (Base*)0 : (Derived*)0; pb = i1 ? (Derived*)0 : (Base*)0; pfm = i1 ? &Base::fn1 : &Derived::fn2; pfm = i1 ? &Derived::fn2 : &Base::fn1; pfm = i1 ? &Derived::fn2 : 0; pfm = i1 ? 0 : &Derived::fn2; const int (MixedFieldsDerived::*mp1) = i1 ? &MixedFields::ci : &MixedFieldsDerived::i; const volatile int (MixedFields::*mp2) = i1 ? &MixedFields::ci : &MixedFields::cvi; (void)(i1 ? &MixedFields::ci : &MixedFields::vi); // Conversion of primitives does not result in an lvalue. &(i1 ? i1 : d1); // expected-error {{cannot take the address of an rvalue}} (void)&(i1 ? flds.b1 : flds.i1); // expected-error {{address of bit-field requested}} (void)&(i1 ? flds.i1 : flds.b1); // expected-error {{address of bit-field requested}} unsigned long test0 = 5; test0 = test0 ? (long) test0 : test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} test0 = test0 ? (int) test0 : test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} test0 = test0 ? (short) test0 : test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} test0 = test0 ? test0 : (long) test0; // expected-warning {{operand of ? changes signedness: 'long' to 'unsigned long'}} test0 = test0 ? test0 : (int) test0; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} test0 = test0 ? test0 : (short) test0; // expected-warning {{operand of ? changes signedness: 'short' to 'unsigned long'}} test0 = test0 ? test0 : (long) 10; test0 = test0 ? test0 : (int) 10; test0 = test0 ? test0 : (short) 10; test0 = test0 ? (long) 10 : test0; test0 = test0 ? (int) 10 : test0; test0 = test0 ? (short) 10 : test0; int test1; test0 = test0 ? EVal : test0; test1 = test0 ? EVal : (int) test0; test0 = test0 ? EVal : test1; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} test0 = test0 ? test1 : EVal; // expected-warning {{operand of ? changes signedness: 'int' to 'unsigned long'}} test1 = test0 ? EVal : (int) test0; test1 = test0 ? (int) test0 : EVal; // Note the thing that this does not test: since DR446, various situations // *must* create a separate temporary copy of class objects. This can only // be properly tested at runtime, though. const Abstract &abstract1 = true ? static_cast<const Abstract&>(Derived1()) : Derived2(); // expected-error {{allocating an object of abstract class type 'const Abstract'}} const Abstract &abstract2 = true ? static_cast<const Abstract&>(Derived1()) : throw 3; // ok }
int main(int argc, char const* argv[]) { // printf("_MSC_VER=%d\n", _MSC_VER); singleton_type singleton; pass_value_type pass_value; Moo moo(5); Foo foo; Foo const const_foo = foo; Foo& ref = foo; Foo const& const_ref = const_foo; Foo* ptr = &foo; Foo const* const_ptr = &const_foo; BOOST_ASSERT(false == is_pimpl<Foo>::value); BOOST_ASSERT(false == is_pimpl<int>::value); BOOST_ASSERT(false == is_pimpl<int*>::value); BOOST_ASSERT(false == is_pimpl<int const&>::value); BOOST_ASSERT(true == is_pimpl<Test1>::value); BOOST_ASSERT(false == is_pimpl<Test1*>::value); BOOST_ASSERT(true == is_pimpl<Test2>::value); BOOST_ASSERT(true == is_pimpl<Base>::value); BOOST_ASSERT(true == is_pimpl<Derived1>::value); BOOST_ASSERT(true == is_pimpl<Derived1 const>::value); BOOST_ASSERT(true == is_pimpl<Derived1 const&>::value); Test1 pt11; BOOST_ASSERT(pt11.trace() == "Test1::implementation()"); Test2 vt11; BOOST_ASSERT(vt11.trace() == "Test2::implementation()"); Test1 pt12(5); BOOST_ASSERT(pt12.trace() == "Test1::implementation(int)"); Test2 vt12(5); BOOST_ASSERT(vt12.trace() == "Test2::implementation(int)"); Test1 pt13 = pt12; BOOST_ASSERT(pt13.id() == pt12.id()); // No copying. Implementation shared. Test2 vt13 = vt12; BOOST_ASSERT(vt13.trace() == "Test2::implementation(implementation const&)"); BOOST_ASSERT(vt13.id() != vt12.id()); // Implementation copied. Test1 pt14(pt12); BOOST_ASSERT(pt14.id() == pt12.id()); // No copying. Implementation shared. Test2 vt14(vt12); BOOST_ASSERT(vt14.trace() == "Test2::implementation(implementation const&)"); BOOST_ASSERT(vt14.id() != vt12.id()); // Implementation copied. Test1 pt15(5, 6); BOOST_ASSERT(pt15.trace() == "Test1::implementation(int, int)"); Test1 pt16(singleton); Test1 pt17(singleton); BOOST_ASSERT(pt16.id() == pt17.id()); // No copying. Implementation shared. Test1 pt21(foo); //BOOST_ASSERT(pt21.trace() == "Test1::implementation(Foo&)"); Test1 pt22(const_foo); BOOST_ASSERT(pt22.trace() == "Test1::implementation(Foo const&)"); Test1 pt23(ref); BOOST_ASSERT(pt23.trace() == "Test1::implementation(Foo&)"); Test1 pt24(const_ref); BOOST_ASSERT(pt24.trace() == "Test1::implementation(Foo const&)"); Test1 pt25(ptr); BOOST_ASSERT(pt25.trace() == "Test1::implementation(Foo*)"); Test1 pt26(const_ptr); BOOST_ASSERT(pt26.trace() == "Test1::implementation(Foo const*)"); Test1 pt31(const_foo, const_foo); BOOST_ASSERT(pt31.trace() == "Test1::implementation(Foo const&, Foo const&)"); Test1 pt32(foo, const_foo); BOOST_ASSERT(pt32.trace() == "Test1::implementation(Foo&, Foo const&)"); Test1 pt33(const_foo, foo); BOOST_ASSERT(pt33.trace() == "Test1::implementation(Foo const&, Foo&)"); Test1 pt34(foo, foo); BOOST_ASSERT(pt34.trace() == "Test1::implementation(Foo&, Foo&)"); Test1 pt35(foo, Foo()); BOOST_ASSERT(pt35.trace() == "Test1::implementation(Foo&, Foo const&)"); Test1 pt36(Foo(), foo); BOOST_ASSERT(pt36.trace() == "Test1::implementation(Foo const&, Foo&)"); Test1 pt37(pass_value); BOOST_ASSERT(pt37.trace() == "Test1::implementation(Foo const&)"); //////////////////////////////////////////////////////////////////////////// // Comparisons with 'int'. g++-4.3.4 (linux). //////////////////////////////////////////////////////////////////////////// // The standard behavior. // bool moo_check1 = moo == int(5); // error: no match for ‘operator==’ in ‘moo == 5’ // bool moo_check2 = moo != int(5); // error: no match for ‘operator!=’ in ‘moo != 5’ // bool moo_check3 = int(5) == moo; // error: no match for ‘operator==’ in ‘5 == moo’ // bool moo_check4 = int(5) != moo; // error: no match for ‘operator!=’ in ‘5 != moo’ // The pointer Pimpl behavior. // bool pcheck01 = pt12 == int(5); // error: no match for ‘operator==’ in ‘pt12 == 5’ // bool pcheck02 = pt12 != int(5); // error: no match for ‘operator!=’ in ‘pt12 != 5’ // bool pcheck03 = int(5) == pt12; // error: no match for ‘operator==’ in ‘5 == pt12’ // bool pcheck04 = int(5) != pt12; // error: no match for ‘operator!=’ in ‘5 != pt12’ // The value Pimpl behavior. bool vcheck01 = vt12 == int(5); // Test2 has its own op==(). Non-explicit Test2(int) called. bool vcheck02 = vt12 != int(5); // Test2 has its own op!=(). Non-explicit Test2(int) called. // bool vcheck03 = int(5) == vt12; // error: no match for ‘operator==’ in ‘5 == vt12’ // bool vcheck04 = int(5) != vt12; // error: no match for ‘operator!=’ in ‘5 != vt12’ //////////////////////////////////////////////////////////////////////////// // Comparisons with 'bool'. g++-4.3.4 (linux). //////////////////////////////////////////////////////////////////////////// // The standard behavior. bool moo_check5 = moo == false; // Deploys operator safebool::type() conversion bool moo_check6 = moo != false; // Deploys operator safebool::type() conversion bool moo_check7 = false == moo; // Deploys operator safebool::type() conversion bool moo_check8 = false != moo; // Deploys operator safebool::type() conversion // The pointer Pimpl behavior. bool pcheck05 = pt12 == false; // Deploys operator safebool::type() conversion bool pcheck06 = pt12 != false; // Deploys operator safebool::type() conversion bool pcheck07 = false == pt12; // Deploys operator safebool::type() conversion bool pcheck08 = false != pt12; // Deploys operator safebool::type() conversion // The value Pimpl behavior. // bool vcheck05 = vt12 == false; // Test2 has its own op==(). error: ambiguous overload for ‘operator==’ in ‘vt12 == false’ // bool vcheck06 = vt12 != false; // Test2 has its own op!=(). error: ambiguous overload for ‘operator!=’ in ‘vt12 != false’ bool vcheck07 = false == vt12; // Deploys operator safebool::type() conversion bool vcheck08 = false != vt12; // Deploys operator safebool::type() conversion //////////////////////////////////////////////////////////////////////////// // Comparisons with Pimpl. g++-4.3.4 (linux). //////////////////////////////////////////////////////////////////////////// bool pcheck1 = pt12 == pt13; // calls pimpl_base::op==() bool pcheck2 = pt12 != pt13; // calls pimpl_base::op!=() bool vcheck1 = vt12 == vt13; // calls Test2::op==() bool vcheck2 = vt12 != vt13; // calls Test2::op!=() if ( moo) {} // Check it calls conversion to safebool. if ( !moo) {} // Check it calls conversion to safebool. if ( pt11) {} // Check it calls conversion to safebool. if (!pt11) {} // Check it calls conversion to safebool. if ( vt11) {} // Check it calls conversion to safebool. if (!vt11) {} // Check it calls conversion to safebool. { // Testing swap(). int pt16_id = pt16.id(); int pt17_id = pt17.id(); int vt13_id = vt13.id(); int vt14_id = vt14.id(); pt16.swap(pt17); vt13.swap(vt14); BOOST_ASSERT(pt16.id() == pt17_id); BOOST_ASSERT(pt17.id() == pt16_id); BOOST_ASSERT(vt13.id() == vt14_id); BOOST_ASSERT(vt14.id() == vt13_id); } int k11 = vt11.get(); BOOST_ASSERT(k11 == 0); int k12 = vt12.get(); BOOST_ASSERT(k12 == 5); int k13 = vt13.get(); BOOST_ASSERT(k13 == 5); vt14.set(33); BOOST_ASSERT(vt12 == vt13); // Good: Only compiles if op==() is part of Test2 interface. BOOST_ASSERT(vt12.trace() == "Test2::operator==(Test2 const&)"); BOOST_ASSERT(vt11 != vt12); // Good: Only compiles if op==() is part of Test2 interface. BOOST_ASSERT(vt11.trace() == "Test2::operator==(Test2 const&)"); { // Testing run-time polymorphic behavior. Base base1 (1); Derived1 derived1 (2, 3); Derived2 derived2 (2, 3, 4); Base base2 (derived1); // calls copy constructor Base base3 (derived2); // calls copy constructor Base base4 (Derived2(2,3,4)/*const ref to temporary*/); // calls copy constructor Derived1 bad1 (pimpl<Derived1>::null()); Derived2 bad2 (pimpl<Derived2>::null()); Base* bp1 = &base1; Base* bp2 = &base2; Base* bp3 = &base3; Base* bp4 = &derived1; Base* bp5 = &derived2; Base* bp6 = &bad1; Base* bp7 = &bad2; Base bad_base1 = Base::null(); Base bad_base2 = pimpl<Base>::null(); // Base bad_base3 = pimpl<Foo>::null(); // correctly does not compile. // Foo bad_foo = pimpl<Foo>::null(); // correctly does not compile. Derived1 bad_derived1 = pimpl<Derived1>::null(); Derived2 bad_derived2 = pimpl<Derived2>::null(); bool check1 = base1 == derived1; bool check2 = base1 == derived2; bool check3 = derived1 == base1; bool check4 = derived2 == base1; if ( bad1) BOOST_ASSERT(0); if (!bad2) BOOST_ASSERT(1); base2.call_virtual(); BOOST_ASSERT(base2.trace() == "Derived1::call_virtual()"); base3.call_virtual(); BOOST_ASSERT(base3.trace() == "Derived2::call_virtual()"); bp1->call_virtual(); BOOST_ASSERT(bp1->trace() == "Base::call_virtual()"); bp2->call_virtual(); BOOST_ASSERT(bp2->trace() == "Derived1::call_virtual()"); bp3->call_virtual(); BOOST_ASSERT(bp3->trace() == "Derived2::call_virtual()"); bp4->call_virtual(); BOOST_ASSERT(bp4->trace() == "Derived1::call_virtual()"); bp5->call_virtual(); BOOST_ASSERT(bp5->trace() == "Derived2::call_virtual()"); // bp6->call_virtual(); // crash. referencing bad1 // bp7->call_virtual(); // crash. referencing bad1 } #ifdef __linux__ { printf("BEG: Testing pimpl and boost::serialization.\n"); Test1 saved (12345); std::ofstream ofs ("filename"); boost::archive::text_oarchive oa (ofs); printf("Calling boost::archive::test_oarchive << Test1.\n"); oa << *(Test1 const*) &saved; // write class instance to archive ofs.close(); std::ifstream ifs ("filename", std::ios::binary); boost::archive::text_iarchive ia (ifs); Test1 restored (Test1::null()); // Implementation will be replaced. printf("Calling boost::archive::test_iarchive >> Test1.\n"); ia >> restored; // read class state from archive assert(saved.get() == restored.get()); printf("END: Testing pimpl and boost::serialization.\n"); } #endif printf("Pimpl test has successfully completed.\n"); return 0; }