对OOP的帮助

[Dmitiry Ananiev]

我正在做这样的课。

class Strategy1
{
        Strategy1();
 };

class Strategy2
{
        Strategy (string sym);
}

现在我想调用一个对象阵列。

Strategy1 S[10];  // компилируется 
Strategy2 Z("EURUSD")[10]; // не компилируется 

如果构造函数在全局层面有参数，那么如何快速创建一个对象数组？

例如？先通过改变构造函数来创建对象，然后我如何在OnInit中用符号替换对象？

也许有一个更简单的解决方案？

[Georgiy Merts]

就个人而言，在这种情况下，我在对象上使用Init()函数。

首先，创建一个数组，然后为数组中的所有对象调用Init()函数，在这里可以设置所有参数。

用单独的函数初始化允许重新初始化对象，如果你在构造函数中初始化，你就不能重新初始化对象。

[Dmitiry Ananiev]

Georgiy Merts #:

就个人而言，在这种情况下，我在对象上使用Init()函数。

首先，创建一个数组，然后为数组中的所有对象调用Init()函数，在这里可以设置所有参数。

用单独的函数初始化允许重新初始化对象，如果你在构造函数中初始化，你就不能重新初始化对象。

嗯，这就是我的想象。谢谢!

[Ihor Herasko]

还有一点。最好是通过指针的方式来创建对象的数组。否则你会在堆栈内存中得到一个数组，这个数组非常小。

Strategy2 *pZ[]; 
if (ArrayResize(pZ, 10) != 10)
{
   Alert("Memory allocation error");
   return;
}

for (int i = 0; i < 10; ++i)
{
   pZ[i] = new Strategy2("EURUSD"); 
   if (CheckPointer(pZ) == POINTER_INVALID)
   {
      Alert("Class instantiation error");
      return;
   }
}

[fxsaber]

Ihor Herasko #:

还有一点。最好是通过指针的方式来创建对象的数组。否则你会在堆栈内存中得到一个非常低的数组。

如果有一个潜在问题的例子就好了。

[Vasiliy Sokolov]

Ihor Herasko #:

还有一点。最好是通过指针的方式来创建对象的数组。否则你会在堆栈内存中得到一个非常小的数组。

哎哟。

[TheXpert]

这没什么大不了的。

[Ihor Herasko]

fxsaber #:

举个潜在问题的例子就好了。

这不是一个问题，当然也不是一个潜在的问题。这只是MT中内存处理的特殊性。这里是一个静态数组。

#define               ARRAY_SIZE           int(60000000)
class Test
{
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};

Test classTest[ARRAY_SIZE];                   // 'classTest' - global variables section is too large
 
void OnStart()
{
}

而这里是一个动态阵列。

#define               ARRAY_SIZE           int(60000000)
class Test
{
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};

Test *pClassTest[];
 
void OnStart()
{
   if (ArrayResize(pClassTest, ARRAY_SIZE) != ARRAY_SIZE)
   {
      Alert("Not enought memory");
      return;
   }
   
   for (int i = 0; i < ARRAY_SIZE; ++i)
   {
      pClassTest[i] = new Test();
      if (CheckPointer(pClassTest[i]) == POINTER_INVALID)
      {
         Alert("Class instantiation error");
         return;
      }
   }

   for (int i = 0; i < ARRAY_SIZE; ++i)
      delete pClassTest[i];
}

在这种情况下，一切都能编译和工作。

[Vasiliy Sokolov]

Ihor Herasko #:

这不是一个问题，更不是一个潜在的问题。这只是MT中内存处理的特殊性。这里是一个静态数组。

而这里是一个动态阵列。

在这种情况下，一切都可以编译和工作。

堆栈与它有什么关系？在第一种情况下，你试图静态地（在编译阶段）在堆中分配一个大的内存块，而编译器公正地踢了你的额头，因为在现实中你是否能分配这么多的内存并不十分清楚。

在第二种情况下，你是在运行时已经分配了一大块内存。而且，你是否可以分配它，马上就清楚了，因为程序已经在使用机器的特定资源（内存）工作。

那么指针与此有什么关系呢？mql中的数组有两种类型，在编译时预定义的和动态的。不仅是指针*，通常的类字段也可以指向动态数组。所以在这里使用指针是绝对不靠谱的。

s.e. 对代码的印象很奇怪，比如指针、类、宏--完全不了解发生了什么事。

[Dmitry Fedoseev]

Ihor Herasko #:

这不是一个问题，更不是一个潜在的问题。这只是MT中内存处理的特殊性。这里是一个静态数组。

而这里是一个动态阵列。

在这种情况下，一切都能编译和工作。

错误的例子，这只是编译器的一个限制，并没有说什么，开发者只是这样决定。

如果有两个版本--其中一个有一个大的静态数组，另一个有一个小的静态数组，而且，看，当程序工作时，在一种情况下出现问题，例如，在递归调用一个函数时，而在另一种情况下，在同样的条件下，没有出现问题。这时你可以得出一个结论......关于鲜榨果汁的危害））））。

[Ihor Herasko]

Vasiliy Sokolov #:

堆栈与此有什么关系？在第一种情况下，你试图静态地（在编译阶段）在堆中分配一个大的内存块，编译器当之无愧地踢了你的头，因为在现实世界中，你是否能分配那么多的内存，一点也不清楚。

在第二种情况下，你是在运行时已经分配了一大块内存。而且，你是否可以分配它，马上就清楚了，因为程序已经在使用机器的特定资源（内存）工作。

那么指针与此有什么关系呢？mql中的数组有两种类型，在编译时预定义的和动态的。不仅是指针*，而且普通的类字段也可以指向动态数组。所以在这里使用指针是绝对不靠谱的。

s.e. 对代码的印象很奇怪，比如指针、类、宏--完全不了解发生了什么事。

如果我们把这个例子改变一下，在本地声明，并加上一个不那么可怕的数字，编译器会直接告诉我们问题出在哪里。

#property strict
#define               ARRAY_SIZE           int(140000)

class Test
{
   
public:
   int               nA;
   double            fB;
   datetime          dtC;

                     Test(void)
                       : nA(0)
                       , fB(1.0)
                       , dtC(__DATETIME__)
                     {
                     };
};
 
void OnStart()
{
   Test classTest[ARRAY_SIZE];    // the size of local variables is too large
}

如果你想和雷纳特争论，欢迎 你这样做。