Static члены класса

point
{ 
public:
    float x;
    float y;
 
    static distance (point A, point B) 
    {
        float dx = A.x - B.x;
        float dy = A.y - B.y;
        return sqrt(dx*dx + dy*dy);
    } 
}

point A;
point B;
cout << A.distance(A,B);
cout << B.distance(A,B);// будет использоваться одна функ в 1-ом и 2-ом случае, те одна область памяти?

struct example
{
    static void foo(){}
};
 
int main()
{
    example::foo(); // ok
 
    example* p = nullptr;
    p->foo(); //UB
}

#include <iostream>
void foo() {  std::cout <<"привет мир!\n"; }
 
int main()
{
    foo();
}

#include <iostream>
void foo() {  std::cout <<"привет мир!\n"; }
 
struct example
{
    static void foo() {  std::cout <<"привет мир!\n"; }
};
 
 
 
int main()
{
    foo();  // обычная свободная
 
    example::foo(); // статический член
}

#include <iostream>
 
struct example
{
     // экземпляры класса могут вызвать статическую функцию член
    example() { foo(); } 
private:
 
    // снаружи уже вызвать нельзя
    static void foo() {  std::cout <<"привет мир!\n"; }
};
 
int main()
{
    example::foo(); // error
 
    example object; // ok
 
}

#include <iostream>
 
struct example
{
    void foo()const {  std::cout <<"привет мир!\n"; v = 33; }
    int v = 10;
};
 
int main()
{
    example obj1, obj2; 
    obj1.foo();
    obj2.foo();
}

struct example { int v; };
 
void foo(example& e) { e.v=10; }
 
int main()
{
    example obj1,obj2;
 
    // вместо этого:  obj1.foo();
    // делаем так:
 
    foo(obj1); //<--- воздействуем на obj1
 
    foo(obj2); //<--- воздействуем на obj2
 
 
    // итого: компилятор генерирует код подстановки
    // obj.foo(); он заменяет на foo(obj);
    // где foo - функция член, которая на самом деле принимает 
    // один, невидимый для программиста аргумент:
    // указатель на объект, на который должна воздействовать
    // функция-член.
}

#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 = (void*)&m;
 
 
    //теперь извлекаем объект обратно, преобразовывая его тип к типу функции
    Free f = *((Free*)proxy);
    
    Example ex;
    
    
    //теперь, если наша теория верна, мы можем запустить функцию, 
    //передав первым аргументом тот самый "не видимый" параметр this
    //а следом все прочие аргуметы
    f(&ex,10);  
}

#include <iostream>
///////////////////////////////////////////////////////////////////////////////
struct  T_t
{
    //-------------------------------------------------------------------------
    int     &   f()
    {
        static  int     n   =   0;
        return  n;
    }
    //-------------------------------------------------------------------------
};
///////////////////////////////////////////////////////////////////////////////
int     main()
{
    for(;;)
    {
        std::cout   <<  "\n\nn = ";
        T_t     t;
        std::cin    >>  t.f();
 
        T_t     tt;
        std::cout   <<  tt.f();
    }//for
}

#include <iostream>
 
// вообще не имеет никакого отношения к классам
int& foo() { static int v; return v; } 
 
int main()
{
    // какому именно экземпляру какого класса в данном случае 
    // прикажите поиметь в собственность локальный статик?
   std::cout << foo() << '\n';
}