i have a class which has a template by other purposes:
template
class MyClass {
public: //of course public...
t foo;
std::string text;
The simplest method would be to make that function a template as well:
template
void bar(MyClass& m) {
// ...
}
Note that that should probably be const MyClass
, because you don't need to modify it.
Your new code is meaningless. There is no such that as an object of type MyClass
, because MyClass
is a template. If you want to operate on these classes irrespective of their template argument, then you need to factor out the non-template portions as a base class:
class MyClassBase
{
public:
// polymorphic base classes should always have virtual destructors
~MyClassBase() {}
virtual void some_function() = 0;
};
template
class MyClass : public MyClassBase
{
public:
// implement abstract functions
void some_function()
{
// template argument T is available here
}
};
Then you can refer to that base, and when you call a virtual function it will dynamically dispatch:
class Container
{
public:
// no magic: use a std::vector for dynamic arrays
std::vector array; // not by value! avoid slicing
void bar(MyClassBase& m)
{
array.push_back(&m);
}
void baz()
{
array[0]->some_function(); // for example
}
};