Erreurs, bugs, questions - page 1873

[Stanislav Korotky]

fxsaber:
Je modifie l'Expert Advisor et, soit par CTRL+F5, soit directement dans le testeur, je vois des résultats adéquats.

Ctrl+F5, c'est du débogage, non ? Mon problème n'est pas le débogage, mais l'exécution d'un test simple.

[fxsaber]

Stanislav Korotky:
Ctrl+F5, c'est du débogage, non ? Mon problème n'est pas le débogage, mais l'exécution d'un test simple.

Sans visuels, je cours après les montages - bien.

[[Supprimé]]

fxsaber:

Comment créer un objet de classe cachée avec un constructeur fermé ?

C'est ainsi que les fuites arrivent.

Il n'est pas clair comment appeler un destructeur dans cette situation. Singleton ne l'est pas.

Un objet de classe dont le constructeur est fermé ne peut être créé qu'à l'aide d'une fonction statique spéciale de cette classe.

Bien que le compilateur ne jure pas actuellement par le code que vous avez cité, cela sera certainement corrigé à l'avenir.

Vous pouvez utiliser un pointeur intelligent pour appeler le destructeur.

Le destructeur doit être ouvert.

[fxsaber]

Koldun Zloy:

Un objet d'une classe avec un constructeur fermé ne peut être créé qu'en utilisant une fonction statique spéciale de cette classe.

Bien que le compilateur ne jure pas actuellement par le code que vous avez cité, cela sera certainement corrigé à l'avenir.

La méthode statique proposée dans ce cas sera une sorte d'auto-illusion, car elle sera essentiellement un constructeur. Vous devrez l'appeler explicitement.

Vous pouvez utiliser un pointeur intelligent pour appeler le destructeur.

Le destructeur doit être ouvert.

Qu'est-ce qu'un pointeur intelligent ?

[[Supprimé]]

Si vous êtes sûr que le constructeur doit être privé, il n'y a pas d'autre moyen.

Un pointeur intelligent est un objet qui contient un pointeur simple et veille à ce qu'il soit supprimé à temps.

class MyClass
{
public:
   MyClass();
};

struct MyClassPtr
{
   MyClass* pMyClass;

   MyClassPtr( MyClass* myClass ) : pMyClass( myClass )
   {
   }
   ~MyClassPtr()
   {
      delete pMyClass;
   }
};

C'est l'option la plus simple.

Il existe également des pointeurs intelligents plus complexes.

Il est très bien écrit à leur sujet dans ce livre : https://rsdn.org/res/book/cpp/cpp_real_programmers.xml.

[Konstantin]

ce qui manque pour que le code se compile :

class CMyClass
  {
public:
   void* core;
   CMyClass(void) : core(NULL) { }
   template<typename T>
   void Create(T* a_ptr) {
      core = dynamic_cast<T *> (a_ptr);
   }
  };

class CCore
  {
public:
   int var;
   CCore(void) : var(3) { }
  };


int OnInit() {
   CCore *_point_1 = new CCore();
   CMyClass _obj;
   _obj.Create(_point_1);
   int _val = _obj.core.var;
   
   delete _point_1;
//---
   return INIT_SUCCEEDED;
}

cette variante écrit 'var' - membre de la structure non défini

PS. J'ai reçu l'erreur ;)

int _val = dynamic_cast <CCore *>(_obj.core).var;

[fxsaber]

void* à partir de quelle construction dans le langage ?

[Sergey Dzyublik]

fxsaber:
void* depuis quelle construction dans le langage ?

c'est alors que les interfaces sont arrivées

[fxsaber]

Sergey Dzyublik:

quand les interfaces sont arrivées.

Merci. J'ai eu l'erreur tout de suite, cependant

struct PTR
{
  void* Ptr; // internal error #40
};

[fxsaber]

Koldun Zloy:

Si vous êtes sûr que le constructeur doit être privé, il n'y a pas d'autre moyen.

Un pointeur intelligent est un objet qui contient un pointeur simple et veille à ce qu'il soit supprimé à temps.

C'est l'option la plus simple.

Il existe des pointeurs intelligents plus complexes.

Il est très bien écrit à leur sujet dans ce livre : https://rsdn.org/res/book/cpp/cpp_real_programmers.xml.

Merci ! J'ai essayé différentes variantes, mais ça ne marche pas.

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

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.