Fehler, Irrtümer, Fragen - Seite 2663

Neuer Kommentar
 
Sie haben einen schwerwiegenden Fehler in der Berechnung der Aktienmärkte und kümmern sich nicht darum, und es ist unklar, ob das Problem absichtlich oder versehentlich unbemerkt bleibt
 
Aleksey Vyazmikin:

Ich habe einen schwierigen Fall - es gibt keine Logik für mich.

Es gibt eine Funktion mit diesen Eingaben

Diese Funktion gibt also manchmal einen Wert von 769 aus

Wenn Sie den ersten Ausdruck auskommentieren

dann wird der richtige Wert angezeigt.

Wenn Sie die Funktion kürzen, indem Sie nur den Code entfernen, der zum Zeitpunkt des Funktionsaufrufs im Moment des Fehlers nicht aktiviert ist, tritt auch kein Fehler auf.

Offensichtlich ein Compilerfehler - Entwickler, an wen soll ich die vollständige Funktion schicken, sie passt nicht ins Forum.

Ich habe es über den Schalter gemacht - alles funktioniert. Es muss also der Compiler sein.

 
Unable to commit to a storage...
 
Alexey Kozitsyn:
Unable to commit to a storage...

Ich glaube, es funktioniert bereits.

 
Artyom Trishkin:

Ich glaube, es funktioniert bereits.

Ja.

 
MT5-Fehler (Build 2345), eine weitere Manifestation des zuvor beschriebenen Fehlers, bei dem ein Zeiger, der an eine Template-Funktion übergeben wird, für einige Operationen als Datentypzeiger und für andere als Datentypklasse fungiert:

#define  PRINT(x) ; Print(#x, ":", string(x))

template<typename T>
T test(T ptr){
   PRINT(typename(ptr));   // A*
   PRINT(typename(T));     // A*
   
   T new_ptr = new T();
   return (new_ptr);
}


class A{};
   
void OnStart(){    
   A a;
   test(&a);                   // Compile Error: OK
}
 

Fehler MT5 (Build 2345), keine Prüfung auf wiederverwendete Template-Typnamen bei der Deklaration einer Template-Funktion innerhalb einer Template-Klasse, was zu unerwartetem Verhalten führte:

#define  PRINT(x) ; Print(#x, ":", string(x))

template<typename T>
class A{
public:   
   template<typename T>         // Compile Error: OK
   T test(T p){
      B b = NULL;
      PRINT(typename(B));       // C*
      PRINT(typename(b));       // C*
      return b;
   }
   
   //real template
   template<typename TT>
   TT test_real(TT p){
      TT b = NULL;
      PRINT(typename(TT));       
      PRINT(typename(b));        
      return b;
   }
};

class B{};
class C : public B{};

   
void OnStart(){  
   A<B> a; 
   B b;
   C c;
    
   C* c_ptr = a.test(&c);
}
 
Bug MT5 (Build 2345) fehlt die Kapselung bei der Arbeit mit Methoden von Vorlagenklassen:

class B{
private:
   template<typename T>
   void you_cannot_call_private_method(T n){
      printf("Wow, Nice job.");
   }
};
   
void OnStart(){  
   B b;   
   b.you_cannot_call_private_method(1);          // Wow, Nice job.
}
 
MT5-Fehler (Build 2345) im Basisklassenkonstruktor, man kann keinen expliziten Typecast durchführen, um einen Zeiger auf ein Objekt einer Basisklasse in einen Zeiger auf eine Elternklasse zu werfen.

#define  PRINT(x) ; Print(#x, ":", string(x))

template<typename T>
class A{
   T* virtual_call;
   
public:   
   A(T* ptr){
      virtual_call = dynamic_cast<T*>(&this);
      PRINT(virtual_call == NULL);              // true, virtual_call == NULL
      
      virtual_call = dynamic_cast<T*>(ptr);
      PRINT(virtual_call == NULL);              // false, virtual_call != NULL
      
      virtual_call = (T*)(&this);               // Execution Error: Incorrect casting of pointers.
      virtual_call = (T*)(ptr);                 // OK
   } 
      
   template<typename TT>
   void test(TT n){
      virtual_call.__test(n);
   }
   
   template<typename TT>
   void __test(TT n){
      printf("AAAA");
   }
};


class B : public A<B>{
public:
   B() : A(&this){}

   template<typename TT>
   void __test(TT n){
      printf("BBBB");
   }
};
   
class C : public A<C>{
public:
   C() : A(&this){}
};

   
void OnStart(){  
   B b;   
   b.test(1);        // should be "BBBB"
   
   C c;
   c.test(1);        // should be "AAAA"
}

Es stellt sich heraus, dass zur Implementierung der "Muster"-Emulation von virtuellen Template-Funktionen neben der Typvererbung auch der direkte Wert des Zeigers auf die Elternklasse in die Basisklasse gezogen werden muss, was nicht gut ist...
 

Hat das jemand zusammengestellt?

class B {};

template<typename T>
class A
{
    static T *array;
    
    static void check()
    {
      T *ptr = array; // unresolved static variable 'A<B>::array'
    }
};

class Y: public A<B>
{
};

template<typename T>
static T *A::array;

void OnStart()
{
  Y y;
}

Was ist daran falsch?

1...265626572658265926602661266226632664266526662667266826692670...3184
Neuer Kommentar