错误、漏洞、问题 - 页 2663

新评论
 
你们在股票市场的计算中存在一个严重的错误，但你们并不关心，不清楚这个问题是有意还是无意地没有被注意到
 
Aleksey Vyazmikin:

我有一个棘手的案子--没有任何逻辑可供我使用。

有一个函数，有这些输入

所以，这个函数有时会输出769的值

如果你取消对第一个打印的注释

那么它就会给出正确的值。

如果你把函数截断，只删除在出错时调用函数 时没有激活的代码，也就没有错误了。

显然是一个编译器错误 - 开发人员，我应该把完整的功能发给谁，它不适合在论坛上。

我是通过开关做的--一切正常。那么，一定是编译器的问题。

 
无法提交到一个存储...
 
Alexey Kozitsyn:
无法提交到一个存储...

我想，这已经在发挥作用了。

 
Artyom Trishkin:

我想，这已经在发挥作用了。

是的。

 
MT5的bug（build 2345），是之前描述的bug 的另一种表现形式，传递给模板函数的指针在某些操作中作为数据类型指针，而在其他操作中作为数据类型类。

#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），在模板类中声明模板函数时，没有检查重复使用的模板类型名称，导致出现意外行为。

#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）在使用模板类方法 时缺乏封装。

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错误（build 2345）在基类构造函数 中，你不能执行显式类型转换，将基类对象的指针投向父类的指针。

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

事实证明，为了实现虚拟模板函数的 "模式 "仿真，除了类型继承之外，还必须将父类的指针的直接值拉到基类中，这并不好...
 

有没有人有这个汇编？

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

它有什么问题？

1...265626572658265926602661266226632664266526662667266826692670...3184
新评论