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.)

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.

Visual Studio 2010 has C++0x support.

O_o

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:

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.