This topic is about avoiding name conflicts and structuring large programs properly.

Part 1: Namespaces

What is a Namespace?

A namespace is a declarative region that provides a scope to identifiers (variables, functions, classes).

It prevents name collisions in large projects.

Why It Is Needed

Suppose two libraries define a function called print():

void print();   // Library A
void print();   // Library B

The compiler cannot distinguish between them.

Namespaces solve this problem.

Basic Syntax

namespace LibraryA {
    void print() {
        std::cout << "From A";
    }
}

namespace LibraryB {
    void print() {
        std::cout << "From B";
    }
}

Calling them:

LibraryA::print();
LibraryB::print();

The :: is called the scope resolution operator.

Standard Namespace (std)

The C++ Standard Library is inside the std namespace.

Example:

std::cout << "Hello";
std::vector<int> v;

If you write:

using namespace std;

You don’t need std:: everywhere.

But in professional code, this is discouraged in header files because it may cause conflicts.

Using Specific Members

Better approach:

using std::cout;
using std::endl;

This imports only specific names.

Nested Namespaces

namespace Company {
    namespace Project {
        void run();
    }
}

Access:

Company::Project::run();

Modern C++ (C++17):

namespace Company::Project {
    void run();
}

Anonymous Namespace

Used for internal linkage (like static).

namespace {
    int secret = 10;
}

Variables/functions inside anonymous namespace are accessible only in that file.

Part 2: Header Organization

In large C++ projects, code is divided into:

• Header files (.h or .hpp)

• Source files (.cpp)

What Goes in Header File?

Header files contain:

• Class declarations

• Function declarations

• Templates

• Constants

• Inline functions

Example: math_utils.h

#ifndef MATH_UTILS_H
#define MATH_UTILS_H

namespace MathUtils {
    int add(int a, int b);
}

#endif

Include Guards

Prevent multiple inclusion.

#ifndef HEADER_NAME
#define HEADER_NAME

// content

#endif

Without include guards, you get redefinition errors.

Modern alternative:

#pragma once

What Goes in Source File?

Implementation.

Example: math_utils.cpp

#include "math_utils.h"

namespace MathUtils {
    int add(int a, int b) {
        return a + b;
    }
}

Important Rules (Very Important for Exams & Interviews)

1. Never write using namespace std; inside header files.

2. Use include guards or #pragma once.

3. Keep headers lightweight.

4. Do not include unnecessary headers.

5. Separate interface (header) from implementation (source).

Why This Topic Is Important

• Required in large-scale software development.

• Prevents naming conflicts.

• Essential for modular programming.

• Core concept for library design.

• Frequently asked in interviews.