Questions on typedef

I notice you more experienced programmers use typedef a lot. I have some questions:

1. When should you use typedef? When writing:

Code:

---

std::list<myType>::iterator

---

100 times can be easier expressed as:

Code:

---

typedef std::list<myType>::iterator list_itr;
list_itr it = a_list.begin();

---

2. I notice often typedefs are written at global scope. Do typedefs follow normal scoping rules? Should they typically be written at global scope?

EDIT:

i guess that's actually:

Code:

---

std::list<myType>::std::iterator

---

1) You just answered your question. When the type becomes unwieldy, unreadable, or simply overly long for the number of times you'll use it, give it an alias.

2) They follow scoping rules. They should be written in the scope where they're useful.

Quote:

---

Originally Posted by dudeomanodude

Code:

---

std::list<myType>::std::iterator

---

---

I think that's extra.

How do you typedef the following:

Code:

---


template <typename T> return_type my_template_class

---

???

Do you include up to return_type or up to my_template_class?

EDIT: I don't have a compiler right now, so I can't play around with it myself.

Are you talking about template typedefs? That language feature will only be available in C++0x.

Quote:

---

Originally Posted by laserlight

Are you talking about template typedefs? That language feature will only be available in C++0x.

---

I'm not sure...

I mean if I have an implementation like this:

Code:

---

template <typename T> void template_container::do_something(){

    std::cout << "Hello there!\n";
}

---

can I shorten the whole template <typename T> void template_container line?

This doesn't look entirely valid, but you could surely shorten it by defining do_something within template_container definition :)

You can't shorten an out-of-line definition, really.

Hmmm.

I want to do something like this:

Code:

---


typedef template <typename T> void template_container void_t;

void_t::do_something(){

    // ...

}

---

that's what I'm trying to get at.

I don't think it's possible with typedefs. However, defines can still do the trick.
(This is, of course, assuming template_container is a template, in which case in should look more like
typedef template <typename T> void template_container<T> void_t;
anyway.)

Code:

---

#include <iostream>

template <typename T>
class my_temp{

        public:

                void do_something();

};

typedef template <typename T> void my_temp void_t;
void_t::do_something(){

    std::cout << "Hello there!\n";
}

int main(){

        my_temp<int> example;
       
        example.do_something();
       
        return 0;
}

---

yea, it didn't like the typedef line.

Unspecialized templates aren't allowed in C++. Unspecialized templates are where you specify the name of something that is a template, but do not specify a type. Example:

Code:

---

typedef my_temp mytypedef; // Illegal
typedef my_temp<int> mytypedef; // Legal

---

Quote:

---

Unspecialized templates aren't allowed in C++. Unspecialized templates are where you specify the name of something that is a template, but do not specify a type.

---

So basically when I write a template I can't abbreviate my template stuff (with typedefs), but when I use a template, it's fair game?

Quote:

---

Originally Posted by dudeomanodude

So basically when I write a template I can't abbreviate my template stuff (with typedefs), but when I use a template, it's fair game?

---

No, you sure can do it, but you must specify the type. You can't use a specialized type such as T and you can't omit it:

Code:

---

typedef template<typename T> my_temp<T> mytd; // Illegal
typedef my_temp mytd; // Illegal
typedef my_temp<int> mytd; // Legal

---

Okay, so the real litmus test is that the template argument itself must be a defined type?

I want to get that right for my benefit and anyone else's.

I think the real reason is that it simply won't allow for "template<typename T>" in a typedef, so you really can't use T as a type.
Otherwise it's right that you must specify a type. You can't pass a templated type without specifying a type.

Quote:

---

Originally Posted by Elysia

I think the real reason is that it simply won't allow for "template<typename T>" in a typedef, so you really can't use T as a type.
Otherwise it's right that you must specify a type. You can't pass a templated type without specifying a type.

---

Okay I think you've got to the heart of it->Why allow a typedef for a type that doesn't even exist.

There's probably a better explanation than that out there, but perhaps that's the gist of it.

I don't know why they did it, I only know it simply doesn't work.
And what the standard says, goes. That's life.

A typedef is an alias for a type. You can only create aliases for actual types. A template name is not a type (except within the context of its definition, but that's a special case that would complicate things now). "template <typename T> foo" is not a type. "foo<T>" is a type, if T is a type or a type parameter, therefore you can give it an alias.

Quote:

---

Originally Posted by dudeomanodude

Okay I think you've got to the heart of it->Why allow a typedef for a type that doesn't even exist.

---

Because it would make life so much nicer. Suppose I want a quick way to refer to the iterator type of ANY kind of std::vector<T>. What I want to do is this:

Code:

---

template <typename T>
typedef std::vector<T>::iterator vec_iterator;

---

Then, I could use it like this:

Code:

---

std::vector<int> vec;
for(vec_iterator<int> i = vec.begin(), end = vec.end(); i != end; ++i)
{
    ...
}

---

vec_iterator, being a "template typedef," does not name a type. But vec_iterator<int> does. Unfortunately, this construct is not supported yet. In practice, you do this:

Code:

---

template <typename T>
struct vec_iterator
{
    typedef typename std::vector<T>::iterator type;
};

---

And then instead of referring to vec_iterator<int>, you refer to vec_iterator<int>::type. Does this suck? Yes. You have to declare a struct whose only purpose is to contain this typedef. But it's what we have for the moment.

Bottom line: you can achieve the same things as if we had template typedefs, it's just ugly.

Yay for C++0x, then.

Code:

---

template <typename T>
using vec_iterator = std::vector<T>::iterator;

---

Or something like that.

Quote:

---

Originally Posted by CornedBee

Yay for C++0x, then.

Code:

---

template <typename T>
using vec_iterator = std::vector<T>::iterator;

---

Or something like that.

---

Why the gratuitous divergence from the syntax one would expect? That looks awful.

There were some sound reasons not to use typedef, but I can't remember them.