Безопасно ли переносить двойное число через int в C ++ 03?

РЕДАКТИРОВАТЬ: пропустите ниже горизонтальное правило для моей новой версии вопроса.

Предполагая только, что sizeof (double) * CHAR_BITS <= 64, всегда ли выполняется утверждение в следующей программе, гарантированное C ++ 03?

union u {
std::int64_t m_int;
double       m_double;
};

int main()
{
double d = get_a_random_double();

u u1;
u1.m_double = d;

u u2;
u2.m_int = u1.m_int;

assert(u2.m_double == d);
}

Я обеспокоен тем, что стандарт может не гарантировать, что копия значения int64_t сохраняет все биты, которые мы используем для хранения двойного числа.

С другой стороны, я уверен, что следующая альтернатива, которая использует символы вместо unt64_t, гарантируется стандартом, чтобы всегда удовлетворять утверждению:

struct chars {
char m_x[sizeof(double)];
};

union u {
chars  m_chars;
double m_double;
};

int main()
{
double d = get_a_random_double();

u u1;
u1.m_double = d;

u u2;
u2.m_chars = u1.m_chars;

assert(u2.m_double == d);
}

Ты согласен?

РЕДАКТИРОВАТЬ:

Хорошо, я должен признать, что преобразования посредством объединения не поддерживаются стандартом.

Так что насчет этого, где я пытаюсь перенести двойной через последовательность символов без использования объединения:

int main()
{
double d, e;
char c[sizeof(double)];

char* p_d = static_cast<char*>(static_cast<void*>(&d));
char* p_e = static_cast<char*>(static_cast<void*>(&e));

d = get_a_random_double();

// double -> chars
std::copy(p_d, p_d+sizeof(double), c);

// chars -> double
std::copy(c, c+sizeof(double), p_e);

assert(e == d);
}

Это гарантировано стандартом, чтобы всегда удовлетворять утверждению?

РЕДАКТИРОВАТЬ: Да! См. C ++ 11 3.9 / 2 «Типы»

Как насчет этого следующего, где я пытаюсь транспортировать двойной желоб через int64_t без использования союзов.

Я знаю, что int64_t не является частью c ++ 03, поэтому давайте вместо этого поговорим о c ++ 11.

Снова обратите внимание, что я предполагаю, что sizeof (double) * CHAR_BITS <= 64

int main()
{
double d, e;
std::int64_t i, j;
char c[sizeof(std::int64_t)];

char* p_d = static_cast<char*>(static_cast<void*>(&d));
char* p_e = static_cast<char*>(static_cast<void*>(&e));
char* p_i = static_cast<char*>(static_cast<void*>(&i));
char* p_j = static_cast<char*>(static_cast<void*>(&j));

d = get_a_random_double();

// double -> chars -> std::int64_t
std::copy(p_d, p_d+sizeof(double), c);
std::copy(c, c+sizeof(std::int64_t), p_i);

// std::int64_t -> std::int64_t
j = i; // <------------ Are all bits preserved here?

// std::int64_t -> chars -> double
std::copy(p_j, p_j+sizeof(std::int64_t), c);
std::copy(c, c+sizeof(double), p_e);

assert(e == d);
}

Как и прежде, меня беспокоит, может ли копирование одного из стандартных целочисленных типов (std :: int64_t) «испортить» некоторые биты (например, некоторые биты, которые не участвуют в представлении целочисленных значений). Или гарантируется ли целочисленное присваивание, чтобы всегда точно копировать все биты байтов, которые занимает целое число?