C++ Development History

C++ traces its origins to 1979, when Bjarne Stroustrup began research at Bell Laboratories focused on computer science and software engineering. While working on complex software projects including simulations and operating systems, he identified limitations in the C programming language's expressiveness, maintainability, and scalability.

In 1983, Stroustrup added object-oriented programming features to C, creating the precursor to C++. This early implementation included core OOP concepts like classes, encapsulation, and inheritance, and the language was officially renamed C++ that same year.

Over the following years, C++ gained traction in both academic and industrial circles. Universities and research institutions adopted it for teaching and research, while corporations began integrating it into product development. The standard library and template features were refined during this period.

Standardization efforts for C++ launched in 1989, with a joint committee formed by ANSI and the International Organization for Standardization (ISO). The first standard draft was released in 1994; this draft retained all of Stroustrup's original design while adding new features. Shortly after, the committee voted to include the Standard Template Library (STL) — developed at Hewlett-Packard Laboratories by Alexander Stepanov, Meng Lee, and David R. Musser — into the C++ standard. Adding STL expanded C++ beyond its initial scope and delayed the final standardization process.

The joint committee approved the final standard draft on November 14, 1997, and the ANSI/ISO C++ standard was officially released in 1998.

Namespaces

Purpose of Namespaces

In C and C++, variables, functions, classes, and other identifiers exist in the global scope by default, which can lead to naming conflicts or "name pollution". Namespaces solve this problem by creating localized scopes for identifiers, preventing unintended collisions. The namespace keyword was introduced specifically to address this issue.

Defining Namespaces

To define a namespace, use the namespace keyword followed by a name, then a pair of curly braces containing the namespace members. Namespaces can include variables, functions, types, and other identifiers. A namespace defines a distinct scope separate from the global scope, allowing identical names to be used across different namespaces without conflict.

C++ supports multiple scope types: function local scope, global scope, namespace scope, and class scope. Scopes affect how the compiler resolves identifiers during compilation. Local and global scopes also impact variable lifetime, while namespace and clas scopes do not.

• Namespaces must be defined at the global scope, but can be nested inside other namespaces.
• Multiple files containing identically named namespaces are automatically merged into a single namespace.
• All C++ standard library components are contained within the std (standard) namespace.

Example 1: Basic Namespace Definition

#include <cstdio>
#include <cstdlib>

// Define a namespace for a project
namespace my_project {
    int random_val = 10;
    int add(int left, int right) {
        return left + right;
    }
    struct Node {
        struct Node* next;
        int value;
    };
}

int main() {
    // Accesses the standard library's rand function
    printf("%p\n", rand);
    // Accesses the variable within the my_project namespace
    printf("%d\n", my_project::random_val);
    return 0;
}

Example 2: Nested Namespaces

namespace my_project {
    namespace team_a {
        int random_val = 1;
        int add(int left, int right) {
            return left + right;
        }
    }

    namespace team_b {
        int random_val = 2;
        int add(int left, int right) {
            return (left + right) * 10;
        }
    }
}

int main() {
    printf("%d\n", my_project::team_a::random_val);
    printf("%d\n", my_project::team_b::random_val);
    printf("%d\n", my_project::team_a::add(1, 2));
    printf("%d\n", my_project::team_b::add(1, 2));
    return 0;
}

Example 3: Namespaces Across Multiple Files

// stack_utils.h
#pragma once
#include <cstdio>
#include <cstdlib>
#include <cstdbool>
#include <cassert>

namespace common_lib {
    typedef int StackDataType;
    typedef struct Stack {
        StackDataType* data;
        int top;
        int capacity;
    } Stack;

    void stack_init(Stack* stack, int initial_size);
    void stack_destroy(Stack* stack);
    void stack_push(Stack* stack, StackDataType value);
    void stack_pop(Stack* stack);
    StackDataType stack_top(Stack* stack);
    int stack_size(Stack* stack);
    bool stack_empty(Stack* stack);
}

// stack_utils.cpp
#include "stack_utils.h"

namespace common_lib {
    void stack_init(Stack* stack, int initial_size) {
        assert(stack);
        stack->data = static_cast<StackDataType*>(malloc(initial_size * sizeof(StackDataType)));
        stack->top = 0;
        stack->capacity = initial_size;
    }

    void stack_push(Stack* stack, StackDataType value) {
        assert(stack);
        if (stack->top == stack->capacity) {
            int new_capacity = stack->capacity == 0 ? 4 : stack->capacity * 2;
            StackDataType* temp = static_cast<StackDataType*>(realloc(stack->data, new_capacity * sizeof(StackDataType)));
            if (!temp) {
                perror("realloc failed");
                return;
            }
            stack->data = temp;
            stack->capacity = new_capacity;
        }
        stack->data[stack->top++] = value;
    }

    // Additional stack function implementations omitted for brevity
}

// queue_utils.h
#pragma once
#include <cstdlib>
#include <cstdbool>
#include <cassert>

namespace common_lib {
    typedef int QueueDataType;
    typedef struct QueueNode {
        int value;
        struct QueueNode* next;
    } QueueNode;
    typedef struct Queue {
        QueueNode* head;
        QueueNode* tail;
        int size;
    } Queue;

    void queue_init(Queue* queue);
    void queue_destroy(Queue* queue);
    void queue_push(Queue* queue, QueueDataType value);
    void queue_pop(Queue* queue);
    QueueDataType queue_front(Queue* queue);
    QueueDataType queue_back(Queue* queue);
    bool queue_empty(Queue* queue);
    int queue_size(Queue* queue);
}

// queue_utils.cpp
#include "queue_utils.h"

namespace common_lib {
    void queue_init(Queue* queue) {
        assert(queue);
        queue->head = nullptr;
        queue->tail = nullptr;
        queue->size = 0;
    }

    // Additional queue function implementations omitted for brevity
}

// test_main.cpp
#include "queue_utils.h"
#include "stack_utils.h"

// Global stack definition separate from common_lib
typedef struct Stack {
    int data[10];
    int top;
} LocalStack;

void local_stack_init(LocalStack* stack) {}
void local_stack_push(LocalStack* stack, int value) {}

int main() {
    // Use the global local stack
    LocalStack local_stack;
    local_stack_init(&local_stack);
    local_stack_push(&local_stack, 1);
    local_stack_push(&local_stack, 2);
    printf("Local stack size: %zu\n", sizeof(local_stack));

    // Use the common_lib stack
    common_lib::Stack lib_stack;
    common_lib::stack_init(&lib_stack, 4);
    common_lib::stack_push(&lib_stack, 1);
    common_lib::stack_push(&lib_stack, 2);
    printf("Common lib stack size: %zu\n", sizeof(lib_stack));
    return 0;
}

Using Namespaces

By default, the compiler searches only the local and global scopes when resolving identifiers, and will not look inside namespaces unless instructed. There are three standard ways to access identifiers within a namespace:

1. Fully Qualified Access: Prepend the namespace name and :: operator to the identifier. This is the recommended approach for production projects to avoid naming conflicts.
2. Import Single Member: Use the using keyword to import a single member from the namespace into the current scope. Useful for frequently accessed identifiers with no collision risk.
3. Import Entire Namespace: Use using namespace <namespace_name> to import all members of the namespace. Not recommended for production projects due to high collision risk, but convenient for small practice programs.

Example: Namespace Usage Methods

#include <cstdio>
namespace sample_ns {
    int val_a = 0;
    int val_b = 1;
}

// Fails to compile: identifier 'val_a' not found in scope
int main_broken() {
    printf("%d\n", val_a);
    return 1;
}

// Fully qualified access
int main_qualified() {
    printf("%d\n", sample_ns::val_a);
    return 0;
}

// Import single member
using sample_ns::val_b;
int main_single_import() {
    printf("%d\n", sample_ns::val_a);
    printf("%d\n", val_b);
    return 0;
}

// Import entire namespace
using namespace sample_ns;
int main_full_import() {
    printf("%d\n", val_a);
    printf("%d\n", val_b);
    return 0;
}

C++ Input and Output

C++ Input/Output (I/O) refers to the standard stream library, which defines core objects for standard input and output operations. Key components include:

• std::cin: An istream object for narrow-character standard input.
• std::cout: An ostream object for narrow-character standard output.
• std::endl: A stream manipulator that inserts a newline character and flushes the output buffer.
• The << (stream insertion) and >> (stream extraction) operators, repurposed from C's bitwise shift operators.

Unlike C's printf and scanf, C++ I/O automatically detects variable types via function overloading, eliminating the need for manual format specifiers. This also makes C++ I/O more flexible for custom types, though full implementation requires knowledge of classes and operator overloading.

All standard I/O components are part of the std namespace, so they must be accessed via namespace resolution unless imported. For casual practice, using namespace std is common, but production projects should avoid this to prevent collisions.

Example: Basic C++ I/O

#define _CRT_SECURE_NO_WARNINGS 1
#include <iostream>
using namespace std;

int main() {
    int int_val = 0;
    double double_val = 0.1;
    char char_val = 'x';

    // Output with full std qualifier
    std::cout << int_val << " " << double_val << " " << char_val << std::endl;
    // Output with using namespace std imported
    cout << int_val << " " << double_val << " " << char_val << endl;

    // C-style I/O for comparison
    scanf("%d%lf", &int_val, &double_val);
    printf("%d %.2lf\n", int_val, double_val);

    // C++ style input
    cin >> int_val;
    cin >> double_val >> char_val;
    cout << int_val << endl;
    cout << double_val << " " << char_val << endl;
    return 0;
}

Example: Optimized C++ I/O for High Throughput

#include <iostream>
using namespace std;

int main() {
    // Optimize I/O performance for large input/output operations
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);

    // I/O operations here
    return 0;
}

Default Arguments

A default argument is a pre-defined value assigned to a function parameter during its declaration or definition. When the function is called without providing a corresponding argument, the default value is used; if an argument is provided, it overrides the default. Default arguments are split into two categories:

• Full Default Arguments: All parameters have default values.
• Partial Default Arguments: Only some parameters have default values, which must be assigned consecutively starting from the rightmost parameter.

Additional rules for default arguments:

• Function arguments must be provided left-to-right, with no skipped parameters.
• Default arguments cannot be specified in both a function's declaration and definition; they must only be included in the declaration.

Example: Default Argument Basics

#include <iostream>
using namespace std;

void print_value(int a = 0) {
    cout << a << endl;
}

int main() {
    print_value(); // Uses default value 0
    print_value(10); // Uses provided argument 10
    return 0;
}

Example: Full and Partial Default Arguments

#include <iostream>
using namespace std;

// Full default arguments
void full_default_func(int a = 10, int b = 20, int c = 30) {
    cout << "a = " << a << ", b = " << b << ", c = " << c << endl << endl;
}

// Partial default arguments
void partial_default_func(int a, int b = 10, int c = 20) {
    cout << "a = " << a << ", b = " << b << ", c = " << c << endl << endl;
}

int main() {
    full_default_func();
    full_default_func(1);
    full_default_func(1, 2);
    full_default_func(1, 2, 3);
    partial_default_func(100);
    partial_default_func(100, 200);
    partial_default_func(100, 200, 300);
    return 0;
}

Function Overloading

C++ allows multiple functions with the same name to exist within the same scope, provided their parameter lists differ (either in number, type, or order of parameters). This enables function call polymorphism, making code more flexible. C does not support function overloading.

Note that differing return types alone do not qualify as overloading, as the compiler cannot resolve ambiguous calls without parameter context.

Example: Function Overloading Examples

#include <iostream>
#include <string>
using namespace std;

// Overload by parameter type
int add(int left, int right) {
    cout << "Integer addition function" << endl;
    return left + right;
}

double add(double left, double right) {
    cout << "Floating-point addition function" << endl;
    return left + right;
}

// Overload by parameter count
void greet() {
    cout << "Hello with no arguments" << endl;
}

void greet(string name) {
    cout << "Hello, " << name << "!" << endl;
}

// Overload by parameter order
void process(int a, char b) {
    cout << "Received int: " << a << ", char: " << b << endl;
}

void process(char b, int a) {
    cout << "Received char: " << b << ", int: " << a << endl;
}

int main() {
    add(5, 3);
    add(2.5, 3.5);
    greet();
    greet("Alice");
    process(10, 'z');
    process('y', 20);
    return 0;
}

References

Reference Concepts and Definition

A reference is an alias for an existing variable, and does not allocate separate memory. The reference and the original variable share the same memory location. The syntax for declaring a reference is type& reference_name = original_variable;. Note that the & symbol is repurposed here from C's address-of operator, so context is required to distinguish usage.

Reference Properties

• A reference must be initialized when declared.
• A single variable can have multiple references.
• Once a reference is bound to a variable, it cannot be rebound to another variable.

Common Reference Use Cases

References are primarily used for function parameters and return values to eliminate unnecessary copy operations and modify the original variable directly. Reference-based parameter passing works similarly to pointer parameter passing but is more concise.

Const References

A const reference can bind to a const object, and can also bind to a non-const object while restricting modification. Access permissions can only be narrowed, not expanded, via a reference. For example, binding a non-const int to a double will create a temporary int object, which requires a const reference to avoid undefined behavior.

Pointers vs. References

Pointers and references have overlapping functionality but distinct syntax and behavior:

• Pointers store the address of a variable and allocate memory, while references are aliases with no separate allocation.
• Pointers can be declared without initialization (though this is unsafe), while references must be initialized on declaration.
• Pointers can be reassigned to point to different variables, while references cannot be rebound after initialization.
• Pointers require dereferencing to access the target variable, while references access the target directly.
• The sizeof operator returns the size of the referenced type for a reference, while the size of a pointer depends on the platform (4 bytes on 32-bit systems, 8 bytes on 64-bit systems).
• Pointers are prone to null pointer and wild pointer errors, while references are generally safer.

Example: Reference Usage

#include <iostream>
using namespace std;

void swap(int& a, int& b) {
    int temp = a;
    a = b;
    b = temp;
}

int main() {
    int x = 10, y = 20;
    cout << "Before swap: x = " << x << ", y = " << y << endl;
    swap(x, y);
    cout << "After swap: x = " << x << ", y = " << y << endl;

    // Const reference example
    const int& ref = x;
    // ref = 30; // Compile error: cannot modify const reference
    cout << "Const reference value: " << ref << endl;

    // Binding to a temporary value
    double pi = 3.14159;
    const int& pi_int = pi; // Creates a temporary int from the double value
    cout << "Double value cast to int via const reference: " << pi_int << endl;
    return 0;
}

Inline Functions

An inline function is a function modified with the inline keyword. During compilation, the compiler will expand the function's code directly at each call site, eliminating the overhead of function stack frame creasion. Inline functions were introduced to replace C-style macro functions, which are error-prone and difficult to debug.

Key notes about inline functions:

• The inline keyword is a suggestion to the compiler, not a mandatory directive; the compiler may choose not to inline large or recursive functions.
• Inline functions should be short and frequently called to see performence benefits.
• Debug builds in Visual Studio do not enable inlining by default to support debugging; this can be adjusted in project settings.
• Inline functions should not have their declaration and definition separated across multiple files, as this can cause linker errors due to missing function symbols.

nullptr

In traditional C, the NULL macro is defined as either 0 or (void*)0, depending on the compiler and standard library implementation. This can cause unexpected behavior in C++ when using overloaded functions. For example, calling f(NULL) where there are overloads for int and int* may resolve to the int overload instead of the pointer overload, as NULL is defined as 0 in many C++ compilers.

C++11 introduced the nullptr keyword, which is a type-safe null pointer literal. nullptr can be implicitly converted to any pointer type, but cannot be converted to an integer type, eliminating the ambiguity associated with NULL.

Example: nullptr Usage

#include <iostream>
using namespace std;

void process_number(int x) {
    cout << "Processing integer: " << x << endl;
}

void process_pointer(int* ptr) {
    cout << "Processing pointer: " << (ptr ? "valid" : "null") << endl;
}

int main() {
    process_number(0);
    // Calls process_pointer correctly with nullptr
    process_pointer(nullptr);
    // May call process_number instead of process_pointer depending on NULL definition
    // process_pointer(NULL);
    return 0;
}