Hidden Features of C++? [closed]

Answer 1

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;

Answer 2

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.

Answer 3

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

Answer 4

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

Answer 5

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
}

Answer 6

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