Использование this в языке С++

MyObj& operator = (const MyObj &other)
{
    if (this != &other)

struct Foo
{
    void f() {}
    void g()
    {
        f(); // при вызове foo *this неявно передаётся как параметр
    }
};

    {   if (this == &obj)
            return *this;

#include <iostream>
#include <iomanip>
 
class Foo
{
    public:
        Foo* getThis()
        {
            return this;
        }
};
 
int main()
{
    Foo f;
    
    std::cout << std::boolalpha << (&f == f.getThis());//адреса одинаковые
}

#include <iostream>
 
struct Foo;
struct Bar;
 
struct Foo 
{
    Bar *b;
    Foo(Bar *barPtr);
    void printBarData();
};
 
struct Bar
{
    int n = 100;
    void doSomething();
};
 
void Bar::doSomething()
{
     Foo f(this);
     f.printBarData();
}
 
 
Foo::Foo(Bar *barPtr)
{
    b = barPtr;
}
 
void Foo::printBarData()
{
    std::cout << b->n;
}
 
int main()
{
    Bar b;
    b.doSomething();
}

#include <memory>
#include <iostream>
 
struct Good: std::enable_shared_from_this<Good> // note: public inheritance
{
    std::shared_ptr<Good> getptr() {
        return shared_from_this();
    }
};
 
struct Bad
{
    std::shared_ptr<Bad> getptr() {
        return std::shared_ptr<Bad>(this);
    }
    ~Bad() { std::cout << "Bad::~Bad() called\n"; }
};
 
int main()
{
    // Good: the two shared_ptr's share the same object
    std::shared_ptr<Good> gp1 = std::make_shared<Good>();
    std::shared_ptr<Good> gp2 = gp1->getptr();
    std::cout << "gp2.use_count() = " << gp2.use_count() << '\n';
 
    // Bad: shared_from_this is called without having std::shared_ptr owning the caller 
    try {
        Good not_so_good;
        std::shared_ptr<Good> gp1 = not_so_good.getptr();
    } catch(std::bad_weak_ptr& e) {
        // undefined behavior (until C++17) and std::bad_weak_ptr thrown (since C++17)
        std::cout << e.what() << '\n';    
    }
 
    // Bad, each shared_ptr thinks it's the only owner of the object
    std::shared_ptr<Bad> bp1 = std::make_shared<Bad>();
    std::shared_ptr<Bad> bp2 = bp1->getptr();
    std::cout << "bp2.use_count() = " << bp2.use_count() << '\n';
} // UB: double-delete of Bad

#include <iostream>
#include <string>
 
std::string name = "Global Name";
 
template <typename T>
struct Base
{
    T name;
};
 
template <typename T>
struct Derived : Base<T>
{
    void setName1(const std::string& n) {name = n;}
    void setName2(const std::string& n) {this->name = n;}
};
 
int main()
{
    std::cout << "Global name: " << name << "\n";
    Derived<std::string> d;
    d.setName1("Derived Name");
    std::cout << "Global name: " << name << "\n";
    std::cout << "d.name: " << d.name << "\n";
 
    d.setName2("Derived Name");
    std::cout << "d.name: " << d.name << "\n";
}

#include <iostream>
using namespace std;
 
// так как функции-члены на самом деле точно такие же "свободные функции"
// то технически, мы можем запустить функцию-член, не как метод класса
// а как самую обычную свободную функцию
// проиллюстрируем это:
 
 
struct Example
{
    // мы будем запускать этот метод не как метод, 
    // а как обычную свободную функцию
    void foo(int) { cout<<"Example::foo(int);\n"; }
};
 
int main()
{
    std::cout << "Hello, world!\n";
    
    typedef 
        void(*Free)(Example*, int);
    typedef 
        void(Example::*Method)(int);
    
    //для того, что бы запустить метод, как свободную функцию
    //нужно выполнить преобразования метода в свободную функцию
    
    Method m = &Example::foo;
    
    //для этого возьмем адрес функции-члена таким образом,
    //что бы компилятор забыл изначальный тип функции-члена
    //это позволит обойти защиту компилятора при некорректном 
    //с точки зрения компилятора преобразовании типов функции-члена к функции
    void* proxy = reinterpret_cast<void*>(&m);
 
 
    //теперь извлекаем объект обратно, преобразовывая его тип к типу функции
    Free f = *(reinterpret_cast<Free*>(proxy));
    
    Example ex;
    
    
    //теперь, если наша теория верна, мы можем запустить функцию, 
    //передав первым аргументом тот самый "не видимый" параметр this
    //а следом все прочие аргуметы
    f(&ex,10);  
}