Erros, bugs, perguntas - página 2663

Novo comentário
 
Tem um erro grave no cálculo das bolsas de valores e não se importa, e não é claro se o problema passa despercebido propositadamente ou acidentalmente
 
Aleksey Vyazmikin:

Tenho um caso difícil - não há lógica disponível para mim.

Existe uma função com estes inputs

Assim, esta função por vezes produz um valor de 769

Se descomentar a primeira impressão

então dá o valor correcto.

Se truncar a função removendo apenas o código que não é activado no momento em que a função é chamada no momento do erro, também não há erro.

Obviamente um erro de compilação - os programadores, a quem devo enviar a função completa, não cabe no fórum.

Fi-lo através de interruptor - tudo funciona. Deve ser o compilador, então.

 
Incapaz de se comprometer com um armazenamento...
 
Alexey Kozitsyn:
Incapaz de se comprometer com um armazenamento...

Já está a funcionar, penso eu.

 
Artyom Trishkin:

Já está a funcionar, penso eu.

Sim.

 
MT5 bug (build 2345), outra manifestação do bug anteriormente descrito, onde um ponteiro passado para uma função modelo actua como ponteiro de tipo de dados para algumas operações e como uma classe de tipo de dados para outras:

#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), sem verificação de nomes de tipos de modelo reutilizados ao declarar uma função de modelo dentro de uma classe de modelo, levando a um comportamento inesperado:

#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) carece de encapsulamento quando se trabalha com métodos de classe modelo:

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 MT5 (build 2345) no construtor da classe base, não se pode realizar uma previsão explícita datilográfica para lançar um ponteiro para um objecto de uma classe base para um ponteiro para uma classe pai.

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

Acontece que para implementar a emulação "padrão" de funções de modelo virtual é necessário puxar o valor directo do ponteiro para a classe mãe para a classe base para além do tipo de herança, o que não é bom...
 

Alguém tem isto compilado?

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

O que há de errado?

1...265626572658265926602661266226632664266526662667266826692670...3184
Novo comentário