C++ vs C: Key Differences Every Beginner Must Know

// This single file demonstrates the core philosophical difference.
// The C-style section uses raw functions and separate data.
// The C++ section bundles data and behavior into one class.

#include <iostream>   // C++ header for input/output (no .h extension)
#include <cstdio>     // C-style header wrapped for C++ use

// ── C-STYLE APPROACH ──────────────────────────────────────────────
// Data and functions are completely separate.
// Nothing stops someone from accidentally changing 'playerHealth' directly.
int playerHealth = 100;
int playerLevel  = 1;

void printPlayerStats_CStyle() {
    // We manually pass context — error-prone at scale
    printf("[C-Style] Player | Health: %d | Level: %d\n",
           playerHealth, playerLevel);
}

// ── C++-STYLE APPROACH ────────────────────────────────────────────
// Data AND behavior live together inside a class.
// Access is controlled — outsiders can't accidentally corrupt internal state.
class Player {
private:
    int health;   // only THIS class can directly touch these
    int level;

public:
    // Constructor — runs automatically when a Player object is created
    Player(int startHealth, int startLevel)
        : health(startHealth), level(startLevel) {}

    void printStats() {
        // std::cout is the C++ way to print — no format strings needed
        std::cout << "[C++ Style] Player | Health: " << health
                  << " | Level: " << level << "\n";
    }

    void takeDamage(int amount) {
        health -= amount;
        if (health < 0) health = 0; // validation lives HERE, not scattered everywhere
    }
};

int main() {
    // C-style: just call the function, data lives separately
    printPlayerStats_CStyle();

    // C++-style: create an object — data and behavior travel together
    Player hero(100, 1);
    hero.printStats();
    hero.takeDamage(30);
    hero.printStats();

    return 0;
}

#include <iostream>  // for std::cout, std::cin
#include <cstdio>    // for printf — showing both styles

// ── DIFFERENCE 1: INPUT/OUTPUT ────────────────────────────────────
void demonstrateIO() {
    int score = 42;
    double temperature = 36.6;

    // C-style: you MUST get the format specifier right (%d for int, %f for double)
    printf("C-style  | Score: %d | Temp: %.1f\n", score, temperature);

    // C++ style: << operator figures out the type for you — no %d needed
    std::cout << "C++ style| Score: " << score
              << " | Temp: " << temperature << "\n";
}

// ── DIFFERENCE 2: NAMESPACES ──────────────────────────────────────
namespace geometry {
    double calculateArea(double radius) {
        return 3.14159 * radius * radius;  // circle
    }
}

namespace agriculture {
    double calculateArea(double lengthMetres, double widthMetres) {
        return lengthMetres * widthMetres;  // field
    }
}
// Both named calculateArea — no clash because of namespaces!

// ── DIFFERENCE 3: REFERENCES vs POINTERS ─────────────────────────
void doubleValue_WithPointer(int* valuePtr) {
    *valuePtr = *valuePtr * 2;   // C-style: need * to dereference
}

void doubleValue_WithReference(int& valueRef) {
    valueRef = valueRef * 2;    // C++ style: looks like a normal variable!
    // No * needed. Reference can NEVER be null — that's the safety benefit.
}

// ── DIFFERENCE 4: FUNCTION OVERLOADING ───────────────────────────
// C would force you to name these calculateRectArea and calculateCircleArea
double calculateArea(int sideLength) {
    return sideLength * sideLength;  // square
}

double calculateArea(double radius) {
    return 3.14159 * radius * radius;  // circle
}
// C++ picks the right one based on the argument type you pass.

// ── DIFFERENCE 5: BOOL TYPE ───────────────────────────────────────
bool isAdult(int age) {
    return age >= 18;   // returns actual true/false, not 1/0
}

// ── DIFFERENCE 6: new/delete vs malloc/free ───────────────────────
struct GameConfig {
    int maxPlayers;
    bool soundEnabled;
    // In C++, we could add a constructor here and 'new' would call it
};

int main() {
    demonstrateIO();
    std::cout << "---\n";

    // Namespaces in action
    std::cout << "Circle area: " << geometry::calculateArea(5.0) << "\n";
    std::cout << "Field area : " << agriculture::calculateArea(10.0, 20.0) << "\n";
    std::cout << "---\n";

    // Reference vs pointer
    int playerScore = 50;
    doubleValue_WithPointer(&playerScore);   // must pass address with &
    std::cout << "After pointer double: " << playerScore << "\n";
    doubleValue_WithReference(playerScore);  // just pass the variable — cleaner!
    std::cout << "After reference double: " << playerScore << "\n";
    std::cout << "---\n";

    // Overloading
    std::cout << "Square area (int 4):    " << calculateArea(4) << "\n";
    std::cout << "Circle area (double 4): " << calculateArea(4.0) << "\n";
    std::cout << "---\n";

    // Bool
    std::cout << "Is age 20 adult? " << std::boolalpha << isAdult(20) << "\n";
    std::cout << "---\n";

    // new/delete
    GameConfig* config = new GameConfig();  // allocates AND could call constructor
    config->maxPlayers  = 4;
    config->soundEnabled = true;
    std::cout << "Max players: " << config->maxPlayers << "\n";
    delete config;  // deallocates AND could call destructor
    // malloc/free would NOT call any constructor or destructor

    return 0;
}

#include <iostream>
#include <string>

// ── C-STYLE BANK ACCOUNT ──────────────────────────────────────────
// Just a struct — data is fully exposed, anyone can corrupt it
struct BankAccount_CStyle {
    int    accountNumber;
    double balance;
    std::string ownerName;
};

// Functions are separate and unprotected — nothing stops direct: account.balance = -99999
void cStyle_deposit(BankAccount_CStyle& account, double amount) {
    if (amount > 0) account.balance += amount;
}

void cStyle_withdraw(BankAccount_CStyle& account, double amount) {
    if (amount > 0 && amount <= account.balance) account.balance -= amount;
}

// ── C++-STYLE BANK ACCOUNT ────────────────────────────────────────
class BankAccount {
private:
    // These fields are LOCKED — code outside this class cannot read OR write them directly
    int         accountNumber;
    double      balance;
    std::string ownerName;

public:
    // Constructor — runs automatically when a BankAccount object is created.
    // The colon syntax is an 'initialiser list' — it's the preferred way to set members.
    BankAccount(int number, std::string owner, double openingBalance)
        : accountNumber(number), ownerName(owner), balance(openingBalance) {
        std::cout << "Account #" << accountNumber
                  << " opened for " << ownerName << "\n";
    }

    // Destructor — runs automatically when this object goes out of scope
    ~BankAccount() {
        std::cout << "Account #" << accountNumber << " closed.\n";
    }

    // The ONLY way outsiders can deposit — validation is centralised here
    bool deposit(double amount) {
        if (amount <= 0) {
            std::cout << "Deposit rejected: amount must be positive.\n";
            return false;
        }
        balance += amount;
        std::cout << "Deposited $" << amount
                  << " | New balance: $" << balance << "\n";
        return true;
    }

    // The ONLY way outsiders can withdraw
    bool withdraw(double amount) {
        if (amount <= 0 || amount > balance) {
            std::cout << "Withdrawal rejected: insufficient funds or invalid amount.\n";
            return false;
        }
        balance -= amount;
        std::cout << "Withdrew $" << amount
                  << " | New balance: $" << balance << "\n";
        return true;
    }

    // A 'getter' — read-only access to balance. Outside code can't WRITE, only READ.
    double getBalance() const {   // 'const' means this function won't modify the object
        return balance;
    }
};

int main() {
    std::cout << "=== C-Style ==="  << "\n";
    BankAccount_CStyle oldAccount;
    oldAccount.accountNumber = 1001;
    oldAccount.ownerName     = "Alice";
    oldAccount.balance       = 500.0;
    cStyle_deposit(oldAccount, 200.0);
    // Nothing stops this — the language has no protection:
    oldAccount.balance = -99999;  // OOPS. Corruption is silent.
    std::cout << "Balance after corruption: $" << oldAccount.balance << "\n";

    std::cout << "\n=== C++ Style ===" << "\n";
    {
        // BankAccount constructor runs here automatically
        BankAccount modernAccount(2001, "Bob", 500.0);
        modernAccount.deposit(200.0);
        modernAccount.withdraw(100.0);
        modernAccount.withdraw(999.0);  // rejected by internal validation
        // modernAccount.balance = -99999;  // COMPILER ERROR if you uncomment this!
        std::cout << "Final balance: $" << modernAccount.getBalance() << "\n";
        // Destructor runs automatically here when modernAccount leaves this scope block
    }

    return 0;
}

#include <iostream>
#include <vector>    // C++ standard library container — no C equivalent
#include <string>
#include <algorithm> // for std::sort

// ── SCENARIO: Managing a list of student scores ───────────────────
//
// C approach: manually manage an array + a count variable.
// You handle every allocation and bounds check yourself.
void cStyle_StudentScores() {
    // Fixed-size array — you must choose the size upfront
    const int MAX_STUDENTS = 5;
    int scores[MAX_STUDENTS] = {72, 88, 55, 91, 63};
    int studentCount = MAX_STUDENTS;

    // Manual bubble sort — must write sorting logic yourself
    for (int pass = 0; pass < studentCount - 1; ++pass) {
        for (int i = 0; i < studentCount - 1 - pass; ++i) {
            if (scores[i] > scores[i + 1]) {
                int temp     = scores[i];
                scores[i]   = scores[i + 1];
                scores[i+1] = temp;
            }
        }
    }

    std::cout << "[C-Style] Sorted scores: ";
    for (int i = 0; i < studentCount; ++i) {
        std::cout << scores[i] << " ";
    }
    std::cout << "\n";
}

// ── C++ approach: std::vector grows automatically, std::sort just works ──
void cppStyle_StudentScores() {
    // vector grows dynamically — no MAX_STUDENTS constant needed
    std::vector<int> scores = {72, 88, 55, 91, 63};

    scores.push_back(79);  // add a score at runtime — vector handles the memory
    scores.push_back(44);

    // std::sort: one line, battle-tested, handles all edge cases
    std::sort(scores.begin(), scores.end());

    std::cout << "[C++ Style] Sorted scores ("
              << scores.size() << " students): ";
    // Range-based for loop — C++ only, much cleaner than index loop
    for (int score : scores) {
        std::cout << score << " ";
    }
    std::cout << "\n";

    // No manual memory management — vector cleans itself up automatically
}

int main() {
    cStyle_StudentScores();
    cppStyle_StudentScores();
    return 0;
}