Hidden Features of C++? [closed]

Question

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++?

Harvest

@Devtron - I've seen some awesome bugs (i.e. unexpected behavior) sold as features. In fact, the games industry actually tries to make this happen nowadays and calls it "emergent gameplay" (also, check out "TK Surfing" from Psi-Ops, was purely a bug, then they left it as is and its one of the best features of the game IMHO) – Tails

@Laith J: Not very many people have read the 786-page ISO C++ standard from cover to cover -- but I suppose you have, and you've retained all of it, right? – Salary

@Laith, @j_random: See my question "What is a programmer's joke, how do I recognize it, and what is the appropriate response" at stackoverflow.com/questions/1/you-have-been-link-rolled. – Mcglone

See meta.stackexchange.com/questions/56669/…, meta.stackexchange.com/questions/57226/… and related Meta posts. – Mcglone

Answer 1

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

Japan

Very interesting. I can see that making some unreadable code though. – Jarrod

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. – Martinmas

Yikes. (a == 0 ? a : b) = (y < 0 ? 10 : 20); – Gaslight

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. – Raoul

(b ? trueCount : falseCount)++ – Moo

Does any other language allow this? – Iodide

I usually refrain from using the ternary operator because it makes code difficult to read. – Beauvoir

Dunno if it's GCC specific, but I was surprised to find this also worked: (value ? function1 : function2)(). – Suds

@Chris Burt-Brown: No, that should work everywhere if they have the same type (i.e. no defaulted arguments) function1 and function2 are implictly converted to function pointers, and the result is implicitly converted back. – Dysentery

Answer 2

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

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

    ...
}

Conard

But only one per function, i suspect? :) – Trifocal

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 – Patriotism

Just don't try adding more than one per source file :P – Batman

@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. – Creech

You can add more than one as long as they have different protocols! ftp.microsoft.com gopher://aerv.nl/1 and so on... – Unfreeze

@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. – Petulia

If you have Warnings as Errors switched on it won't build, in VS2005 at least – Regulable

@Chris: you can fix that by adding a goto http; ;-) – Sadiras

Unfortunately goto http; doesn't actually follows the URL. :( – Chair

@titaniumdecoy Wait, Java supports gotos? – Sharpeared

@muntoo, actually yes, sort of. https://mcmap.net/q/24096/-is-there-a-goto-statement-in-java – Parathion

Answer 3

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.

Quadratics

We avoid pointers because of bugs? Pointers are basically everything that dynamic C++ coding is about! – Rigid

Analog literals are great for obfuscated C++ contest entries, especially the ASCII-art type. – Bozeman

Answer 4

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 )

Wolfram

+1 very thorough answer. it's incomplete for obvious reasons (otherwise there wouldn't be "hidden features" anymore!) :p in 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"? – Thereby

CRTP - en.wikipedia.org/wiki/Curiously_Recurring_Template_Pattern – Laruelarum

what you are mentioning about with 1 must be koenig lookup, right? – Turkish

@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 – Wolfram

@Comptrol: You're almost right, it is the consequence of Keonig's Lookup. – Wolfram

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. ;) – Douty

Answer 5

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

Zitvaa

I guess this is useful if you don't want to use using. – Beauvoir

It's also useful as a way to switch between implementations, whether selecting say thread-safe versus non-thread-safe, or version 1 versus 2. – Sadiras

It's especially useful if you're working on a very large project with large namespace hierarchies and you don't want your headers to cause namespace pollution (and you want your variable declarations to be human-readable). – Espy

Answer 6

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.

Zuber

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. – Amen

@Sir: It might be interesting to use for generated code or macro trickery, though. – Squireen

-1: Sorry, but unfortanutelly it doesn't work on VS2008. for(struct { int a; float b; } loop = { 1, 2 };;); causes: "error C2332: 'struct' : missing tag name" – Torment

Actually, what would work in this context is using a pair: for ( std::pair<int,float> loop=std::make_pair(1,2); loop.first > 0; loop.second+=1) – Torment

@Valentin well then I recommend you to try and make a bugreport against VS2008 instead of downvoting the hidden feature. It's clearly the fault of your compiler. – Zuber

Hmm, it doesn't work in msvc10 either. How sad :( – Creaky

@Creaky in fact, gcc introduced a bug that makes it reject too, in v4.6 :) see gcc.gnu.org/bugzilla/show_bug.cgi?id=46791 – Zuber

Reminds me of 'write a C program to output your name but no using semicolons in your program'. We just use if (printf("Nav")) – Diann

Answer 7

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

Icarus

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. – Vigilance

you mean "commutative" where you say "associative"? – Marpet

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. – Burkhardt

Beware that A must be a pointer, and not a class overloading operator[]. – Neomaneomah

Vincent, in this there has to be one integral type and one pointer type, and neither C nor C++ cares which one goes first. – Petulia

A[8] evaluates to *(A + 8). 8[A] evaluates to *(8 + A). They are the same. – Carabin

Answer 8

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

Zuber

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? – Salary

j_random_hacker oh, right that's nonsense. good catch. i wrote it as it would be a struct. wait i'll fix it – Zuber

Doesn't this invoke undefined behavior? – Membranous

@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. – Zuber

That is interesting, never knew that unions actually had those features from classes and structs! – Maus

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. – Paramour

So basically you're doing this? *(B *)&a – Rigid

@JohannesSchaub-litb: also, bitfields can be templated: https://mcmap.net/q/24097/-integer-subtraction-with-wrap-around-for-n-bits – Haigh

Answer 9

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.

Burkhardt

Answer 10

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
}

Zuber

Answer 11

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

Bettyannbettye

Can you elaborate? As is you're just teasing ;) – Strickman

ScopeGuard (ddj.com/cpp/184403758) is a great example that leverages this feature. – Bettyannbettye

I am with Joseph Garvin. Please enlighten us. – Bushbuck

I just did in the comments. Besides, it's a natural consequence of using a const reference parameter. – Bettyannbettye

I've read the answer and the link to ScopeGuard and I still don't understand what this means. – Roband

@Oak: #257224 – Gregggreggory

How is this different from: const MyClass x; ? – Japan

@Ferruccio, in this case it is identical, but you can use a derived class and still have its lifetime extended to the scope of the const reference. – Bettyannbettye

Answer 12

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.

Laval

I don't think you can return from catch block of Function Try, only rethrow. – Trifocal

I just tried compiling the above, and it gave no warning. I think the above example works. – Laval

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. – Sham

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. – Doubtless

@Sham 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. – Extraneous

This is pretty rad. I had no idea you could that, and it doesn't appear to people that it would even compile. – Rigid

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. – Usher

@kizzx: it saves you one open and one close brace. – Chair

@kizzx: it also saves further indentation of the function body... nice if you're lazy to reindent or work in a fixed-width screen and want to use more of it. – Sadiras

Answer 13

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; };

Zuber

Interesting, but initially I actually had more trouble reading some of those definitions. Another way to fix the inside-out problem with C++ declarations is to write some template type aliases: template<typename Ret,typename... Args> using function = Ret (Args...); template<typename T> using pointer = *T; -> pointer<function<void,int>> f(pointer<function<void,void>>); or pointer<void(int)> f(pointer<void()>); or function<pointer<function<void,int>>,pointer<function<void,void>>> f; – Dolphin

Answer 14

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

Zuber

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... – Sham

puetzk, no there isn't . but glad you like it :) – Zuber

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. – Kellar

+1 Enjoy this link: ddj.com/cpp/184401728 – Buddha

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. – Comedy

@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. – Zuber

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. – Luanneluanni

@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 :) – Zuber

Very good, except you didn't mention the intended use for this feature was for dynamic pointer casts, I believe. – Moving

Answer 15

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.

Zuber

I just used this to finish off my overkill expression ignorer. :) – Taam

Answer 16

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()
{
}

Liz

You can do this with any array anywhere. – Paramour

@Potatoswatter: harder than it looks, due to the most vexing parse. I can't think of anywhere else it can be done, except maybe a return value – Normy

If the type of the array is a class type, then this isn't needed right? – Sweated

Answer 17

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.

Chrysolite

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++. – Divaricate

Destructors need to be virtual only if you intend to destroy polymorphically, which is a little subtly different from the first point. – Neomaneomah

With C++0x local types can be used as template parameters. – Kellogg

With C++0x, destructors will be virtual if the object has any virtual functions (i.e. a vtable). – Muskogean

don't forget NRVO, and of course any optimization is allowed as long as it doesn't change the program output – Cardie

With C++0x exception specifications are deprecated from the standard – Exfoliation

Answer 18

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

Zuber

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. – Barrelhouse

@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. – Zuber

Answer 19

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);
}

Zuber

bitbucket.org/kniht/scraps/src/tip/cpp/pubadaptor.hpp – Mcglone

Answer 20

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 a bad_exception was thrown. Read more here.

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

5. function parameter defaults can be changed at runtime. Read more here.

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

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

Applicatory

P Daddy: A[i] == *(A+i) == *(i+A) == i[A] – Isolationist

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. – Martinmas

Backward compatibility with C – Photojournalism

Regarding your first point: There's one particular case where you have to implement a pure virtual function: pure virtual destructors. – Comedy

Answer 21

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.

Trifocal

And on the opposite end you cannot use operator[] on a const map – Neomaneomah

+1 for Nick, people can go insane if they don't know about .find(). – Wonderstricken

or "const map::operator[] generates error messages" – Spidery

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. – Maus

It still does bite people: "map<int, data*> m -> if (m[i] == 0) return; /* Not found */" is an insidious memory leak. – Anzus

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#. – Squireen

Once before knowing much about C++ containers, I've already used PHP associative arrays a lot. With that background, it was the exact opposite surpise. In fact it was quite surprising to me that there is no V operator[] (K) const. – Wavellite

Answer 22

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

Henke

"deprecates" is a strong term… – Paramour

@Potato: Old comment, I know, but the standard does say the use of static in namespace scope is deprecated, with preference for unnamed namespaces. – Taam

@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) – Paramour

Ah, on closer reading, "A name declared in the global namespace has global namespace scope (also called global scope)." Does that really mean that? – Paramour

@Potato: Yup. :) static use should only be used within a class-type or function. – Taam

Answer 23

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

Victoriavictorian

Answer 24

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; !
};

Zuber

Answer 25

Read a file into a vector of strings:

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

istream_iterator

Jarrod

Or: vector<string> V((istream_iterator<string>(cin)), istream_iterator<string>); – Ness

you mean vector<string> V((istream_iterator<string>(cin)), istream_iterator<string>());-- missing parentheses after second param – Cupp

This isn't really a hidden C++ feature. More of an STL feature. STL != a language – Rigid

Answer 26

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.

Jefe

See here, where I recently suggested it for n-bit arithmetic: #8310038 – Haigh

Answer 27

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.

Imaginal

is there any difference between 1st and 2nd? though, I know they are both initializations. – Turkish

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. – Isolationist

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. – Imaginal

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; } – Upbraid

True - the first line will not work if the constructor is declared explicit. – Imaginal

Otherwise known as: The most vexxing parse. "Fixed" in C++0x with new syntax: SomeType t{SomeType{u}} – Moving

Answer 28

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.

Zuber

Neat. Any particular reason you included struct C in your example...? Cheers. – Sadiras

Answer 29

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

Fetor

For what it's worth, Neil has a question on this: #1213478 , just for extra info. – Taam

Answer 30

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;

Chiapas

FStruct s = {}; is even shorter. – Trifocal

In the last example, it would be simpler with: a(); b(); float c=1.0f; – Hobbema

@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! – Hyps

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. – Chiapas

+1 Shouldn't you be calling main? I'd suggest global().main(); and just forget about the singleton (you can just work with the temporary, which gets it's lifetime extended) – Haigh

I doubt assigning references is portable. I love the struct to waive forward declarations though. – Sweated

Answer 31

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

Rexanna

Answer 32

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

Katakana

Answer 33

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
}

Deactivate

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. – Rigid

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 cplusplus.com/doc/tutorial – Ovipositor

Answer 34

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!

Zuber

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. – Martinmas

@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. – Zuber

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. – Martinmas

Answer 35

Primitive types have constructors.

int i(3);

works.

Tindle

That's not a constructor, that's just a form of initialization, namely direct initialization. Primitive types do not have constructors. – Taam

@Midas: it initialized i with the value 3. This syntax is allows for uniformity with user-defined types, which is especially useful in templates. – Gulfweed

Answer 36

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]

Volgograd

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. – Burkhardt

Answer 37

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

Jobie

Answer 38

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]

Dulcie

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. – Laevogyrate

@Jon: And what's the difference after you strip the executables? – Mcglone

Answer 39

Is it possible for C++ template to check for a function’s existence?

Victoriavictorian

Answer 40

throw is an expression

Sandysandye

Answer 41

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";
}

Casper

+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. – Salary

Answer 42

• pointers to class methods
• The "typename" keyword

Upanddown

Answer 43

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.

Tiger

We don't ignore it, we shun it.... – Cusp

Duplicate of template metaprogramming from https://mcmap.net/q/24095/-hidden-features-of-c-closed/…. These examples merged into that answer so this duplicate can be deleted. – Mcglone

Answer 44

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

Madeline

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. – Mcglone

Or you can learn to embrace them, which is a Good Thing. – Sweated

Answer 45

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

Midsummer

Even though older by 55 mins, should be merged/combined with the duplicate at https://mcmap.net/q/24095/-hidden-features-of-c-closed/…, or just deleted in favor of the other. – Mcglone

Please... PLEASE do not use Duff's Device. – Jessabell

Answer 46

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;
   

Towering

Answer 47

main() does not need a return value:

int main(){}

is the shortest valid C++ program.

Glomerule

Technically not, because you need a newline for it to be valid :p – Jefe

@Kaz: The newline is there, click 'edit' to view the source. :) – Mcglone

Answer 48

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.

Victoriavictorian

Answer 49

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

Muskogean

Answer 50

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.

Mcglone

Answer 51

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.

Victoriavictorian

but also see safe bool idiom – Haigh

Answer 52

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.

Victoriavictorian

Answer 53

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.

Katsuyama

Answer 54

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

Mcglone

Answer 55

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.

Winepress

huh - you're basically saying that you can use overloading to change semantics? Now, if you were to demonstrate how the semantics of a=b=c wasn't fixed even for builtin types/operators... That would be interesting. § 3.10 For example, the built-in assignment operators expect that the left operand is an lvalue and that the right operand is a prvalue and yield an lvalue as the result. User-defined operators are functions, and the categories of values they expect and yield are determined by their parameter and return types. – Haigh

@Haigh how about an overload for int to always assign say 1/3 of c to a in a=b=c? – Winepress

how will you define the non static member operator= on the class (sic) int? – Haigh

@Haigh never said I would – Winepress

how about an overload for int to always assign say 1/3 of c to a in a=b=c? doesn't materialize into legal code for me. Could you show what it is that you mean? You claiming a lack of semantics as hidden feature of the C++ language. I think it makes sense that you explain what you meant? – Haigh

@Haigh are you claiming that the semantics for the assignment operator is fixed in c++? that you can reason (with certainty) what a will be assigned related to b and c in the statement a=b=c? – Winepress

Oh. That's anticlimactic then. I thought you were somehow suggesting that is was 'under-spec-ed' and a hidden feature. Obviously it is by design. Without this notion there would be no such thing as expression templates, so no Blitz++, Eigen, Boost Proto (heck, 25% of boost) etc. etc. Also, would you say the same about C# then? ideone.com/6dxZG – Haigh

Semantics are fixed for builtin types. You can also reason about it for custom types, rigidly and formally. (If operator= takes a const&, there is no way the value will become clobbered). Your opening sentence is just way too broad: the lack of sematics in a statement like A=B=C. Not just any statement: a statement involving types with non-standard semantics. Well doh? Also that is not a lack of semantics, that is an abundance of possibility. (The former suggests a language flaw) – Haigh

that any given operator can mean any given thing is by definition lack of semantics. Yes it might create an abundance of possibility but lack of mean is lack of meaning – Winepress

Answer 56

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']

Kellar

Answer 57

Adding constraints to templates.

Victoriavictorian

Answer 58

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;" */
}

Stichous

No, extending std is absolutely not OK, and the standard explicitly forbids it (with one exception: overloads of swap). – Burkhardt

Thanks. I was misguided. But is it just swap or does the standard say: Only specialisations of standard templates? – Stichous

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. – Zuber

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

"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) – Mcglone

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 #2197641. – Mcglone

@Konrad: Where is that exception specified? I don't believe it exists. – Mcglone

@Roger, you're right. I meant specialize, not overload. – Burkhardt

Answer 59

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

Casper

What would be the point of that? – Hobbema

Zifre, nothing. but the result is the same in both cases. see here: informit.com/blogs/… – Turkish

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*)(&var); Also, shouldn't your static_cast<void> be static_cast<void*>? – Farias

@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. – Turkish

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. – Douty

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. – Zuber

Answer 60

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
}

Ebonyeboracum

I know I shouldn't ask this, but why the downvote? – Regulus

I wouldn't call that hidden - common examples are the stream-operators, operator* for iterators, prefix ++, std::vector<T>::front(), compound-assignments, ... – Panaggio

Answer 61

Not actually a hidden feature, but pure awesomeness:

#define private public 

Linseylinseywoolsey

Its not even a feature, its simply illegal to redefine keywords. – Panaggio

Says where? Preprocessing stage is applied before keywords are even considered by the parser/lexer. You can redefine virtually EVERYTHING. – Linseylinseywoolsey

To prove it, try this: #define while if void main() { while(1); } – Linseylinseywoolsey

@mihai: It says so here: § 17.6.1.3 ad 7: Identifiers that are keywords or operators in C++ shall not be defined as macros in C++ standard library headers., combined with the One Definition Rule. So the only way out is to not include any standard library headers and not use any standard library code – Haigh

Answer 62

Template metaprogramming is.

Amalgamation

Answer 63

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

Duggins

Answer 64

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;

Inestimable

I'd change the name though. This leads to major confusion. – Doggy

He only uses it when he programs stuff for himself. – Inestimable

Why on earth would he return int* instead of int& in that case!? – Diadromous

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. – Taam

It's not really a waste of space, as it's declared inline ;) – Fritillary

It defeats the whole point of using getters and setters by exposing the internal implementation thereby making it impossible to change the implementation later on without affecting every caller. Your friend managed to combine all the disadvantages of direct member access with all the disadvantages of getters/setters. Good work. – Japan

@Ferruccio: and you forgot to mention lifetime issues because of returned reference/pointers to members.. Truly awesomely bad code it is. – Haigh