The C and C++ Club : At a glance


Modern C++ has been there for quite some time. It has been almost a decade since it was first introduced; C++ 11 being the first standard modern C++. Since then, three standards have been added viz. C++14, C++17 and now C++20. Though, full backward compatibility to classical C++ a.k.a C++98/03 has been retained, for obvious reasons, modern C++ philosophy is different from that of C++98. Or rather, I would say modern C++ facilitates a programmer to express his/her ideas more profoundly. I will consider C++ as a highly philosophical language, mostly achieved through its elegant abstractions and model of execution.

C++ is a complex programming language, or one can call it a savvy-friendly programming language. Modern C++ has introduced lots of useful features, but certainly it has become more complex. But once you begin to understand the philosophy of this language, you will begin to realize the elegance of its simplicity.

The three foundation pillars of classical C++ are the ‘C’ subset, features for object-oriented programming and generic programming using templates. But modern C++, in addition to these, has introduced lot more features. Support for concurrent programming using threads and its associated features, ‘r-value’ references and ‘move’ semantics, smart pointers such as unique pointer, shared pointer and weak pointer are the major additions to modern C++. Of course, there are other additions that includes the ‘auto’ keyword, ‘decltype’, initializer_list, lambdas, constexpr, class template type/argument deduction, ‘nullptr’, enum classes, variadic templates, static_assert, ranged ‘for’ loops, ‘noexcept’ keyword, ‘default’ keyword, a dedicated ‘override’ keyword etcetera. Modern C++ has come a long way since C++ 98/03.

One does not have to necessarily understand all these modern features to start working on real projects in modern C++. But as I said, one has to at least grasp the major features of modern C++, such as ‘r-value’ reference and ‘move’ semantics, ownership management using smart-pointers and the basics of threads.

On this blog, I focus on the major philosophical aspects of modern C++. I also have detailed about classical C++ and its three main pillars: the ‘C’ subset, object orientation and generic programming using templates. The blog has a partitioned layout.

Part 1 is about the philosophy of ‘C’ – data abstraction, address abstraction, composite data types in ‘C’, and about the stacks in ‘C’ and how it is related to the execution model of ‘C’.

Part 2 and Part 3 illustrates the journey from classical to modern C++ and the major philosophical aspects in detail.

Part 2 is about philosophy of C++, how it achieves object orientation with classes, inheritance, polymorphism etc, what all are the main abstractions for object orientation, how compile-time and run-time polymorphism is achieved, object management model, object life-cycle management, constructors, destructors in detail, copy and move semantics in modern C++ etc.

Part 3 is about generic programming in C++, template functions and template classes, variadic templates, introduction to template specialization illustrating the working of smart pointers such as unique pointers and shared pointers, and finally about threads and concurrency.

Part 4 is a series on Design Patterns with modern C++. Implementation of realistic examples using patterns such as singleton, factory method, command, composite, observer, decorator, strategy, state, and bridge are detailed in this series.

Part 5 is about application of C++ that details how important data structures such as binary search tree, hash tables, custom arrays, queues, stacks etc. can be implemented in C++.

This blog does not teach you ‘C’ or ‘C++’ from scratch, and hence, is not an introductory material. This blog is for advancing your skills in modern C++ by understanding the philosophical essence of the language and understanding how it works. I hope that this blog will be helpful and will be a great online resource.

Let us see the topics that I’ve covered on this blog, chapter wise


Philosophy Aspects Covered

Chapter 1 :
C’s Abstraction Mechanisms


The simplicity of ‘C’ and it’s power – the art of abstracting data, Storing Integers – the magic of byte ordering and packing them together, Storing negative numbers – adding a negative sign ‘-‘ just isn’t enough, Let us fix our perception of floating point numbers.


Chapter 2 :
Address Abstraction

Address abstraction underneath the arrays, Array size – does it really matter to the compiler or to the programmer? Negative indexes on arrays – seriously? Does it work? Function-addresses and how to use them correctly?


Chapter 3 :

Introduction to composite data types, The wonders of union: Vagaries of behavior, Same memory different perspectives, Elegant use of unions for mitigating bit manipulation.


Chapter 4 :
The Stacks In C

Stacks and its mysteries, C’s execution model and its companionship with stacks, The famous stack frames of ‘C’, Functions returning big values, Parameter size promotion – The size-default and integers, Variadic function and stack manipulation, The labyrinth of stack corruption – do all roads lead to Rome or can we take another path?


Chapter 5 :
The Philosophy Of C++, Part A

Introduction : The three aspects of C++, Classes – establishing behaviors, Objects – manifestation of behaviors, achieving uniqueness, How big an object really is ?, Code Reuse – Inheritance, late binding and achieving polymorphism, Name mangling and how to decrypt C++’s generated mangled naming convention, Code to base class idiom, Static classes, Static member functions, initializing, working and their intricacies, Making friends, putting enums to use, introduction to operator overloading.


Chapter 6 :
The Philosophy Of C++, Part B

Introduction to object management, The beauty of creation with constructors, The horrors of wandering : Resource leakage, destructors to the rescue, Virtual destructors and their significance, The principle of Resource Acquisition Is Initialization (RAII), Establishing class invariants, Making copies via copy constructors and copy assignment operators, The dangers of shallow copy and understanding deep copy, Moving objects via move constructors and move assignment operators, Compiler defaults, their vagaries in copying and moving objects.


Chapter 7 :
The Philosophy Of C++, Part C

Introduction to cloning idiom in C++, Derived class objects and the copy conundrum, How to clone correctly?, Moving objects of derived classes.


Chapter 8 :
The Philosophy Of Generic Programming In C++

Introduction to generic programming, Three stages of template programming, Variadic templates and parameter packages, Containers for storage, The elegance of C++ Standard Template Library; Meet the STL’s three musketeers : containers – iterators – algorithms, Let’s write an Array class, make it generic, and support iterators, Improvising object construction using std::initializer_lists.


Chapter 9 :
Introduction To Template Specialization In C++

Introduction to template specialization, Selective method to teach template specialization in C++, Use-case – Improvising our Unique_Ptr class from chapter 8 to add

Array support using template specialization, default custom deleters using template specialization and default template parameters.

Chapter 10 :
Shared Pointers, An Introduction To Atomics In C++


Sharing ownership via Shared Pointers and their need, Atomics in Shared pointer.


Chapter 11 :
Threads In C++ And Concurrency

Concurrency achieved via threads – parallel execution units, Let’s understand the subtleties : Task, Process and Threads

Learn about process abstraction, Let’s spawn a process – what are the essential steps that every programmer must understand, Threads and their inherent issues – race conditions and same time access, Mutex locks and Condition Variables, Let’s guard our thread using thread guards, How to mitigate issues with concurrent execution using C++ facilities, Mutually Exclusive  Locks a.k.a mutex locks, lock ownership and management in C++, Let’s implement a Queue, Let’s implement a thread-safe queue – classic producer-consumer pattern


Chapter 12 :
Series On Design Patterns – Factory Method

Factory Method and abstracting the creation, How to implement Factory method in the modern C++ way


Chapter 13 :

Series On Design Patterns –

Command Pattern


Understanding a behavioral design pattern with command pattern, How we implemented command in classic C++ (C++ 98) way, How we should implement command in modern C++ way, Let us understand how GUI elements like Menu and Menu Items work, and how a button click execute actions?


Chapter 14 :
Series On Design Patterns –

Observer Pattern


Let us observe a subject closely, how we can improvise our Document editor application with observer pattern, Document editor application is now 2.0 !


Chapter 15 :
Series On Design Patterns – Composite Pattern

Composites, containers and primitives, Document Editor Application is now version 3.0!


Chapter 16 :
Series On Design Patterns – Decorator Pattern

Let us decorate objects, Inheritance misuse, Decorating windows on screen!


Chapter 17 :
Series On Design Patterns – Strategy Pattern

Let us strategize before action, Document Editor App is now version 4.0!


Chapter 18 :
Series On Design Patterns – Singleton Pattern

Playing safe with singletons – how to incorporate singleton design pattern in multi-threaded environment, Let’s put singleton and concurrency into action with our logger class.


Chapter 19 :
Series On Design Patterns – State Pattern

Delegating state manipulation using state objects, Let us turn on a bulb!

Chapter 20 :
Series On Design Patterns – Bridge Pattern

Let us bridge the abstracts and the implementation entities, Let us turn on an incandescent bulb and adjust its brightness, Let us make a florescent bulb as well.


Chapter 21 :
Data Structures With C++ – Binary Search Tree

The simplicity of linear data structures – revisiting our custom Array, Queue, The algorithmic efficiency of non-linear data structures, Understanding Binary Search Tree (BST) and how to implement one in C++, What all things to consider in deleting a node in a BST


Chapter 22 :
Data Structures With C++ – Hash Tables

Understanding Hash Tables, hash functions, hash buckets, How to implement a custom Hash table that can store integers and strings.


Chapter 23 :

Implementing A Custom Heap

How to implement a custom heap in C++

How to overload new and delete to make use of custom heap



Let us start the Journey!

Go to chapter 1 >>