Прихований покажчик this

#include <iostream>

using namespace std;

class Counter
{
private:
    int value;

public:
    Counter(int initialValue) : value(initialValue) {}

    void increment()
    {
        value++;  // Яка саме змінна value збільшується?
    }

    int getValue() const
    {
        return value;  // Яке саме value повертається?
    }
};

int main()
{
    Counter counter1(10);
    Counter counter2(20);
    
    counter1.increment();  // Як метод знає, що це counter1?
    counter2.increment();  // Як метод знає, що це counter2?
    
    cout << "counter1: " << counter1.getValue() << "\n";  // 11
    cout << "counter2: " << counter2.getValue() << "\n";  // 21
    
    return 0;
}

counter1.increment();

increment(&counter1);  // Адреса counter1 передається як неявний аргумент

void increment()
{
    value++;
}

void increment(Counter* const this)  // Прихований параметр this
{
    this->value++;  // Доступ до поля через this
}

int getValue() const
{
    return value;  // Ви пишете це
}

// Компілятор перетворює на:
int getValue(const Counter* const this) const
{
    return this->value;  // Фактичний код
}

class Point
{
private:
    int x;
    int y;

public:
    Point(int xCoord, int yCoord) : x(xCoord), y(yCoord) {}

    void print() const
    {
        cout << "Point(" << x << ", " << y << ")\n";
        // Фактично: this->x та this->y
    }

    void move(int dx, int dy)
    {
        x += dx;
        y += dy;
        // Фактично: this->x += dx; this->y += dy;
    }
};

int main()
{
    Point p1(10, 20);
    Point p2(30, 40);
    
    p1.print();  // this вказує на p1
    p2.print();  // this вказує на p2
    
    return 0;
}

#include <iostream>

using namespace std;

class Demo
{
private:
    int id;

public:
    Demo(int demoId) : id(demoId)
    {
        // В конструкторі this вказує на обєкт, що створюється
        cout << "Constructor: this = " << this << ", id = " << id << "\n";
    }

    void printInfo() const
    {
        cout << "Method: this = " << this << ", id = " << id << "\n";
    }
};

int main()
{
    Demo obj1(100);  // this = адреса obj1 в конструкторі
    Demo obj2(200);  // this = адреса obj2 в конструкторі
    
    obj1.printInfo();  // this = адреса obj1 в методі
    obj2.printInfo();  // this = адреса obj2 в методі
    obj1.printInfo();  // this знову = адреса obj1
    
    return 0;
}

class Rectangle
{
private:
    int width;
    int height;

public:
    // ❌ Проблема: параметри мають ті самі імена, що й поля
    Rectangle(int width, int height)
    {
        width = width;    // ⚠️ Присвоєння параметра самому собі!
        height = height;  // ⚠️ Присвоєння параметра самому собі!
        // Поля width і height залишаються неініціалізованими
    }
};

Rectangle(int width, int height)
{
    this->width = width;    // ✅ this->width — поле, width — параметр
    this->height = height;  // ✅ this->height — поле, height — параметр
}

Rectangle(int w, int h) : width(w), height(h)  // ✅ Списки ініціалізації
{
}

// Або
Rectangle(int rectWidth, int rectHeight) : width(rectWidth), height(rectHeight)
{
}

class Logger
{
public:
    void log(const string& message, const void* objectPtr)
    {
        cout << "[LOG] " << message << " from object at " << objectPtr << "\n";
    }
};

class Worker
{
private:
    int workerId;
    Logger& logger;

public:
    Worker(int id, Logger& log) : workerId(id), logger(log) {}

    void doWork()
    {
        // Передаємо адресу поточного об'єкта в логер
        logger.log("Starting work", this);
        
        cout << "Worker " << workerId << " is working...\n";
        
        logger.log("Finished work", this);
    }
};

int main()
{
    Logger mainLogger;
    
    Worker worker1(1, mainLogger);
    Worker worker2(2, mainLogger);
    
    worker1.doWork();
    worker2.doWork();
    
    return 0;
}

class Calculator
{
private:
    int value;

public:
    Calculator() : value(0) {}

    void add(int x)
    {
        value += x;
    }

    void subtract(int x)
    {
        value -= x;
    }

    void multiply(int x)
    {
        value *= x;
    }

    int getResult() const
    {
        return value;
    }
};

int main()
{
    Calculator calc;
    
    // ❌ Потрібно багато окремих рядків
    calc.add(10);
    calc.subtract(3);
    calc.multiply(2);
    
    cout << "Result: " << calc.getResult() << "\n";  // ((0 + 10) - 3) * 2 = 14
    
    return 0;
}

class Calculator
{
private:
    int value;

public:
    Calculator() : value(0) {}

    // Методи повертають посилання на поточний об'єкт
    Calculator& add(int x)
    {
        value += x;
        return *this;  // Повертаємо поточний об'єкт
    }

    Calculator& subtract(int x)
    {
        value -= x;
        return *this;
    }

    Calculator& multiply(int x)
    {
        value *= x;
        return *this;
    }

    int getResult() const
    {
        return value;
    }
};

int main()
{
    Calculator calc;
    
    // ✅ Ланцюжок викликів на одному рядку!
    calc.add(10).subtract(3).multiply(2);
    
    cout << "Result: " << calc.getResult() << "\n";  // 14
    
    return 0;
}

#include <iostream>
#include <string>

using namespace std;

class QueryBuilder
{
private:
    string query;

public:
    QueryBuilder() : query("") {}

    QueryBuilder& select(const string& columns)
    {
        query = "SELECT " + columns;
        return *this;
    }

    QueryBuilder& from(const string& table)
    {
        query += " FROM " + table;
        return *this;
    }

    QueryBuilder& where(const string& condition)
    {
        query += " WHERE " + condition;
        return *this;
    }

    QueryBuilder& orderBy(const string& column)
    {
        query += " ORDER BY " + column;
        return *this;
    }

    string build() const
    {
        return query + ";";
    }
};

int main()
{
    QueryBuilder qb;
    
    string sql = qb.select("name, age, city")
                   .from("users")
                   .where("age >= 18")
                   .orderBy("name")
                   .build();
    
    cout << "Generated SQL:\n" << sql << "\n";
    
    return 0;
}

class Resource
{
private:
    int id;
    static int nextId;

public:
    Resource()
    {
        id = nextId++;
        cout << "Resource created at " << this << " with ID " << id << "\n";
    }

    ~Resource()
    {
        cout << "Resource destroyed at " << this << " with ID " << id << "\n";
    }
};

int Resource::nextId = 1;

int main()
{
    Resource r1;
    Resource r2;
    
    return 0;
}

class Student
{
private:
    string name;
    int studentId;

public:
    Student(const string& n, int id) : name(n), studentId(id) {}

    bool isSameObject(const Student& other) const
    {
        // Порівнюємо адресу поточного об'єкта з адресою іншого
        return this == &other;
    }

    bool hasEqualData(const Student& other) const
    {
        // Порівнюємо дані (не адреси)
        return name == other.name && studentId == other.studentId;
    }

    void printInfo() const
    {
        cout << "Student: " << name << " (ID: " << studentId << ")\n";
    }
};

int main()
{
    Student s1("Ivan", 101);
    Student s2("Ivan", 101);  // Ті самі дані, але інший об'єкт
    Student& s3 = s1;         // Посилання на s1
    
    cout << "s1.isSameObject(s2): " << s1.isSameObject(s2) << "\n";  // 0 (false)
    cout << "s1.isSameObject(s3): " << s1.isSameObject(s3) << "\n";  // 1 (true)
    
    cout << "s1.hasEqualData(s2): " << s1.hasEqualData(s2) << "\n";  // 1 (true)
    
    return 0;
}

class Counter
{
private:
    int count;

public:
    Counter(int initial = 0) : count(initial) {}

    // Повертає посилання — дозволяє chaining
    Counter& increment()
    {
        count++;
        return *this;
    }

    // Повертає копію — не дозволяє chaining
    Counter incrementAndCopy()
    {
        count++;
        return *this;  // Створюється копія поточного об'єкта
    }

    int getCount() const
    {
        return count;
    }
};

int main()
{
    Counter c1(0);
    
    // Chaining з посиланням
    c1.increment().increment().increment();
    cout << "c1 count: " << c1.getCount() << "\n";  // 3
    
    Counter c2(0);
    
    // Без chaining — копія повертається
    Counter temp = c2.incrementAndCopy();
    cout << "c2 count: " << c2.getCount() << "\n";       // 1
    cout << "temp count: " << temp.getCount() << "\n";   // 1
    
    return 0;
}

class DynamicArray
{
private:
    int* data;
    int size;

public:
    DynamicArray(int sz) : size(sz)
    {
        data = new int[size];
    }

    ~DynamicArray()
    {
        delete[] data;
    }

    // Перевантажений оператор присвоєння
    DynamicArray& operator=(const DynamicArray& other)
    {
        // ✅ Перевірка самоприсвоєння через this
        if (this == &other)
        {
            cout << "Self-assignment detected, skipping\n";
            return *this;  // Нічого не робимо
        }

        // Звільняємо старі дані
        delete[] data;

        // Копіюємо нові дані
        size = other.size;
        data = new int[size];
        for (int i = 0; i < size; i++)
        {
            data[i] = other.data[i];
        }

        return *this;
    }

    int getSize() const { return size; }
};

int main()
{
    DynamicArray arr1(5);
    DynamicArray arr2(10);
    
    arr1 = arr2;  // Нормальне присвоєння
    arr1 = arr1;  // Самоприсвоєння — виявляється через this
    
    return 0;
}