Pergunta datilografada - página 4

Novo comentário
 
Ilya Malev:

Não está muito claro qual é o problema. A inicialização do objeto não poderia ser colocada em um método separado como o Init(), talvez até mesmo virtual?

Sim, é claro. Não poderia class.get_int()/class.get_double()/class.get_string()/... ?)). Estilo, hábito ...

 
pavlick_:

É claro que você pode. Não poderia class.get_int()/class.get_double()/class.get_string()/. ?)). Estilo, hábito ...

Podemos, mas vamos escrever d=var[x].get_double em vez de d=var[x] onde quer que haja double d, var[];. Se vamos nos engajar no masoquismo, devemos fazê-lo coletivamente =))

 
Ilya Malev:

Assim, no final das contas, trata-se do desejo de introduzir em mql a capacidade de sobrecarregar as operações de digitação (inclusive implícita), ou seja, definir um contexto de chamada de método e, dependendo do esperado neste contexto, o tipo de valor de retorno para chamar o código requerido.

Isto obviamente não é um padrão C++, e em geral, o bom do C++ (e foi tomado pelos desenvolvedores do MQL como base) é que tudo em C++ que o programador não conseguia lidar explicitamente, ele tinha que trabalhar com as dicas e escrever seu tipo dedactilografia

um ponteiro é apenas um ponteiro para um endereço de memória, você sempre pode passá-lo como um parâmetro e obtê-lo como resultado de uma função, desreferenciar um ponteiro lhe dá um valor físico em bytes de memória, converter um ponteiro para seu novo tipo lhe dá muitos bytes de memória ))))

Na MQL, os indicadores são difíceis de dizer por que, mas eles estão lá, os desenvolvedores disseram que a prioridade é a proteção de dados, por isso todas as inovações que poderiam levar a saídas de caixas de areia são excluídas



sobre o assunto, infelizmente tenho pouca prática trabalhando com modelos ( template ), mas suspeito que você possa fazê-lo:

1. escrever algumas funções sobrecarregadas que retornam o tipo exigido como resultado, e tomar esse tipo como parâmetro, ou seja, como este:

//+------------------------------------------------------------------+
int f(const int x)
  {
   return((int)1);
  };
//+------------------------------------------------------------------+
double f(const double x)
  {
   return((double)2);
  }
//+------------------------------------------------------------------+
string f(const string x)
  {
   return((string)3);
  }
//+------------------------------------------------------------------+
void OnStart()
  { 
   int    a=0;
   double b=0;
   string c="0";
   a = f(a);
   b = f(b);
   c = f(c);
   Print("a = ",a);
   Print("b = ",b);
   Print("c = ",c);
}

2. agora a função f() precisa ser envolvida em um modelo e esconder o parâmetro x - se os modelos permitirem, então a chamada será a=f() - visualmente tudo será agradável, como digitar

 
Igor Makanu:

obviamente não é um padrão C++

Eu acho que você está errado - embora eu não tenha escrito em C++ "puro" por muito tempo, há muitos exemplos de código como este na web

class A
{
public:
    operator int()const;
};

A::operator int()const
{
    return 0;
}
 
Ilya Malev:

Eu acho que você está errado - embora eu não tenha escrito em C++ "puro" por muito tempo, mas a web está cheia de exemplos de código como este

Mas e se for um tipo complexo? - Uma estrutura ou uma matriz? Em C++ isto foi resolvido usando ponteiros para seu tipo, fisicamente o compilador retornou o endereço de memória e desreferenciando o ponteiro garantiu que os dados foram tratados corretamente

 
Igor Makanu:

Este exemplo funcionaria corretamente, mas e se for um tipo complexo? - Em C++ isto foi resolvido com apontadores para seu tipo, fisicamente o compilador retornou o endereço da memória e o desreferenciamento do ponteiro forneceu o tratamento correto dos dados

Tal exemplo não funcionaria corretamente em mql, infelizmente.

Um tipo, estrutura ou matriz complexa pode sobrecarregar o que você precisar, não requer sobrecarga de conversão de tipo...

 
Ilya Malev:

Em mql tal exemplo não funcionaria corretamente, infelizmente.

Bem, sim, acabei de ver, você quer sobrecarregar a conversão do tipo, a ajuda da MQL diz claramente que é permitido sobrecarregar, e as operações unárias são sobrecarregadas apenas como unárias e binárias, respectivamente, eu estava trabalhando com matrizes, tentei sobrecarregar ^ - não funciona, eu tive que usar!

  • бинарные +,-,/,*,%,<<,>>,==,!=,<,>,<=,>=,=,+=,-=,/=,*=,%=,&=,|=,^=,<<=,>>=,&&,||,&,|,^;
  • unário +,-,++,--,~;
  • operador de atribuição =;
  • operador de indexação [].


Eu posso retornar((1/x) - e posso dar uma string string como parâmetro x. Normalmente todos os compiladores C verificam a correspondência do tipo em tempo de compilação, e o MQL não permite envolver soluções ambíguas emtemplates.

imho, seu problema - pós 1 do tópico, em MQL pode ser resolvido corretamente, apenas descrevendo todas asfunções sobrecarregadas. Então, todos os tipos de variáveis que são passadas e retornadas e todas as funções sobrecarregadas serão verificadas no momento da compilação.

 
Igor Makanu:

Sim, eu acabei de ver, você quer sobrecarregar a conversão do tipo, a ajuda da MQL diz claramente que a sobrecarga é permitida, e as operações unárias são sobrecarregadas apenas como unárias e binárias respectivamente, eu estava trabalhando com matrizes, tentei sobrecarregar ^ - não funciona, eu tive que usar !

Posso afirmar por 99% que não existe tal situação em que ^ não possa sobrecarregar, enquanto ! E a capacidade de sobrecarga não depende do tipo de operador. Você deve ter entendido mal alguma coisa. Basta colocar este exemplo aqui, mas se você já esqueceu e esqueceu, é melhor não o fazer).

A única limitação que encontrei em relação ao tipo de operador é uma proibição de sobrecarga de operadores lógicos ==, !=, ! e = como aplicado aos ponteiros (qualquer_tipo * ). Sobrecarregá-los corretamente requer ou trabalhar com autobjetos ou estruturas. Só nos últimos meses eu comi muitos cães nessas coisas, então posso falar com confiança :)

 
Ilya Malev:

Posso dizer por 99% que não há situação em que ^ não sobrecarregue, mas ! sobrecarrega. E a capacidade de sobrecarga não depende do tipo de operador. Você deve ter entendido mal alguma coisa. Basta colocar este exemplo aqui, mas se você já esqueceu e esqueceu, é melhor não o fazer).

A única restrição que encontrei com relação aos tipos de operadores é uma proibição de sobrecarga dos operadores lógicos ==, !=, ! e = aplicada aos ponteiros (qualquer_tipo * ). Sobrecarregá-los corretamente requer ou trabalhar com autobjetos ou estruturas. Nos últimos meses tenho comido muitos desses truques, então posso dizer com confiança :)

#include <Math\Alglib\linalg.mqh>
class Matrix
  {
public:
   CMatrixDouble     M;
   int               row;//m_strok;
   int               col;//n_stolb;
   void              Matrix(void)         {                             }
   void              Matrix(int m,int n)  { M.Resize(m,n); row=m;col=n; }
   //----      умножение матриц
   Matrix operator*(const Matrix &B){Matrix res(this.row,B.col);CAblas::RMatrixGemm(this.row,B.col,this.col,1.0,this.M,0,0,0,B.M,0,0,0,0,res.M,0,0);return(res);  }
   //----      транспонирование матрицы
   Matrix operator!(void){Matrix res(this.col,this.row);CAblas::RMatrixTranspose(this.row,this.col,this.M,0,0,res.M,0,0);return(res);                             }
   //----      нулевая матрица
   void              zeros(int r,int c) {this.M.Resize(r,c);this.row=r;this.col=c;for(int i=0;i<r;i++){for(int j=0;j<c;j++){this.M[i].Set(j,0.0);}}               }
   //----      вывод в журнал матрицы
   void MatrixPrint(string  separator="|",uint digits=3){string s,sep=" "+separator+" ";for(int i=0;i<row;i++){s=separator;for(int j=0;j<col;j++) s+=DoubleToString(M[i][j],digits)+sep;Print(s);Sleep(123);}}
private:
   void              Matrix(const Matrix &R) { this=R;                                                                                                            }
  };

No manuseio "clássico" de matrizes você precisa usar ^ operador para transpor matrizes, aqui está meu exemplo - eu portei o método SSA da Matlab, é a mais simples multiplicação, atribuição e transposição de matrizes baseadas no CMatrixDouble - ele ... não sabe o tamanho das matrizes que armazena (quantas filas e colunas tem).

 
P.S., ah, ou seja, você queria sobrecarregar um operador binário como unário (2ar como 1ar), então sim, é claro que não vai. A única exceção é []
12345678910
Novo comentário