Buon punto. Sarebbe bello se gli argomenti fossero supportati da un codice piuttosto che solo bla, bla, bla.
Sostenere la cosa.
Ecco la mia classe CMyObject:
#include <Object.mqh>
// Перечисление, в котором должны указываться все объекты, которые могут быть пронаследованны от моего объектаenum EMyObjectTypes
{
MOT_BASE_OBJECT = 0001, // Просто CObject - фактически, никогда не должен использоваться.
MOT_STRUCT_WRAPPER = 0002, // Неинициализированный CStructWrapper
MOT_PRICE_POINT = 0003, // Класс CPricePoint
MOT_PRICEIDX_POINT = 0004, // Класс CPriceIdxPoint
MOT_WPRICEIDX_POINT = 0005, // Класс CWPriceIdxPoint
MOT_WAVE_TRIANGLE_DATA = 0006, // Класс CWaveTriangleData
MOT_WAVE_TRIANGLE = 0007, // Класс CWaveTriangle
MOT_TRADERESULT_I = 0008, // Класс CTradeResultI
MOT_TRADERESULT = 0009, // Класс CTradeResult// Тут еще куча типов объектов - для каждого класса, свой ID
MOT_UNKNOWN = -0001// Неинициализированный объект.
};
/*
Класс СMyObject - потомок от СObject, несет функциональность именования.
*/class CMyObject: public CObject
{
protected:
EMyObjectTypes m_motType;
int m_iUDCreationValue; // Значение, определяемое пользователем при создании объекта. Предназначено для идентификации отдельных экземпляров объекта. void SetMyObjectType(EMyObjectTypes motType) { m_motType = motType; };
// Функции вывода на печать параметров. void _PrintStringParameter(string strParameterName,string strParameterValue) { Print("Object ID: " + IntegerToString(GetType()) + "; " + strParameterName + " = " + strParameterValue + "; String."); };
void _PrintDoubleParameter(string strParameterName,double dParameterValue,int iDigits = 8) { Print("Object ID: " + IntegerToString(GetType()) + "; " + strParameterName + " = " + DoubleToString(dParameterValue,iDigits) + "; Double"); };
void _PrintIntegerParameter(string strParameterName,long lParameterValue) { Print("Object ID: " + IntegerToString(GetType()) + "; " + strParameterName + " = " + IntegerToString(lParameterValue) + "; Integer"); };
void _PrintBoolParameter(string strParameterName,bool bParameterValue) { if(bParameterValue) Print("Object ID: " + IntegerToString(GetType()) + "; " + strParameterName + " = True; Bool"); elsePrint("Object ID: " + IntegerToString(GetType()) + "; " + strParameterName + " = False; Bool"); };
public:
CMyObject(int iUDCreationValue = WRONG_VALUE) { m_iUDCreationValue = iUDCreationValue; m_motType = MOT_UNKNOWN; };
EMyObjectTypes GetType() const { return(m_motType); };
bool CheckType(EMyObjectTypes motType) { return(m_motType == motType); };
int GetUDCreationValue() { return(m_iUDCreationValue); };
void SetUDCreationValue(int iValue) { m_iUDCreationValue = iValue; };
};
#ifdef ASSERTION_CODE_ON
CMyObject* _PerformObjectConvertWithCheck(CMyObject* pmoObject,EMyObjectTypes motType)
{
ASSERT_MYPOINTER(pmoObject); // проверим указатель
ASSERT(pmoObject.CheckType(motType) == true); // проверим внутренний ID типа объектаreturn(pmoObject);
};
#define CONVERT_OBJECT_WITH_CHECK(objFrom,typeTo,checkType) ((typeTo*)_PerformObjectConvertWithCheck(objFrom,checkType))
#else // ASSERTION_CODE_ON#define CONVERT_OBJECT_WITH_CHECK(objFrom,typeTo,checkType) ((typeTo*)objFrom)
#endif // ASSERTION_CODE_ON
La macro CONVERT_OBJECT_WITH_CHECK è anche definita alla fine, che per la versione DEBUG esegue un ulteriore controllo di conversione del puntatore basato sul tipo di oggetto
La macro CONVERT_OBJECT_WITH_CHECK è anche definita alla fine, che, per la versione DEBUG, esegue un ulteriore controllo di conversione del puntatore basato sul tipo di oggetto
È bellissimo. Naturalmente, è una questione di gusti. Ma, basandomi sulla sintassi MQL, lo scriverei così:
enum ENUM_OBJECT_TYPES
{
OBJECT_TYPES_BASE_OBJECT = 0001, // Просто CObject - фактически, никогда не должен использоваться.
OBJECT_TYPES_STRUCT_WRAPPER = 0002, // Неинициализированный CStructWrapper
OBJECT_TYPES_PRICE_POINT = 0003, // Класс CPricePoint
OBJECT_TYPES_PRICEIDX_POINT = 0004, // Класс CPriceIdxPoint
OBJECT_TYPES_WPRICEIDX_POINT = 0005, // Класс CWPriceIdxPoint
OBJECT_TYPES_WAVE_TRIANGLE_DATA = 0006, // Класс CWaveTriangleData
OBJECT_TYPES_WAVE_TRIANGLE = 0007, // Класс CWaveTriangle
OBJECT_TYPES_TRADERESULT_I = 0008, // Класс CTradeResultI
OBJECT_TYPES_TRADERESULT = 0009, // Класс CTradeResult// Тут еще куча типов объектов - для каждого класса, свой ID
OBJECT_TYPES_UNKNOWN = -0001// Неинициализированный объект.
};
È bellissimo. Naturalmente, è una questione di gusti. Ma, basandomi sulla sintassi MQL, lo scriverei in questo modo:
Sì, proprio così.
Ma questo è il mio "stile di programmazione" senile (ciao, Volchansky con il suo recente thread).
Ho tutte le enumerazioni - iniziano con E, e poi con la notazione "gobba" - nome. E i tipi stessi in enumerazione iniziano con un'abbreviazione (fino a quattro lettere) di tipo enumerazione.
Di conseguenza, poiché l'enumerazione è EMyObjectType, tutti i valori iniziano con MOT_
Sei un idiota? )) Non ho detto una parola negativa su F#. Impara a leggere e a capire quello che ti viene detto prima di postare i tuoi stupidi commenti.
Se si confronta OOP con FP, è più sensato confrontarlo con un linguaggio FP puro, cioè Haskel. F# è già così così, mentre Python e R non lo sono affatto. Questo è quello che voglio dire. Altrimenti potremmo arrivare ad un punto in cui il C++ è anche un linguaggio FP.
Sei un troll analfabeta. Per la cronaca, tutte le lingue elencate sono funzionali in un modo o nell'altro. Andate a imparare la materia. La domanda è stata posta per capire in quale quadro di riferimentoAndrei sta probabilmente praticando uno dei linguaggi della FP, quindi l'elenco era molto generale.
Cosa dovrebbe esserci nell'"oggetto base" secondo voi?
Personalmente ho quasi TUTTI gli oggetti in tutti i miei progetti - ereditati da CMyObject: public CObject, (nel mio oggetto sono aggiunti altri due campi - nome della classe e ID dell'istanza), e ripetutamente ho trovato che ho bisogno della funzionalità CObject::Compare() molto. Un paio di volte sono stati utili anche i puntatori di liste.
CObject ha un solo obiettivo: fornire il controllo dei tipi. E ci riesce traballantemente. Metodi come Next(), Prev(), ecc. sono per collezioni molto specializzate. Non appartengono a CObject. Lo stesso vale per i metodi Save e Load. Sarebbe bello non avere nemmeno Comparer, ma questa è l'unica soluzione senza interfacce.
Per quanto riguarda il metodo Type(), non fornisce una tipizzazione rigorosa, perché restituisce il solito numero. Potete vedere sull'esempio del vostro codice. Si definisce un nuovo metodo GetType() che restituisce il tipo come enumerazione. Non c'è davvero altro modo, lo faccio da solo. Per questo si deve aggiungere il CObject standard, ed è scorretto.
Ho tale oggetto CFactoryBalanceResultSeries - è una serie con risultati di bilanciamento con riferimento all'oggetto factory di Expert Advisor. In realtà è una curva di equilibrio sulla storia con riferimento all'Expert Advisor che l'ha scambiata.
Quindi ho uno script in cui confronto queste serie molto equilibrate.
Finché ci sono solo due serie è facile confrontarle. Ma quando ce ne sono dozzine - non si può confrontare a occhio, è necessario un confronto più formale.
E solo per automatizzare questo processo - ho dovuto scrivere una funzione che ordina proprio queste serie. E qui è stato utile, perché la classe CFactoryBalanceResultSeries è un erede di CObject con la sua funzione di confronto. Se sovrascriviamo questa funzione, abbiamo una pronta possibilità di ordinare le serie.
Ecco come appare questa funzione nel mio caso:
int CFactoryBalanceResultSeries::Compare(const CObject *poNode,constint iMode) const
{
CFactoryBalanceResultSeries* pfdsAnother = CONVERT_OBJECT_WITH_CHECK(poNode,CFactoryBalanceResultSeries,MOT_FACTORYBALANCERES_SERIES);
switch(iMode)
{
case FSM_BY_PART_OF_MAX_DD_A: return(_CompareByPartOfMaxDDWith(pfdsAnother,true));
case FSM_BY_PART_OF_MAX_DD_D: return(_CompareByPartOfMaxDDWith(pfdsAnother,false));
case FSM_BY_PART_OF_MAX_SLQUEUE_A: return(_CompareByPartOfMaxSLQueueWith(pfdsAnother,true));
case FSM_BY_PART_OF_MAX_SLQUEUE_D: return(_CompareByPartOfMaxSLQueueWith(pfdsAnother,false));
case FSM_BY_LAST_PRCDATA_A: return(_CompareByLastPrcdataWith(pfdsAnother,true));
case FSM_BY_LAST_PRCDATA_D: return(_CompareByLastPrcdataWith(pfdsAnother,false));
case FSM_BY_LAST_MNYDATA_A: return(_CompareByLastMnydataWith(pfdsAnother,true));
case FSM_BY_LAST_MNYDATA_D: return(_CompareByLastMnydataWith(pfdsAnother,false));
case FSM_BY_LAST_MNYLOTDATA_A: return(_CompareByLastMnylotdataWith(pfdsAnother,true));
case FSM_BY_LAST_MNYLOTDATA_D: return(_CompareByLastMnylotdataWith(pfdsAnother,false));
case FSM_BY_PRCYEARRECOVERY_A: return(_CompareByYearPrcrecoveryWith(pfdsAnother,true));
case FSM_BY_PRCYEARRECOVERY_D: return(_CompareByYearPrcrecoveryWith(pfdsAnother,false));
case FSM_BY_MNYYEARRECOVERY_A: return(_CompareByMnyYearRecoveryWith(pfdsAnother,true));
case FSM_BY_MNYYEARRECOVERY_D: return(_CompareByMnyYearRecoveryWith(pfdsAnother,false));
case FSM_BY_MNYLOTYEARRECOVERY_A:return(_CompareByMnylotYearRecoveryWith(pfdsAnother,true));
case FSM_BY_MNYLOTYEARRECOVERY_D:return(_CompareByMnylotYearRecoveryWith(pfdsAnother,false));
case FSM_BY_PRCVAR_A: return(_CompareByPrcVarWith(pfdsAnother,true));
case FSM_BY_PRCVAR_D: return(_CompareByPrcVarWith(pfdsAnother,false));
case FSM_BY_MNYVAR_A: return(_CompareByMnyVarWith(pfdsAnother,true));
case FSM_BY_MNYVAR_D: return(_CompareByMnyVarWith(pfdsAnother,false));
case FSM_BY_MNYLOTVAR_A: return(_CompareByMnylotVarWith(pfdsAnother,true));
case FSM_BY_MNYLOTVAR_D: return(_CompareByMnylotVarWith(pfdsAnother,false));
case FSM_BY_PRC_GRAILRATIO_A: return(_CompareByPrcGrailratioWith(pfdsAnother,true));
case FSM_BY_PRC_GRAILRATIO_D: return(_CompareByPrcGrailratioWith(pfdsAnother,false));
case FSM_BY_MAGIC_A: return(_CompareByMagicWith(pfdsAnother,true));
case FSM_BY_MAIGC_D: return(_CompareByMagicWith(pfdsAnother,false));
default:
break;
};
return(NULL);
};
Cioè, a seconda del tipo di ordinamento - selezioniamo la funzione di confronto richiesta, che viene utilizzata nella funzione di ordinamento generale.
Per esempio, se vogliamo ordinare la serie dei saldi in base alla parte dell'ultimo prelievo dal massimo, si useranno le seguenti funzioni:
A library for common rounding methods used in MQL development, primitive wrapper class for type (double), and vector for CDouble objects. MQL5 and MQL4 compatible! CDouble The CDouble class wraps a value of the primitive type double in an object. Additionally, this class provides several methods and static methods for rounding doubles and...
int CFactoryBalanceResultSeries::Compare(const CObject *poNode,constint iMode) const
{
CFactoryBalanceResultSeries* pfdsAnother = CONVERT_OBJECT_WITH_CHECK(poNode,CFactoryBalanceResultSeries,MOT_FACTORYBALANCERES_SERIES);
switch(iMode)
{
case FSM_BY_PART_OF_MAX_DD_A: return(_CompareByPartOfMaxDDWith(pfdsAnother,true));
case FSM_BY_PART_OF_MAX_DD_D: return(_CompareByPartOfMaxDDWith(pfdsAnother,false));
case FSM_BY_PART_OF_MAX_SLQUEUE_A: return(_CompareByPartOfMaxSLQueueWith(pfdsAnother,true));
case FSM_BY_PART_OF_MAX_SLQUEUE_D: return(_CompareByPartOfMaxSLQueueWith(pfdsAnother,false));
Ma, questo è il mio 'stile di programmazione' senile (ciao, Wolchansky con il suo recente thread).
Con me, tutte le enumerazioni - iniziano con E, e poi con la notazione "gobba" - nome. E i tipi stessi in enumerazione iniziano con un'abbreviazione (fino a quattro lettere) di tipo enumerazione.
Corrispondentemente, poiché l'enumerazione EMyObjectType - tutti i valori iniziano con MOT_
Sì, ho la stessa enumerazione.
ZS: Sono arrivato ora al computer. Come previsto, questo thread è rapidamente sceso nella spazzatura). Cercherò di finire la storia delle funzioni virtuali più tardi. Dovremmo chiamare questo forum Blah Blah Blah Blah).
Consenti l'uso dei cookie per accedere al sito MQL5.com.
Abilita le impostazioni necessarie nel browser, altrimenti non sarà possibile accedere.
Hai effettuato l'accesso. L'autenticazione a due fattori è stata disattivata. Configurala di nuovo e scansiona un nuovo codice QR, oppure continua con l'autenticazione a due fattori disattivata.
Buon punto. Sarebbe bello se gli argomenti fossero supportati da un codice piuttosto che solo bla, bla, bla.
Sostenere la cosa.
Ecco la mia classe CMyObject:
La macro CONVERT_OBJECT_WITH_CHECK è anche definita alla fine, che per la versione DEBUG esegue un ulteriore controllo di conversione del puntatore basato sul tipo di oggetto
Sostenere la cosa.
Ecco la mia classe CMyObject:
La macro CONVERT_OBJECT_WITH_CHECK è anche definita alla fine, che, per la versione DEBUG, esegue un ulteriore controllo di conversione del puntatore basato sul tipo di oggetto
È bellissimo. Naturalmente, è una questione di gusti. Ma, basandomi sulla sintassi MQL, lo scriverei così:
È bellissimo. Naturalmente, è una questione di gusti. Ma, basandomi sulla sintassi MQL, lo scriverei in questo modo:
Sì, proprio così.
Ma questo è il mio "stile di programmazione" senile (ciao, Volchansky con il suo recente thread).
Ho tutte le enumerazioni - iniziano con E, e poi con la notazione "gobba" - nome. E i tipi stessi in enumerazione iniziano con un'abbreviazione (fino a quattro lettere) di tipo enumerazione.
Di conseguenza, poiché l'enumerazione è EMyObjectType, tutti i valori iniziano con MOT_
Sei un idiota? )) Non ho detto una parola negativa su F#. Impara a leggere e a capire quello che ti viene detto prima di postare i tuoi stupidi commenti.
Se si confronta OOP con FP, è più sensato confrontarlo con un linguaggio FP puro, cioè Haskel. F# è già così così, mentre Python e R non lo sono affatto. Questo è quello che voglio dire. Altrimenti potremmo arrivare ad un punto in cui il C++ è anche un linguaggio FP.Sei un troll analfabeta. Per la cronaca, tutte le lingue elencate sono funzionali in un modo o nell'altro. Andate a imparare la materia. La domanda è stata posta per capire in quale quadro di riferimentoAndrei sta probabilmente praticando uno dei linguaggi della FP, quindi l'elenco era molto generale.
Cosa dovrebbe significare?
Cosa dovrebbe esserci nell'"oggetto base" secondo voi?
Personalmente ho quasi TUTTI gli oggetti in tutti i miei progetti - ereditati da CMyObject: public CObject, (nel mio oggetto sono aggiunti altri due campi - nome della classe e ID dell'istanza), e ripetutamente ho trovato che ho bisogno della funzionalità CObject::Compare() molto. Un paio di volte sono stati utili anche i puntatori di liste.
CObject ha un solo obiettivo: fornire il controllo dei tipi. E ci riesce traballantemente. Metodi come Next(), Prev(), ecc. sono per collezioni molto specializzate. Non appartengono a CObject. Lo stesso vale per i metodi Save e Load. Sarebbe bello non avere nemmeno Comparer, ma questa è l'unica soluzione senza interfacce.
Per quanto riguarda il metodo Type(), non fornisce una tipizzazione rigorosa, perché restituisce il solito numero. Potete vedere sull'esempio del vostro codice. Si definisce un nuovo metodo GetType() che restituisce il tipo come enumerazione. Non c'è davvero altro modo, lo faccio da solo. Per questo si deve aggiungere il CObject standard, ed è scorretto.
Continuiamo con CObject::Compare().
Ho tale oggetto CFactoryBalanceResultSeries - è una serie con risultati di bilanciamento con riferimento all'oggetto factory di Expert Advisor. In realtà è una curva di equilibrio sulla storia con riferimento all'Expert Advisor che l'ha scambiata.
Quindi ho uno script in cui confronto queste serie molto equilibrate.
Finché ci sono solo due serie è facile confrontarle. Ma quando ce ne sono dozzine - non si può confrontare a occhio, è necessario un confronto più formale.
E solo per automatizzare questo processo - ho dovuto scrivere una funzione che ordina proprio queste serie. E qui è stato utile, perché la classe CFactoryBalanceResultSeries è un erede di CObject con la sua funzione di confronto. Se sovrascriviamo questa funzione, abbiamo una pronta possibilità di ordinare le serie.
Ecco come appare questa funzione nel mio caso:
Cioè, a seconda del tipo di ordinamento - selezioniamo la funzione di confronto richiesta, che viene utilizzata nella funzione di ordinamento generale.
Per esempio, se vogliamo ordinare la serie dei saldi in base alla parte dell'ultimo prelievo dal massimo, si useranno le seguenti funzioni:
Continuerò con CObject::Compare().
Dal recente
Non è molto bello, imho.
Si potrebbe usare un puntatore a una funzione.
Sì, proprio così.
Ma, questo è il mio 'stile di programmazione' senile (ciao, Wolchansky con il suo recente thread).
Con me, tutte le enumerazioni - iniziano con E, e poi con la notazione "gobba" - nome. E i tipi stessi in enumerazione iniziano con un'abbreviazione (fino a quattro lettere) di tipo enumerazione.
Corrispondentemente, poiché l'enumerazione EMyObjectType - tutti i valori iniziano con MOT_
Sì, ho la stessa enumerazione.
ZS: Sono arrivato ora al computer. Come previsto, questo thread è rapidamente sceso nella spazzatura). Cercherò di finire la storia delle funzioni virtuali più tardi. Dovremmo chiamare questo forum Blah Blah Blah Blah).
Ho letto i diversi interessi di ognuno... Sono in procinto di ridisegnare una classe per impostare e gestire una griglia virtuale, ne ho bisogno.