Deducing type traits from a variable.

The following fails...

Code:

---

int main (void) {
  std::vector<int> my_vector;

  // Some code

  // At this point, I dunno what my_vector is
  my_vector::const_iterator ci = my_vector.begin(); // Error

  // ...

  return 0;
}

---

as does

Code:

---

my_vector.const_iterator ci = my_vector.begin();

---

Basically, I want to avoid looking up the type, and let the compiler handle that for me. Am I trying to do something here that C++ doesn't allow? It seems like this should be possible somehow.

How can you not know what type my_vector is? You have to know.

The next standard will use auto to make this easier, but for now unless I'm missing something you should know what type my_vector is and you have to use that. If it is just too ugly or verbose, consider a typedef for the type.

You could use a template function.

Code:

---

template <typename T>
void function( /* ... */) {
    std::vector<T> x;
    std::vector<T>::iterator i;
}

---

Or you could declare the type somewhere (with a typedef?) and use that.

But these are just ways of getting around the issue, while still putting the type in.

GetType() ?

http://msdn2.microsoft.com/en-us/lib...pe(VS.71).aspx

Quote:

---

Originally Posted by kryptkat

GetType() ?

http://msdn2.microsoft.com/en-us/lib...pe(VS.71).aspx

---

Er...no. Only if you want to compile as C++/CLI. Instead, you could use RTTI if you really wanted to go that route.

At first I was kind of surprised there isn't a base non-templated iterator that every iterator derives from. Then I tried to find a way to use the thing, and I just couldn't (except for counting). You've got to know the type.

You can't access nested typenames through an object, you have to use a qualified typename. What you're really looking for is a function that returns a type instead of an object, but such a thing can't exist in C++.

Since a variable must always be declared with some concrete type, you will never find a situation where you do not know the type of the variable. So you can always just refer to the concrete type, in this case, std::vector<int>::const_iterator. It kind of sucks, but that's the way it is.

Well, thanks guys, and I'm sorry to hear it can't happen. A few notes...

• When I said "I don't know", I meant me as the coder. Figuring out a given variable's type becomes a non-trivial exercise once things get complicated enough, and typedefs can hurt as much as they help.
• A second question, related. Is there a reason C++ does support this? Offhand, it seems like a good feature that's (relatively) trivial to implement. The fact that it can't be done makes me think there's some fundamental problem with it that I am missing.

>> When I said "I don't know", I meant me as the coder.
I've been there, but in reality in every case you can find out, so that's just what you have to do.

>> Is there a reason C++ does support this?
C++ doesn't support this because it isn't necessary. You can always find out the type you need to use by looking at the code.

But as I said, they are adding a feature in the next release that does what you want, mostly for the reasons you want it. It can be annoying to try to figure out the exact type needed there, and it should be relatively easy for the compiler to figure it out from the context. Search for the auto keyword and C++0x for more information.

Quote:

---

Originally Posted by QuestionC

[list][*]When I said "I don't know", I meant me as the coder. Figuring out a given variable's type becomes a non-trivial exercise once things get complicated enough, and typedefs can hurt as much as they help.

---

The STL handles this by encapsulating manipulations into template algorithms. You could do the same. You're trying to get a begin() vector, and presumably then do something with it. Imagine that this "something" is encapsulated into a function called frob_the_vector(). This function can be made a template:

Code:

---

template <typename T>
void frob_the_vector(T &vec)
{
    typename T::const_iterator begin = vec.begin();
    // ... do whatever
}

---

This relieves you of having to determine and fully name the type of "vec," because the template function call mechanism will automatically substitute it for "T" in frob_the_vector<T>().

And I do understand that sometimes it is difficult to figure out exactly what type some expression has, even if in principle you can figure it out. For instance, boost::lambda functors can have some insanely complicated types.

Here's a trick to figure out the type of some crazy template type:

Code:

---

int x = expression_of_unknown_type;

---

The compiler will barf and spit out an error message like "can't convert from type BLAHBLAHBLAH to integer in assignment," where BLAHBLAHBLAH is the type you're looking for. Very crude, but it works.