Thread: Typeid of vectors

Why do you want to do this?

Originally Posted by laserlight

Why do you want to do this?

Seconded. But in case the reason is valid why not do:

Code:

    std::vector<int> abc;    
    if(typeid(std::vector<int>) == typeid(abc))
    {
        std::cout<<"Matching Type";
    }//if

Originally Posted by sanjivko

I would like to perform some operation on the variable depending on the type of variable.

Ah, but then manually checking the variable's type should be a last resort.

Originally Posted by sanjivko

For example:
writing a toString() implementation, that will convert the object into string representation.

Write a function template instead.

These kinds of things are handled by templates. Runtime type information will be completely useless for this purpose.

For example, a function to turn a vector into a string representation might look like this:

Code:

#include <iostream>
#include <sstream>
#include <vector>

template <class T>
std::string to_string(const std::vector<T>& vec)
{
    std::stringstream result;
    result << "(";
    if (!vec.empty()) {
        result << vec[0];
        for (std::size_t i = 1; i != vec.size(); ++i) {
            result << ", " << vec[i];
        }
    }
    result << ")";
    return result.str();
}

int main()
{
    std::vector<int> vec;
    std::cout << to_string(vec) << '\n';           // ()
    vec.push_back(1);
    std::cout << to_string(vec) << '\n';           // (1)
    std::vector<std::string> string_vec;
    string_vec.push_back("Hello");
    string_vec.push_back("world");
    std::cout << to_string(string_vec) << '\n';    //(Hello, world)
}

This relies on ostream operator<< being overloaded for the type T (the standard library way to convert something to its string representation).

If you need to use a variable of type T, then you know what it is: T.

Code:

template <class T>
void foo(const std::vector<T>& vec)
{
     T first = vec.front();
     ...
}

Originally Posted by anon

For example, a function to turn a vector into a string representation might look like this:

I think phantomap once mentioned to me that an implementation is permitted additional template parameters for the standard containers, so even if we account for the allocator, it is still a little iffy as to how portable this might be. However, we could write:

Code:

template <class T>
std::string to_string(const T& container)
{
    std::stringstream result;
    result << "(";
    if (!container.empty()) {
        typedef typename T::const_iterator iterator_type;
        iterator_type i = container.begin();
        result << *i;
        ++i;
        for (const iterator_type end = container.end(); i != end; ++i) {
            result << ", " << *i;
        }
    }
    result << ")";
    return result.str();
}

EDIT:
As a bonus, I expect that this will not only work for std::vector, but also std::deque, std::list, and even std::set and std::multiset.