1. É melhor falar sobre algo no lugar onde está, em vez de pensar em como o moderador o faria. Caso contrário, tudo realmente se desfez em dois fios, e agora, mesmo que o moderador decida que a discussão deve estar lá ou não, é uma tarefa bastante trabalhosa mover a discussão normalmente com a preservação da ordem dos postos e seu significado.
2) Discutir as ações de um moderador não é todo espirro... Não é todo espirro, mas se você quiser desafiá-lo publicamente, seja para restaurar a ordem ou acalmar um frenesi. E se você tem uma opinião, quem o proíbe de expressá-la? Talvez sua opinião seja uma sugestão muito racional, mas você tem medo de dizê-lo, para não cair no menu não amado do moderador? Então isso é uma besteira :)
Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.
Ainda não é como se você fosse um moderador, para determinar em qual linha o que é mais apropriado. E os moderadores já deixaram claro que a discussão das características deve ser em um ramo separado, ou seja, aqui, e não no ramo das características em si.
Em sua descrição, não está nada claro como se referir uniformemente a um método de classe por referência e por um valor do tipo T. Eu não sei do que você está falando, mas eu estava falando sobre isso mesmo.
Eis a situação: percebi que nem tudo pode ser adaptado às especificidades que os membros do fórum esperam ver nesse tópico. A discussão aqui é (e estava lá, então eu a mudei para cá) sobre um tópico bastante específico, que decidi separar em um fio à parte. Que haja mais geral e compreensível para a maioria das características, e aqui - aulas, formas complicadas de trabalhar com elas, incluindo macros (que quebra-cabeças para muitos).
Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.
Vamos manter as coisas assim a partir de agora. Basta - se possível - copiar o exemplo que você está discutindo de lá para seu próprio posto, o que se refere a esse exemplo (estou tendo dificuldade em descobrir onde ele começou). Ou, se você não puder mais editar seu posto, então me diga em particular de onde colar o quê.
Que a partir de agora continue assim. Basta - se possível - copiar o exemplo discutido de lá para o seu posto, que se refere a esse exemplo (é difícil para mim descobrir o que o iniciou aqui). Ou, se você ainda não pode editar seu posto, então me diga em particular de onde colar o quê.
Eu já copiei o código aqui desse tópico há um par de posts atrás, então nenhuma ação adicional é necessária, imho.
Atualização sobre o tema das interfaces através de modelos e estáticas. Para ser mais preciso, não interfaces, mas sim operações convenientemente parametrizáveis em tipos arbitrários, implementadas através de classes externas. Neste caso, a comparação (Comparador) e a fundição (Fundidor).
Abordei parcialmente as críticas anteriores, a classe "interface" (embora não seja uma interface) não é herdada da classe de parâmetros (tal método não pegou...), e sem usar o dynamic_cast, é claro. Esperemos que este modelo pareça mais lógico.
#property strict#define tnm typename#define ttt template<tnm T>
#define ttf template<tnm F>
#define ttr template<tnm R>
#define tft template<tnm T,tnm F>
#define up(P) (CheckPointer(P)!=POINTER_INVALID)
enum ECMP{ EQUAL=0, GREATER=1, LESSER=-1, UNDEF=INT_MAX };
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+
ttt class Type
{
private:
T item;
public:
Type(){ ZeroMemory( item ); }
Type *operator= (T par){ item = par; return &this; }
T Get(){ return item; }
ttf intoperator!= ( Type<F>&par )
{
int r = Comparer< Type< T > *, Type< F > * >::Get().Compare( &this, &par );
if( r == UNDEF ) printf("Cannot compare %s to %s!",tnm(T),tnm(F));
else{
printf("%s (%s) to %s (%s) is %s",
Caster<Type<T>*,string>::Get().Cast(&this), tnm(T),
Caster<Type<F>*,string>::Get().Cast(&par), tnm(F), Caster<ECMP,string>::Get().Cast((ECMP)r)); }
return r;
}
};
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+
tft class Comparer
{
private:
static Comparer *handle;
public:
Comparer(){ if( handle == NULL ) handle = &this; }
static Comparer *Get(){ return handle ; }
virtual ECMP Compare( T, F ){ return UNDEF; }
};
//---
tft Comparer *Comparer::handle=NULL;
tft class Caster
{
private:
static Caster *handle;
public:
Caster(){ if( handle == NULL ) handle = &this; }
static Caster *Get(){ return handle ; }
virtual F Cast( T ){ F r; ZeroMemory(r); return r; }
};
//---
tft Caster *Caster::handle=NULL;
ttt class ToStrCaster: public Caster<T,string>
{
public:
virtualstring Cast( T ){ return"N/A"; }
};
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+class CmpIntToInt: public Comparer<Type<int>*,Type<int>*>
{
public:
virtual ECMP Compare( Type<int>* op1, Type<int>* op2 ){ return ECMP(up(op1)&&up(op2)?(op1.Get()>op2.Get())-(op1.Get()<op2.Get()):UNDEF); }
}
citi;
class CmpDoubleToDouble: public Comparer<Type<double>*,Type<double>*>
{
public:
virtual ECMP Compare( Type<double>* op1, Type<double>* op2 ){
return ECMP(up(op1)&&up(op2)?int(op1.Get()-op2.Get()>DBL_EPSILON)-int(op2.Get()-op1.Get()>DBL_EPSILON):UNDEF); }
}
cdtd;
class CmpStrToStr: public Comparer<Type<string>*,Type<string>*>
{
public:
virtual ECMP Compare( Type<string>* op1, Type<string>* op2 ){
return ECMP(up(op1)&&up(op2)?StringCompare(op1.Get(),op2.Get()):UNDEF); }
}
csts;
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+class IntToStrCaster: public ToStrCaster<Type<int>*>
{
public:
virtualstring Cast( Type<int>* par ){ return up(par)?IntegerToString(par.Get()):NULL; }
}
itsc;
class DoubleToStrCaster: public ToStrCaster<Type<double>*>
{
public:
virtualstring Cast( Type<double>* par ){ return up(par)?DoubleToString(par.Get(),6):NULL; }
}
dtsc;
class StringToStrCaster: public ToStrCaster<Type<string>*>
{
public:
virtualstring Cast( Type<string>* par ){ return up(par)?par.Get():NULL; }
}
stsc;
class ECMPToStrCaster: public ToStrCaster<ECMP>
{
public:
virtualstring Cast( ECMP par ){ returnEnumToString(par); }
}
etsc;
//+------------------------------------------------------------------+//| |//+------------------------------------------------------------------+voidOnStart()
{
Type<int> t1=AccountNumber(), t2=AccountLeverage();
Type<double> t3=Ask, t4=Bid;
Type<string> t5=_Symbol;
t1!=t2;
t4!=t3;
t5!=t5;
t1!=t3;
t2!=t5;
}
Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhaseu não sei
Quão realista é fazer uma macro para esta seção de código?
ainda não decidiram o número de variáveis de entrada ( input ), cansados de corrigir a peça selecionada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei
Devo dizer de imediato que não o verifiquei no µl, apenas o passei por um pré-processador pardo para testes, o µl tem peculiaridades, se algo precisa ser afinado.
#define ARGS HLP(InDealType_) \
HLP(InVolType_), \
HLP(InVolume_), \
HLP(InPrice_), \
HLP(InVolCoeff_), \
HLP(InClosePips_), \
Mirror
#define _CAT(L, R) L##R
#define CAT(L, R) _CAT(L, R)
#define HLP(ARG) CAT(ARG, INDEX)
#define INDEX 01
EA.AddDealsSettings(ARGS);
#undef INDEX
#define INDEX 02
EA.AddDealsSettings(ARGS);
#undef INDEX
#define INDEX 03
EA.AddDealsSettings(ARGS);
#undef INDEX
Quão realista é escrever uma macro para esta seção de código?
Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei
Até agora, isto é tudo o que encontrei. Se os desenvolvedores aparafusassem um número variável de parâmetros, como em C, seria possível torná-lo mais curto.
Para login e uso do site MQL5.com, você deve ativar o uso de cookies.
Ative esta opção no seu navegador, caso contrário você não poderá fazer login.
Você entrou na conta. A autenticação de dois fatores foi desativada. Configure-a novamente e escaneie um novo código QR ou continue com a autenticação de dois fatores desativada.
1. É melhor falar sobre algo no lugar onde está, em vez de pensar em como o moderador o faria. Caso contrário, tudo realmente se desfez em dois fios, e agora, mesmo que o moderador decida que a discussão deve estar lá ou não, é uma tarefa bastante trabalhosa mover a discussão normalmente com a preservação da ordem dos postos e seu significado.
2) Discutir as ações de um moderador não é todo espirro... Não é todo espirro, mas se você quiser desafiá-lo publicamente, seja para restaurar a ordem ou acalmar um frenesi. E se você tem uma opinião, quem o proíbe de expressá-la? Talvez sua opinião seja uma sugestão muito racional, mas você tem medo de dizê-lo, para não cair no menu não amado do moderador? Então isso é uma besteira :)
Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.
Ainda não é como se você fosse um moderador, para determinar em qual linha o que é mais apropriado. E os moderadores já deixaram claro que a discussão das características deve ser em um ramo separado, ou seja, aqui, e não no ramo das características em si.
Em sua descrição, não está nada claro como se referir uniformemente a um método de classe por referência e por um valor do tipo T. Eu não sei do que você está falando, mas eu estava falando sobre isso mesmo.
Eis a situação: percebi que nem tudo pode ser adaptado às especificidades que os membros do fórum esperam ver nesse tópico. A discussão aqui é (e estava lá, então eu a mudei para cá) sobre um tópico bastante específico, que decidi separar em um fio à parte. Que haja mais geral e compreensível para a maioria das características, e aqui - aulas, formas complicadas de trabalhar com elas, incluindo macros (que quebra-cabeças para muitos).
Obrigado pelo esclarecimento. Achei melhor ter a discussão em um fio à parte para não desorganizar as informações supostamente valiosas no fio principal. Se você decidir mudar os postos, eu discutirei para onde os mudará.
Vamos manter as coisas assim a partir de agora. Basta - se possível - copiar o exemplo que você está discutindo de lá para seu próprio posto, o que se refere a esse exemplo (estou tendo dificuldade em descobrir onde ele começou). Ou, se você não puder mais editar seu posto, então me diga em particular de onde colar o quê.
Que a partir de agora continue assim. Basta - se possível - copiar o exemplo discutido de lá para o seu posto, que se refere a esse exemplo (é difícil para mim descobrir o que o iniciou aqui). Ou, se você ainda não pode editar seu posto, então me diga em particular de onde colar o quê.
Eu já copiei o código aqui desse tópico há um par de posts atrás, então nenhuma ação adicional é necessária, imho.
Eu já copiei o código desse tópico há um par de posts atrás, portanto não são necessários passos extras.
Bom.
Atualização sobre o tema das interfaces através de modelos e estáticas. Para ser mais preciso, não interfaces, mas sim operações convenientemente parametrizáveis em tipos arbitrários, implementadas através de classes externas. Neste caso, a comparação (Comparador) e a fundição (Fundidor).
Abordei parcialmente as críticas anteriores, a classe "interface" (embora não seja uma interface) não é herdada da classe de parâmetros (tal método não pegou...), e sem usar o dynamic_cast, é claro. Esperemos que este modelo pareça mais lógico.
Quão realista é escrever uma macro para esta seção de código?
Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhaseu não sei
Quão realista é fazer uma macro para esta seção de código?
ainda não decidiram o número de variáveis de entrada ( input ), cansados de corrigir a peça selecionada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei
Devo dizer de imediato que não o verifiquei no µl, apenas o passei por um pré-processador pardo para testes, o µl tem peculiaridades, se algo precisa ser afinado.
obteve a saída (gcc -E):
argumentos adicionais que você/doará para a lista ARGS.
Quão realista é escrever uma macro para esta seção de código?
Ainda não decidi o número de variáveis de entrada ( input ), estou cansado para corrigir a seção alocada, a macro para uma linha não é um problema, mas como multiplicá-la para 10-15 linhas eu não sei
Até agora, só assim surgiu. Se os desenvolvedores tivessem adicionado um número variável de parâmetros, como em C, ele poderia ser mais curto.
Até agora, isto é tudo o que encontrei. Se os desenvolvedores aparafusassem um número variável de parâmetros, como em C, seria possível torná-lo mais curto.
Algo que eu compliquei em demasia )).
E deixá-los usar o primeiro, provavelmente é o melhor.
#define TEST(dId)Não é um problema escrever o TESTE várias vezes.