Errori, bug, domande - pagina 1874

[fxsaber]

Koldun Zloy:

Se siete sicuri che il costruttore deve essere privato, non c'è altro modo.

Un puntatore intelligente è un oggetto che contiene un puntatore semplice e assicura che venga rimosso in tempo.

Questa è l'opzione più semplice.

Ci sono puntatori intelligenti più complessi.

È scritto molto bene su di loro in questo libro: https://rsdn.org/res/book/cpp/cpp_real_programmers.xml

Grazie! Provato diverse varianti, ma non funziona

template <typename T>
struct PTR
{
  T* Ptr;
  
  PTR( void )
  {
  }
  
  void operator =( T* &Value )
  {
    this.Ptr = Value;
  }
  
  ~PTR( void )
  {
    Print(__FUNCSIG__);
    delete this.Ptr;
  }
};

class CLASS
{
private:
  static CLASS* Tmp;
  static PTR<CLASS> Ptr;
  
  CLASS()
  {
    CLASS::Ptr = CLASS::Tmp;
  }
};

static CLASS* CLASS::Tmp = new CLASS;
static PTR<CLASS> CLASS::Ptr;

void OnStart()
{
}

In effetti, è logico che non funzioni. Non potete fare in modo che il distruttore di un puntatore intelligente sia chiamato prima del distruttore della classe.

[fxsaber]

Invece di specificare l'errore e dove si verifica, il compilatore dà un errore interno non specificato #112

class CLASS {};

template <typename T>
class CLASS2
{
public:
  static void Func() {}
};

void OnStart()
{
  CLASS2<CLASS>::Func;  
}

[[Eliminato]]

fxsaber:
Grazie! Ho provato diverse varianti, ma non funzionano.

In realtà, è logico che non funzioni. Non potete fare in modo che il distruttore di un puntatore intelligente sia chiamato prima del distruttore della classe.

Provate il seguente modo:

template < typename T >
struct PTR
{
  T* Ptr;
  
  PTR( T* Value ) : Ptr( Value )
  {
  }
  
  ~PTR()
  {
    Print(__FUNCSIG__);
    delete Ptr;
  }
};

class CLASS
{
private:
  static PTR< CLASS > Ptr;
  
public:
  CLASS()
  {
      Print(__FUNCSIG__);
  }
  ~CLASS()
  {
      Print(__FUNCSIG__);
  }
};

static PTR< CLASS > CLASS::Ptr( new CLASS );

void OnStart()
{
}

Non so cosa stai facendo, ma in MQL rendere il costruttore privato ha senso solo per il singleton.

[fxsaber]

Koldun Zloy:

Provate in questo modo:

Grazie per l'esempio dettagliato! Sfortunatamente, non ha un costruttore chiuso. Non funziona così con una chiusa, ovviamente.

Ciò di cui ho bisogno è che esista un oggetto che sia nascosto a tutti. Allo stesso tempo, nessun altro oggetto di questo tipo potrebbe essere creato in alcun modo.

[fxsaber]

È corretto in tal caso

class CLASS
{
public:
  ~CLASS()
  {
    static bool FirstRun = true;
    
    if (FirstRun && CheckPointer(&this) == POINTER_DYNAMIC)
    {
      FirstRun = false;
      
      delete &this;
    }
    
    Print(__FUNCSIG__);
  }
};

void OnStart()
{
  CLASS* Class = new CLASS;
  delete Class;
}

per emettere questo nel registro di esecuzione?

void CLASS::~CLASS()
void CLASS::~CLASS()
delete invalid pointer

Ed è corretto che la __FUNCSIG__ del costruttore/distruttore dia un tipo void?

[fxsaber]

Koldun Zloy:

Prova in questo modo:

Perché il distruttore del puntatore intelligente è chiamato prima del distruttore della classe nella tua versione, ma il contrario nella mia (anche se il costruttore è pubblico)?

[[Eliminato]]

fxsaber:

Ho bisogno di avere un oggetto che sia nascosto a tutti. Allo stesso tempo, un altro oggetto di questo tipo non poteva essere creato in alcun modo.

È così che si chiama:"Singleton".

Perché dici che non è adatto a te?

Ecco un esempio di un singleton.

template < typename T >
struct PTR
{
   T* Ptr;
   
   PTR() : Ptr( NULL ){}
   PTR( T* ptr ) : Ptr( ptr )
   {
   }
   
   ~PTR()
   {
      Print(__FUNCSIG__);
      if( Ptr )delete Ptr;
   }
   
   void Set( T* ptr )
   {
      Ptr = ptr;
   }
};

class CLASS
{
   static PTR< CLASS > sPtr;
   
   CLASS()
   {
      Print(__FUNCSIG__);
   }
   
public:
   ~CLASS()
   {
      Print(__FUNCSIG__);
   }
   
   static CLASS* GetPtr()
   {
      if( !sPtr.Ptr ){
         sPtr.Set( new CLASS );
      }
      return sPtr.Ptr;
   }
};

static PTR< CLASS > CLASS::sPtr;

void OnStart()
{
   CLASS* ptr = CLASS::GetPtr();
}

[[Eliminato]]

fxsaber:
È corretto in tal caso
per emettere questo nel registro di esecuzione?

Ed è corretto che la __FUNCSIG__ del costruttore/distruttore dia un tipo void?

Non fare mai

delete &this;

[Sergey Dzyublik]

fxsaber:
È corretto emettere questo nel registro di esecuzione in un caso simile?

Ed è corretto che la __FUNCSIG__ del costruttore/distruttore emetta void-type?

Sì, è così.

[fxsaber]

Koldun Zloy:

È così che si chiama:"Singleton".

Perché dici che non ti si addice?

Ecco un esempio di un singleton.

Grazie mille, funziona!

template < typename T >
struct PTR
{
   T* Ptr;
   
   PTR( void ) : Ptr(NULL)   
   {
   }
   
   PTR( T* ptr ) : Ptr(ptr)
   {
   }
   
   ~PTR( void )
   {
     if (this.Ptr)
       delete this.Ptr;
   }
   
   bool Set( T* ptr )
   {
      this.Ptr = ptr;
      
      return(true);
   }
   
   void operator =( bool )
   {
   }
};

class CLASS
{
private:   
   static PTR<CLASS> sPtr;
   
   CLASS()
   {
   }
   
public:
  static bool Set()
  {
    return(CLASS::sPtr.Ptr ? false : CLASS::sPtr.Set(new CLASS));
  }
};

static PTR<CLASS> CLASS::sPtr = CLASS::Set();

void OnStart()
{
}

Ma rimane ancora un mistero.

Forum sul trading, sistemi di trading automatico e test di strategia

Bug, bug, domande

fxsaber, 2017.04.25 10:34

Perché il distruttore del puntatore intelligente è chiamato prima del distruttore della classe nella tua versione e il contrario nella mia (anche se il costruttore è pubblico)?