Errori, bug, domande - pagina 1742
Ti stai perdendo delle opportunità di trading:
- App di trading gratuite
- Oltre 8.000 segnali per il copy trading
- Notizie economiche per esplorare i mercati finanziari
Registrazione
Accedi
Accetti la politica del sito e le condizioni d’uso
Se non hai un account, registrati
La guida afferma:
Nelle modalità di esecuzione "By Market" e "Exchange" la politica di riempimento "Return" è sempre consentita per tutti i tipi di ordine. Il permesso di altri tipi è controllato usando le proprietà SYMBOL_FILLING_FOK e SYMBOL_FILLING_IOC.
Ma non sempre. Quindi sui conti Robo "Return" non funziona, né su quelli Pro, né su quelli ECN.
La guida afferma:
Nelle modalità di esecuzione "By Market" e "Exchange" la politica di riempimento "Return" è sempre consentita per tutti i tipi di ordine. Il permesso di altri tipi è controllato usando le proprietà SYMBOL_FILLING_FOK e SYMBOL_FILLING_IOC.
Ma non sempre. Quindi, sui conti Robo "Return" non funziona, né su Pro, né su conti ECN.
Forum sul trading, sistemi di trading automatico e test di strategie di trading
Bug, bug, domande
fxsaber, 2016.10.20 08:24
SB su tutti i server di trading//| Get the property value "ORDER_TYPE_FILLING" |
//+------------------------------------------------------------------+
ENUM_ORDER_TYPE_FILLING COrderInfo::TypeFilling(void) const
{
return((ENUM_ORDER_TYPE_FILLING)OrderGetInteger(ORDER_TYPE_FILLING));
}
SEMPRE nel tester ritornaENUM_ORDER_TYPE_FILLING::ORDER_FILLING_RETURN.
Ecco perché se si imposta il riempimento in OrderModify tramite COrderInfo::TypeFilling(), allora sullo stesso RoboForexEU-MetaTrader 5 ci sarà un errore logico [Unsupported filling mode]. Tuttavia, questo errore non si verifica in MetaQuotes-Demo - server dello sviluppatore configurato male?
La guida afferma:
Nelle modalità di esecuzione "By Market" e "Exchange" la politica di riempimento "Return" è sempre consentita per tutti i tipi di ordine. Il permesso di altri tipi è controllato usando le proprietà SYMBOL_FILLING_FOK e SYMBOL_FILLING_IOC.
Ma non sempre. Per esempio, "Return" non funziona sui conti Robo, né su quelli Pro, né su quelli ECN.
Ho il sospetto che l'impostazione "Ritorno" sia di default su tutti i server di trading (almeno FxPro ha risposto così.
Forum sul trading, sistemi di trading automatico e test di strategie di trading
Modalità di riempimento dei server
Karputov Vladimir, 2016.10.14 19:18
Modalità di riempimento "Ritorno":
Ritorna
Nessun ID
Questa modalità è usata per gli ordini di mercato (Acquisto e Vendita), limite e stop-limit e solo nelle modalità "Esecuzione a mercato" e "Esecuzione in borsa". In caso di esecuzione parziale, un ordine di mercato o limite con un volume residuo non viene rimosso, ma rimane in vigore.
Ecco la risposta della società di intermediazione riguardo allamodalità "Ritorno
Il nostro esperto di MT5 ha confermato con Metaquotes che il ritorno è usato di default, e viene applicato quando non si sceglie nulla sul riempimento.
)
In altre parole - è una specie di stub.C'è il sospetto che l'impostazione di riempimento "Return" sia il default per tutti i server di trading (almeno, FxPro ha risposto come tale).
In altre parole - è una specie di stub.In alcune aziende (in particolare MT5 è stato lanciato di recente) è necessario specificare chiaramente il tipo di riempimento - se non si specifica, ci sarà un errore.
Anche se, in Robo, il server restituisce true per il controllo "Return", ma in realtà, questo tipo di riempimento non funziona. In breve, è un casino totale con questi riempimenti.
{
public:
virtual int f()
{
Print(__FUNCSIG__);
return(0);
}
};
class B : public A
{
public:
virtual int f()
{
Print(__FUNCSIG__);
return(0);
}
};
void OnStart()
{
// A* b = new B;
B* b = new B;
((A*)b).f();
delete b;
}
Ho capito bene che se il virtuale nel discendente è sovrascritto, il virtuale di base non può mai essere raggiunto? Cioè non c'è modo di chiamare A::f da b.
Quasi. In C++, è consentita la seguente voce:
b.A::f();
Ma qui non si può fare. Quindi, solo ed esclusivamente per stampella:
{
public:
virtual int f()
{
Print(__FUNCSIG__);
return(0);
}
int f1()
{
return A::f();
}
};
Quasi. In C++, è consentita la seguente voce:
b.A::f();
Allora non capisco perché funziona in C++. Dopo tutto, un virtuale sovrascritto nella tabella dei metodi virtuali dovrebbe essere completamente sovrascritto. E non ci dovrebbe essere traccia di quella base.
Ma è impossibile farlo qui. Ecco perché è solo per stampella:
{
public:
virtual int f()
{
Print(__FUNCSIG__);
return(0);
}
int f1()
{
return A::f();
}
};
Dopo tutto, l'overridden virtual nella tabella dei metodi virtuali dovrebbe essere completamente sovrascritto. E non dovrebbe esserci traccia del metodo base.
Se il tipo è specificato esplicitamente, il metodo viene chiamato direttamente, senza usare la tabella delle funzioni virtuali.
In questo modo, anche una funzione virtuale pura può essere chiamata se ha un corpo.
Allora A* b = new B; non funzionerà.
In questo caso, avete bisogno di un'altra stampella: spostare gli interni della funzione nella classe base in un metodo non virtuale e chiamarlo dentro quello virtuale. Poi potremmo chiamare esplicitamente i metodi non virtuali dalla classe base e dall'erede.
Se il tipo è specificato esplicitamente, il metodo viene chiamato direttamente, senza usare la tabella delle funzioni virtuali.
Anche una funzione puramente virtuale può essere chiamata in questo modo se ha un corpo.
In questo caso, abbiamo bisogno di un'altra stampella, che sarebbe quella di spostare gli interni della funzione in un metodo non virtuale della classe base e chiamarlo dentro quello virtuale. Poi, potreste chiamare esplicitamente il metodo non virtuale sia dalla base che dal discendente.