Псевдоним строгого указателя: любое решение для конкретной проблемы?

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))
        ...

В моей системе GCC оптимизирует как is_T_0(), так и memcpy(), в результате чего в myfunc() всего несколько инструкций по сборке.

Вы слышали о boost::optional ?

Я должен признать, что мне неясна реальная проблема здесь... но boost::Optional позволяет сохранять по значению и при этом знать, была ли инициализирована фактическая память. Я также допускаю строительство и разрушение на месте, так что, думаю, это может подойти.

ИЗМЕНИТЬ:

Я думаю, что наконец понял проблему: вы хотите иметь возможность размещать множество объектов в различных точках памяти, и вы хотели бы знать, действительно ли память в этот момент содержит объект или нет.

К сожалению, у вашего решения есть огромная проблема: оно неверно. Если когда-нибудь T можно каким-то образом представить null битовым шаблоном, то вы подумаете, что это унитаризованная память.

Вам придется прибегнуть к помощи, чтобы добавить хотя бы один бит информации. На самом деле это немного, ведь это всего 3% прироста (33 бита на 4 байта).

Вы могли бы, например, использовать некоторую имитацию boost::optional, но в виде массива (чтобы избежать потери заполнения).

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]);
}

примечание. Для простоты я не рассматривал вопрос выравнивания. Если не разбираетесь в теме, прочтите о ней, прежде чем возиться с памятью :)

Как насчет этого:

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

Это может быть не так эффективно, но должно избавиться от предупреждения.

ПРИЛОЖЕНИЕ №1:

Поскольку T ограничено тем же размером, что и Int, создайте себе фиктивное побитовое нулевое значение типа T и сравните непосредственно с ним (вместо приведения и сравнения с 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_ и иметь каждый экземпляр контейнера, содержащий свой собственный член 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_;
};

ПРИЛОЖЕНИЕ №2:

Позвольте мне изложить вышеприведенное дополнение по-другому, проще:

// 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)

Почему бы не просто:

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

(вы можете попробовать добавить квалификатор static к zero, чтобы увидеть, влияет ли это на производительность)

Используйте 33-битный компьютер. ;-П

Похоже на хак, но, видимо, я нашел решение: использовать volatile для приведения Int. По сути, то, что я делаю сейчас, это:

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

Проблема с битовым полем T ушла. Тем не менее, я не очень доволен этим, поскольку volatile не очень хорошо определен в С++ AFAIK...