Placement-new array offset
It turns out that on some compilers new[] might allocate an integer before an actual array even when placement-new is used:
void *mem = new char[sizeof(A) * n];
A *arr = new(mem) A[n];
Solution - cast pointer and manually loop over array creating each object individually via placement-new.
Pointer that changes
class Base {int x; };
class Derived : public Base {virtual void foo() {} };
Derived *d = new Derived;
Base *b = d;
Things get more funny when there are many classes in the hierarchy and multiple inheritance is involved.
Solution: well, don't cast pointers to objects into void*.
Return void
This code is valid:
void foo() {}
void bar() { return foo(); }
Pure-virtual function with implementation
Pure-virtual function means that derived class must override it in order to create objects of it. But it does not mean that such method can not be implemented in the base class. The code bellow compiles and works:
class A
{
public:
virtual void foo() = 0;
};
void A::foo() { std::cout << "A::foo called\n"; }
class B : public A
{
public:
virtual void foo() override
{
A::foo();
std::cout << "B::foo called\n";
}
};
Note that it did not compile for me using GCC, when I tried to provide implementation for A::foo inline.
Function-try block
This is quite a tricky feature. Function-try block basically looks like this:
void foo()
try {
throw int();
} catch(...) {
std::cout << "Exception caught\n";
}
The real use for this feature (which also works differently) is for constructors. First of all, when used for constructor, it does not really catch exception! It catches and rethrows them! The real use for it is to free resources allocated in initializer list:
class A
{
public:
A(int x) { throw x; }
};
class B
{
A a;
public:
B()
try
: a(5)
{ } catch(...) {
std::cout << "Exception in initializer merely-caught\n";
}
};
Bitfields
When defining a struct it is possible to specify variable sizes in bits:
struct Bitfields
{
int i:16;
int j:8;
bool b:1;
char c:7;
};
The size of this structure is 4 bytes (on my machine at least). Each variable in the struct takes as much bits as specified and can hold appropriate value range.
And, since this is about C++, there are definitly more :)
