Класс, знающий все свои экземпляры

A a;

A b;

A *p=new A[1024];

static A c;

static A *d=new A[2058];

/////////////////////////////////////////////////////////////////////////////////////////
//Класс имеет некую функцию-член, пусть её зовут f. Её требуется вызвать один раз и она 
//должна выполнить некие действия со всеми экземплярами, будь они автоматическими, 
//статическими, или динамическими. Пусть он не парсит всю память в поисках своих экземпляров, 
//пусть информация сразу куда то заносится в конструкторах с применением статического члена. 
//Но как лучше её организовать? Список всех экземпляров и статический член-указатель на 
//последний? На первый? Статический член-указатель на динамический массив указателей 
//на все экземпляры?
/////////////////////////////////////////////////////////////////////////////////////////
#include <algorithm>
#include <iostream>
#include <iterator>
#include <memory>
#include <set>
/////////////////////////////////////////////////////////////////////////////////////////
class   T_a
{
    //-----------------------------------------------------------------------------------
    typedef std::set< T_a*  >   T_obj_pointers;
    //-----------------------------------------------------------------------------------
    static  T_obj_pointers      obj_pointers_;
    //-----------------------------------------------------------------------------------
public:
    //-----------------------------------------------------------------------------------
    T_a()
    {
        obj_pointers_.insert( this );
        std::cout   <<  "++\t"
                    <<  this
                    <<  " :\t";
        print();
    }
    //-----------------------------------------------------------------------------------
    ~T_a()
    {
        obj_pointers_.erase( this );
        std::cout   <<  "--\t"
                    <<  this
                    <<  " :\t";
        print();
    }
    //-----------------------------------------------------------------------------------
    void    print()
    {
        std::copy
            (
                obj_pointers_.begin                                     (),
                obj_pointers_.end                                       (),
                std::ostream_iterator< T_obj_pointers::value_type >     ( std::cout, "\t" )
            );
 
        std::cout   <<  std::endl
                    <<  std::endl;
    }
    //-----------------------------------------------------------------------------------
};
/////////////////////////////////////////////////////////////////////////////////////////
T_a::T_obj_pointers     T_a::obj_pointers_;
/////////////////////////////////////////////////////////////////////////////////////////
T_a     _1;
/////////////////////////////////////////////////////////////////////////////////////////
int     main()
{
    T_a     _2;
    auto    a_ptr_3   =   new     T_a;
 
    {
        T_a                     _4;
        std::shared_ptr< T_a >  sh_ptr_5( new   T_a );
    }
 
    delete  a_ptr_3;
    system("pause");
}

A::first=new A;

class A
{
 private:
  static A *First;
  static A *Last;
         A *Previous;
         A *Next;
 public :
                      A ();
                     ~A ();
  static size_t       Count     ();
};
         A *
A::         First=NULL;
         A *
A::         Last =NULL;
A::         A ()
{
 if (First==NULL)
 {
  First   =this;
  Last    =this;
  Previous=NULL;
  Next    =NULL;
 }
 else
 {
  Last->Next    =this;
        Previous=Last;
        Next    =NULL;
  Last          =this;
 }
}
A::        ~A ()
{
 if (Previous!=NULL)
 {
  Previous->Next=Next;
 }
 if (Next!=NULL)
 {
  Next->Previous=Previous;
 }
}
 
         size_t
A::         Count     ()
{
 size_t     Result;
 A *p;
 if (First==NULL)
 {
  return 0;
 }
 for (p=First, Result=0; p!=NULL; p=p->Next)
 {
  ++Result;
 }
 return Result;
}

         A *
A::         First=NULL;

class oop 
{
public:
    void set_pointer(void *ptr) { ptr_ = ptr;}
    void* get_pointer()         { return ptr_; }
 
private:
    void *ptr_;
};