views:

19261

answers:

65

No C++ love when it comes to the "hidden features of" line of questions? Figured I would throw it out there. What are some of the hidden features of C++?

A: 

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

Markowitch
Just because there is a set of rules laid out doesn't mean they can't be used creatively to do things that weren't originally intended (such as template meta-programming). Also, "hidden features" can simply mean features that many coders aren't aware of (its not actually hidden from the standards, but most people don't read the standards, due to its size, complexity and of course, you actually have to buy a copy). Reading the standards is something that is usually only done by the hardcore c++ developers, or compiler writers (which usually fit the former category anyway).
Grant Peters
+3  A: 

I'm not sure about hidden, but there are some interesting 'tricks' that probably aren't obvious from just reading the spec.

dbrien
Even though older by 55 mins, should be merged/combined with the duplicate at http://stackoverflow.com/questions/75538/hidden-features-of-c/76058#76058, or just deleted in favor of the other.
Roger Pate
Please... PLEASE do not use Duff's Device.
Billy ONeal
+56  A: 

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.

Konrad Rudolph
+1. It's indeed cool that you can have the compiler calculate Fibonacci sequences, Taylor series sums (for sin/cos) and a lot of other things.
Marcus Lindblom
+8  A: 

I found this blog to be an amazing resource about the arcanes of C++ : C++ Truths.

Drealmer
+4  A: 

There is no hidden features, but the language C++ is very powerful and frequently even developers of standard couldn't imagine what C++ can be used for.

Actually from simple enough language construction you can write something very powerful. A lot of such things are available at www.boost.org as an examples (and http://www.boost.org/doc/libs/1_36_0/doc/html/lambda.html among them).

To understand the way how simple language constuction can be combined to something powerful it is good to read "C++ Templates: The Complete Guide" by David Vandevoorde, Nicolai M. Josuttis and really magic book "Modern C++ Design ... " by Andrei Alexandrescu.

And finally, it is difficult to learn C++, you should try to fill it ;)

sergdev
+2  A: 

There are a lot of "undefined behavior". You can learn how to avoid them reading good books and reading the standards.

ugasoft
How is this a feature? There are two different ways of considering it as a feature, but I see no indication of either here. -1 for being vague.
Roger Pate
+1  A: 

There are tons of "tricky" constructs in C++. They go from "simple" implementions of sealed/final classes using virtual inheritance. And get to pretty "complex" meta programming constructs such as Boost's MPL (tutorial). The possibilities for shooting yourself in the foot are endless, but if kept in check (i.e. seasoned programmers), provide some of the best flexibility in terms of maintainability and performance.

Amir
+5  A: 

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.

Template metaprogramming is hardly a hidden feature. It's even in the boost library. See MPL. But if "almost hidden" is good enough, then take a look at the boost libraries. It contain many goodies which are not easy accesible without the backing of a strong library.

One example is boost.lambda library, which is interesting since C++ does not have lambda functions in the current standard.

Another example is Loki, which "makes extensive use of C++ template metaprogramming and implements several commonly used tools: typelist, functor, singleton, smart pointer, object factory, visitor and multimethods." [Wikipedia]

Markowitch
Template metaprogramming isn't hidden anymore because it was so useful. However, it's hidden in the way that the feature is not designed into C++ but rather turned up by coincidence.
Konrad Rudolph
+40  A: 

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
MSN
It got Herb Sutter to get Guru of the Week out one last time.
David Thornley
Can you elaborate? As is you're just teasing ;)
Joseph Garvin
ScopeGuard (http://www.ddj.com/cpp/184403758) is a great example that leverages this feature.
MSN
I am with Joseph Garvin. Please enlighten us.
Peter Mortensen
I just did in the comments. Besides, it's a natural consequence of using a const reference parameter.
MSN
I've read the answer and the link to ScopeGuard and I still don't understand what this means.
Oak
@Oak: http://stackoverflow.com/questions/256724/in-c-is-it-safe-to-extend-scope-via-a-reference/256748#256748
BlueRaja - Danny Pflughoeft
+50  A: 

The array operator is associative.

A[8] is a synonym for *(A + 8). Since addition is associative, that can be rewritten as *(8 + A), which is a synonym for..... 8[A]

You didn't say useful... :-)

Colin Jensen
Actually, when using this trick, you should really pay attention to what type you are using. A[8] is actually the 8th A while 8[A] is the Ath integer starting at address 8. If A is a byte, you have a bug.
Vincent Robert
you mean "commutative" where you say "associative"?
DarenW
Vincent, you're wrong. The type of `A` doesn't matter at all. For example, if `A` were a `char*`, the code would still be valid.
Konrad Rudolph
Beware that A must be a pointer, and not a class overloading operator[].
David Rodríguez - dribeas
Vincent, in this there has to be one integral type and one pointer type, and neither C nor C++ cares which one goes first.
David Thornley
+2  A: 

Most C++ developers ignore the power of template metaprogramming. Check out Loki Libary. It implements several advanced tools like typelist, functor, singleton, smart pointer, object factory, visitor and multimethods using template metaprogramming extensively (from wikipedia). For most part you could consider these as "hidden" c++ feature.

Sridhar Iyer
We don't ignore it, we shun it....
Jimmy J
Duplicate of template metaprogramming from http://stackoverflow.com/questions/75538/hidden-features-of-c/76058#76058. These examples merged into that answer so this duplicate can be deleted.
Roger Pate
+90  A: 

I agree with most posts there: C++ is a multi-paradigm language, so the "hidden" features you'll find (other than "undefined behaviours" that you should avoid at all cost) are clever uses of facilities.

Most of those facilities are not build-in features of the language, but library-based ones.

The most important is the RAII, often ignored for years by C++ developers coming from the C world. Operator overloading is often a misunderstood feature that enable both array-like behaviour (subscript operator), pointer like operations (smart pointers) and build-in-like operations (multiplying matrices.

The use of exception is often difficult, but with some work, can produce really robust code through exception safety specifications (including code that won't fail, or that will have a commit-like features that is that will succeed, or revert back to its original state).

The most famous of "hidden" feature of C++ is template metaprogramming, as it enables you to have your program partially (or totally) executed at compile-time instead of runtime. This is difficult, though, and you must have a solid grasp on templates before trying it.

Other make uses of the multiple paradigm to produce "ways of programming" outside of C++'s ancestor, that is, C.

By using functors, you can simulate functions, with the additional type-safety and being stateful. Using the command pattern, you can delay code execution. Most other design patterns can be easily and efficiently implemented in C++ to produce alternative coding styles not supposed to be inside the list of "official C++ paradigms".

By using templates, you can produce code that will work on most types, including not the one you thought at first. You can increase type safety,too (like an automated typesafe malloc/realloc/free). C++ object features are really powerful (and thus, dangerous if used carelessly), but even the dynamic polymorphism have its static version in C++: the CRTP.

I have found that most "Effective C++"-type books from Scott Meyers or "Exceptional C++"-type books from Herb Sutter to be both easy to read, and quite treasures of info on known and less known features of C++.

Among my preferred is one that should make the hair of any Java programmer rise from horror: In C++, the most object-oriented way to add a feature to an object is through a non-member non-friend function, instead of a member-function (i.e. class method), because:

  • In C++, a class' interface is both its member-functions and the non-member functions in the same namespace

  • non-friend non-member functions have no privileged access to the class internal. As such, using a member function over a non-member non-friend one will weaken the class' encapsulation.

This never fails to surprise even experienced developers.

(Source: Among others, Herb Sutter's online Guru of the Week #84: http://www.gotw.ca/gotw/084.htm )

paercebal
+1 for mentioning the free functions. :-)
Konrad Rudolph
+1 very thorough answer. it's incomplete for obvious reasons (otherwise there wouldn't be "hidden features" anymore!) :pin the first point at the end of the answer, you mentioned members of a class interface. do you mean ".. is both its member-functions and the *friend* non-member functions"?
wilhelmtell
I Treasure Effective C++ as well.
J.J.
CRTP - http://en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern
J.J.
what you are mentioning about with 1 must be koenig lookup, right?
Comptrol
@wilhelmtell: No no no... :-p ... I DO mean "its member-functions and NON-FRIEND non-member functions".... Koenig's Lookup will make sure these functions will be considered sooner than other "outside" functions in its search for symbols
paercebal
@Comptrol: You're almost right, it is the *consequence* of Keonig's Lookup.
paercebal
Great post, and +1 especially for the last part, which far too few people realize.I'd probably add the Boost library as a "hidden feature" as well. I pretty much consider it the standard library that C++ should have had. ;)
jalf
this is a very nice answer. +1 for the last part :)
Johannes Schaub - litb
+23  A: 

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.
Robert
pet hate: no defined ABI for C++ apps, unlike C ones that everyone uses because every language can guarantee to call a C function, no-one can do the same for C++.
gbjbaanb
+1 for Function Try Blocks. It was a hidden feature for me.
Constantin
Destructors need to be virtual only if you intend to destroy polymorphically, which is a little subtly different from the first point.
David Rodríguez - dribeas
With C++0x local types can be used as template parameters.
tstenner
+1 for virtual destructor reminder. This one got me the other day -- ah! Memory leaks!
Zack Mulgrew
With C++0x, destructors will be virtual if the object has any virtual functions (i.e. a vtable).
Marcus Lindblom
don't forget NRVO, and of course any optimization is allowed as long as it doesn't change the program output
jk
+91  A: 

One language feature that I consider to be somewhat hidden, because I had never heard about it throughout my entire time in school, is the namespace alias. It wasn't brought to my attention until I ran into examples of it in the boost documentation. Of course, now that I know about it you can find it in any standard C++ reference.

namespace fs = boost::filesystem;

fs::path myPath( strPath, fs::native );
Jason Mock
Hrm... "metanamespacing"...
Chris
I guess this is useful if you don't want to use `using`.
Exception
+1  A: 
  • pointers to class methods
  • The "typename" keyword
shoosh
+1, not sure why this was downvoted.
j_random_hacker
+177  A: 

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

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

    ...
}
Ben
But only one per function, i suspect? :)
Constantin
I was not expecting to laugh out loud while reading these answers. ;)
Adrian
bad-dum-dum tisssh!
Paul Nathan
Is this a bug? What's it meant to do? I tried it and it indeed compiled without error; I did get a warning: warning C4102: 'http' : unreferenced label
jpoh
Just don't try adding more than one per source file :P
X-Istence
@jpoh: http followed by a colon becomes a "label" which you use in a goto statement later. you get that warning from your compiler because it's not used in any goto statement in the above example.
utku_karatas
very cool and funny!! and genious
hasen j
You can add more than one as long as they have different protocols! ftp://ftp.microsoft.com gopher://aerv.nl/1 and so on...
Daniel Earwicker
For shame! SO highlighting doesn't recognise gopher!
Daniel Earwicker
AWESOME! Took me about four takes to realize you weren't joking.
Vulcan Eager
This works in Java as well.
titaniumdecoy
Guys, but what does this do? :)
Pavel Radzivilovsky
@Pavel: An identifier followed by a colon is a label (for use with `goto`, which C++ does have). Anything following two slashes is a comment. Therefore, with `http://stackoverflow.com`, `http` is a label (you could theoretically write `goto http;`), and `//stackoverflow.com` is just an end-of-line comment. Both of these are legal C++, so the construct compiles. It doesn't do anything vaguely useful, of course.
David Thornley
Awesome, I agree... :-D... + 1
paercebal
A: 

Pointer arithmetics.

It's actually a C feature, but I noticed that few people that use C/C++ are really aware it even exists. I consider this feature of the C language truly shows the genius and vision of its inventor.

To make a long story short, pointer arithmetics allows the compiler to perform a[n] as *(a+n) for any type of a. As a side note, as '+' is commutative a[n] is of course equivalent to n[a].

bernardn
Duplicate........
Billy ONeal
+3  A: 

Getting rid of forward declarations:

struct global
{
     void main()
     {
           a = 1;
           b();
     }
     int a;
     void b(){}
}
singleton;

Writing switch-statements with ?: operators:

string result = 
    a==0 ? "zero" :
    a==1 ? "one" :
    a==2 ? "two" :
    0;

Doing everything on a single line:

void a();
int b();
float c = (a(),b(),1.0f);

Zeroing structs without memset:

FStruct s = {0};

Normalizing/wrapping angle- and time-values:

int angle = (short)((+180+30)*65536/360) * 360/65536; //==-150

Assigning references:

struct ref
{
   int& r;
   ref(int& r):r(r){}
};
int b;
ref a(b);
int c;
*(int**)&a = &c;
AareP
`FStruct s = {};` is even shorter.
Constantin
In the last example, it would be simpler with: a(); b(); float c=1.0f;
Zifre
@Zifre: the trick is exactly the last line **float c = (a(),b(),1.0f);** - putting everything that is closed by a semiclon in one line is no trick at all. But be careful: **int d = (a(),b(),1.0f);** would get the value of b!
fmuecke
This syntax "float c=(a(),b(),1.0f);" is useful for accenting the assigment-operation (assigment of "c"). Assigment-operations are important in programming because they are less likely to become deprecated IMO. Don't know why, might be something to do with functional programming where program state is re-assigned every frame.PS. And no, "int d = (11,22,1.0f)" will be equal to "1". Tested a minute ago with VS2008.
AareP
+33  A: 

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.

vividos
I don't think you can `return` from catch block of Function Try, only rethrow.
Constantin
I just tried compiling the above, and it gave no warning. I think the above example works.
vividos
darnz . i thought i was the first one telling that in this thread. but then i saw your answer :p nice didnt know you could return from a catch like that.
Johannes Schaub - litb
return is only banned for constructors. A constructor's function try block will catch errors initializing the base and members (the only case where a function try block does something different than just having a try inside the function); not re-throwing would result in an incomplete object.
puetzk
Interesting puetzk!
j_random_hacker
Yes. This is very useful. I wrote macros BEGIN_COM_METHOD and END_COM_METHOD to catch exceptions and return HRESULTS so that exceptions didn't leak out of a class implementing a COM interface. It worked well.
Scott Langham
@puetzk I guess It could become very usefull to return a "DefaultObject" from a constructor that failed. Like if the constructor fail. You can still return an empty object. Like you want to load a image. On loading error it return a default image.
Sybiam
This is pretty rad. I had no idea you could that, and it doesn't appear to people that it would even compile.
Nick Bedford
As pointed out by @puetzk, this is the only way to handle exceptions thrown by *anything* in a constructor's **initialiser list**, such as base classes' constructors or those of data members.
shambulator
Oh my god. That's nuts.
DanDan
It's just like moving a few lines around. Not one character is saved :p
kizzx2
+16  A: 

Hidden features:

  1. Pure virtual functions can have implementation. Common example, pure virtual destructor.
  2. If a function throws an exception not listed in its exception specifications, but the function has std::bad_exception in its exception specification, the exception is converted into std::bad_exception and thrown automatically. That way you will at least know that an a bad_exception was thrown. Read more: http://cpptruths.blogspot.com/2007/05/use-of-stdbadexception.html

  3. function try blocks

  4. The template keyword in disambiguating typedefs in a class template. If the name of a member template specialization appears after a ., ->, or :: operator, and that name has explicitly qualified template parameters, prefix the member template name with the keyword template. Read more: http://en.wikibooks.org/wiki/More_C%2B%2B_Idioms/Policy_Clone

  5. function parameter defaults can be changed at runtime. Read more: http://cpptruths.blogspot.com/2005/07/changing-c-function-default-arguments.html

  6. A[i] works as good as i[A]

  7. Temporary instances of a class can be modified! A non-const member function can be invoked on a temporary object. For example,

    struct Bar { void modify() {} } int main (void) { Bar().modify(); /* non-const function invoked on a temporary. */ }

    Read more http://cpptruths.blogspot.com/2009/08/modifying-temporaries.html

  8. If two different types are present before and after the ':' in the ternary (?:) operator expression, then the resulting type of the expression is the one that is the most general of the two. For example,

    void foo (int) {} void foo (double) {} struct X { X (double d = 0.0) {} }; void foo (X) {}

    int main(void) { int i = 1; foo(i ? 0 : 0.0); // calls foo(double) X x; foo(i ? 0.0 : x); // calls foo(X) }

Sumant
#6 leaves me wondering: WHY?
P Daddy
P Daddy: A[i] == *(A+i) == *(i+A) == i[A]
abelenky
I get the commutation, it's just that this means that [] has no semantic value of its own and is simply equivalent to a macro-style replacement where "x[y]" is replaced with "(*((x) + (y)))". Not at all what I expected. I wonder why it's defined this way.
P Daddy
Backward compatibility with C
jmucchiello
Regarding your first point: There's one particular case where you *have to* implement a pure virtual function: pure virtual destructors.
Frerich Raabe
+21  A: 

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()
{
}
siri
You can do this with any array anywhere.
Potatoswatter
+18  A: 

map::operator[] creates entry if key is missing and returns reference to default-constructed entry value. So you can write:

map<int, string> m;
string& s = m[42]; // no need for map::find()
if (s.empty()) { // assuming we never store empty values in m
  s.assign(...);
}
cout << s;

I'm amazed at how many C++ programmers don't know this.

Constantin
And on the opposite end you cannot use operator[] on a const map
David Rodríguez - dribeas
This is arguably more of a gotcha than a feature :-)
Nick
+1 for Nick, people can go insane if they don't know about `.find()`.
LiraNuna
or "`const map::operator[]` generates error messages"
just somebody
Not a feature of the language, it is a feature of the Standard template library. It is also pretty obvious, since operator[] returns a valid reference.
Ramon Zarazua
It still does bite people: "map<int, data*> m -> if (m[i] == 0) return; /* Not found */" is an insidious memory leak.
Lars
I had to use maps in C# for while, where maps don't behave that way, in order to realize that this is a feature. I thought I was annoyed by it more than I used it, but it seems I was wrong. I'm missing it in C#.
sbi
+15  A: 

Putting functions or variables in a nameless namespace deprecates the use of static to restrict them to file scope.

Jim Hunziker
"deprecates" is a strong term…
Potatoswatter
@Potato: Old comment, I know, but the standard does say the use of static in namespace scope is deprecated, with preference for unnamed namespaces.
GMan
@GMan: no prob, I don't think SO pages really "die." Just for both sides of the story, `static` in global scope is not deprecated in any way. (For reference: C++03 §D.2)
Potatoswatter
Ah, on closer reading, "A name declared in the global namespace has global namespace scope (also called global scope)." Does that really mean that?
Potatoswatter
@Potato: Yup. :) `static` use should only be used within a class-type or function.
GMan
+225  A: 

Most C++ programmers are familiar with the ternary operator:

x = (y < 0) ? 10 : 20;

However, they don't realize that it can be used as an lvalue:

(a == 0 ? a : b) = 1;

which is shorthand for

if (a == 0)
    a = 1;
else
    b = 1;

Use with caution :-)

Ferruccio
Very interesting. I can see that making some unreadable code though.
Jason Baker
You have to move your closing parenthesis: "(a == 0 ? a : b) = 1", otherwise, it compiles as "a == 0 ? a : (b = 1)". Note that parens around "a == 0" are not necessary.
P Daddy
thanks, P Daddy - I missed that
Ferruccio
Yikes. (a == 0 ? a : b) = (y < 0 ? 10 : 20);
Jasper Bekkers
Probably shouldn't even be a feature :)
Andrei Taranchenko
It's strange that this isn't in C. Things like single-line comments (//) were backported, and this certainly couldn't break any code. I think this might be kind of useful, too. Oh well.
Andrew Keeton
`(!a ? a : b) = 1` ?
Sukasa
(b ? trueCount : falseCount)++
Pavel Radzivilovsky
Does any other language allow this?
Casebash
I usually refrain from using the ternary operator because it makes code difficult to read.
Exception
Dunno if it's GCC specific, but I was surprised to find this also worked: `(value ? function1 : function2)()`.
Chris Burt-Brown
+13  A: 

Read a file into a vector of strings:

 vector<string> V;
 copy(istream_iterator<string>(cin), istream_iterator<string>(),
     back_inserter(V));

istream_iterator

Jason Baker
Or: vector<string> V((istream_iterator<string>(cin)), istream_iterator<string>);
UncleBens
you mean `vector<string> V((istream_iterator<string>(cin)), istream_iterator<string>());`-- missing parentheses after second param
knittl
This isn't really a hidden C++ feature. More of an STL feature. STL != a language
Nick Bedford
+87  A: 

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.

+1 for the analog literals -- that's insane!
Martin B
+1: that is messed up.
Trevor Harrison
I second Trevor Harrison, that IS messed up. New respect for C++!
blwy10
+1 for complete insanity
KitsuneYMG
Wow. That's crazy
Alexandre Jasmin
We avoid pointers because of bugs? Pointers are basically everything that dynamic C++ coding is about!
Nick Bedford
+31  A: 

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 :)

Johannes Schaub - litb
Neat! I never knew you could do that... it would have (and will) save some hassle when writing code with error return values. Is there any way to still have a conditional instead of just != 0 in this form? if((int r = func()) < 0) doesn't seem to work...
puetzk
puetzk, no there isn't . but glad you like it :)
Johannes Schaub - litb
Actually a friend of mine had to use this first feature to precisely craft a very tricky macro that was needed in the existing system.
Kamil Szot
+1 Enjoy this link: http://www.ddj.com/cpp/184401728
fnieto
This is really only hidden for people who never seriously wrote C code. It's *very* common to capture return values in variables like this.
Frerich Raabe
@Frerich, this is not possible in C code at all. I think you are thinking of `if((a = f()) == b) ...`, but this answer actually declares a variable in the condition.
Johannes Schaub - litb
This isn't very different from `for (int i=foo(); i<N; ++i)`The lifetime of `i` is until the loop is exited. The iterator is very commonly defined inside the parenthesis.
AngryWhenHungry
@Angry it's very different, because the variable declaration is tested for its boolean value straight away. There is a mapping to for-loops too, which looks like `for(...; int i = foo(); ) ...;` This will go through the body as long as `i` is true, initializing it each time again. The loop that you show is simply demonstrating a variable declaration, but not a variable declaration that simultanuously acts as a condition :)
Johannes Schaub - litb
+3  A: 

From C++ Truths.

Defining functions having identical signatures in the same scope, so this is legal:

template<class T> // (a) a base template
void f(T) {
  std::cout << "f(T)\n";
}

template<>
void f<>(int*) { // (b) an explicit specialization
  std::cout << "f(int *) specilization\n";
}

template<class T> // (c) another, overloads (a)
void f(T*) {
  std::cout << "f(T *)\n";
}

template<>
void f<>(int*) { // (d) another identical explicit specialization
  std::cout << "f(int *) another specilization\n";
}
Comptrol
+1 for obscurity, though you yourself are obscuring things by omitting the fact the above code needs 2 more function template declarations (1 at the start, 1 in between) to compile.
j_random_hacker
+1  A: 

If operator delete() takes size argument in addition to *void, that means it will, highly, be a base class. That size argument render possible checking the size of the types in order to destroy the correct one. Here what Stephen Dewhurst tells about this:

Notice also that we've employed a two-argument version of operator delete rather than the usual one-argument version. This two-argument version is another "usual" version of member operator delete often employed by base classes that expect derived classes to inherit their operator delete implementation. The second argument will contain the size of the object being deleted—information that is often useful in implementing custom memory management.

Comptrol
+7  A: 

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.

Eclipse
is there any difference between 1st and 2nd? though, I know they are both initializations.
Comptrol
Comptrol: I don't think so. Both will end up calling the copy-constructor, even though the first one LOOKS like the assignment operator, it is really the copy-constructor.
abelenky
If u is a different type from SomeType, then the first one will call the conversion constructor first and then the copy constructor, whereas the second one will only call the conversion constructor.
Eclipse
Thanks for the answers guys.
Comptrol
Yes, what a *wonderful* *feature* that is...
j_random_hacker
1st is implicit call of constructor, 2nd is explicit call. Look at the following code to see the difference:#include <iostream>class sss{public: explicit sss( int ) { std::cout << "int" << std::endl; }; sss( double ) { std::cout << "double" << std::endl; };};int main(){ sss ddd( 7 ); // calls int constructor sss xxx = 7; // calls double constructor return 0;}
Kirill V. Lyadvinsky
True - the first line will not work if the constructor is declared explicit.
Eclipse
+55  A: 

One thing that's little known is that unions can be templates too:

template<typename From, typename To>
union union_cast {
    From from;
    To   to;

    union_cast(From from)
        :from(from) { }

    To getTo() const { return to; }
};

And they can have constructors and member functions too. Just nothing that has to do with inheritance (including virtual functions).

Johannes Schaub - litb
Interesting! So, must you initialise all members? Does it follow the usual struct order, implying that the last member will be initialised "on top of" earlier members?
j_random_hacker
j_random_hacker oh, right that's nonsense. good catch. i wrote it as it would be a struct. wait i'll fix it
Johannes Schaub - litb
Doesn't this invoke undefined behavior?
Greg Bacon
@gbacon, yes it does invoke undefined behavior if `From` and `To` are set and used accordingly. Such an union can be used with defined behavior though (with `To` being an array of unsigned char or a struct sharing an initial sequence with `From`). Even if you use it in an undefined way, it might still be useful for low-level work. Anyway, this is just one example of an union template - there may be other uses for an templated union.
Johannes Schaub - litb
That is interesting, never knew that unions actually had those features from classes and structs!
Ramon Zarazua
Careful with the constructor. Note that you are required to only construct the first element, and it's only allowed in C++0x. As of the current standard, you have to stick to trivially constructible types. And no destructors.
Potatoswatter
Nick Bedford
+14  A: 

Defining ordinary friend functions in class templates needs special attention:

template <typename T> 
class Creator { 
    friend void appear() {  // a new function ::appear(), but it doesn't 
        …                   // exist until Creator is instantiated 
    } 
};
Creator<void> miracle;  // ::appear() is created at this point 
Creator<double> oops;   // ERROR: ::appear() is created a second time!

In this example, two different instantiations create two identical definitions—a direct violation of the ODR

We must therefore make sure the template parameters of the class template appear in the type of any friend function defined in that template (unless we want to prevent more than one instantiation of a class template in a particular file, but this is rather unlikely). Let's apply this to a variation of our previous example:

template <typename T> 
class Creator { 
    friend void feed(Creator<T>*){  // every T generates a different 
        …                           // function ::feed() 
    } 
}; 

Creator<void> one;     // generates ::feed(Creator<void>*) 
Creator<double> two;   // generates ::feed(Creator<double>*)

Disclaimer: I have pasted this section from C++ Templates: The Complete Guide / Section 8.4

Comptrol
+1, this was the biggest C++ wtf for me...
missingfaktor
+6  A: 

A dangerous secret is

Fred* f = new(ram) Fred(); http://www.parashift.com/c++-faq-lite/dtors.html#faq-11.10
f->~Fred();

My favorite secret I rarely see used:

class A
{
};

struct B
{
  A a;
  operator A&() { return a; }
};

void func(A a) { }

int main()
{
  A a, c;
  B b;
  a=c;
  func(b); //yeah baby
  a=b; //gotta love this
}
acidzombie24
Umm, hate to say it but that's actually a not very hidden "type cast operator". Anyone who's ever looked at operator overloads probably knows about this.
Nick Bedford
The lead programmers at my work didnt know about it. Only one person i have met knew about it. Also i seen tutorials that do not mention it including my favorite tutorial http://www.cplusplus.com/doc/tutorial/
acidzombie24
A: 
class Empty {};

namespace std {
  // #1 specializing from std namespace is okay under certain circumstances
  template<>
  void swap<Empty>(Empty&, Empty&) {} 
}

/* #2 The following function has no arguments. 
   There is no 'unknown argument list' as we do
   in C.
*/
void my_function() { 
  cout << "whoa! an error\n"; // #3 using can be scoped, as it is in main below
  // and this doesn't affect things outside of that scope
}

int main() {
  using namespace std; /* #4 you can use using in function scopes */
  cout << sizeof(Empty) << "\n"; /* #5 sizeof(Empty) is never 0 */
  /* #6 falling off of main without an explicit return means "return 0;" */
}
dirkgently
No, extending std is absolutely *not* OK, and the standard explicitly forbids it (with one exception: overloads of `swap`).
Konrad Rudolph
Thanks. I was misguided. But is it just swap or does the standard say: Only specialisations of standard templates?
dirkgently
It's allowed to specialize templates within `std`, as long as the specialization depends on a user defined type. It's not restricted to swap.
Johannes Schaub - litb
Your specific example however is invalid, because your specialization doesn't match any function template signature. You would have to have two reference parameters etc :)
Johannes Schaub - litb
D'oh! That was a slip.
dirkgently
"It is undefined for a C++ program to add declarations or definitions to namespace std or namespaces within namespace std unless otherwise specified." (17.4.3.1/1) You can't overload std::swap, etc., but you can specialize them: "A program may add template specializations for any standard library template to namespace std. Such a specialization ... results in undefined behavior unless the declaration depends on a user-defined name of external linkage and unless the specialization meets the standard library requirements for the original template." (17.4.3.1/1)
Roger Pate
Note that std::swap, in particular, cannot be partially specialized (it is a function) and cannot be overloaded (see above standard quote), so you must do something else for templates you write. Example of how to use ADL with std::swap at http://stackoverflow.com/questions/2197141/why-template-specialization-is-important-and-necessary-in-c/2197682#2197682.
Roger Pate
@Konrad: Where is that exception specified? I don't believe it exists.
Roger Pate
@Roger, you're right. I meant specialize, not overload.
Konrad Rudolph
+1  A: 

Indirect Conversion Idiom:

Suppose you're designing a smart pointer class. In addition to overloading the operators * and ->, a smart pointer class usually defines a conversion operator to bool:

template <class T>
class Ptr
{
public:
 operator bool() const
 {
  return (rawptr ? true: false);
 }
//..more stuff
private:
 T * rawptr;
};

The conversion to bool enables clients to use smart pointers in expressions that require bool operands:

Ptr<int> ptr(new int);
if(ptr ) //calls operator bool()
 cout<<"int value is: "<<*ptr <<endl;
else
 cout<<"empty"<<endl;

Furthermore, the implicit conversion to bool is required in conditional declarations such as:

if (shared_ptr<X> px = dynamic_pointer_cast<X>(py))
{
 //we get here only of px isn't empty
}

Alas, this automatic conversion opens the gate to unwelcome surprises:

Ptr <int> p1;
Ptr <double> p2;

//surprise #1
cout<<"p1 + p2 = "<< p1+p2 <<endl; 
//prints 0, 1, or 2, although there isn't an overloaded operator+()

Ptr <File> pf;
Ptr <Query> pq; // Query and File are unrelated 

//surprise #2
if(pf==pq) //compares bool values, not pointers!

Solution: Use the "indirect conversion" idiom, by a conversion from pointer to data member[pMember] to bool so that there will be only 1 implicit conversion, which will prevent aforementioned unexpected behaviour: pMember->bool rather that bool->something else.

Comptrol
+2  A: 

Pay attention to difference between free function pointer and member function pointer initializations:

member function:

struct S
{
 void func(){};
};
int main(){
void (S::*pmf)()=&S::func;//  & is mandatory
}

and free function:

void func(int){}
int main(){
void (*pf)(int)=func; // & is unnecessary it can be &func as well; 
}

Thanks to this redundant &, you can add stream manipulators-which are free functions- in chain without it:

cout<<hex<<56; //otherwise you would have to write cout<<&hex<<56, not neat.
Comptrol
A: 

Emulating reinterpret cast with static cast :

int var;
string *str = reinterpret_cast<string*>(&var);

the above code is equivalent to following:

int var;    
string *str = static_cast<string*>(static_cast<void*>(&var));
Comptrol
What would be the point of that?
Zifre
Zifre, nothing. but the result is the same in both cases. see here: http://www.informit.com/blogs/blog.aspx?uk=30-C-Tips-in-30-Days-Tip-4-Using-staticcast-instead-of-reinterpretcast
Comptrol
I really don't see the "trick" to this, as your second example is basically just describing what happens with a reinterpret_cast. You could have also done this: string *str = (string*)(void*)(Also, shouldn't your static_cast<void> be static_cast<void*>?
Jared
@Jared, There is no trick. I just didn't know the inner workings of reinterpret_cast and wanted to share it. You don't even need to add (void*) , after all C style casting encompasses both reinterpret_cast and static_cast. you are right about void*, thanks.
Comptrol
This isn't true. The double static cast is what people typically *think* reinterpret_cast does. But it doesn't. They're not equivalent. static_cast guarantees that it'll yield a pointer to the same address. reinterpret_cast just provides an implementation-defined mapping.
jalf
`static_cast` only guarantees the same address if you cast back to the same type that you had before converting to `void*`. There is some hidden mystery in the Standard about some special handling of a double `static_cast` like shown in this answer, but i yet have to see anyone proving the real existance of this special handling beyond "there is this, but i dunno where" wordings.
Johannes Schaub - litb
In any case, i don't think it deserves -1. +1 by me!
Johannes Schaub - litb
+1  A: 

The class and struct class-keys are nearly identical. The main difference is that classes default to private access for members and bases, while structs default to public:

// this is completely valid C++:
class A;
struct A { virtual ~A() = 0; };
class B : public A { public: virtual ~B(); };

// means the exact same as:
struct A;
class A { public: virtual ~A() = 0; };
struct B : A { virtual ~B(); };

// you can't even tell the difference from other code whether 'struct'
// or 'class' was used for A and B

Unions can also have members and methods, and default to public access similarly to structs.

a_m0d
+70  A: 

Not only can variables be declared in the init part of a for loop, but also classes and functions.

for(struct { int a; float b; } loop = { 1, 2 }; ...; ...) {
    ...
}

That allows for multiple variables of differing types.

Johannes Schaub - litb
Nice to know that you can do it, but personally I'd really try to avoid doing anything like that. Mostly because it's difficult to read.
Sir Oddfellow
That is totally awesome!
Nick Bedford
@Sir: It might be interesting to use for generated code or macro trickery, though.
sbi
A: 

Adding constraints to templates.

Comptrol
+10  A: 

Primitive types have constructors.

int i(3);

works.

+3  A: 

It seems to me that only few people know about unnamed namespaces:

namespace {
  // Classes, functions, and objects here.
}

Unnamed namespaces behave as if they was replaced by:

namespace __unique_name__ { /* empty body */ }
using namespace __unique_name__;
namespace __unique_name__ {
  // original namespace body
}

".. where all occurances of [this unique name] in a translation unit are replaced by the same identifier and this identifier differs from all other identifiers in the entire program." [C++03, 7.3.1.1/1]

vobject
Unfortunately, using an anon namespace alone still leaves external (though unreferenceable) symbols in your final link. Until this changes, if you care about final binary size, its best to declare any file local functions and variable static as well.
Jon
@Jon: And what's the difference after you strip the executables?
Roger Pate
+17  A: 

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);
}
Johannes Schaub - litb
Great stuff. Thanks :)
navigator
http://bitbucket.org/kniht/scraps/src/tip/cpp/pubadaptor.hpp
Roger Pate
A: 

Member pointers and member pointer operator ->*

#include <stdio.h>
struct A { int d; int e() { return d; } };
int main() {
    A* a = new A();
    a->d = 8;
    printf("%d %d\n", a ->* &A::d, (a ->* &A::e)() );
    return 0;
}

For methods (a ->* &A::e)() is a bit like Function.call() from javascript

var f = A.e
f.call(a)

For members it's a bit like accessing with [] operator

a['d']
Kamil Szot
+30  A: 

Many know of the identity / id metafunction, but there is a nice usecase for it for non-template cases: Ease writing declarations:

// void (*f)(); // same
id<void()>::type *f;

// void (*f(void(*p)()))(int); // same
id<void(int)>::type *f(id<void()>::type *p);

// int (*p)[2] = new int[10][2]; // same
id<int[2]>::type *p = new int[10][2];

// void (C::*p)(int) = 0; // same
id<void(int)>::type C::*p = 0;

It helps decrypting C++ declarations greatly!

// boost::identity is pretty much the same
template<typename T> 
struct id { typedef T type; };
Johannes Schaub - litb
+3  A: 

throw is an expression

sdcvvc
+1  A: 

I find recursive template instatiations pretty cool:

template<class int>
class foo;

template
class foo<0> {
    int* get<0>() { return array; }
    int* array;  
};

template<class int>
class foo<i> : public foo<i-1> {
    int* get<i>() { return array + 1; }  
};

I've used that to generate a class with 10-15 functions that return pointers into various parts of an array, since an API I used required one function pointer for each value.

I.e. programming the compiler to generate a bunch of functions, via recursion. Easy as pie. :)

Marcus Lindblom
+1  A: 

main() does not need a return value:

int main(){}

is the shortest valid C++ program.

Jeffrey Faust
Technically not, because you need a newline for it to be valid :p
Kaz Dragon
@Kaz: The newline is there, click 'edit' to view the source. :)
Roger Pate
+5  A: 

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.

Kaz Dragon
A: 

My favorite (for the time being) is the lack of sematics in a statement like A=B=C. What the value of A is basically undetermined.

Think of this:

class clC
{
public:
   clC& operator=(const clC& other)
   {
      //do some assignment stuff
      return copy(other);
   }
   virtual clC& copy(const clC& other);
}

class clB : public clC
{
public:
  clB() : m_copy()
  {
  }

  clC& copy(const clC& other)
  {
    return m_copy;
  }

private:
  class clInnerB : public clC
  {
  }
  clInnerB m_copy;
}

now A might be of a type inaccessible to any other than objects of type clB and have a value that's unrelated to C.

Rune FS
+8  A: 

void functions can return void values

Little known, but the following code is fine

void f() { }
void g() { return f(); }

Aswell as the following weird looking one

void f() { return (void)"i'm discarded"; }

Knowing about this, you can take advantage in some areas. One example: void functions can't return a value but you can also not just return nothing, because they may be instantiated with non-void. Instead of storing the value into a local variable, which will cause an error for void, just return a value directly

template<typename T>
struct sample {
  // assume f<T> may return void
  T dosomething() { return f<T>(); }

  // better than T t = f<T>(); /* ... */ return t; !
};
Johannes Schaub - litb
+10  A: 

Preventing comma operator from calling operator overloads

Sometimes you make valid use of the comma operator, but you want to ensure that no user defined comma operator gets into the way, because for instance you rely on sequence points between the left and right side or want to make sure nothing interferes with the desired action. This is where void() comes into game:

for(T i, j; can_continue(i, j); ++i, void(), ++j)
  do_code(i, j);

Ignore the place holders i put for the condition and code. What's important is the void(), which makes the compiler force to use the builtin comma operator. This can be useful when implementing traits classes, sometimes, too. In C++0x, this has the effect of suppressing any special meaning of the operand of decltype:

T &&f();

// since f's return type is "T&&", i is declared as "T&&". 
decltype(f()) i; 

// since function invocation scanning is suppressed, 
// i is declared with the type of "f()", which is "T":
decltype(void(), f()) i;

Notice that parentheses around f() will not help - the call still has the special treatment by decltype.

Johannes Schaub - litb
A: 

You can view all the predefined macros through command-line switches with some compilers. This works with gcc and icc (Intel's C++ compiler):

$ touch empty.cpp
$ g++ -E -dM empty.cpp | sort >gxx-macros.txt
$ icc -E -dM empty.cpp | sort >icx-macros.txt
$ touch empty.c
$ gcc -E -dM empty.c | sort >gcc-macros.txt
$ icc -E -dM empty.c | sort >icc-macros.txt

For MSVC they are listed in a single place. They could be documented in a single place for the others too, but with the above commands you can clearly see what is and isn't defined and exactly what values are used, after applying all of the other command-line switches.

Compare (after sorting):

 $ diff gxx-macros.txt icx-macros.txt
 $ diff gxx-macros.txt gcc-macros.txt
 $ diff icx-macros.txt icc-macros.txt
Roger Pate
+4  A: 

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).

AndreyT
For what it's worth, Neil has a question on this: http://stackoverflow.com/questions/1212978/in-c-if-throw-is-an-expression-what-is-its-type , just for extra info.
GMan
+1  A: 
  1. map::insert(std::pair(key, value)); doesn't overwrite if key value already exists.

  2. You can instantiate a class right after its definition: (I might add that this feature has given me hundreds of compilation errors because of the missing semicolon, and I've never ever seen anyone use this on classes)

    class MyClass {public: /* code */} myClass;
    
Viktor Sehr
A: 

I know somebody who defines a getter and a setter at the same time with only one method. Like this:

class foo
{
    int x;

    int* GetX(){
        return &x;
    }
}

You can now use this as a getter as usual (well, almost):

int a = *GetX();

and as a setter:

*GetX() = 17;
aheld
I'd change the name though. This leads to major confusion.
Tobias Langner
He only uses it when he programs stuff for himself.
aheld
Johann Gerell
No offense to you, aheld, but my down-vote is for your friend. :) There's no reason to have it return a pointer when a non-const reference will do. Additionally, there's no point in even having a getter, it's just a waste of space; make the member variable public.
GMan
It's not really a waste of space, as it's declared inline ;)
Joe D
A: 

Template metaprogramming is.

osgx
That was already mentioned.
Georg Fritzsche
A: 

Not actually a hidden feature, but pure awesomeness:

#define private public 
mihai
Its not even a feature, its simply illegal to redefine keywords.
Georg Fritzsche
A: 

You can return a variable reference as part of a function. It has some uses, mostly for producing horrible code:

int s ;
vector <int> a ;
vector <int> b ;

int &G(int h)
{
    if ( h < a.size() ) return a[h] ;
    if ( h - a.size() < b.size() ) return b[ h - a.size() ] ;
    return s ;
}

int main()
{
    a = vector <int> (100) ;
    b = vector <int> (100) ;

    G( 20) = 40 ; //a[20] becomes 40
    G(120) = 40 ; //b[20] becomes 40
    G(424) = 40 ; //s becomes 40
}
Martín Fixman
I know I shouldn't ask this, but why the downvote?
Martín Fixman
I wouldn't call that hidden - common examples are the stream-operators, `operator*` for iterators, prefix `++`, `std::vector<T>::front()`, compound-assignments, ...
Georg Fritzsche
+4  A: 

Local classes are awesome :

struct MyAwesomeAbstractClass
{ ... };


template <typename T>
MyAwesomeAbstractClass*
create_awesome(T param)
{
    struct ans : MyAwesomeAbstractClass
    {
        // Make the implementation depend on T
    };

    return new ans(...);
}

quite neat, since it doesn't pollute the namespace with useless class definitions...

Alexandre C.
+5  A: 

One hidden feature, even hidden to the GCC developers, is to initialize an array member using a string literal. Suppose you have a structure that needs to work with a C array, and you want to initialize the array member with a default content

struct Person {
  char name[255];
  Person():name("???") { }
};

This works, and only works with char arrays and string literal initializers. No strcpy is needed!

Johannes Schaub - litb
Maybe it's just me, but this seems obvious, given that `void foo(){char p[255] = "daddy";}` is also a legal way to initialize an array.
P Daddy
@PDaddy, it's not too obvious, because while the `= "foo"` thing is often done in code, it's hardly never done for member initializers. I have never seen it before, until i read the Standard and found it is allowed and works with other compilers.
Johannes Schaub - litb
Not trying to be argumentative, but as a beginner, this was the next thing that came to mind after trying something like `class C{char p[255] = "daddy";};` and getting "only static const integral data members can be initialized with a class". But at the time, I had just recently learned of initialization lists, so perhaps that made it easier. In any case, this is certainly a clear example of how initialization lists are different from assignment within the constructor body.
P Daddy
+13  A: 

Another hidden feature is that you can call class objects that can be converted to function pointers or references. Overload resolution is done on the result of them, and arguments are perfectly forwarded.

template<typename Func1, typename Func2>
class callable {
  Func1 *m_f1;
  Func2 *m_f2;

public:
  callable(Func1 *f1, Func2 *f2):m_f1(f1), m_f2(f2) { }
  operator Func1*() { return m_f1; }
  operator Func2*() { return m_f2; }
};

void foo(int i) { std::cout << "foo: " << i << std::endl; }
void bar(long il) { std::cout << "bar: " << il << std::endl; }

int main() {
  callable<void(int), void(long)> c(foo, bar);
  c(42); // calls foo
  c(42L); // calls bar
}

These are called "surrogate call functions".

Johannes Schaub - litb
When you say overload resolution is done on the result of them, do you mean it actually converts it to both Functors and then does overload resolution? I tried printing something in operator Func1* (), and operator Func2* (), but it seems to pick the correct one when it figures out which conversion operator to invoke.
navigator
@navigator, yep it conceptually converts to both and then picks the best. It does not need to actually call them, because it knows from the result-type what they will yield already. The actual call is done when it turns out what was finally picked.
Johannes Schaub - litb
@litb, thanks for the clarification.
navigator
+21  A: 

Another hidden feature that doesn't work in C is the functionality of the unary + operator. You can use it to promote and decay all sorts of things

Converting an Enumeration to an integer

+AnEnumeratorValue

And your enumerator value that previously had its enumeration type now has the perfect integer type that can fit its value. Manually, you would hardly know that type! This is needed for example when you want to implement an overloaded operator for your enumeration.

Get the value out of a variable

You have to use a class that uses an in-class static initializer without an out of class definition, but sometimes it fails to link? The operator may help to create a temporary without making assumptins or dependencies on its type

struct Foo {
  static int const value = 42;
};

// This does something interesting...
template<typename T>
void f(T const&);

int main() {
  // fails to link - tries to get the address of "Foo::value"!
  f(Foo::value);

  // works - pass a temporary value
  f(+Foo::value);
}

Decay an array to a pointer

Do you want to pass two pointers to a function, but it just won't work? The operator may help

// This does something interesting...
template<typename T>
void f(T const& a, T const& b);

int main() {
  int a[2];
  int b[3];
  f(a, b); // won't work! different values for "T"!
  f(+a, +b); // works! T is "int*" both time
}
Johannes Schaub - litb
Didn't know this one. Very nice!
jweyrich
All I can say is:Whoa.
Martín Fixman
Nice !!!!!!!!!!
Tarantula
Very cool indeed. I almost didn't believe you, since this is the first time I've heard of a unary + operator... But it checks out :-)
Tomer Vromen
+7  A: 

The dominance rule is useful, but little known. It says that even if in a non-unique path through a base-class lattice, name-lookup for a partially hidden member is unique if the member belongs to a virtual base-class:

struct A { void f() { } };

struct B : virtual A { void f() { cout << "B!"; } };
struct C : virtual A { };

// name-lookup sees B::f and A::f, but B::f dominates over A::f !
struct D : B, C { void g() { f(); } };

I've used this to implement alignment-support that automatically figures out the strictest alignment by means of the dominance rule.

This does not only apply to virtual functions, but also to typedef names, static/non-virtual members and anything else. I've seen it used to implement overwritable traits in meta-programs.

Johannes Schaub - litb