Piyush's Blog

A foolish consistency is the hobgoblin of little minds, adored by little statesmen and philosophers and divines - Self-Reliance, Ralph Waldo Emerson

What’s New in C++11

I heard a lot of cool things about the new features and here is what I came across so far:

New Keywords

  • “long long”

    C++11 defines a new integer type “long long”, which is guaranteed to be at least 64 bits in length. The largest integer type “long” defined in C++03 is platform specific, so can be 32 or 64 bits in length. Just a heads up, C99 and other compliers already supported it even before C++11.

  • “auto”

    Automatic type inteference has been introduced using “auto” keyword.

Previously in C++03 
1
2
3
4
5
6
7
8
9

  int a = 10;
  float b = 20.5;
  int c = a;
  string s = "test";
  vector<int> v;
  v.push_back(1);
  v.push_back(2);
  for (vector<int>::iterator itr = v.begin(); itr != v.end(); itr++) {...}
New in C++11 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  auto a = 10;                 // a is infered to be of type int
  float b = 20.5;              // b is infered to be of type float
  int c = a;                   // c is infered to be of type int
  string s = "test";           // s is infered to be of type const char *
  vector<int> v;
  v.push_back(1);
  v.push_back(2);
  auto d = v[0];               // d is infered to be of type int
  for (auto itr = v.begin(); itr != v.end(); itr++) {...}    // itr is infered to be of type vector<int>::iterator
  for (auto itr: v) {cout << itr;}                              // Another easier way to do the same, called range-based 
                                                                // for statement. itr is read only here
  for (auto& itr: v) {cout << ++itr;}                           // Another easier way to do the same, called range-based 
                                                                // for statement. itr is writable here

  • “decltype”

    To know the type of an expression at the compile time. For eg,

New in C++11 
1
2
3
4
5

  decltype(a) a2;              // a2's type is int since a is of type int (above)
  const int&& fun();
  decltype(fun()) e;           // e's type is const int&&
  decltype(b) b2 = 0.5;        // b2's type is float since b is of type float (above)

  • “nullptr”

    No more initializing pointers with NULL which can both act as an int or int * leading to oddity.

New in C++11 
1
2
3

  int *f = nullptr;
  auto g = NULL;

  • “enum class”

    enums have got an upgrade too and now they are type safe

Previously in C++03 
1
2
3
4

  enum SPORTS {BADMINTON, TENNIS};
  enum PERSON {EMILY, BOB};
  if (BADMINTON == EMILY) {}   // if condition will evaluate to true
New in C++11 
1
2
3
4

  enum class SPORTS {BADMINTON, TENNIS};
  enum class PERSON {EMILY, BOB};
  if (SPORT::BADMINTON == PERSON::EMILY) {}   // if condition will evaluate to false

  • “static_assert”

    C++11 defines a new compile time assert.

New in C++11 
1
2

  static_assert(sizeof(int) == 4, "This program cannot be run on machines not supporting integer to be 4 bytes long");

  • “default”, “delete”, “final” and “override”

    All of these 4 new additions are w.r.t. to the inheritance constructs:

“default”

To explicity tell the compiler to provide the default constructor. The only use I see is the enhanced readability.

New in C++11 
1
2
3
4
5
6

  class Temp {
     public:
        Temp() {}            // Own implementation of the default constructor
        Temp() = default;    // Explicitly ask compiler to provide the implementation
  };
“delete”

To not to allow anyone call a function. It is definitely very useful.

New in C++11 
1
2
3
4
5
6
7

  class Temp {
     public:
        Temp() {}
        Temp(const Temp&) = delete;          // Does not allow copy construction
        Temp& Temp(const Temp&) = delete;    // Does not allow assignment operation
  };
“final”

To not to allow anyone override a virtual function or inherit from class. Looks kind of odd :)

New in C++11 
1
2
3
4
5
6
7
8
9
10
11
12
13

  class B {
     public:
        virtual f() final;     // Overriding not allowed
  };

  class D {
     public:
        virtual f();           // Compiler error
  };

  class B2 final {};           // Inheriting not allowed
  class D2 : public B2 {};     // Compiler error
“override”

To explicity tag functions we intend to override in a derived class class. Definitely useful.

New in C++11 
1
2
3
4
5
6
7
8
9
10
11
12
13
14

  class B {
     public:
        virtual void f();
        virtual void g();
        void h();
  };

  class D {
     public:
        virtual void f(int) override;    // Compiler error
        virtual void g() override;       // Okay
        void h() override;               // Compiler error
  };

Initializer Lists

C++11 patches up the inconsistency between initializing simple data types and containers:

Previously in C++03 
1
2
3
4
5

  int v[3] = {0, 1, 2};
  struct PERSON {int id; string name};
  PERSON p = {1, "EMILY"};
  vector<int> v2[3] = {0, 1, 2};          // Not possible in C++03
New in C++11 
1
2

  vector<int> v2[3] = {0, 1, 2};          // Possible in C++11

The way it works is that it calls the constructor std::vector(std::initializer_list). std::initializer_list is a new template class. So, you can add this into your container classes as well:

New in C++11 
1
2
3
4
5
6
7
8
9
10

  class MyVector {
     vector<int> v;

     public:
        MyVector() {}
        MyVector(std::initializer_list<int>& l) {
           for(auto i: l) v.push_back(i);
        }
  };

Uniform Initialization

New in C++11 
1
2
3

  vector<int> v(3);         // Creates a vector of size 3 with uninitialized elements
  vector<int> v{3, 2, 1};   // Creates a vector of size 3 with elements 3, 2, 1. This is called uniform initialization

This concept can be used during the function calls and while returning from the functions too:

New in C++11 
1
2
3
4
5
6

  vector<int> myfunc(vector<int> v) {
     return {1, 2, 3};
  }

  myfunc({3, 2, 1});

Delegating Constructors

It is now possible to call an another constructor from the first one i.e we can chain constructors:

New in C++11 
1
2
3
4
5
6
7
8
9
10
11
12
13

  class MyVector {
     public:
        MyVector() {
           // accomplishes task A
        }
        MyVector(int a): MyVector() {
           // accomplishes task A and B
        }
        MyVector(int a, int b): MyVector(a) {
           // accomplishes task A, B and C
        }
  };

Template Alias or Type Alias

Just like typedef, you can create template alias or type alias (synonyms) refer to a familty of template types. Then, what is the difference between typedef and type alias. Here, it is:

Previously in C++03 
1
2
3
4
5
6
7
8
9

  template<class T> class MyVec {};

  typedef MyVec<int> V1;
  V1 a1;                                        // Okay

  typedef template<class T> class MyVec V2;     // Compiler error here
  typedef template<class T> MyVec V2;           // Compiler error here
  // V2<int> a2;                                // Not possible. So, typedefs cannot be templated

As you can see, the limitation with the typedef is that they cannot be templated. This is where type alias comes in picture:

New in C++11 
1
2
3
4
5

  template<class T> class MyVec {};
  template<class T> using V1 = MyVec<T>;
  V1<int> v1;                                   // Okay
  V1<float> v2;                                 // Okay

Inspiring Quotations and My Favorites

A foolish consistency is the hobgoblin of little minds, adored by little statesmen and philosophers and divines.

Ralph Waldo Emerson

To think, you have to write. If you’re thinking without writing, you only think you’re thinking.

Leslie Lamport

Fractals in GoLang

I wanted to explore Fractals ever since my friend Avijit told me about them. I found them fascinating. Just one equation and you can do wonders with it. It is more fascinating to know how nature uses recursion/fractals in things like trees, leaves, corals and even broccoli !! Here are some interesting fractals I generated using Mandelbrot Set:

Here is the implementation.