History of C++ program

The history of C++ traces its roots back to the late 1970s when Bjarne Stroustrup, a Danish computer scientist, began working on what would later become C++. Here’s a more detailed timeline of the development of C++:

1979: Inception at Bell Labs:

Bjarne Stroustrup started working on “C with Classes” at Bell Labs. This language was an extension of the C programming language, introducing the concept of classes for object-oriented programming.

Early C++ Features:

  • Classes: Encapsulate employee data and functions within a Employee class.
  • Constructors: Initialize an Employee object with name, department, and initial salary.
  • Member functions: Define functions like raiseSalaryprintEmployeeInfo within the class.
  • Pointers: Access and manipulate employee objects dynamically using pointers.

1983: Renaming to C++:

The language was officially renamed C++ in 1983. The name reflects the use of increment operators in C and the evolutionary nature of the language. The “++” signifies an improvement over C.

Early C++ Features (circa 1983):

  • Classes: Encapsulate state and behavior related to traffic lights (e.g., TrafficLight).
  • Member functions: Define internal functions for each class like changeState().
  • Constructors: Initialize objects with starting states.
  • Operator overloading: Extend operators like ++ to change traffic light states.
  • Dynamic memory allocation: Allocate memory for traffic light objects at runtime using new

1985: First Edition of “The C++ Programming Language”:

Bjarne Stroustrup published the first edition of his book, “The C++ Programming Language.” This book became a seminal work and played a crucial role in popularizing C++.

C++ Features in 1985 (based on “The C++ Programming Language” first edition):

  • Functions: Define reusable blocks of code with input and output parameters.
  • Function overloading: Create multiple functions with the same name but different parameter types.
  • Arrays: Store sequences of data elements of the same type.
  • Pointers: Access and manipulate memory locations dynamically.
  • Operator overloading (limited): Extend predefined operators like + for custom data types.

1989: Release of C++ 2.0:

The second version of C++, C++ 2.0, was released. It included multiple inheritance, abstract classes, static member functions, and const member functions.

C++ 2.0 Key Features:

  • Multiple Inheritance: A class can inherit from multiple parent classes, enabling complex behavior combinations.
  • Abstract Classes: Define base classes with pure virtual functions, enforcing specific functionality in derived classes.
  • Static Member Functions: Define class-level functions that operate on the class itself, not specific objects.

1990: ANSI Standardization:

The American National Standards Institute (ANSI) standardized C++ for the first time, which helped in establishing a common set of rules and features for the language.

C++ Features Relevant to ANSI Standardization:

  • Operator overloading: Extend operators like +-*, and / to work with custom data types like numbers and expressions.
  • Templates: Define generic functions or classes that work with different data types without code duplication.
  • Standard Template Library (STL): Access pre-built data structures like stacks for efficient expression parsing.
  • Exceptions:

1998: ISO/IEC Standardization (C++98):

The International Organization for Standardization (ISO) released the first international standard for C++, known as C++98. This standardization was significant for ensuring portability and consistency across different implementations.

C++98 Key Features:

  • Standard Template Library (STL) enhancements: Powerful and versatile algorithms like findsort, and iterators for improved data manipulation.
  • Namespaces: Organize code into logical named scopes to avoid name collisions and enhance code structure.
  • Exception handling improvements: More refined exception specifications and improved handling capabilities.
  • Rvalue references: Capture temporary values efficiently for improved performance and resource management.
  • Lambda expressions: Define anonymous inline functions, streamlining code and enhancing conciseness.

2003: C++03 Standard:

A minor update to the C++98 standard was released, known as C++03. It addressed some issues and made clarifications but did not introduce major language changes.

C++03 Key Aspects:

  • Bug fixes: Resolved inconsistencies and ambiguities in C++98 specifications, leading to greater code reliability and compatibility.
  • Value initialization: Automatically initializes variables with default values for their types, simplifying initializations and enhancing conciseness.

2011: C++11 Standard:

C++ underwent a major overhaul with the release of C++11. This update introduced features such as auto keywords, lambda expressions, smart pointers, and a range-based for loop, significantly enhancing the language’s expressiveness and productivity.

C++11 Key Features:

  • Lambda expressions: Define anonymous functions in place, enhancing readability and conciseness.
  • Range-based for loop: Iterate over container elements without manual indexing, simplifying common loops.
  • Auto type deduction: Let the compiler infer variable types, reducing boilerplate and improving readability.
  • Move semantics: Efficiently transfer ownership of resources with minimal overhead, reducing memory copies.
  • Smart pointers: Manage memory automatically, preventing leaks and simplifying resource management.

2014: C++14 Standard:

C++14 was a minor update to C++11, introducing bug fixes and small improvements without major language changes.

C++14 Key Features:

  • Extended auto type deduction: Infer types even in more complex situations, like return values of lambda expressions.
  • Template lambdas: Define generic lambdas that can work with different data types.
  • Binary literals: Represent binary numbers directly in the code for easier bit manipulation.
  • Generic lambdas in STL algorithms: Utilize lambdas directly with standard library algorithms like std::transform.

2017: C++17 Standard:

C++17 brought several new features and improvements, including structured bindings, filesystem libraries, and parallel algorithms.

C++17 Key Features:

  • Structured bindings: Unpack elements from containers or returned values directly into variables, simplifying nested access and improving code readability.
  • Fold expressions: Perform repeated operations on a range of elements in a concise and readable way.
  • Template argument deduction: Let the compiler infer template arguments automatically based on the context, reducing boilerplate and potential errors.
  • constexpr if: Perform compile-time conditional evaluation based on constant expressions, enabling optimizations and generating efficient code.

2020: C++20 Standard:

The journey of C++20 as a standard spans several years of development and contributions from the global C++ community. Here’s a look at its key milestones:

  • 2011: The Working Group 21 (WG21) responsible for C++ evolution starts exploring potential features for the next standard, initially dubbed “C++17.”
  • 2014: Early proposals for concepts, ranges, and other major features are submitted and discussed. Initial prototypes and testing begin.
  • 2017: C++17 is finalized and released, laying the groundwork for some later C++20 features like modules and lambda improvements.
  • 2018: Focus shifts to C++20, with active development and refinement of proposed features based on community feedback and experimental implementations.
  • February 2020: WG21 reaches technical consensus on C++20 features at a meeting in Prague.
  • March 2020: The final draft of the C++20 standard is announced.
  • September 2020: C++20 is officially approved by the ISO/IEC Joint Technical Committee.
  • December 2020: The C++20 standard (ISO/IEC 14882:2020) is formally published, making it available for developers to start using.
  • Post-2020: Ongoing work on documentation, compiler implementations, libraries, and educational resources to support widespread adoption of C++20 features.


C++ continues to evolve, with ongoing efforts to enhance the language’s capabilities, address shortcomings, and provide better support for modern software development practices. The language remains a vital tool in various domains, from system programming to high-performance applications.

Share this post:

Newsletter Updates

Enter your email address below and subscribe to our newsletter