我有一段时间没有做C++编程了，决定利用业余时间研究一下。我想写一个小型的数据库程序，但在创建一个模板类对象数组时遇到了问题。
我想使用这个类来表示数据库记录中的一个字段。
template <class T, int fieldTypeId>
class Field
{
private:
T field;
int field_type;
public:
// ...
};
我希望使用该类的数组来表示数据库中的记录。
class Database_Record
{
private:
int id;
Field record[];
public:
Database_Record(int);
Database_Record(int, Field[]);
~Database_Record();
};
Database_Record类中创建数组，因为那是一个模板类对象的数组，每个元素可能是不同类型的，我不确定因为这个我需要如何声明数组。我尝试的事情是否可能或者我走错了路？谢谢您的帮助。Field<T1> 和 Field<T2> 是两种完全不同的类型。如果要将它们放入一个向量中处理，则需要将它们泛化。您可以编写 AbstractField。
struct AbstractField{
virtual ~AbstractField() = 0;
};
template<class T,int fieldTypeId>
class Field: public AbstractField{
private:
T field;
public:
const static int field_type;
public:
virtual ~Field(){}
};
class Database_Record{
std::vector<AbstractField*> record;
public:
~Database_Record(){
//delete all AbstractFields in vector
}
};
然后保持一个AbstractField的vector。同时使用vector代替[]。在AbstractField中使用AbstractField*，并至少编写一个纯虚函数。
您可以将AbstractField的析构函数设置为纯虚函数。不要忘记在~Database_Record()中删除所有AbstractField。
你走错了方向。
模板用于创建不同类型：std::vector<int>和std::vector<float>的区别与int和float的区别相同（并且一样多）。
你的语法也有误；要创建动态数组，你需要在Database_Record中放入以下成员：
std::vector<Field> record; // if this was possible; however, it's not
class Field
{
public:
virtual ~Field() {}
virtual std::string toString() const = 0;
// and possibly other interface functions...
};
template <class T> FieldImpl : public Field
{
public:
virtual std::string toString() const
{
std::stringstream ss;
ss << val;
return ss.str();
}
// implementation of possibly other interface functions
private:
T val;
}
这将是您所需的类型。数组将类似于
std::vector<std::unique_ptr<Field>> my_array;
然后，您可以使用接口函数对数组执行操作，例如：
my_array[i]->toString();
正如之前所说，C++模板不是这样工作的。
同时，由于性能限制，使用继承和指针向量不适合实现数据库记录。
退一步看问题，以更抽象的方式来看待问题。从您的代码中我理解到，意图是将不同类型的任意数量的字段打包成连续的内存块。示意图如下：
struct DBRecord {
Type1 f1;
Type2 f2;
Type3 f3;
Type4 f4;
// etc...
}
您可以通过一个有点丑陋但实用的结构来实现这一点，该结构由抽象模板声明和几个特化组成。
声明如下：
template <
typename T1,
typename T2 = void,
typename T3 = void,
typename T4 = void,
typename T5 = void,
typename T6 = void,
typename T7 = void,
typename T8 = void,
typename T9 = void,
typename T10 = void
> struct DBRecord;
它显然限制了字段的最大数量。如果您需要真正任意数量的字段，则需要切换到列导向的范例。
然后，部分特化应该为每个参数数量从1到10声明结构的解剖学：
template <
typename T1
> struct DBRecord <T1, void, void, void, void, void, void, void, void, void>
{
int id;
T1 f1;
DBRecord(int ID, T1 F1) {/*...*/};
};
template <
typename T1,
typename T2
> struct DBRecord <T1, T2, void, void, void, void, void, void, void, void>
{
int id;
T1 f1;
T2 f2;
DBRecord(int ID, T1 F1, T2 F2) {/*...*/};
};
// etc...
new[]调用中。
而且，通常您不需要关心每个字段的销毁，因为您会释放整个结构的内存。class UnknownType_t {
public:
virtual operator long&() { throw "Unsupported"; };
virtual operator const std::string() { throw "Unsupported"; };
virtual void Set(char*, long) = 0;
};
class Number : public UnknownType_t {
public:
Number(long _n) { n = _n; };
virtual operator long&() { return n; };
virtual void Set(char* buf, long size) {
n = 0;
memcpy(&n, buf, size);
}
long n;
};
class String : public UnknownType_t {
public:
String(const char *_s) : s(_s) {};
virtual operator const std::string() { return s; };
virtual void Set(char* buf, long size) {
s = std::string(reinterpret_cast<char*>(buf), size);
}
std::string s;
};
您可以尝试使用 dynamic_cast 检查类型，结果在 UnknownType_t 的常规数组中看起来像是{n=123}或{s="ABC"}。
Base 不是纯虚的，这是有意为之 - 跨越 getter 将没有意义...
将每个使用不同模板参数的实例化视为不同的类。您需要存储特定的类（即Field<int，17>），或者您需要使Field具有非模板基类，以便您可以将其存储在列表中。
vector或std::array。fieldTypeId？我猜这与您作为模板参数使用的类型T有关。通过部分特化外部化机制：template<typename T>
struct fieldTypeId;
template<>
struct fieldTypeId<int> {
const static int value = 0;
};
// etc....
template <class T, int fieldTypeId>
class Field
{
private:
T field;
int field_Type;
};
template <class T, int fieldTypeId>
class Database_record
{
private:
int id;
std::vector<Field<T, fieldTypeId> > record_;
};
Field不是一个“模板类”。它是一个类模板。这种区别是你困惑的唯一根源。Field<int>将会是一个模板类。 - Kerrek SB