Static обьект, в каких случаях применяется?

class A
 
{
    int x;
 
    static A c;
 
public:
 
    A(int h) : x(h) {}
 
    A() : x(0) {}
 
    ~A() {}
 
    static A & GF() 
 
    {
        return c;
    }
 
    int hjhj() const {return x;}
};
 
 A A :: c ;

class A
 
{
    int x;
 
    static A c;
 
public:
 
    A(int h) : x(h) {printf("\n *** KONST 2 %p\n",this);}
 
    A() : x(0) {printf("\n *** KONST %p\n",this);}
 
    ~A() {printf("\n *** DEST %p\n",this);}
 
    static A & GF() 
 
    {
        printf("\n *** static int () \n");
 
        return c;
    }
 
    int hjhj() const {return x;}
};
 
 A A :: c ;

static A & GF() 
 
    {
        printf("\n *** static int () \n");
 
        return c;
    }

int main()
 
{
    A  &c = A::GF();
 
       getch();
 
    return 0;
}

void hhjg()
 
{
    A  &c = A::GF();
        
    printf("\n  ********* %p\n",&c);
 
     printf("\n  ********** %d\n",c.hjhj());
 
 
}

#include "Class_algorithms.h"
 
void foo(int num1, int num2)
{
   int suma = Class_algorithms::suma(num1, num2);
}
// если в классе Class_algorithms метод suma статический, подключаем Class_algorithms.h, и юзаем

void A::setZarplata(int num)
{
    mZarplata = num;
 
    if(num > A::getMaxZarplata())
    {
        A::setMaxZarplata(num);
    }
}

static void foo(Foo* bar)
{
    bar->a = 10;
        a = 10; // ошибка потому что в реале это расскладывается как this->a = 10;
 
}
 
int main()
{
    Foo a;
    Foo::foo(&a);
}

// **********************************
//
// Название: Подведение итогов
//
// Файл: Week2
//
// Описание: Демонстрация создания и использования связанного списка
//
// Классы: PART - содержит идентификационный
 // номер детали и обеспечивает возможность
 // добавлять другие данные
 // PartNode - функционирует как узел в PartsList
 //
 // PartsList - реализует механизм связывания
 // узлов в список
 //
 // **********************************
 
 #include <iostream.h>
 
 
 
 // **************** Part ************
 
 // Абстрактный базовый класс, общий для всех деталей
 class Part
 {
    public:
       Part():itsPartNumber(1) { }
       Part(int PartNumber):itsPartNumber(PartNumber) { }
       virtual ~Part() { };
       int GetPartNumber() const { return itsPartNumber; }
       virtual void Display() const =0; // должна быть замещена как private
    private:
       int itsPartNumber;
 };
 
 // выполнение чистой виртуальной функции в
 // стандартном виде для всех производных классов
 void Part::Display() const
 {
    cout << "\nНомер детали: " << itsPartNumber << endl;
 }
 
 // ************* Автомобильные детали **********
 
 class CarPart : public Part
 {
    public:
       CarPart():itsModelYear(94){ }
       CarPart(int year, int partNumber);
       virtual void Display() const
       {
          Part::Display(); cout << "Год создания: ";
          cout << itsModelYear << endl;
       }
    private:
       int itsModelYear;
 };
 
 CarPart::CarPart(int year, int partNumber):
    itsModelYear(year),
    Part(partNumber)
 { }
 
 
 // ************* Авиационные детали **********
 
 class AirPlanePart : public Part
 {
    public:
       AirPlanePart():itsEngineNumber(1){ } ;
       AirPlanePart(int EngineNumber, int PartNumber);
       virtual void Display() const
       {
          Part::Display(); cout << "Номер двигателя: ";
          cout << itsEngineNumber << endl;
       }
    private:
       int itsEngineNumber;
 };
 
 AirPlanePart::AirPlanePart(int EngineNumber, intPartNumber):
    itsEngineNumber(EngineNumber),
    Part(PartNumber)
 { }
 
 // ************** Узлы списка деталей **********
 class PartNode
 {
    public:
       PartNode (Part*);
       ~PartNode();
       void SetNext(PartNode * node) { itsNext = node; }
       PartNode * GetNext() const;
       Part * GetPart() const;
    private:
       Part *itsPart;
       PartNode * itsNext;
};
 
// Выполнение PartNode...
 
PartNode::PartNode(Part* pPart):
itsPart(pPart),
itsNext(0)
{ }
 
PartNode::~PartNode()
{
   delete itsPart;
   itsPart = 0;
   delete itsNext;
   itsNext = 0;
}
 
//Возвращается NULL, если нет следующего узла PartNode
PartNode * PartNode::GetNext() const
{
   return itsNaxt;
}
 
Part * PartNode::GetPart() const
{
   if (itsPart)
      return itsPart;
   else
      return NULL; // ошибка
}
 
// **************** Список деталей ************
class PartsList
{
   public:
      PartsList();
      ~PartsList();
      // Необходимо, чтобы конструктор-копировщик и оператор соответствовали друг другу!
      Part* Find(int & position, int PartNumber) const;
      int GetCount() const { return itsCount; }
      Part* GetFirst() const;
      static PartsList& GetGlobalPartsList()
      {
      return GlobalPartsList;
      }
      void Insert(Part *);
      void Iterate(void (Part::*f)()const) const;
      Part* operator[](int) const;
   private:
      PartNode * pHead;
      int itsCount;
      static PartsList GlobalPartsList;
};
 
PartsList PartsList::GlobalPartsList;
 
// Выполнение списка...
 
PartsList::PartsList():
   pHead(0),
   itsCount(0)
{ }
 
PartsList::^PartsList()
{
   delete pHead;
}
 
Part* PartsList::GetFirst() const
{
   if (pHead)
      return pHead->GetPart();
   else
      return NULL; // ловушка ошибок
}
 
Part * PartsList::operator[](int offSet) const
{
   PartNode* pNode = pHead;
 
   if (!pHead)
      return NULL; // ловушка ошибок
 
   if (offSet > itsCount)
      return NULL; // ошибка
 
   for (int i=0;i<offSet; i++)
      pNode = pNode->GetNext();
 
   return pNode->GetPart();
}
 
Part* PartsList::Find(int & position, int PartNumber) const
{
   PartNode * pNode = 0;
   for (pNode = pHead, position = 0;
      pNode!=NULL;
      pNode = pNode->GetNext(), position++)
   {
      if (pNode->GetPart()->GetPartNumber() == PartNumber)
         break;
   }
   if (pNode == NULL)
      return NULL;
   else
      return pNode->GetPart();
}
 
void PartsList::Iterate(void (Part::*func)()const) const
{
   if (!pHead)
      return;
   PartNode* pNode = pHead;
   do
      (pNode->GetPart()->*func)();
   while (pNode = pNode->GetNext());
}
 
void PartsList::Insert(Part* pPart)
{
   PartNode * pNode = new PartNode(pPart);
   PartNode * pCurrent = pHead;
   PartNode >> pNext = 0;
 
   int New = pPart->GetPartNumber();
   int Next = 0;
   itsCount++;
 
   if (!pHead)
   {
      pHead = pNode;
      return;
   }
 
   // Если это значение меньше головного узла,
   // то текущий узел становится головным
   if (pHead->GetPart()->GetPartNumber()->New)
   {
      pNode->SetNext(pHead);
      pHead = pHode;
      return;
   }
 
   for (;;)
   {
      // Если нет следующего, вставляется текущий
      if (!pCurrent->GetNext())
      {
         pCurrent->SetNext(pNode);
         return;
      }
 
      // Если текущий больше предыдущего, но меньше следующего, то вставляем
      // здесь. Иначе присваиваем значение указателя Next
      pNext = pCurrent->GetNext();
      Next = pNext->GetPart()->GetPartNumber();
      if (Next > New)
      {
         pCurrent->SetNext(pNode);
         pNode->SetNext(pNext);
         return;
      }
      pCurrent = pNext;
   }
}
 
int main()
{
   PartsList&pl = PartsList::GetGlobalPartsList();
   Part * pPart = 0;
   int PartNumber;
   int value;
   int Choice;
 
   while (1)
   {
      cout << "(0)Quit (1)Car (2)Plane: ";
      cin >> choice;
 
      if (!choice)
         break;
 
      cout << "New PartNumber?: ";
      cin >> PartNumber;
 
      if (choice == 1)
      {
         cout << "Model Year?: ";
         cin >> value;
         pPart = new CarPart(value,PartNumber);
      }
      else
      {
         cout << "Engine Number?: ";
         cin >> value;
         pPart = new AirPlanePart(value,PartNumber);
      }
 
      pl.Insert(pPart);
   }
   void (Part::*pFunc)()const = Part::Display;
   pl.Iterate(pFunc);
   return 0;
}