C++ emerged from Bell Labs in 1979, developed by Bjarne Stroustrup as an extension of the C language, incorporating object-oriented principles. It is characterized by high performance, low-level control, and object-oriented features.

The evolution of C++ reached a significant milestone with the release of the C++11 standard, which introduced modern features like type inference, lambdas, move semantics, and multithreading support, enhancing development efficiency.

C++ finds extensive use in gaming, graphics processing, and embedded systems. Major companies such as Tencent utilize C++ for game engines and client applications. It also serves as a foundational language for operating systems like Linux and Windows.

C++ integrates three programming paradigms:

• Procedural programming (from C)
• Object-oriented programming (classes added to C)
• Generic programming (suported via templates)

C++ builds upon C, inheriting its syntax and operators while extending it with new concepts. Both languages share many similarities, often referred to collectively as "C/C++". C++ is not a replacement for C but rather an enhanced version, fully compatible with C's features.

C++ Standards and Portability

For cross-platform compatibility, a C++ program must meet these criteria to run on new platforms without source code changes:

1. Use only standard C++ language elements and libraries
2. Avoid direct hardware access or platform-specific CPU instructions
3. Follow current ISO C++ standards and library definitions

Key factors for portability:

1. Hardware independence: Programs should avoid direct hardware interaction
2. Consistent implementation: Compilers must implement C++ standards uniformly across platforms

Standard versions include:

• C++98 (1998): First official standard
• C++03 (2003): Minor updates to C++98
• C++11 (2011): Introduced auto, lambdas, smart pointers
• C++14 (2014): Enhanced constexpr, binary literals
• C++17 (2017): Modules, parallel programming
• C++20 (2020): Ranges, concepts, variadic templates

C++ Advantages

C++ offers several key strengths:

Feature	Description
Portability	No virtual machine dependency; executables run directly on supported OS
Safety	Supports OOP, templates, exceptions to prevent resource leaks
Object-Oriented	Full support for classes, inheritance, polymorphism
Simplicity	Retains C simplicity while adding OOP features
Performance	Leading performance in games, graphics, embedded systems
Distributed	Supports networking and remote calls
Multithreading	C++11 adds native threading support
Robustness	Smart pointers, exception handling reduce crashes

Sample C++ Program

#include <iostream>
using namespace std;

int main(int argc, char* argv[]) {
    int a = 10;
    cout << "a: " << a << endl;
    cout << "Hello, World!" << endl;
    return 0;
}

Output:

a: 10
Hello, World!

Note:

1. C++ header files do not use .h extensions; e.g., math.h becomes cmath
2. Namespaces organize identifiers to preveent naming conflicts
3. cout is the standard output stream, endl outputs newline and flushes buffer

Namespaces in C++

Namespaces encapsulate identifiers (variables, functions, classes) to prevent naming collisions. The std namespace contains all standard library components.

Defining Namespaces

namespace myNamespace {
    int myVariable = 0;
    void myFunction() {
        // function implementation
    }
}

Access members using scope resolution operator :::

myNamespace::myVariable;
myNamespace::myFunction();

Nested Namespaces

namespace outerNamespace {
    int outerVar = 10;
    
    namespace nestedNamespace {
        void nestedFunction() {
            std::cout << "Inside nestedFunction" << std::endl;
        }
    }
    
    inline namespace inlineNamespace {
        void inlineFunction() {
            std::cout << "Inside inlineFunction" << std::endl;
        }
    }
}

namespace {
    void anonymousFunction() {
        std::cout << "Inside anonymousFunction" << std::endl;
    }
}

int main() {
    std::cout << "outerVar: " << outerNamespace::outerVar << std::endl;
    outerNamespace::nestedNamespace::nestedFunction();
    outerNamespace::inlineFunction();
    anonymousFunction();
    return 0;
}

Accessing Namespace Members

Several methods exist to access namespace contents:

1. Fully qualified names

MyNamespace::myFunction();
int value = MyNamespace::myVariable;

2. Using declarations

using MyNamespace::myFunction;
using MyNamespace::myVariable;
myFunction();
int value = myVariable;

3. Using directives

using namespace MyNamespace;
myFunction();
int value = myVariable;

4. Nested namespaces (C++17+)

namespace Outer::Inner {
    void innerFunction() {
        std::cout << "void innerFunction()" << std::endl;
    }
}

using namespace Outer::Inner;
innerFunction();

Namespace Scope Considerations

When multiple namespaces define the same identifier, explicit qualification is required:

#include <iostream>
using namespace std;

namespace A {
    int a = 10;
    int b = 66;
    int c = 108;
}

namespace B {
    int a = 10;
    int b = 6;
    int c = 109;
}

int a = 36;

using namespace A;
using namespace B;

int main() {
    cout << ::a << endl;      // Global 'a'
    cout << A::a << endl;     // Namespace A's 'a'
    // cout << b << endl;     // Ambiguous
    int c = 999;
    cout << c << endl;        // Local 'c'
    return 0;
}

Namespaces can be redefined across translation units, merging into one namespace during compilation.