What's the point of "typedef sometype sometype" ?

Question

Lately I've run into the following construction in the code:

typedef sometype sometype;

Pay attention please that "sometype" stands for absolutely the same type without any additions like "struct" etc.

I wonder what it can be useful for?

UPD: This works only for user defined types.

UPD2: The actual code was in a template context like this:

template <class T>
struct E
{
   typedef T T;
   ...
}

Answer 1

In C++, you can put a typedef in a namespace or class, and then refer to it relative to that namespace or class, which can be useful if the real type might change in the future.

e.g.

class IntHolder
{
    public:
        typedef int int;
        IntHolder::int i;
};
...
IntHolder foo;
IntHolder::int i = foo.i;

(NB: I haven't checked that's quite the right syntax - but hopefully you get the idea)

If at some future point you actually want to hold long in IntHolder you only need to change the IntHolder code.

Now, normally you name the type differently, but maybe you can do as above?

Answer 2

I have a theory. It could be a result of some refactorings. For example a templated type become not templated.

typedef SomeCleverTemplate<Rocket> SuperThing;

Then they deleted the template, beacuse there were no other usage of it in the code, and for just to be safe they replaced every SomeCleverTemplate<Rocket> to SuperThing.

typedef SuperThing SuperThing;

Does it make sense in the real context?

Answer 3

How about to make Template parameters visible to outside entities?

template <class Foo>
struct Bar
{
    typedef Foo Foo;
};

int main()
{
    Bar<int>::Foo foo = 4;
}

Note: Please don't vote this up any more. It was a guess, and I've since tried it. It doesn't work.

Answer 4

Given your additional information about templates, we can now answer.

The use-case is when you want to specialize on the type of a template. One typical example is the following:

template <typename T>
struct nonconst {
    typedef T t;
};

template <typename T>
struct nonconst<T const> {
    typedef T t;
};

This effectively allows you to remove the const qualifier from any type:

nonconst<int>::t x;
nonconst<int const>::t y;
assert(typeid(x) == typeid(int));
assert(typeid(y) == typeid(int));

There are many similar use-cases, e.g. to add (or remove) the pointer qualifier from a type, provide defaults and specializations for certain types, etc.

However, notice the different casing of the type names! Equal types in typedef T T are illegal C++.[I stand corrected: §7.1.3.2] Furthermore, the de-fact naming standard (cemented by its use in Boost libraries) is to call the type name alias type, e.g.:

typedef T type;

Answer 5

As it as already been mentioned, it works especially well within a template:

template <class Foo>
struct Bar
{
  typedef Foo Foo;
};

But it can also be combined with template specialization:

template <class Foo>
struct Bar<Foo*>
{
  typedef Foo Foo;
};

Now, I can do:

Bar<int>::Foo i = 0;
Bar<int*>::Foo j = i;

Bar thus effectively behaves as a kind of type wrapper, which may be important for its interface (if there is a bool equals(Foo i) const for example).

Usually the name elected has some meaning value_type for example...