Modern C++ Feature Lists (C++ 11)

This article summarizes the new features of C++ 11. This list is summarized according to Bo Qian’s youtube channel: https://www.youtube.com/playlist?list=PL5jc9xFGsL8FWtnZBeTqZBbniyw0uHyaH

If you are new to C++, I personally highly recommend following his channel. His tutorial is well organized and easy to follow. If you just want to quickly go through the list, just scroll down. Let’s start.

#include<iostream>
#include<vector>
#include<string>
#include<iterator>
using namespace std;
/******************************************************************************************************/
/* 1. Initializer list */
//Implemented by initilaizer list constructor
vector<int> v = {1, 4, 6, 10};
//All the relevant STL containers have been updated to accept the initializer list (e.g. map, list)
//Customized the initializer constructor for our own classes
//For example:
#include<initializer_list>
class OurStudents{
private:
vector<int> m_studentID;
public:
OurStudents(const initializer_list<int> & studentLists){
for(initializer_list<int>::iterator it = studentLists.begin(); it != studentLists.end(); ++it){
m_student.push_back(*it);
}
}
};
OurStudents OurStudents_T1 = {12, 3, 4};
OurStudents OurStudents_T2{12, 3, 4}; //The same as above
/******************************************************************************************************/
/* 2. Uniform Initialization */
//C++ 03
class dog{ //Aggregate class or struct
public:
int age;
string name;
};
dog d1 = {2, "Jack"}; // Aggregate initialization
//C++ 11 extended the scope of curly brace initialization
class dog{
public:
dog(int age, string name){
//
}
};
dog d2 = {2, "Jack"}; //As long as we have a matching constructor in our class, this is valid
//All three initialization takes exact the same form, however, from compiler's perspective, they are
//different
/*
The priority of three forms:
1. Initializer list constructor (first priority)
2. Regular constructor takes appropriate parameters
3. Aggregate initializer
*/
/******************************************************************************************************/
/* 3. auto type */
vector<int> myVec = {3, 4, 4};
vector<int>::iterator it = myVec.begin();
//===the same as above
auto it = myVec.begin();
/******************************************************************************************************/
/* 4. foreach */
for(int i : myVec){ // Work only with classes which have begin() and end() methods
cout<<i; // read-only
}
for(int &i : myVec){
i++; //
}
/******************************************************************************************************/
/* 5. nullptr */
//Replace NULL in C++03
//Compared with NULL, nullptr always represents a pointer.
void foo(int i){cout << "foo int" << endl;}
void foo(char *i){cout << "foo pointer" << endl;}
int main(){
foo(NULL); //Ambiguity
foo(nullptr)// always call foo(char *i)
return 0;
}
/******************************************************************************************************/
/* 6. enum class */
//C++ 11
enum class apple{green, red};
enum class orange(big, small);
apple A = apple::green;
orange O = orange::big;
if(A == O){//Compile error, you should define ==(apple, orange) first
//
}
/******************************************************************************************************/
/* 7. static_assert */
//runtime assert
assert(ptr != nullptr);
//Compile time assert
static_assert(sizeof(int) == 4);
/******************************************************************************************************/
/* 8. Delegating Constructor */
//Won't work in C++, work in Java
class dog{
public:
dog(){ … }
dog(int a){
dog();
//Other staff here;
}
}
//C++ 03
class dog{
public:
void init(){ … }; //Add one more function here which will be used in both constructors
dog(){ init(); }
dog(int a){
init();
//Other staff here;
}
}
/*Downsides:
1. Cubersome code
2. init() maybe invoked by other
*/
//C++ 11, limitation: first constructor dog() is always called first
class dog{
int m_age = 9; // C++ 11 initialize member variable directly
public:
dog(){ … }
dog(int a) : dog() {
//Other staff here;
}
}
/******************************************************************************************************/
/* 9. Override for virtual functions */
//To avoid inadvertently create new functions in derived class
class dog{
virtual void A(int a);
virtual void B() const;
};
class YellowDog : dog{
/* Explicitly tell the compiler that A and B should override the function from parent class.
In this case, since we cannot find any valid function to override. Compiler will issue errors.
*/
virtual void A(float) override; //error
virtual void B() override;//error
}
/******************************************************************************************************/
/* 10. final key word for virtual function and class */
class dog final { //No class can be derived from dog any more
//
};
class dog {
virtual void bark() final; //No derived class can override bark() any more
};
/******************************************************************************************************/
/* 11. Compiler generated default constructor */
/*
Typically, compiler will not generate default constructor if we provide one. However, in C++ 11 we can
force the compiler to generate default constructor.
*/
class dog{
public:
dog(int age){
//
}
};
dog D1; //error: compiler cannot find constructor with no parameters
class dog{
public:
dog(int age){
//
}
dog() = default; //Force the compiler to generate a default constructor
};
dog D1; // OK
/******************************************************************************************************/
/* 12. delete key word */
class dog{
dog(int age){
//
}
};
dog D1(3); //OKay, with constructor we provide
dog D2(4.0); //Okay, compiler will convert double to int and call the constructor we provide
D1 = D2; //Okay, compiler will generate an assign constructor override for us
/*
If we want to restrict such situations, let's say users can only give integer as the age, we can restrict
compiler by delete key word
*/
class dog{
dog(int age){
//
}
dog(double age) = delete;
dog& operator=(const dog& d) = delete;
};
dog D1(3); //OKay, with constructor we provide
dog D2(4.0); //Compile error
D1 = D2;//Compile error
/******************************************************************************************************/
/* 13. constexpr */
int A[6]; // It's OKay
int Func(){return 3;}
int A[Func() + 3];//Error: Compile does not know the return value at compile time
//Force the computation to happen at compile time, the return value is treated as constant value
constexpr int Func(){return 3;}
int A[Func()+ 3];//Okay, an array with length to be 6
//Write a faster program
constexpr int cubed(int x){ return x*x*x; } //Compile time calculation
int k = cubed(26);
/******************************************************************************************************/
/* 14. New string literals */
//C++ 03
char *a = "Hello World";
//C++ 11
char *a = u8"Hello World"; //UTF 8 string
char16_t *b = u"Hello World"; //UTF 16 string
char32_t *c = U"Hello World"; //UTF 32 string
char* d = R"(Hello World)"; //Raw string
/******************************************************************************************************/
/* 15. lambda function */
cout << [](int x, int y){return x + y;}(3, 4) << endl; //print 7
auto f = [](int x, int y){return x + y;};
cout << f(3, 4) << endl; //print 7
template<typename func>
void filter(func f, vector<int>& A){
for(auto i : A){
if(f(i))
cout << i << " ";
}
}
int main(){
vector<int> V = {1,2,3,4,5,6};
int y = 4;
filter([](int x){return x>3;}, V); // Print out 4 5 6
filter([&](int x){return x > y;}, V); // Print out 5 6
//Note: [&] tells the compiler that we want variable capture
return 0;
}

Thanks for reading.

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out /  Change )

Google photo

You are commenting using your Google account. Log Out /  Change )

Twitter picture

You are commenting using your Twitter account. Log Out /  Change )

Facebook photo

You are commenting using your Facebook account. Log Out /  Change )

Connecting to %s