C++ is a robust, high-performance programming language widely utilized in system software, game engines, embedded systems, and high-performance computing. Extending the C language, it introduces Object-Oriented Programming (OOP) features that enhance code modularity and reusability. This guide covers the foundational syntax and concepts necessary to begin programming in C++.

1. The First C++ Program

---

C++ maintains backward compatibility with C, so standard C syntax functions correctly. However, C++ source files typically use the .cpp extension. While you can use C-style input/output, the idiomatic C++ approach leverages the standard input/output stream library.

// main.cpp
#include <iostream>
// utilizing the standard namespace
using namespace std;

int main() {
    // Use cout for standard output
    cout << "Hello, World!" << endl;
    return 0;
}

2. Namespaces

---

In large projects, naming collisions between variables, functions, and classes in the global scope are common. Namespaces provide a mechanism to organize identifiers into logical scopes, preventing name pollution.

Defining Namespaces

A namespace is defined using the namespace keyword followed by the desired name and a code block. It creates a separate scope that can encapsulate variables, functions, and types. Namespaces can be nested, and definitions across different files with the same name are treated as part of the same namespace. The C++ Standard Library is contained with in the std namespace.

#include <iostream>
using namespace std;

namespace MathUtils {
    int constantValue = 42;
    
    int Multiply(int x, int y) {
        return x * y;
    }
}

int main() {
    // Accessing the global constant
    cout << "Global access example..." << endl;
    
    // Accessing the namespace member explicitly
    cout << "MathUtils::constantValue = " << MathUtils::constantValue << endl;
    
    return 0;
}

3. Input and Output Streams

---

The <iostream> library defines the standard input and output objects.

• std::cin: An object of the istream class used for standard input (usually keyboard).
• std::cout: An object of the ostream class used for standard output (usually console).
• std::endl: A manipulator that inserts a newline character and flushes the buffer.
• Operators: << is the stream insertion operator, and >> is the stream extraction operator.

Unlike C's printf and scanf, C++ I/O streams automatically recognize variable types, eliminating the need for format specifiers.

#include <iostream>
using namespace std;

int main() {
    int id = 0;
    double score = 0.0;
    char grade = 'A';

    // Output operation
    cout << "ID: " << id << ", Score: " << score << ", Grade: " << grade << endl;

    // Input operation (automatically detects type)
    cout << "Enter ID, Score, and Grade: ";
    cin >> id >> score >> grade;

    cout << "Updated Data: " << id << " " << score << " " << grade << endl;
    return 0;
}

4. Default Arguments

---

Default arguments allow you to specify a value for a parameter in the function declaration or definition. If the caller omits the argument, the default value is used. These can be fully specified (all parameters) or partially specified (only some parameters). In partial defaulting, parameters with defaults must apppear consecutively at the end of the parameter list.

#include <iostream>
using namespace std;

// Fully default arguments
void DisplayInfo(int year = 2023, int month = 1, int day = 1) {
    cout << "Date: " << year << "-" << month << "-" << day << endl;
}

// Partially default arguments
void LogMessage(int priority, string text = "System OK") {
    cout << "[" << priority << "] " << text << endl;
}

int main() {
    DisplayInfo();          // Uses 2023, 1, 1
    DisplayInfo(2024);      // Uses 2024, 1, 1
    DisplayInfo(2024, 5);   // Uses 2024, 5, 1
    
    LogMessage(1);          // Uses default text
    LogMessage(2, "Warning"); // Uses provided text
    return 0;
}

5. Function Overloading

---

C++ allows multiple functions to share the same name within the same scope, provided they have different parameter lists. This difference can be in the number of parameters or their data types. This enables compile-time polymorphism.

#include <iostream>
using namespace std;

// Overloaded based on parameter type
int Calculate(int a, int b) {
    cout << "Integer calculation" << endl;
    return a + b;
}

double Calculate(double a, double b) {
    cout << "Double calculation" << endl;
    return a + b;
}

// Overloaded based on parameter count
void ShowData(int id) {
    cout << "ID: " << id << endl;
}

void ShowData(int id, string name) {
    cout << "ID: " << id << ", Name: " << name << endl;
}

int main() {
    Calculate(10, 20);
    Calculate(5.5, 2.2);
    ShowData(101);
    ShowData(102, "Alice");
    return 0;
}

6. References

---

Concept

A reference is an alias for an existing variable. Unlike pointers, references do not occupy their own memory space; they simply refer to the memory location of the target variable.

#include <iostream>
using namespace std;

int main() {
    int original = 100;
    // ref is an alias for original
    int& ref = original;
    
    // Modifying ref affects original
    ref = 200;
    
    cout << "Original: " << original << endl; // Outputs 200
    cout << "Address of original: " << &original << endl;
    cout << "Address of ref: " << &ref << endl;
    return 0;
}

Characteristics

1. References must be initialized when defined.
2. A variable can have multiple references.
3. Once initialized, a reference cannot be changed to refer to another entity.

Pointers vs. References

While references are often safer due to their inability to be null or re-bound, pointers offer more flexibility in memory management and iteration. References are generally preferred for function parameters where modification of the argument is required without the complexity of pointer syntax.

7. Inline Functions

---

The inline keyword suggests to the compiler that the function body should be expanded at the call site rather than generating a standard function call. This can reduce the overhead of stack frame creation for small, frequently called functions.

#include <iostream>
using namespace std;

inline int Square(int x) {
    return x * x;
}

int main() {
    int result = Square(5);
    cout << "Square of 5: " << result << endl;
    return 0;
}

Note that inline is a request; the compiler may ignore it for complex functions, such as recursive functions or those with large bodies. Inline functions are typically defined in header files to avoid linker errors.

8. The nullptr Keyword

---

In legacy C++, NULL is often defined as the integer 0. This can cause ambiguity in function overloading where both int and pointer types are acceptable. C++11 introduced nullptr, a strongly-typed null pointer constant that converts implicitly to any pointer type but not to integer types.

#include <iostream>
using namespace std;

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

void Process(char* ptr) {
    if (ptr)
        cout << "Processing pointer: " << ptr << endl;
    else
        cout << "Pointer is null" << endl;
}

int main() {
    Process(0);       // Calls Process(int)
    // Process(NULL); // Ambiguous, usually calls Process(int)
    
    // Clearly calls the pointer version
    Process(nullptr); 
    
    return 0;
}