Thread: typedef

typedef defines a user-defined type. So:

Code:

typedef unsigned long long ULLong;

defines a new type, ULLong, that can be used in variable and member declarations. typedef can be used to define both simple types and structured types, such as in

Code:

typedef struct tabent_s {
    UULong value;
    char name[200];
} tabent_t;

which defines a new type called tabent_t that can be used where you might otherwise use struct tabent_s. The namespace for structs and user-defined types is separate in C, so only one type is defined in the above example, but in C++, defining the named struct automatically defines a type of the same name, so in C++ the typedef in the above example defines two identical types, tabent_s and tabent_c.

You can think of typedef as a short-hand, similar to #define, but it's not handled by the pre-processor, and the compiler can do strong type checking on user defined types, thus making the code more portable and robust.

Thanks

long long var?

Actually, typedefs aren't new types, they're just aliases. In other words:

Code:

typedef int myint;

myint mi = 3;
int i = mi;
mi = i;

There is absolutely no type conversion going on here, not even implicit. Typedefs could, in many cases, be replaced using search&find (or by the preprocessor):

Code:

void func(int i);
void func(myint i); // Overloading error: signatures aren't different.

See also §7.1.3 in the C++ standard.

So why not just use the preprocessor? Because a typedef is aware of being a C++ construct. The most important case here are pointers. You probably know about the dangers of this syntax:

Code:

int* a, b;

a is a pointer, but b is not! b is just a plain int.
Now suppose you introduce a preprocessor macro pint as a pointer to int:

Code:

#define pint int*

This works fine for a time:

Code:

pint a;
pint b;

But it will fail for this, because the preprocessor only does text substitution.

Code:

pint a, b;

Again, (but far less obvious even for an experienced coder), a is a pointer but b is not. That's because the code after expansion looks again like this:

Code:

int* a, b;

Typedefs are aware of C++ syntax. A typedef'd name is a unit and cannot be taken apart:

Code:

typedef int *pint;
pint a, b;

Both a and b are pointers here.
A similar case:

Code:

#define mpint int*
typedef int *tpint;

const mpint a;
const tpint b;

What are the types of a and b?
a is a pointer to const int. b is a const pointer to int.