How far to go with typedef'ing primitive types like int

Question

Do you bother typedef'ing most of your number types like this? Or do you just use "int" in most places? It might be more important in my current project with is client / server based and the types have to match when transmitted through the wire as binary data - but I just wondered how far people go with this generally:

types.h:

typedef int16_t Version;
typedef int32_t PacketLength;
typedef int32_t Identity;
typedef int32_t CabinetNumber;
typedef int64_t Time64;
typedef int64_t RFID;
typedef int64_t NetworkAddress;
typedef int64_t PathfinderAddress;
typedef int16_t PathfinderPan;
typedef int16_t PathfinderChannel;
typedef int64_t HandsetSerialNumber;
typedef int16_t PinNumber;
typedef int16_t LoggingInterval;
typedef int16_t DelayMinutes;
typedef int16_t ReminderDelayMinutes;
typedef int16_t EscalationDelayMinutes;
typedef float CalibrationOffset;
typedef float AnalogValue;
typedef int8_t PathfinderEtrx;
typedef int8_t DampingFactor;
typedef int8_t RankNumber;
typedef int8_t SlavePort;
typedef int8_t EventLevel;
typedef int8_t Percent;
typedef int8_t SensorNumber;
typedef int8_t RoleCode;
typedef int8_t Hour;
typedef int8_t Minute;
typedef int8_t Second;
typedef int8_t Day;
typedef int8_t Month;
typedef int16_t Year;
typedef int8_t EscalationLevel;

It seems logical to try and make sure the same type is always used for a particular thing to avoid overflows, but I do often see code where "int" has just been used pretty much everywhere instead. The typedef'ing often does lead to code that looks a bit like this though:

DoSomething(EscalationLevel escalationLevel)
{
    ...
}

Which then makes me think which bit is actually describing the parameter - the parameters type or the parameters name?!

Thanks.

Answer 1

The name of a parameter should describe what it means - in your case the escalation level. The type is how the value is represented - adding typedefs as in your example obfuscates this part of the function-signature, so I would not recommend it.

Typedefs are useful for templates, or if you want to change the type used for certain parameters, for instance when migrating from a 32bit to a 64bit platform.

Answer 2

typedef basically allows you to give an alias for an type.
It gives you the flexibility of avoiding typing the long type names again and again and making your type more easily readable wherein the alias name indicates the intent or purpose of the type.

It's more of an matter of choice if you wish to have more readable names through typedef in your project.
Usually, I avoid using typedef on primitive types, unless they are unusually long to be typed. I keep my parameter names more indicative.

Answer 3

I would never do something like this. Making sure they all have the same size is one thing- but you only need to refer to them as integral types, then.

Answer 4

At first I thought "Why not" but then it occurred to me that if you're going to go to such lengths to separate the types like that, then make better use of the language. Instead of using aliases, actually define types:

class AnalogueValue
{
public:
    // constructors, setters, getters, etc..
private:
    float m_value;
};

There is no performance difference between:

typedef float AnalogueValue;
AnalogValue a = 3.0f;
CallSomeFunction (a);

and:

AnalogValue a (3.0f); // class version
CallSomeFunction (a);

and you also have the advantages of adding parameter validation and type safety.

Answer 5

Using typedefs for primitive types like that looks more like C style code.

In C++ you will get interesting errors as soon as you try to overload functions for, say, EventLevel and Hour. That makes the extra type names pretty useless.

Answer 6

Using typedefs like this is okay as long as whoever winds up using them doesn't need to know anything about their underlying representation. For example, if you want to pass a PacketLength object to either printf or scanf, you'll need to know its actual type so you can pick the right conversion specifier. In cases like that, the typedef just adds a level of obfuscation without buying anything in return; you might as well have just defined the object as int32_t.

If you need to enforce semantics specific to each type (such as allowable ranges or values), then you're better off creating an abstract data type and functions to operate on that type, rather than just creating a typedef.