ForumSections

Erreurs, bugs, questions - page 1184

Nouveau commentaire
Par exemple, un opérateur d'addition peut être appliqué entre des références, ce qui appellera l'opérateur+(...). L'ajout de pointeurs n'a aucun sens, car nous obtiendrons un nombre qui n'a aucune utilité pratique.
A100:
Qu'est-ce qui empêche les opérateurs qui n'ont pas de sens de les surcharger en tant qu'objets ou simplement de ne pas les implémenter ?

C'est ainsi que cela se passe maintenant (surchargé comme pour les objets) et tout semble aller bien. Mais il y a une contradiction entre ce qui est significatif (== et !=) et le reste.

class A {
public:
        bool operator ==( A* a ) { Print( __FUNCTION__ ); return ( true  );  }
        bool operator !=( A* a ) { Print( __FUNCTION__ ); return ( true  );  }
//остальные
        bool operator >>( A* a ) { Print( __FUNCTION__ ); return ( true  );  }
        bool operator +( A* a )  { Print( __FUNCTION__ ); return ( false  ); }
        bool operator !()        { Print( __FUNCTION__ ); return ( true   ); }
//... и т.д.
};

comme

void OnStart()
{
        A *a = new A;
        if ( a == a ) Print( "1" ); //сравнение указателей как чисел
        if ( a >> a ) Print( "3" ); //вызывается operator<<( A *)
}

Ce que nous proposons d'éliminer en comparant les pointeurs uniquement par le biais de la fonction spéciale

void OnStart()
{
        A *a = new A;
        if ( isEqualPoiner( a, a ) ) Print( "1" ); //сравнение указателей как чисел
        if ( a == a )               Print( "2" ); //вызывается operator==( A *)
        if ( a >> a )               Print( "3" ); //вызывается operator<<( A *)
}

Une fonction spéciale pour comparer les pointeurs peut être conçue comme suit

template<typename T1, typename T2>
bool isEqualPointer( T1 *t1, T2 *t2 ) { return ( ulong(t1) == ulong(t2) ); }
A100:

J'ai une question indiscrète à vous poser. Allez-vous partager vos expériences ?

Vous êtes l'une des rares personnes à utiliser activement et constamment des modèles et des macros. Et vous avez probablement une grande quantité de code accumulé.

Je ne sais pas pour les autres, mais je serais très intéressé de voir votre code et vos développements, si vous en avez, que vous ne voyez pas d'inconvénient à partager avec le public.

Je ne sais pas... l'implémentation des modèles, vos enveloppes pour travailler avec les indicateurs, les graphiques, tout ce que vous voulez...

Comment utiliser les modèles ? - Pour raccourcir une entrée. Par exemple, il n'y a pas d'opération virgule dans MQL. Disons qu'il y a un enregistrement

int f2( string str )
{
        Print( str );
        return ( 0 );
}

bool f( int a )
{
        if ( a == 5 )
                return ( true )
        f2( "abc" );
        return ( false );
}
Puis avoir un modèle
template<typename T 1, typename T 2>
T2 opComma( T1 expression, T2 assignment_expression ) { return ( assignment_expression ); }

au lieu de 4 lignes, nous en avons une

bool f( int a )
{
        return ( a == 5 ? true : opComma( f2( "abc" ), false ) );
}

Comment utiliser les macros ? - Encore une fois - pour raccourcir le dossier. Par exemple, il n'y a pas de modèles de classe dans MQL. Pas de problème - nous utilisons une macro

#define  Macro( type ) \
class A {       \
public:         \
/*...еще много строк...*/ \
        type a; \
};

//осталось написать
Macro(  uint )
Macro( ulong )
Encore une fois pour raccourcir les choses - après avoir défini une fois
#define  MDT( dt_struct, dt )     \
        MqlDateTime dt_struct;   \
        ZeroMemory( dt_struct ); \
        TimeToStruct( dt, dt_struct );

il suffira ensuite de déclarer

datetime dt;
MDT( dt_struct, dt )

La copie bit à bit, par exemple, est mise en œuvre par le biais de modèles, puisque plusieurs types peuvent être impliqués en même temps.

template<typename T1, typename T2>
T2 BitwiseCopying( T1 type1, T2 )
{
struct Union1 {
        T1      type1;
};
struct Union2 {
        T2      type2;
};
        Union1 union;
        union.type1 = type1;
        return ( ((Union2)union).type2 );
}
void f()
{
        ulong ul = 0x16;
        double d = BitwiseCopying( ul, double(0)); //побитовое копирование из ulong в double
        float f = 36.6;
        uint ui = BitwiseCopying( f,    uint(0));  //побитовое копирование из float в uint

}
A100:

Le fait de n'adopter que (*a) pour faire référence aux fonctions membres n'apporte pas d'avantages évidents, mais conduit au contraire à l'impossibilité d'une application multiple simple et claire des opérateurs.

Essayez de le réécrire en tenant compte de votre suggestion.

Vous ne pouvez pas utiliser l'objet lui-même au lieu du pointeur car l'opérateur <<(...) ne peut retourner qu'un pointeur vers l'objet.

Vous avez dû mal comprendre. Je ne parlais pas de désactiver l'implémentation actuelle. J'ai demandé à ce qu'il soit possible en plus de prendre une référence ou un pointeur sur un objet afin de ne pas dépendre des caprices du compilateur.Et je déciderai de ce qu'il faut faire dans chaque cas. Si j'ai besoin d'un programme super fiable, je peux facilement le faire de la manière que vous avez décrite. Oui, c'est compliqué. Mais si les métacitations introduisent soudainement une action spéciale de l'opérateur << pour les pointeurs, nous n'en aurons pas peur.

1...117711781179118011811182118311841185118611871188118911901191...3184
Nouveau commentaire