The primary distinctions between C++ and C programming languages encompasss several fundamental aspects of modern software development:

• Memory Management: C++ utilizes new and delete operators, while C relies on malloc and free functions
• Input/Output Systems: C++ implements the iostream library with istream and ostream classes for character stream handling, replacing C's stdio standard library
• String Handling: C++ provides built-in string classes that eliminate the need for C's character array manipulation functions
• Error Handling: C++ employs try/catch/throw exception mechanisms instead of C's setjmp() and longjmp() functions
• Function Overloading: C++ supports function overloading based on parameter types or counts, which C does not support
• Variable Declaration: C++ allows variable declaration anywhere before usage, while C requires declarations at function beginning
• Reference Types: C++ introduces reference variables, absent in C
• Namespaces: C++ includes namespace functionality for name collision prevention, unavailable in C

Namespace Functionality

Namespaces serve to prevent naming conflicts and follow specific implementation rules:

1. Namespaces must be defined at global scope level
2. Namespaces support nesting capabilities
3. Additional members can be added to existing namespaces at any time

Basic Namespace Example:

namespace Container {
    int value_x = 500;
    int value_y = 600;
}

// Adding new member to existing namespace Container
namespace Container {
    int value_z = 700;
}

void demonstrate_namespace_access() {
    std::cout << "Container value_x: " << Container::value_x << std::endl; // Output: 500
    std::cout << "Container value_z: " << Container::value_z << std::endl; // Output: 700
}

Namespace Content Storage:

Namespaces can contain both variables and functions:

namespace DataStore {
    int data_field = 800; // Variable storage
    
    void process_data() { // Function definition
        std::cout << "Processing data with value: " << data_field << std::endl;
    }
}

void demonstrate_content_usage() {
    // Accessing stored variable
    std::cout << "DataStore field: " << DataStore::data_field << std::endl;
    
    // Invoking stored function
    DataStore::process_data();
}

External Function Definition:

Namespace functions can be defined outside the namespace block:

namespace Module {
    int module_var = 900; // Stored variable
    
    void execute_operation(); // Forward declaration
}

void Module::execute_operation() { // External definition with scope resolution
    // Direct access to namespace members without scope operator
    std::cout << "Executing with module_var: " << module_var << std::endl;
}

void regular_function() { // Standard function
    std::cout << "Accessing module_var: " << Module::module_var << std::endl;
}

void demonstrate_external_definition() {
    Module::execute_operation();
    regular_function();
}

Anonymous Namespaces:

Unnamed namespaces provide file-local scope similar to static function modifiers, restricting access to the current file only.

Namespace Aliasing:

Namespaces can be assigned aliases for convenience:

namespace extremely_verbose_name {
    int counter = 15;
    
    void display_message() { 
        std::cout << "Greetings from namespace" << std::endl; 
    }
}

void demonstration_function() {
    namespace alias = extremely_verbose_name;
    std::cout << "Using alias - counter value: " << alias::counter << std::endl;
    extremely_verbose_name::display_message();
    alias::display_message();
}