template specialization problem

Hello

I would like to do:

Code:

---

std::list<some_templated_class> _list;
_list.push_back(some_templated_class<some_object>(arguments));

---

but my compiler wont allow me to compile this. I get error:
unspecialized class template can't be used as a template argument for template parameter '_Ty', expected a real type

Is there any other way to be able to do/override this?

Thanks for help

Code:

---

std::list<some_templated_class<some_object> > _list;

---

You can't have the list hold templated objects of different types, since each is actually a different class, so you just need to specify the type for the some_templated_class.

Quote:

---

Originally Posted by Daved

Code:

---

std::list<some_templated_class<some_object> > _list;

---

You can't have the list hold templated objects of different types, since each is actually a different class, so you just need to specify the type for the some_templated_class.

---

I want to store handler within some_templated_class.
For instance:

some_templated_class<boost:bind(arguments)> _list;

Each would be build with boost::bind but with different arguments.
Is this possible to do?

Maybe I could use boost::any or boost::tuple?

You'll need to store the pointers on the list instead, if the classes are not of identical type. Perhaps a boost ptr_container.

Quote:

---

Originally Posted by iMalc

You'll need to store the pointers on the list instead, if the classes are not of identical type. Perhaps a boost ptr_container.

---

Is this the only solution?
Does boost ptr_map exist?

However, I get the same error with

Code:

---

boost::ptr_vector<some_templated_class> _list;

---

Is there something I'm doing wrong?

I don't see how storing pointers will help, you still have to provide the type of the pointer.

I don't actually know boost::bind well enough to figure out a good solution. boost::any and boost::variant can be used when you will have different types, so that is an option, but I don't know if it is a good option.

Thanks for help Daved. Maybe someone else knows?

Quote:

---

Originally Posted by l2u

Thanks for help Daved. Maybe someone else knows?

---

Store pointers to a base class and dispatch functionality through virtuals. In other words, derive the some_templated_class from a common NON-template base:

Code:

---

class my_base
{
public:
    virtual ~my_base(); // always need this

    virtual void do_this();
    virtual void do_that();
    // etc...
};

template <typename T>
class some_templated_class : public my_base
{
    // ...
};

---

Now, you store my_base pointers in the list, not instances:

Code:

---

std::list<my_base *> _list;
_list.push_back(new some_templated_class<some_object>(arguments));

---

You'll have to take care of cleaning up the dynamically allocated instances when the _list goes away. You can do that by using some kind of smart pointer.

Cant I use boost ptr_container for this?

Right. Then you wouldn't have to worry about the last thing brewbuck said.

Thanks brewbuck. That was what I was getting at.

In this case, however, boost::function (or tr1::function) may well be the type erasure root you seek, since what you want to store is bind expressions.

Quote:

---

Originally Posted by CornedBee

In this case, however, boost::function (or tr1::function) may well be the type erasure root you seek, since what you want to store is bind expressions.

---

I took a look at boost function..
Is it possible to call boost::function with unknown arguments?

For instance:

Code:

---

boost::function<void(void)> func;
func = boost::bind(&Test::func,&test, someargument, argument2);

---

No, a compatible signature of the function must be given.