ForumBölümler

Hatalar, hatalar, sorular - sayfa 2639

Yeni yorum
Aleksey Vyazmikin :

Herhangi bir şans eseri bir taşınabilir mod anahtarı gerekli değil mi?

Eller tüm terminaller başlatıldı mı?

Eller, evet her şey başladı. Sonuç olarak, elleriyle fırlattı.

Taşınabilir mod tuşu bu konuda hiçbir şeyi değiştirmez.

Gerçek şu ki, MT4 yetkilendirme penceresini atıyor ve programın başlatılması tamamlanmış sayılmaz.

Toplu iş dosyasında "start" kullanmanız gerekir.

Genel olarak, ortaya çıktı, bu sorunu anladım.

Katıldığınız için teşekkürler!

Petros Shatakhtsyan :

Hala konunun ne olduğunu anlamıyorsun, görünüşe göre dikkatsizce yazılarımı okuyorsun. Benim itirazım geliştiricilere , size değil. Ucuz tavsiyene ihtiyacım yok.

Rahatlayın ve bu kadar endişelenmeyin.

Bir kez daha, serebral kıvrım gelişimi düşük olan kişilerin, kural olarak, nezaket hakkında çok az şey anladığına ikna oldum.

Daha bilgili insanların size ne söylediğini bile anlayamıyorsunuz ama anaokulundan henüz doğru yazmayı öğrenmemiş bir çocuk gibi kabasınız.

Ne yazık ki, ya da belki de neyse ki, doğrudan geliştirme ile uğraşmıyorum,
ancak dilin yeteneklerini değerlendirmeyi, eksikliklerini ve hatalarını keşfetmeyi mümkün kılan projeler üzerinde çalışmaktır...

Önceden, MQL projeleri üzerinde çalışırken, kusurlar (hatalar) hakkında bilgi, keşfedildikleri sırayla sağlanıyordu.
Şimdi yeni bir yaklaşım denemeye karar verildi - tespit edilen tüm olanlar hakkında daha sonra bilgi sağlanmasıyla bir engelleme kusuruna kadar çalışmak. 
#ifdef __cplusplus
   #include <iostream>
#endif 

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


template < typename T>
class main_wrapper{
public :
   T data;
};

template < typename T>
class external_wrapper{
public :
   T data;
};

template < typename T>
class A{
public :
   class internal_wrapper : public external_wrapper<T> {};
   
   main_wrapper<internal_wrapper> internal_wrapper_0;
   main_wrapper<external_wrapper<T>> external_wrapper_0;
   
   A(){
        main_wrapper<internal_wrapper> internal_wrapper_1;
        main_wrapper<external_wrapper<T>> external_wrapper_1;
   
         #ifdef __MQL5__
            PRINT( __FUNCSIG__ );
            PRINT( typename (internal_wrapper_0.data.data));       // (Bug) int  int
            PRINT( typename (external_wrapper_0.data.data));       // (OK)  int  B*
            PRINT( typename (internal_wrapper_1.data.data));       // (Bug) int  int
            PRINT( typename (external_wrapper_1.data.data));       // (OK)  int  B*
         #endif
   }
};

class B{
   char data[ 10 ];
};

class C{
   char data[ 1000 ];
};


void OnStart ()
{ 
   A< int > val_int;
   A<B*> val_ptr;
   
   printf ( "%d\n" , sizeof (main_wrapper<A<B>::internal_wrapper>));   // (Bug) 36  //sizeof(main_wrapper<A< int >::internal_wrapper>) is used
   printf ( "%d\n" , sizeof (main_wrapper<A<C>::internal_wrapper>));   // (Bug) 36  //sizeof(main_wrapper<A< int >::internal_wrapper>) is used
}

int main(){
   OnStart ();
   return 1 ;
}
Daha fazla gelişmeyi engelleyen çok kötü MT5(build 2316) hatası.
Birkaç kez dahili bir "C" türü ile sarılmış karmaşık bir nesne yaratırsınız ve orada tamamen farklı bir veri türü olduğu ortaya çıkar, belki "B", belki "int", ne isterseniz ...

Sorunun kodda değil, MQL derleyicisinin çalışmasında olduğunu kazmak ve anlamak için çok zaman ve çaba harcadı. (C++ çevrimiçi: https://onlinegdb.com/H1R1fR5ML )
Muhtemelen sorun, derleme zamanında kod oluştururken "main_wrapper" şablon sınıfının önbelleğinde, "internal_wrapper" dahili sınıfı çeşitli veri türleri (int, B*, M.Ö).
"main_wrapper<A<TEMPLATE_TYPE>::internal_wrapper> şablon sınıfı tarafından hangi ilk veri türü oluşturulacak, bu veri türü gelecekte bu şablonun tüm nesnelerinde daha fazla kullanılacaktır.


Şablon sınıfı kodu oluşturma ile ilgili başka bir hata aşağıda sağlanacaktır. 
class A{
public :
   class B{};
};

template < typename T>
class wrapper{
public :
   T data;
};

template < typename T>
class wrapped_B{
public :
   A::B data;
};
   
void OnStart ()
{ 
   A::B a;                 // OK
   wrapper<A::B> b0;       // 'B' - unexpected token, probably type is missing?  'data' - semicolon expected     
   
   wrapped_B<A::B> b2;     // OK
   
   class local_B : public A::B{};
   wrapper<local_B> b1;   // OK
}


int main(){
   OnStart ();
   return 0 ;
}

Dahili sınıf kullanılırken şablon sınıfı kod üretimiyle ilgili başka bir MT5(build 2316) hatası.
C++ çevrimiçi: https://onlinegdb.com/HJkKXAqMU

template < typename T>
class type_wrapper{
    T data;
};

template < typename T>
class A{
   class type_wrapper : public :: type_wrapper<T>{}; // '::' - syntax error      
};

void OnStart ()
{ 
   A< int > a;
}


int main(){
   OnStart ();
   return 0 ;
}

MT5(build 2316) içindeki dahili sınıfla ilgili diğer bir kusur, genel ad alanına açıkça atıfta bulunulamamasıdır.
C++ çevrimiçi: https://onlinegdb.com/H14NF05G8

Sergey Dzyublik :
Daha fazla gelişmeyi engelleyen çok kötü bir hata.
Birkaç kez dahili bir "C" türü ile sarılmış karmaşık bir nesne yaratırsınız ve orada tamamen farklı bir veri türü olduğu ortaya çıkar, belki "B", belki "int", ne isterseniz ...

Sorunun kodda değil, MQL derleyicisinin çalışmasında olduğunu kazmak ve anlamak için çok zaman ve çaba harcadı. (C++ çevrimiçi: https://onlinegdb.com/H1R1fR5ML )
Muhtemelen sorun, derleme zamanında kod oluştururken "main_wrapper" şablon sınıfının önbelleğinde, "internal_wrapper" dahili sınıfı çeşitli veri türleri (int, B*, M.Ö).
"main_wrapper<A<TEMPLATE_TYPE>::internal_wrapper> şablon sınıfı tarafından hangi ilk veri türü oluşturulacak, bu veri türü gelecekte bu şablonun tüm nesnelerinde daha fazla kullanılacaktır.


Şablon sınıfı kodu oluşturma ile ilgili başka bir hata aşağıda sağlanacaktır.
 #ifdef __cplusplus
   #include <iostream>
#endif 

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


template < typename T>
class main_wrapper{
public :
   T data;
};

template < typename T>
class external_wrapper{
public :
   T data;
};

template < typename T>
class A{
public :
   template < typename T1>
   class internal_wrapper : public external_wrapper<T1> {};
   
   main_wrapper<internal_wrapper<T>> internal_wrapper_0;
   main_wrapper<external_wrapper<T>> external_wrapper_0;
   
   A(){
        main_wrapper<internal_wrapper<T>> internal_wrapper_1;
        main_wrapper<external_wrapper<T>> external_wrapper_1;
   
         #ifdef __MQL5__
            PRINT( __FUNCSIG__ );
            PRINT( typename (internal_wrapper_0.data.data));       // (Bug) int  int
            PRINT( typename (external_wrapper_0.data.data));       // (OK)  int  B*
            PRINT( typename (internal_wrapper_1.data.data));       // (Bug) int  int
            PRINT( typename (external_wrapper_1.data.data));       // (OK)  int  B*
         #endif
   }
};

class B{
   char data[ 10 ];
};

class C{
   char data[ 1000 ];
};


void OnStart ()
{ 
   A< int > val_int;
   A<B*> val_ptr;
   
   printf ( "%d\n" , sizeof (main_wrapper<A<B>::internal_wrapper<B>>));   // (Bug) 36  //sizeof(main_wrapper<A<int>::internal_wrapper>) is used
   printf ( "%d\n" , sizeof (main_wrapper<A<C>::internal_wrapper<C>>));   // (Bug) 36  //sizeof(main_wrapper<A<int>::internal_wrapper>) is used
}
Bu doğru mu?
Vladimir Simakov :
Bu doğru mu?

Teşekkürler, gerçekten de örnek durumlarda sahte bir şablon parametresi eklemek sorunu atlar.
Ancak, global proje ile ilgili olarak, burada her şey biraz daha karmaşıktır: hem geliştirme sürecini hem de son kapsayıcı sınıfının kullanımını basitleştirmek için, eksik typedef typename işlevine alternatif olarak dahili sınıf kullanıldı.
Geliştiricilerden bir düzeltme beklemeye değer olabilir.
Aşırı durumlarda, yürütme sırasında tanımsız davranışa sahip başka bir başarılı derlemenin olmaması umuduyla tüm bağımlılıkların sürüklenmesi gerekecektir.

Dahili sınıf işlevselliğini özetlemek için,
kesinlikle normal kullanımı için typedef bildirim işlevinin çok eksik olduğu söylenebilir, en azından ilkel biçimi...
Oldukça kompakt ve anlaşılır C++ kodu yerine:

 template < class _Tp, class _Allocator>
class vector
    : private __vector_base<_Tp, _Allocator>
{
private :
     typedef __vector_base<_Tp, _Allocator>           __base;
public :
     typedef vector                                   __self;
     typedef _Tp                                      value_type;
     typedef _Allocator                               allocator_type;
     typedef typename __base::__alloc_traits          __alloc_traits;
     typedef typename __base::reference               reference;
     typedef typename __base::const_reference         const_reference;
     typedef typename __base::size_type               size_type;
..............................


İç sınıf aracılığıyla #define ve kalıtım ile çiti çitlemeliyiz:

 template < typename _Tp, typename _Allocator>
class __vector_base{
public :
   class allocator_type    : public _Allocator{}; 
   
protected :
   #define value_type          _Tp
   #define size_type           DEFAULT_SIZE_TYPE
   #define difference_type     size_type
   
   struct pointer          : public allocator_type::pointer{};
   struct iterator         : public allocator_type::pointer{};
............................

   #undef value_type
   #undef size_type
   #undef difference_type
};


Ve ilk bakışta göründüğünden çok daha fazla sorun var.
typedef bildirimi olarak #define kullanırken sorunlar:

- sınıf dışında kullanılan veri türünü aktarmanın bir yolu yoktur (basit veri türleri hiç aktarılamaz);
- karşılık gelen #undef çifti olan #define kapsamını sürekli olarak kontrol etmeniz gerekir

typedef bildirimi olarak dahili sınıf kullanırken sorunlar:
- kullanılan veri sınıfının/yapının türünü sınıfın dışına aktarabilirsiniz (basit veri türleri hiç aktarılamaz);
- devralırken, tüm kurucular kaybolur, temel sınıftan imzalara göre manuel olarak yeniden yazılmaları gerekir;
- typedef bildiriminin kullanıldığı sınıfın bir temel sınıfı varsa, bu durumda ad alanlarının çakışması yoluyla aynı adı bir typedef bildirimi olarak kullanmak mümkün değildir;
- sınıflar sınıflardan, yapılar yapılardan miras alınır, bu sürekli izlenmelidir;
Varsayılan atama operatörlerinin tanıtılması nedeniyle, temel sınıf için yanlışlıkla atamanın önlenmesine ihtiyaç vardı.
Bunu yapmak için geliştiriciler "operatör=delete" eklediler.
Ancak yine her şeyin manuel olarak yazılması gerektiğinden sil/varsayılan bağlantısını kırmak mantıklı görünmüyor.
Belki yanlış bir şey yapıyorum?

 class Base{
     char base_data[ 100 ];
};

template < typename T>
class A : public Base{
   int data_1;
   int data_2;
   int data_3;
   int data_4;
   int data_5;
   int data_6;
   int data_7;
   int data_8;
   int data_9;
   
   char arr_1[];
   char arr_2[];
public :    
   // MQL
   A* operator =(A &obj){
      data_1 = obj.data_1; 
      data_2 = obj.data_2; 
      data_3 = obj.data_3; 
      data_4 = obj.data_4; 
      data_5 = obj.data_5; 
      data_6 = obj.data_6; 
      data_7 = obj.data_7; 
      data_8 = obj.data_8; 
      data_9 = obj.data_9; 
      
       ArrayCopy (arr_1, obj.arr_1);
       ArrayCopy (arr_2, obj.arr_2); 
      
      (Base) this = obj;
       return & this ;
   };
   
   // C++
   // A& operator=(A &) = default;
    
   template < typename TT>
   A* operator =(A<TT> &) = delete ;
};

void OnStart ()
{ 
   A< int > a;
   A< int > b;
   
   A< double > c;
   
   a = b;      
   //a = c;       
}
1...263226332634263526362637263826392640264126422643264426452646...3184
Yeni yorum