Hidden Features of C++? [closed]

Answer 1

Oooh, I can come up with a list of pet hates instead:

• Destructors need to be virtual if you intend use polymorphically
• Sometimes members are initialized by default, sometimes they aren't
• Local clases can't be used as template parameters (makes them less useful)
• exception specifiers: look useful, but aren't
• function overloads hide base class functions with different signatures.
• no useful standardisation on internationalisation (portable standard wide charset, anyone? We'll have to wait until C++0x)

On the plus side

• hidden feature: function try blocks. Unfortunately I haven't found a use for it. Yes I know why they added it, but you have to rethrow in a constructor which makes it pointless.
• It's worth looking carefully at the STL guarantees about iterator validity after container modification, which can let you make some slightly nicer loops.
• Boost - it's hardly a secret but it's worth using.
• Return value optimisation (not obvious, but it's specifically allowed by the standard)
• Functors aka function objects aka operator(). This is used extensively by the STL. not really a secret, but is a nifty side effect of operator overloading and templates.

Answer 2

You can put URIs into C++ source without error. For example:

void foo() {
    http://stackoverflow.com/
    int bar = 4;

    ...
}

Answer 3

One of the most interesting grammars of any programming languages.

Three of these things belong together, and two are something altogether different...

SomeType t = u;
SomeType t(u);
SomeType t();
SomeType t;
SomeType t(SomeType(u));

All but the third and fifth define a SomeType object on the stack and initialize it (with u in the first two case, and the default constructor in the fourth. The third is declaring a function that takes no parameters and returns a SomeType. The fifth is similarly declaring a function that takes one parameter by value of type SomeType named u.

Answer 4

Lifetime of temporaries bound to const references is one that few people know about. Or at least it's my favorite piece of C++ knowledge that most people don't know about.

const MyClass& x = MyClass(); // temporary exists as long as x is in scope

Answer 5

The ternary conditional operator ?: requires its second and third operand to have "agreeable" types (speaking informally). But this requirement has one exception (pun intended): either the second or third operand can be a throw expression (which has type void), regardless of the type of the other operand.

In other words, one can write the following pefrectly valid C++ expressions using the ?: operator

i = a > b ? a : throw something();

BTW, the fact that throw expression is actually an expression (of type void) and not a statement is another little-known feature of C++ language. This means, among other things, that the following code is perfectly valid

void foo()
{
  return throw something();
}

although there's not much point in doing it this way (maybe in some generic template code this might come handy).

Answer 6

A nice feature that isn't used often is the function-wide try-catch block:

int Function()
try
{
   // do something here
   return 42;
}
catch(...)
{
   return -1;
}

Main usage would be to translate exception to other exception class and rethrow, or to translate between exceptions and return-based error code handling.