Question

我有一个主要用于“结构化”缓冲区的类。一个客户端通常用于写入，另一个用于读取。对于写入，类会设置默认值，但是对于读取，它应该不管它。

class Formatter
{
public:
  //! Used by writer
  Formatter( unsigned char* Buffer ) :
    m_Buffer( Buffer )
  {
      Buffer[ 0 ] = 1; //say this is the format
  }

  //! Used by reader
  Formatter( const unsigned char* Buffer ) :
    m_Buffer( Buffer )
  {

  }

  //...Other methods returns pointer to structure

private:
  unsigned char* m_Buffer;
};

这里的问题是读者很容易通过传入非const缓冲区来犯错误。

//..assume pBuffer is non-const
//We really want to read
const Formatter myFormatter( pBuffer );
//We really want const Formatter myFormatter( const_cast<const unsigned char*>(pBuffer) );

我真的无法想象一种防止用户犯这个错误的好方法，而不会让用户明白。

任何人都知道一个很好的伎俩吗？

提前致谢。

Answer 1

self.job_id

这里我们使用标记标记具有不同语义的构造函数。意外使用几乎是不可能的。您通过传递struct writer_access {}; Formatter( writer_access, unsigned char* Buffer ) :

来调用它

Answer 2

我想到了两个技巧：

使SELECT CAT_CD, PRD_CD, PTG_CAT, HN, OTC_FL, CASE WHEN PTG_CAT = '1' THEN 'MEGA POWER' WHEN PTG_CAT = '2' THEN 'POWER' WHEN PTG_CAT = '3' THEN 'NEW' WHEN PTG_CAT = '4' THEN 'OTHERS' WHEN HN = 'H' OR HN = 'E' THEN 'POWERHERBALEYE' END AS "BRAND_CATEGORY" FROM PROD_TG_CAT抽象并提供它的子类，一个用于阅读，一个用于写作：
```
Formatter
```

为这两个任务创建两个静态成员函数：

class ReadFormatter : public Formatter {
  public:
    ReadFormatter(const unsigned char*);
};

class WriteFormatter : public Formatter {
  public:
    WriteFormatter(unsigned char*);
};

IMO子类化将是更好的方式。

常量和重载的构造函数

2 个答案: