错误、漏洞、问题

fxsaber 2017.04.25 06:19 #18731

Koldun Zloy:

如果你确定构造函数必须是私有的，那就没有别的办法了。

智能指针是一个包含简单指针的对象，并确保它被及时删除。

这是最简单的选择。

还有更复杂的智能指针。

这本书中对他们写得非常好：https://rsdn.org/res/book/cpp/cpp_real_programmers.xml

谢谢你!尝试了不同的变体，但没有效果

template <typename T>
struct PTR
{
  T* Ptr;
  
  PTR( void )
  {
  }
  
  void operator =( T* &Value )
  {
    this.Ptr = Value;
  }
  
  ~PTR( void )
  {
    Print(__FUNCSIG__);
    delete this.Ptr;
  }
};

class CLASS
{
private:
  static CLASS* Tmp;
  static PTR<CLASS> Ptr;
  
  CLASS()
  {
    CLASS::Ptr = CLASS::Tmp;
  }
};

static CLASS* CLASS::Tmp = new CLASS;
static PTR<CLASS> CLASS::Ptr;

void OnStart()
{
}

事实上，这也是符合逻辑的，因为它不起作用。你不能让一个智能指针的析构器在类的析构器之前被调用。

fxsaber 2017.04.25 07:05 #18732

编译器没有指定错误和错误发生的位置，而是给出了一个未指定的内部错误#112

class CLASS {};

template <typename T>
class CLASS2
{
public:
  static void Func() {}
};

void OnStart()
{
  CLASS2<CLASS>::Func;  
}

Koldun Zloy 2017.04.25 07:22 #18733

fxsaber:
谢谢你!我尝试了不同的变体，但它们不起作用。

实际上，这是不符合逻辑的。你不能让一个智能指针的析构器在类的析构器之前被调用。

试试下面的方法。

template < typename T >
struct PTR
{
  T* Ptr;
  
  PTR( T* Value ) : Ptr( Value )
  {
  }
  
  ~PTR()
  {
    Print(__FUNCSIG__);
    delete Ptr;
  }
};

class CLASS
{
private:
  static PTR< CLASS > Ptr;
  
public:
  CLASS()
  {
      Print(__FUNCSIG__);
  }
  ~CLASS()
  {
      Print(__FUNCSIG__);
  }
};

static PTR< CLASS > CLASS::Ptr( new CLASS );

void OnStart()
{
}

我不知道你在做什么，但在MQL中，使构造函数私有化只对单子有意义。

fxsaber 2017.04.25 07:53 #18734

Koldun Zloy:

这样试试吧。

谢谢你的详细例子!不幸的是，它没有一个封闭的构造函数。当然，封闭式的就不是这样了。

我需要的是存在一个不为人知的物体。同时，也不能以任何方式创建这种类型的其他对象。

fxsaber 2017.04.25 08:12 #18735

在这种情况下，是否正确

class CLASS
{
public:
  ~CLASS()
  {
    static bool FirstRun = true;
    
    if (FirstRun && CheckPointer(&this) == POINTER_DYNAMIC)
    {
      FirstRun = false;
      
      delete &this;
    }
    
    Print(__FUNCSIG__);
  }
};

void OnStart()
{
  CLASS* Class = new CLASS;
  delete Class;
}

将其输出到执行日志？

void CLASS::~CLASS()
void CLASS::~CLASS()
delete invalid pointer

而且，构造函数/析构函数的__FUNCSIG__给出了一个空的类型，这是否正确？

fxsaber 2017.04.25 08:34 #18736

Koldun Zloy:

这样试试吧。

为什么在你的版本中，智能指针的析构器在类的析构器之前被调用，而在我的版本中则相反（尽管构造函数是公共的）？

Koldun Zloy 2017.04.25 09:06 #18737

fxsaber:

我需要有一个对所有人都隐藏的对象。同时，这种类型的另一个对象也不能以任何方式被创建。

这就是它的名字。"单子"。

为什么你说它不适合你？

下面是一个单子的例子。

template < typename T >
struct PTR
{
   T* Ptr;
   
   PTR() : Ptr( NULL ){}
   PTR( T* ptr ) : Ptr( ptr )
   {
   }
   
   ~PTR()
   {
      Print(__FUNCSIG__);
      if( Ptr )delete Ptr;
   }
   
   void Set( T* ptr )
   {
      Ptr = ptr;
   }
};

class CLASS
{
   static PTR< CLASS > sPtr;
   
   CLASS()
   {
      Print(__FUNCSIG__);
   }
   
public:
   ~CLASS()
   {
      Print(__FUNCSIG__);
   }
   
   static CLASS* GetPtr()
   {
      if( !sPtr.Ptr ){
         sPtr.Set( new CLASS );
      }
      return sPtr.Ptr;
   }
};

static PTR< CLASS > CLASS::sPtr;

void OnStart()
{
   CLASS* ptr = CLASS::GetPtr();
}

Koldun Zloy 2017.04.25 09:07 #18738

fxsaber:
在这种情况下，是否正确
将其输出到执行日志？

而且，构造函数/析构函数的__FUNCSIG__给出了一个空的类型，这是否正确？

永远不要做

delete &this;

Sergey Dzyublik 2017.04.25 09:23 #18739

fxsaber:
在这种情况下，将其输出到执行日志中是否正确？

而构造函数/析构函数的__FUNCSIG__输出void-type，这是否正确？

是的，它是。

fxsaber 2017.04.25 09:32 #18740

Koldun Zloy:

这就是它的名字。"单子"。

为什么你说它不适合你？

下面是一个单子的例子。

非常感谢你，它的工作原理!

template < typename T >
struct PTR
{
   T* Ptr;
   
   PTR( void ) : Ptr(NULL)   
   {
   }
   
   PTR( T* ptr ) : Ptr(ptr)
   {
   }
   
   ~PTR( void )
   {
     if (this.Ptr)
       delete this.Ptr;
   }
   
   bool Set( T* ptr )
   {
      this.Ptr = ptr;
      
      return(true);
   }
   
   void operator =( bool )
   {
   }
};

class CLASS
{
private:   
   static PTR<CLASS> sPtr;
   
   CLASS()
   {
   }
   
public:
  static bool Set()
  {
    return(CLASS::sPtr.Ptr ? false : CLASS::sPtr.Set(new CLASS));
  }
};

static PTR<CLASS> CLASS::sPtr = CLASS::Set();

void OnStart()
{
}

但它仍然是一个谜。

关于交易、自动交易系统和策略测试的论坛

虫子、虫子、问题

fxsaber, 2017.04.25 10:34

为什么在你的版本中，智能指针的析构器被调用在类的析构器之前，而在我的版本中则相反（即使构造函数是公共的）？

错误、漏洞、问题 - 页 1874