Errori, bug, domande - pagina 2663

Nuovo commento
 
Avete un grave bug nel calcolo dei mercati azionari e non vi importa, e non è chiaro se il problema passa inosservato di proposito o accidentalmente
 
Aleksey Vyazmikin:

Ho un caso difficile - non c'è nessuna logica a mia disposizione.

C'è una funzione con questi input

Così, questa funzione a volte produce un valore di 769

Se si decommenta la prima stampa

allora dà il valore corretto.

Se si tronca la funzione togliendo solo il codice che non è attivato nel momento in cui la funzione viene chiamata al momento dell'errore, non c'è neanche l'errore.

Ovviamente un errore del compilatore - sviluppatori, a chi devo inviare la funzione completa, non va bene sul forum.

L'ho fatto tramite interruttore - tutto funziona. Deve essere il compilatore, allora.

 
Impossibile impegnarsi in un deposito...
 
Alexey Kozitsyn:
Impossibile impegnarsi in un deposito...

Sta già funzionando, credo.

 
Artyom Trishkin:

Sta già funzionando, credo.

Sì.

 
Bug di MT5 (build 2345), un'altra manifestazione del bug precedentemente descritto, in cui un puntatore passato a una funzione template si comporta come un puntatore al tipo di dati per alcune operazioni e come una classe di tipo di dati per altre:

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

Bug MT5 (build 2345), nessun controllo per i nomi dei tipi di template riutilizzati quando si dichiara una funzione template all'interno di una classe template, portando a un comportamento inaspettato:

#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);
}
 
Il bug MT5 (build 2345) manca di incapsulamento quando si lavora con i metodi delle classi template:

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.
}
 
Bug di MT5 (build 2345) nel costruttore della classe base, non è possibile eseguire un typecast esplicito per lanciare un puntatore a un oggetto di una classe base a un puntatore a una classe madre.

#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"
}

Si scopre che per implementare l'emulazione "pattern" delle funzioni template virtuali è necessario tirare il valore diretto del puntatore alla classe madre nella classe base oltre all'ereditarietà del tipo, il che non è buono...
 

Qualcuno ha questa compilazione?

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

Cosa c'è che non va?

1...265626572658265926602661266226632664266526662667266826692670...3184
Nuovo commento