iterator to unspecified container?

If you have a template with two template arguments, one for the underlying type, and the other being a container of the underlying type, how can you get an iterator to an unspecified container?

Code:

---



template<typename T, typename K>
class Foo{

    K container;

    public:

        Foo(const K& container){

            // get iterator to 'k'

            // copy 'T' elements from 'k'
        }
};

int main(){

    std::vector<int> vec;
    Foo<int, std::vector<int> > foo_vec(vec);

    std::list<int> list;
    Foo<int, std::list<int> > foo_list(list);

    return 0;
}

---

As a design co sideration, would it be better to implement a range copy in a constructor accepting iterators to the external container thus eliminating the need for the second template argument?

Opinions?

As for the first question, you would just do

Code:

---

typename K::iterator

---

Now, normally you don't need the "underlying" type. First off, you probably won't use it. Secondly, there are typedefs wrapped inside the containers that contains the type they encapsulate 99% of the cases (can't remember what exactly they're called, though).
Better yet, in C++0x, you should be able to do...

Code:

---

decltype(*K.begin())

---

...to get the encapsulated type (or the like).

As for the second question, I assume that you want to copy all the elements from container to this->container?
Then you don't need to know T. All you need to do is:

Code:

---

std::copy(container.begin(), container.end(), std::back_inserter(this->container));

---

(Assuming your container supports the push_back method.)

Quote:

---

Originally Posted by Elysia

As for the first question, you would just do

Code:

---

typename K::iterator

---

Now, normally you don't need the "underlying" type. First off, you probably won't use it. Secondly, there are typedefs wrapped inside the containers that contains the type they encapsulate 99% of the cases (can't remember what exactly they're called, though).
Better yet, in C++0x, you should be able to do...

Code:

---

decltype(*K.begin())

---

...to get the encapsulated type (or the like).

---

I swear "typename" is like the magic band-aid word in C++ templates -apply it, and all is well...

Thank you.

The reason I need T, is I will be copying T values into wrapper objects that contains members of type T and a pointer to an iterator of type K<T>, then added to a private container K<T>. The idea is to provide instant access to objects of type T, in any iterateable container, in other containers with the same elements, just sorted differently.

I know, I know, boost::multi_index_container does indeed provide this exact end-functionality, I'm just trying to implement something similar for my own practice. I desperately need the template practice.

Of course, I am always open to any suggestions, and opinions, and if any of you c++ wizards on this forum can steer me in a better direction, I'll be very happy to listen.

STL containers define typedef's for the underlying type and iterators, so you really just need the container as a template parameter. Also, they can be initialized and assigned via their copy-constructor and assignment operator, respectively.

Code:

---

template<typename K>
class Foo{

    typedef typename K::value_type value_type;
    typedef typename K::iterator iterator;
    typedef typename K::const_iterator const_iterator;
   
    K container;

    public:

        Foo(const K& container)
        : container(container) {
        }       
};

int main(){

    std::vector<int> vec;
    Foo<std::vector<int> > foo_vec(vec);

    std::list<int> list;
    Foo<std::list<int> > foo_list(list);

    return 0;
}

---

**edit**

Another thing you can do in this kind of situation is to make the constructor a template function, so as to accept any arbitrary container type, eg:

Code:

---

        template< typename Other >
        Foo( const Other& rhs )
        : container( rhs.begin( ), rhs.end( ) ) {
        }

---

To make Sebastiani's example a little more fancy with lovely C++0x functionality:

Code:

---

template<typename K>
class Foo
{
    typedef typename K::iterator iterator;
    typedef typename K::const_iterator const_iterator;
   
    K container;

    public:

        Foo(const K& container)
        : container(container)
        {
            typedef decltype(*container.begin()) value_type;
        }       
};

int main()
{
    // No space between ">>" needed in C++0x.
    std::vector<int> vec;
    Foo<std::vector<int>> foo_vec(vec);

    std::list<int> list;
    Foo<std::list<int>> foo_list(list);

    return 0;
}

---

And I'll also tell you a remember rule for typename. So long as you are using a dependent type, you must use typename. A dependent type is a type which relies on some unknown type T. To know WTH I'm talking about, here are some examples:

Code:

---

template<typename T> struct bar { typedef int myint; };

template<typename T>
void foo()
{
    int MyVar1; // Not a dependent name. Obviously.
    typename bar<T>::myint MyVar2; // Dependant name, because we are accessing myint inside bar which depends on T which is unknown.
    bar<int>::myint MyVar3; // Not a dependent name because int is a known type.
    typename std::vector<T>::iterator MyIt1; // Dependent name because T is unknown.
    std::vector<char>::iterator MyIt2; // Not dependent name because char is a known type.
}

---

Not sure, but doesn't C++0x have also "auto" keyword for these things?

It does, if you try to assign something to a variable. There are some situations where auto cannot help. Try iterating a vector by indices with auto.

Thank you all for the helpful replies!

@ Elysia

I guess I never even wondered what exactly *typename* was used for until I ran into this situation. Now it seems so clear. Thank you.

I'm not sure if I'm using C++0x, what version of gcc would that be (i.e. x.x.x whatever)?
I've been using for_each but my compiler still b*tches about the space between > > So i'm not really sure.

My available compilers are whatever gcc version came with Code::Blocks 10.5, I have Visual Studio Pro 2008, and gcc 3.4.4 via cygwin

Well, compile this snippet:

Code:

---

int main() { auto i = 0; }

---

Does it compile? Then your compiler supports C++0x.
From what I understand, Code::Blocks 10.05 (the newest) has a GCC 4.4.x version which should support C++0x. But I am not exactly keeping myself up-to-date on GCC. It might also be that GCC doesn't support the ">>" syntax. Yet.
Visual Studio 2010 has C++0x support. 2008 does not.

Quote:

---

Visual Studio 2010 has C++0x support.

---

O_o

Quote:

---

Visual Studio 2010 has some C++0x support.

---

Fixed.

Soma

Heh. My bad.
There is no full C++0x support anywhere since it's... well, not finished.
GCC has some C++0x support, too.

No dice. But wait... I lied, I have Code::Blocks 8.02. Time for a quick upgrade.

Didn't compile with Code::Blocks 10.05, although this helpful message was displayed:

Quote:

---

C:\Projects\_CPP\cpp0102\main.cpp|1|warning: 'auto' will change meaning in C++0x; please remove it|

---

I guess they're working on it?

*shrug* I guess someone with the proper knowledge will have to step in. I don't know anything about GCC or C::B.

Ok just figured it out. Code::Blocks 10.05 does ship with gcc 4.4.1. There's an option under compiler settings to follow the C++0x standard

Very nice. Now go wild with the new features in the new standard that GCC supports.