Пролог: честно искал ответ прежде чем спросить, даже жуйковал в поисках ответа.

Завязка: ISO/IEC 9899:1999 говорит, что компилятор может опционально предоставлять набор типови вида [u]intN_t, которые буду занимать ровно N байт, а также, в случае знаковых, будут гарантированно использовать two's completion.

Кульминация: ISO/IEC 14882:1999 про подобные типы умалчивает и даже говорит что размер char в битах может быть любым (лишь бы основной character set влезал).

Развязка: Как в плюсах определить тип, который будет занимать ровно 32 бита?

Эпилог:
1. Заранее спасибо, за ссылки по теме.
2. Варианты типа: "не сцю — юзай int", не котируются.

Здравствуйте, potapov.d, Вы писали:

PD>Развязка: Как в плюсах определить тип, который будет занимать ровно 32 бита?

boost::int32_t

Здравствуйте, Roman Odaisky, Вы писали:

RO>boost::int32_t

ISO/IEC 14882:2003

буст юзает stdint.h который в данном стандартне не помянут.

Здравствуйте, potapov.d, Вы писали:

PD>2. Варианты типа: "не сцю — юзай int", не котируются.

Не ссы, юзай stdint.h
Откуда такие дикие предосторожности? Есть целевые платформы, где нет stdint.h? Или есть платформы, в которых его собираются убрать?

Здравствуйте, Michael Chelnokov, Вы писали:

MC>Не ссы, юзай stdint.h
MC>Откуда такие дикие предосторожности? Есть целевые платформы, где нет stdint.h? Или есть платформы, в которых его собираются убрать?

Дело не в предосторожностях, а в том что в языке подобная фича должна быть, а её как оказалось — выкинули.
Вернее не выкинули, а заменили секасом с std::numeric_limits<T>::digits (как оказалось)
Собс-но решение с std::numeric_limits<T>::digits найдено, осталось его реализовать

PD>Развязка: Как в плюсах определить тип, который будет занимать ровно 32 бита?

Не люблю сам себе в темах отвечать, но если уж осилил, то не вижу причин не выложить.
Похоже это самый простой способ задефайнить целочисленный тип, который будет занимать ровно 32 бита, в стогом соответствии с ISO/IEC 14882:2003

#include <limits>

template <bool define, class T>
struct Definer
{
static const bool defined = false;
};

template<class T>
struct Definer<true, T>
{
typedef T type;
static const bool defined = true;
};

template <class T>
struct Checker :
Definer<
std::numeric_limits<T>::digits == 32 &&
std::numeric_limits<T>::is_signed == false &&
std::numeric_limits<T>::is_integer == true &&
std::numeric_limits<T>::radix == 2,
T
>
{
};

struct EmptyType
{
};

template<class T, class U>
struct Pair
{
typedef T first;
typedef U second;
};

template <class T, class U, bool defined>
struct IteratorHelper :
IteratorHelper<typename U::first, typename U::second, Checker<T>::defined>, Checker<T>
{
};

template<class T, bool defined>
struct IteratorHelper<T, EmptyType, defined>
{
};

template<class T, class U>
struct IteratorHelper<T, U, true>
{
};

template<class T>
struct IteratorHelper<T, EmptyType, true>
{
};

template <class T>
struct Iterator :
IteratorHelper<typename T::first, typename T::second, false>
{
};

typedef Iterator
<Pair<char,
Pair<unsigned char,
Pair<wchar_t,
Pair<short,
Pair<int,
Pair<long,
Pair<unsigned short,
Pair<unsigned int,
Pair<unsigned long, EmptyType>
> > > > > > > > >::type uint32_t;

Здравствуйте, Michael Chelnokov, Вы писали:

MC>Не ссы, юзай stdint.h
MC>Откуда такие дикие предосторожности? Есть целевые платформы, где нет stdint.h?

Конечно, есть. Самая популярная платформа разработки — MSVC — не продоставляет stdint.h.

Здравствуйте, potapov.d, Вы писали:

PD>Развязка: Как в плюсах определить тип, который будет занимать ровно 32 бита?

Полагаю, что это просто по недоглядке. Подразумевается, что все хидеры, типы и функции, которые есть в С, есть и в С++.
Кстати, в С++0x это недоразумение пофиксили:

18.4.1 Header <cstdint> synopsis [cstdint.syn]
namespace std {
typedef signed integer type int8_t; // optional
typedef signed integer type int16_t; // optional
typedef signed integer type int32_t; // optional
typedef signed integer type int64_t; // optional
typedef signed integer type int_fast8_t;
typedef signed integer type int_fast16_t;
typedef signed integer type int_fast32_t;
typedef signed integer type int_fast64_t;
typedef signed integer type int_least8_t;
typedef signed integer type int_least16_t;
typedef signed integer type int_least32_t;
typedef signed integer type int_least64_t;
typedef signed integer type intmax_t;
typedef signed integer type intptr_t; // optional
typedef unsigned integer type uint8_t; // optional
typedef unsigned integer type uint16_t; // optional
typedef unsigned integer type uint32_t; // optional
typedef unsigned integer type uint64_t; // optional
typedef unsigned integer type uint_fast8_t;
typedef unsigned integer type uint_fast16_t;
typedef unsigned integer type uint_fast32_t;
typedef unsigned integer type uint_fast64_t;
typedef unsigned integer type uint_least8_t;
typedef unsigned integer type uint_least16_t;
typedef unsigned integer type uint_least32_t;
typedef unsigned integer type uint_least64_t;
typedef unsigned integer type uintmax_t;
typedef unsigned integer type uintptr_t; // optional
} // namespace std
1 The header also defines numerous macros of the form:
INT_[FAST LEAST]{8 16 32 64}_MIN
[U]INT_[FAST LEAST]{8 16 32 64}_MAX
INT{MAX PTR}_MIN
[U]INT{MAX PTR}_MAX
{PTRDIFF SIG_ATOMIC WCHAR WINT}{_MAX _MIN}
SIZE_MAX

Table 143 — Atomics for standard typedef types
atomic typedef name <cstdint> typedef name
atomic_int_least8_t int_least8_t
atomic_uint_least8_t uint_least8_t
atomic_int_least16_t int_least16_t
atomic_uint_least16_t uint_least16_t
atomic_int_least32_t int_least32_t
atomic_uint_least32_t uint_least32_t
atomic_int_least64_t int_least64_t
atomic_uint_least64_t uint_least64_t
atomic_int_fast8_t int_fast8_t
atomic_uint_fast8_t uint_fast8_t
atomic_int_fast16_t int_fast16_t
atomic_uint_fast16_t uint_fast16_t
atomic_int_fast32_t int_fast32_t
atomic_uint_fast32_t uint_fast32_t
atomic_int_fast64_t int_fast64_t
atomic_uint_fast64_t uint_fast64_t
atomic_intptr_t intptr_t
atomic_uintptr_t uintptr_t
atomic_size_t size_t
atomic_ptrdiff_t ptrdiff_t
atomic_intmax_t intmax_t
atomic_uintmax_t uintmax_t

Здравствуйте, potapov.d, Вы писали:

PD>буст юзает stdint.h

на тех платформах, где он есть. Где его нет, использует платформенно-зависимые типы (вроде __int64) или попросту #if ULONG_MAX == 0xffffffff — typedef long int32_t.

Здравствуйте, remark, Вы писали:

PD>>Развязка: Как в плюсах определить тип, который будет занимать ровно 32 бита?
R>Полагаю, что это просто по недоглядке. Подразумевается, что все хидеры, типы и функции, которые есть в С, есть и в С++.
R>Кстати, в С++0x это недоразумение пофиксили:
R>

R>18.4.1 Header <cstdint> synopsis [cstdint.syn]
R>namespace std {
R>typedef signed integer type int8_t; // optional
R>typedef signed integer type int16_t; // optional
R>typedef signed integer type int32_t; // optional
R>typedef signed integer type int64_t; // optional

А как тут размер задаётся собственно?

Здравствуйте, Vain, Вы писали:

R>>Кстати, в С++0x это недоразумение пофиксили:
R>>

R>>18.4.1 Header <cstdint> synopsis [cstdint.syn]
R>>namespace std {
R>>typedef signed integer type int8_t; // optional
R>>typedef signed integer type int16_t; // optional
R>>typedef signed integer type int32_t; // optional
R>>typedef signed integer type int64_t; // optional

V>А как тут размер задаётся собственно?

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