Re: Purely Virtual Functions With Varying Data Types
"Volkan YAZICI" <volkan.yazici@gmail.com> wrote in message
news:5571e034-21ad-47f1-907d-7a790fe74c68@e8g2000vbz.googlegroups.com...
Hi,
I'd like to implement a simple database, that is, a collection of
tables, where the tables are just a vector of rows, and rows are just
a vector of fields with varying data types. I use a vector<Field> to
represent a row, and Field has children like IntField, StringField,
etc. Field class would have a getData() method, which is obviously
expected to be defined as a purely virtual function in Field. But the
problem is, what would be the function footprint of such a purely
virtual function? That is, for IntField, it will be "const int&
getData() const"; for StringField, it will be "const string& getData()
const", etc. Can anybody help me on this, please? How should I
approach the problem? Do you recommend another solution? (BTW, Field
is also expected to have relevant ctor and comparison methods as well.
FYI.)
OTOH, one can argue that, why not using sth like Field<int>(),
Field<string>(), etc.? In such a case, I won't be able to define a
vector of different data types. That is, to denote a row, I'll use
vector<Field<int>>, and I'll only be able to store "int"s, no other
data types will be permitted.
Yes variant types are quite easy to impliment here's how to do it:
#include <iostream>
#include <string>
template<typename T1 ,typename T2>
class ItemBase{
public:
virtual ~ItemBase(){}
virtual operator T1(){return 0;}
virtual operator T2() {return 0;}
virtual ItemBase<T1,T2>& getData(){;return *this;}
};
template<typename T, typename T1, typename T2>
class DataItem: public ItemBase<T1,T2>{
T itsData;
public:
DataItem(const T& p):itsData(p){}
operator T(){return itsData;}
};
template<typename T1, typename T2>
class Field{
ItemBase<T1,T2>* itsData;
public:
Field(): itsData(0){}
~Field(){delete itsData;}
void setData(const T1& p){itsData = new DataItem<T1,T1,T2>(p);}
void setData(const T2& p){itsData = new DataItem<T2,T1,T2>(p);}
ItemBase<T1,T2>& getData(){return *itsData;}
};
int main(){
Field<int, std::string> f1, f2;
f1.setData("string");
f2.setData(5);
std::cout<< f2.getData();
std::cout<< (std::string)f1.getData(); /*Needs explicit cast to call
correct conversion operator*/
std::strings str = f1.getData(); /*Correct conversion is called without
explicit cast.*/
}
Note how you need to be carefull with conversion rules.
You need to add copy constructors etc to make it container safe. I left
alot out so that you can easily understand the code paths. Just add T3 , T4
etc to templates to get more types.
HTH.