Barry,
Thanks for the help. I have been working on a different method to do
this, but have hit the same results.
I have created a base class:
template <typename T>
class base {
public:
base(T eval) :
mValue(eval)
{};
virtual ~base() {};
bool run(const string &actualValue) {
runInternal(mValue, actualValue);
}
protected:
virtual bool runInternal(int v1, const string &v2) = 0;
virtual bool runInternal(const string &v1, const string &v2) = 0;
protected:
T mValue;
};
template <typename T>
class d1 : public base<T> {
public:
d1(T eval) :
base<T>(eval)
{};
private:
bool runInternal(int v1, const string &v2) {
// convert string to int
return v1 == v2;
};
bool runInternal(const string &v1, const string &v2) {
return v1 == v2;
};
};
As I am sure you can see, I can not create a map<string, base *>
because base needs a type at that point. Can I somehow use a template
function in the class and not a complete template class?
Basically I need to have a map of functions, classes whatever that
test <, > and == of a known value and actual value. They can be
strings, int, and doubles. Is this possible?
So don't have
template <class T>
class Base;
instead have
class Base {
public:
virutal bool Compare(boost::any arg0, boost::any arg2) = 0;
};
template <class T, U>
class Child : public Base
{
// override Compare
// boost::any_cast to T and U with arg0 and arg1, then do the compare
};
the code can be like this:
#include <iostream>
#include <map>
#include <algorithm>
#include <string>
#include <sstream>
#include <boost/any.hpp>
class Base {
public:
virtual bool Compare(boost::any const& arg0, boost::any const& arg1)
{
return false;
}
virtual bool Compare(boost::any const& arg)
{
return false;
}
virtual ~Base () { }
};
template <class T, class U>
class Child1 : public Base
{
public:
Child1(U arg1) : arg1_(arg1) {}
protected:
virtual bool Compare(boost::any const& arg0)
{
if (T const* pT = boost::any_cast<T>(&arg0))
{
if ((*pT) == arg1_) {
std::cout << "true" << std::endl;
return true;
}
}
return false;
}
private:
U arg1_;
};
template <class T, class U>
class Child2 : public Base
{
protected:
virtual bool Compare(boost::any const& arg0, boost::any const& arg1)
{
T const* pT = boost::any_cast<T>(&arg0);
U const* pU = boost::any_cast<U>(&arg1);
if (pT && pU)
{
if ((*pT) == (*pU)) {
std::cout << "true" << std::endl;
return true;
}
}
return false;
}
};
bool operator== (std::string const& lhs, int rhs)
{
std:
stringstream oss;
oss << rhs;
return lhs == oss.str();
}
bool operator== (int lhs, std::string const& rhs)
{
std:
stringstream oss;
oss << lhs;
return rhs == oss.str();
}
int main()
{
std::map<std::string, Base*> Map;
Map["test1"] = new Child1<int, int>(10);
Map["test2"] = new Child1<int, std::string>("100");
Map["test3"] = new Child1<std::string, int>(100);
Map["test1"]->Compare(10);
Map["test2"]->Compare(100);
Map["test3"]->Compare(std::string("100"));
Map["test4"] = new Child2<int, int>();
Map["test5"] = new Child2<int, std::string>();
Map["test6"] = new Child2<std::string, int>();
Map["test4"]->Compare(10, 10);
Map["test5"]->Compare(100, std::string("100"));
Map["test6"]->Compare(std::string("100"), 100);
for (std::map<std::string, Base*>::iterator it = Map.begin();
it != Map.end(); ++it)
{
delete it->second;
}
}
