Erreurs, bugs, questions - page 1874

[fxsaber]

Au lieu de spécifier l'erreur et l'endroit où elle se produit, le compilateur donne une erreur interne non spécifiée #112

class CLASS {};

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

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

[Koldun Zloy]

fxsaber:
Merci ! J'ai essayé différentes variantes, mais elles ne fonctionnent pas.

En fait, il est logique que ça ne fonctionne pas. Vous ne pouvez pas faire en sorte que le destructeur d'un pointeur intelligent soit appelé avant le destructeur de la classe.

Essayez la méthode suivante :

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()
{
}

Je ne sais pas ce que vous faites, mais en MQL, rendre le constructeur privé n'a de sens que pour le singleton.

[fxsaber]

Koldun Zloy:

Essayez de cette façon :

Merci pour cet exemple détaillé ! Malheureusement, il ne dispose pas d'un constructeur fermé. Cela ne fonctionne pas comme ça avec un appareil fermé, bien sûr.

Ce dont j'ai besoin, c'est d'un objet qui existe et qui soit caché à tous. En même temps, aucun autre objet de ce type ne pouvait être créé de quelque manière que ce soit.

[fxsaber]

Est-il correct dans un tel cas

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;
}

pour afficher ceci dans le journal d'exécution ?

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

Et est-il correct que le __FUNCSIG__ du constructeur/destructeur donne un type void ?

[fxsaber]

Koldun Zloy:

Essayez de cette façon :

Pourquoi le destructeur du pointeur intelligent est-il appelé avant le destructeur de la classe dans votre version, mais l'inverse dans la mienne (même si le constructeur est public) ?

[Koldun Zloy]

fxsaber:

J'ai besoin d'un objet qui soit caché de tous. En même temps, un autre objet de ce type ne pouvait être créé d'aucune manière.

C'est comme ça que ça s'appelle :"Singleton".

Pourquoi dites-vous qu'il ne vous convient pas ?

Voici un exemple de 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();
}

[Koldun Zloy]

fxsaber:
Est-il correct dans un tel cas
pour afficher ceci dans le journal d'exécution ?

Et est-il correct que le __FUNCSIG__ du constructeur/destructeur donne un type void ?

Ne le faites jamais.

delete &this;

[Sergey Dzyublik]

fxsaber:
Est-il correct d'envoyer ce message au journal d'exécution dans un tel cas ?

Et est-il exact que la __FUNCSIG__ du constructeur/destructeur sort le type void ?

Oui, c'est vrai.

[fxsaber]

Koldun Zloy:

C'est comme ça que ça s'appelle :"Singleton".

Pourquoi dites-vous qu'il ne vous convient pas ?

Voici un exemple de singleton.

Merci beaucoup, ça marche !

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()
{
}

Mais cela reste un mystère.

Forum sur le trading, les systèmes de trading automatisés et les tests de stratégie

Bugs, bugs, questions

fxsaber, 2017.04.25 10:34

Pourquoi le destructeur du pointeur intelligent est-il appelé avant le destructeur de la classe dans votre version et l'inverse dans la mienne (même si le constructeur est public) ?

[Koldun Zloy]

Probablement parce que vous l'appelez manuellement dans la fonction OnStart().

Les destructeurs d'objets statiques sont appelés après cette fonction dans l'ordre inverse de la déclaration.