Este é um exemplo da documentação mql5. Aqui está o link para essa página. E abaixo está este código.
//+------------------------------------------------------------------+//| Класс с конструктором по умолчанию |//+------------------------------------------------------------------+class CFoo
{
datetime m_call_time; // время последнего обращения к объектуpublic:
//--- конструктор с параметром, имеющем значение по умолчанию, не является конструктором по умолчанию
CFoo(constdatetime t=0){m_call_time=t;};
//--- конструктор копирования
CFoo(const CFoo &foo){m_call_time=foo.m_call_time;};
string ToString(){return(TimeToString(m_call_time,TIME_DATE|TIME_SECONDS));};
};
//+------------------------------------------------------------------+//| Script program start function |//+------------------------------------------------------------------+voidOnStart()
{
// CFoo foo; // такой вариант использовать нельзя - конструктор по умолчанию не задан//--- допустимые варианты создания объекта CFoo
CFoo foo1(TimeCurrent()); // явный вызов параметрического конструктора
CFoo foo2(); // явный вызов параметрического конструктора с параметром по умолчанию
CFoo foo3=D'2009.09.09'; // неявный вызов параметрического конструктора
CFoo foo40(foo1); // явный вызов конструктора копирования
CFoo foo41=foo1; // неявный вызов конструктора копирования
CFoo foo5; // явный вызов конструктора по умолчанию (если конструктор по умолчанию отсутствует,// то вызывается параметрический конструктор с параметром по умолчанию)//--- допустимые варианты получения указателей CFoo
CFoo *pfoo6=new CFoo(); // динамическое создание объекта и получение указателя на него
CFoo *pfoo7=new CFoo(TimeCurrent());// ещё один вариант динамического создания объекта
CFoo *pfoo8=GetPointer(foo1); // теперь pfoo8 указывает на объект foo1
CFoo *pfoo9=pfoo7; // pfoo9 и pfoo7 указывают на один и тот же объект// CFoo foo_array[3]; // такой вариант использовать нельзя - конструктор по умолчанию не задан//--- выведем значения m_call_timePrint("foo1.m_call_time=",foo1.ToString());
Print("foo2.m_call_time=",foo2.ToString());
Print("foo3.m_call_time=",foo3.ToString());
Print("foo4.m_call_time=",foo4.ToString());
Print("foo5.m_call_time=",foo5.ToString());
Print("pfoo6.m_call_time=",pfoo6.ToString());
Print("pfoo7.m_call_time=",pfoo7.ToString());
Print("pfoo8.m_call_time=",pfoo8.ToString());
Print("pfoo9.m_call_time=",pfoo9.ToString());
//--- удалим динамически созданные объектыdelete pfoo6;
delete pfoo7;
//delete pfoo8; // удалять pfoo8 явно не нужно, так как он указывает на автоматически созданный объект foo1//delete pfoo9; // удалять pfoo9 явно не нужно, так как он указывает на тот же объект, что и pfoo7
}
Em que base foi abolida a conversão de objectos não constantes em objectos constantes? Tenho centenas de métodos internos que deixam de funcionar, só porque não são constantes, e as viseiras não podem agora ser usadas em objectos constantes. Centenas das minhas funções estão ligadas à constante CObject.Compare(....) e agora nem todas funcionam!
Se "A" contém um método não-constante, mas é ele próprio passado para uma função como um objecto constante, então este método não-constante não pode ser chamado na função agora.
class A
{
public:
void PrintMyName(){printf("my name A");}
};
void f(const A* a)
{
a.PrintMyName(); //Хренушки. Теперь PrintMyName должен быть константым.
}
voidOnStart()
{
A a; //не const A
f(GetPointer(a));
}
E agora a questão da atenção: vamos limpar o CObject.Comparar():
virtualint Compare(
CObject const * node, // элемент int mode=0// вариант
) const
Também é um método constante que toma um nó de objecto constante. É o seu direito de declarar o nó como constante. Mas em que base deve agora comparar apenas com métodos constantes de nodo? O nó não é obrigado a ter métodos constantes para efeitos de comparação. Mas acontece que só com base no facto de o objecto ser complexo e não ter métodos constantes, agora não pode usar a biblioteca padrão com tudo o que ela implica!!!
Se "A" contém um método não constante, mas é ele próprio passado para a função como um objecto constante, então este método não constante não pode agora ser chamado na função.
É isso mesmo, é assim que deve ser, caso contrário, qual é o objectivo de especificar
Se "A" contém um método não constante, mas é ele próprio passado para a função como um objecto constante, então este método não constante não pode agora ser chamado na função.
Hum, esta é na verdade a maneira chique de o fazer.
Por favor, afixe todo o seu código.
Este é um exemplo da documentação mql5. Aqui está um link para essa página. E abaixo está este código.
Parece que com a actualização, não só foi introduzida acolocação obrigatória de membros de dados estáticos de classe,
mas também eliminou a chamada implícita para o construtor paramétrico.
Utilizar uma chamada explícita:
Com que fundamentos cancelaram a conversão de objectos não constantes em objectos constantes?
Tudo se compila normalmente - sem erros ou avisos
Se houver algum erro, ele está apenas em estrutura, mas acabarão por chegar a elesTudo se compila sem erros ou avisos
Se "A" contém um método não-constante, mas é ele próprio passado para uma função como um objecto constante, então este método não-constante não pode ser chamado na função agora.
E agora a questão da atenção: vamos limpar o CObject.Comparar():
Também é um método constante que toma um nó de objecto constante. É o seu direito de declarar o nó como constante. Mas em que base deve agora comparar apenas com métodos constantes de nodo? O nó não é obrigado a ter métodos constantes para efeitos de comparação. Mas acontece que só com base no facto de o objecto ser complexo e não ter métodos constantes, agora não pode usar a biblioteca padrão com tudo o que ela implica!!!É agora obrigatória a colocação de membros estáticos.
E como é suposto colocar objectos estáticos complexos se os construtores estáticos não são permitidos?
Se "A" contém um método não constante, mas é ele próprio passado para a função como um objecto constante, então este método não constante não pode agora ser chamado na função.
É isso mesmo, é assim que deve ser, caso contrário, qual é o objectivo de especificar
em vez de
void f(A* a)Se "A" contém um método não constante, mas é ele próprio passado para a função como um objecto constante, então este método não constante não pode agora ser chamado na função.
E como é suposto colocar objectos estáticos complexos se os construtores estáticos não são permitidos?