Hidden Features of C++? [closed]

Answer 1

You can template bitfields.

template <size_t X, size_t Y>
struct bitfield
{
    char left  : X;
    char right : Y;
};

I have yet to come up with any purpose for this, but it sure as heck surprised me.

Answer 2

C++ is a standard, there shouldn't be any hidden features...

C++ is a multi-paradigm language, you can bet your last money on there being hidden features. One example out of many: template metaprogramming. Nobody in the standards committee intended there to be a Turing-complete sublanguage that gets executed at compile-time.

Answer 3

You can access protected data and function members of any class, without undefined behavior, and with expected semantics. Read on to see how. Read also the defect report about this.

Normally, C++ forbids you to access non-static protected members of a class's object, even if that class is your base class

struct A {
protected:
    int a;
};

struct B : A {
    // error: can't access protected member
    static int get(A &x) { return x.a; }
};

struct C : A { };

That's forbidden: You and the compiler don't know what the reference actually points at. It could be a C object, in which case class B has no business and clue about its data. Such access is only granted if x is a reference to a derived class or one derived from it. And it could allow arbitrary piece of code to read any protected member by just making up a "throw-away" class that reads out members, for example of std::stack:

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        static std::deque<int> &get(std::stack<int> &s) {
            // error: stack<int>::c is protected
            return s.c;
        }
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = pillager::get(s);
}

Surely, as you see this would cause way too much damage. But now, member pointers allow circumventing this protection! The key point is that the type of a member pointer is bound to the class that actually contains said member - not to the class that you specified when taking the address. This allows us to circumvent checking

struct A {
protected:
    int a;
};

struct B : A {
    // valid: *can* access protected member
    static int get(A &x) { return x.*(&B::a); }
};

struct C : A { };

And of course, it also works with the std::stack example.

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        static std::deque<int> &get(std::stack<int> &s) {
            return s.*(pillager::c);
        }
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = pillager::get(s);
}

That's going to be even easier with a using declaration in the derived class, which makes the member name public and refers to the member of the base class.

void f(std::stack<int> &s) {
    // now, let's decide to mess with that stack!
    struct pillager : std::stack<int> {
        using std::stack<int>::c;
    };

    // haha, now let's inspect the stack's middle elements!
    std::deque<int> &d = s.*(&pillager::c);
}

Answer 4

Array initialization in constructor. For example in a class if we have a array of int as:

class clName
{
  clName();
  int a[10];
};

We can initialize all elements in the array to its default (here all elements of array to zero) in the constructor as:

clName::clName() : a()
{
}

Answer 5

Pointer arithmetics.

C++ programmers prefer to avoid pointers because of the bugs that can be introduced.

The coolest C++ I've ever seen though? Analog literals.

Answer 6

A quite hidden feature is that you can define variables within an if condition, and its scope will span only over the if, and its else blocks:

if(int * p = getPointer()) {
    // do something
}

Some macros use that, for example to provide some "locked" scope like this:

struct MutexLocker { 
    MutexLocker(Mutex&);
    ~MutexLocker(); 
    operator bool() const { return false; } 
private:
    Mutex &m;
};

#define locked(mutex) if(MutexLocker const& lock = MutexLocker(mutex)) {} else 

void someCriticalPath() {
    locked(myLocker) { /* ... */ }
}

Also BOOST_FOREACH uses it under the hood. To complete this, it's not only possible in an if, but also in a switch:

switch(int value = getIt()) {
    // ...
}

and in a while loop:

while(SomeThing t = getSomeThing()) {
    // ...
}

(and also in a for condition). But i'm not too sure whether these are all that useful :)