Advanced OOP in C++

#include <iostream>
using namespace std;

class BankAccount {
    static int accountCount;   // ONE shared copy for the whole class
    int balance;               // each object has its OWN balance
public:
    BankAccount(int opening) : balance(opening) {
        ++accountCount;        // every new account bumps the shared counter
    }
    // A static method belongs to the class, not to any one object.
    // It can only touch static members (there's no 'this').
    static int howMany() { retur
...

#include <iostream>
using namespace std;

class Player {
    static int playerCount;   // shared across ALL players
    string name;
public:
    // 🎯 YOUR TURN — fill in the ___ blanks, then press "Try it Yourself".

    Player(string n) : name(n) {
        // 1) Increase the shared counter by one each time a Player is made
        ___;                  // 👉 ++playerCount;
    }

    // 2) Write a STATIC method that returns the count
    static int count() { return ___; }   // 👉 playerCount


...

#include <iostream>
using namespace std;

class Vault {
    int secretCode;   // private — normally untouchable from outside
public:
    Vault(int code) : secretCode(code) {}

    // Grant ONE function access to our private members:
    friend void reveal(const Vault& v);

    // Grant a whole class access:
    friend class Auditor;
};

// 'reveal' is a free function, yet it can read secretCode:
void reveal(const Vault& v) {
    cout << "Vault code is: " << v.secretCode << endl;  // 4242
}

clas
...

#include <iostream>
using namespace std;

// Base shared by both sides of the diamond.
class Device {
protected:
    string serial;
public:
    // 'virtual public' keeps ONLY ONE Device inside MultiFunctionPrinter.
    Device(string sn) : serial(sn) {
        cout << "Device(" << sn << ") built" << endl;
    }
    virtual ~Device() = default;   // virtual dtor for safe deletion
    string getSerial() const { return serial; }
};

class Printer : virtual public Device {   // note: virtual
public:

...

#include <iostream>
using namespace std;

// A type is "polymorphic" once it has a virtual function — that's what
// makes dynamic_cast and RTTI possible (they read the hidden vtable).
class Animal {
public:
    virtual void speak() const { cout << "..." << endl; }
    virtual ~Animal() = default;
};

class Dog : public Animal {
public:
    void speak() const override { cout << "Woof" << endl; } // override = checked
    void fetch() const { cout << "Dog fetches the ball" << endl; }
};

// 'fina
...

#include <iostream>
using namespace std;

class Shape {
public:
    virtual double area() const = 0;   // pure virtual -> polymorphic type
    virtual ~Shape() = default;
};

class Circle : public Shape {
    double r;
public:
    Circle(double radius) : r(radius) {}
    double area() const override { return 3.14159 * r * r; }
    double radius() const { return r; }
};

class Square : public Shape {
    double s;
public:
    Square(double side) : s(side) {}
    double area() const override { ret
...

#include <iostream>
#include <cstring>
using namespace std;

// This class OWNS a raw resource (heap memory), so it must manage copying
// and moving itself — the "rule of five".
class Buffer {
    char* data;
    size_t size;
public:
    // Constructor — acquire the resource
    Buffer(const char* s) : size(strlen(s)) {
        data = new char[size + 1];
        strcpy(data, s);
    }
    // 1) Destructor — release the resource
    ~Buffer() { delete[] data; }

    // 2) Copy constructor — DEEP
...