Question

我有一个问题,是打破严格点别规则造成的。我有一个类型的<条码>。同一尺寸的斜线/代码(见sizeof)。我的法典基本上做到如下:

T x = some_other_t;
if (*reinterpret_cast <Int*> (&x) == 0)
  ...

由于<代码>T是某些可设构体的借方(但规模限制除外)类型,我不能将<代码>T和Int合并。 (只有C++0x允许使用,甚至得到海湾合作委员会的支持。)

我是否可以重写上述假代码,以维护功能并避免违反严格的别条规则? 请注意,这是一个模板,我无法控制<代码>T或<编码>_other_t;转让和随后的比较的确在模板代码内进行。

<>m>(关于记录,上述代码开始在海合会4.5上签字,如果<条码>, 包含任何领域。

Answer 1

static inline int is_T_0(const T *ob)
{
        int p;
        memcpy(&p, ob, sizeof(int));
        return p == 0;
}

void myfunc(void)
{
    T x = some_other_t;
    if (is_T_0(&x))
        ...

在我的系统中,海合会优化了is_T_0()和memcpy(,导致在myfunc(>上只发出几个组装指示。

Answer 2

您是否听取了<条码>boost:optional?

我必须承认,我不清楚这里的真正问题......但促进的是:选择允许按价值储存,但知道实际记忆是否已经启动。我也允许进行建筑和销毁,这样就能够成为一种适合我的想法。

www.un.org/Depts/DGACM/index_spanish.htm

我认为,我最后抓住了这个问题:你希望能够把许多物体分配给各个记忆点,你想知道,现在的记忆是否真的带有物体。

不幸的是,你的解决办法是一个巨大的问题:它是错误的。如果有的话,则。在某些方面,可以用<代码>null<>/code> 借方模式表示,然后,你就认为它是一个统一的记忆。

你们将不得不放弃,至少增加一线信息。在增长率仅为3%之后,这一增长并不真的(43比4比特)。

例如,你可以使用一些缩略语<代码>boost:optional,但采用阵列方式(以避免dding损失)。

template <class T, size_t N>
class OptionalArray
{
public:


private:
  typedef unsigned char byte;

  byte mIndex[N/8+1];
  byte mData[sizeof(T)*N]; // note: alignment not considered
};

之后,它简单地说:

template <class T, size_t N>
bool OptionalArray<T,N>::null(size_t const i) const
{
  return mIndex[i/8] & (1 << (i%8));
}

template <class T, size_t N>
T& OptionalArray<T,N>::operator[](size_t const i)
{
  assert(!this->null(i));
  return *reinterpret_cast<T*>(mData[sizeof(T)*i]);
}

<>note:为了简明起见,我没有审议一致性问题。如果你不了解这个主题,在回忆之前阅读:

Answer 3

使用33轨计算机。 —— P-3

Answer 4

为什么不简单:

const Int zero = 0;
if (memcmp(&some_other_t, &zero, sizeof(zero)) == 0)
  /* some_other_t is 0 */

(请设法在<条码>上添加<>static > 等到zero上,看它是否造成业绩上的改观”。)

Answer 5

如何做到这一点:

Int zero = 0;
T x = some_other_t;
if (std::memcmp(&x, &zero, sizeof(zero)) == 0)

这样做可能不像效率高,但应当摆脱警告。

ADDENDUM:

由于<代码>T限值与<代码>相同。 Int , make yourself a dummy bitwise amount of category T and compar direct against it (inboling and comparing agaist Int(0).

如果你的方案是单一阅读的,你可以有这样的内容:

template <typename T>
class Container
{
public:
    void foo(T val)
    {
        if (zero_ == val)
        {
            // Do something
        }
    }

private:
    struct Zero
    {
        Zero() {memset(&val, 0, sizeof(val));}
        bool operator==(const T& rhs) const {return val == rhs;}
        T val;
    };
    static Zero zero_;
};

如果经过多面阅读,你希望避免使用静态成员,并且每个箱子都有自己的zero_:

template <typename T>
class MTContainer
{
public:
    MTContainer() {memset(zero_, 0, sizeof(zero_));}

    void foo(T val)
    {
        if (val == zero_)
        {
            // Do something
        }
    }

private:
    T zero_;
};

ADDENDUM:

让我以另一种更简单的方式对上述增编进行阐述:

// zero is a member variable and is inialized in the container s constructor
T zero;
std::memset(&zero, 0, sizeof(zero));

T x = some_other_t;
if (x == zero)

友情链接