C++ C++；在派生类中指定后验变量类型

我有两个不同类型对象的数据库，其中包含一些公共函数，因此我想创建一个包含公共函数定义的父类。其思想是，即使对象的类型不同，这些函数也必须执行相同的操作。一个愚蠢的例子：

class Database
{
public:
    // retrieve size of the dataset
    int Size() const {return list_.size();}
};

class DerivedDatabase : public Database
{
private:
    // list of dataset objects
    std::vector<Object1> list_;
};

class DerivedDatabase2: public Database
{
private:
    // list of dataset objects
    std::vector<Object2> list_;
};

类数据库
{
公众：
//检索数据集的大小
int Size（）常量{return list_u.Size（）；}
};
类DerivedDatabase:公共数据库
{
私人：
//数据集对象列表
std：：向量列表；
};
类DerivedDatabase2：公共数据库
{
私人：
//数据集对象列表
std：：向量列表；
};

---

一种解决方案是将函数定义为

virtualsize（）const=0

，然后让派生类重写它。然而，当我必须创建新类型的数据库时，想法是让它已经实现。有没有办法在派生类中指定变量类型的后验概率？这两个派生数据库本质上是不同的，除了一些常见的函数外，它们的行为完全不同。因此，它们必须是独立的对象

当然，

模板

用于：

class Database {
    virtual int size() = 0;
public:
    // retrieve size of the dataset
    int Size() const {return size();}
}

template<typename T>
class DerivedDatabase: public Database {
    std::vector<T> list_;
    int size() const {return list_.size();}
}

类数据库{
虚拟整数大小（）=0；
公众：
//检索数据集的大小
int Size（）常量{return Size（）；}
}
模板
类DerivedDatabase:公共数据库{
std：：向量列表；
int size（）常量{return list_u.size（）；}
}

当然，

模板的作用是：

class Database {
    virtual int size() = 0;
public:
    // retrieve size of the dataset
    int Size() const {return size();}
}

template<typename T>
class DerivedDatabase: public Database {
    std::vector<T> list_;
    int size() const {return list_.size();}
}

类数据库{
虚拟整数大小（）=0；
公众：
//检索数据集的大小
int Size（）常量{return Size（）；}
}
模板
类DerivedDatabase:公共数据库{
std：：向量列表；
int size（）常量{return list_u.size（）；}
}
当然，
模板的作用是：

class Database {
    virtual int size() = 0;
public:
    // retrieve size of the dataset
    int Size() const {return size();}
}

template<typename T>
class DerivedDatabase: public Database {
    std::vector<T> list_;
    int size() const {return list_.size();}
}

类数据库{
虚拟整数大小（）=0；
公众：
//检索数据集的大小
int Size（）常量{return Size（）；}
}
模板
类DerivedDatabase:公共数据库{
std：：向量列表；
int size（）常量{return list_u.size（）；}
}
当然，
模板的作用是：

class Database {
    virtual int size() = 0;
public:
    // retrieve size of the dataset
    int Size() const {return size();}
}

template<typename T>
class DerivedDatabase: public Database {
    std::vector<T> list_;
    int size() const {return list_.size();}
}

类数据库{
虚拟整数大小（）=0；
公众：
//检索数据集的大小
int Size（）常量{return Size（）；}
}
模板
类DerivedDatabase:公共数据库{
std：：向量列表；
int size（）常量{return list_u.size（）；}
}
您可以使用分解代码，例如：

template <typename T> class Database
{
// T should have a container named list_
public:
    // retrieve size of the dataset
    int Size() const { return AsDerived().list_.size(); }
private:
    const T& AsDerived() const { return static_cast<const T&>(*this); }
    T& AsDerived() { return static_cast<T&>(*this); }
};

模板类数据库
{
//T应该有一个名为list的容器_
公众：
//检索数据集的大小
int Size（）常量{return AsDerived（）.list_uz.Size（）；}
私人：
const T&AsDerived（）const{return static_cast（*this）；}
T&AsDerived（）{return static_cast（*this）；}
};

然后

class DerivedDatabase : public Database<DerivedDatabase>
{
    friend class Database<DerivedDatabase>;
private:
    std::vector<Object1> list_;
};

class DerivedDatabase2 : public Database<DerivedDatabase2>
{
    friend class Database<DerivedDatabase2>;
private:
    std::vector<Object2> list_;
};

class DerivedDatabase:公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};
类DerivedDatabase2：公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};

请注意，
DerivedDatabase
和
DerivedDatabase2
在这里不共享公共基类型

您可以使用分解代码，例如：

template <typename T> class Database
{
// T should have a container named list_
public:
    // retrieve size of the dataset
    int Size() const { return AsDerived().list_.size(); }
private:
    const T& AsDerived() const { return static_cast<const T&>(*this); }
    T& AsDerived() { return static_cast<T&>(*this); }
};

模板类数据库
{
//T应该有一个名为list的容器_
公众：
//检索数据集的大小
int Size（）常量{return AsDerived（）.list_uz.Size（）；}
私人：
const T&AsDerived（）const{return static_cast（*this）；}
T&AsDerived（）{return static_cast（*this）；}
};

然后

class DerivedDatabase : public Database<DerivedDatabase>
{
    friend class Database<DerivedDatabase>;
private:
    std::vector<Object1> list_;
};

class DerivedDatabase2 : public Database<DerivedDatabase2>
{
    friend class Database<DerivedDatabase2>;
private:
    std::vector<Object2> list_;
};

class DerivedDatabase:公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};
类DerivedDatabase2：公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};

请注意，
DerivedDatabase
和
DerivedDatabase2
在这里不共享公共基类型

您可以使用分解代码，例如：

template <typename T> class Database
{
// T should have a container named list_
public:
    // retrieve size of the dataset
    int Size() const { return AsDerived().list_.size(); }
private:
    const T& AsDerived() const { return static_cast<const T&>(*this); }
    T& AsDerived() { return static_cast<T&>(*this); }
};

模板类数据库
{
//T应该有一个名为list的容器_
公众：
//检索数据集的大小
int Size（）常量{return AsDerived（）.list_uz.Size（）；}
私人：
const T&AsDerived（）const{return static_cast（*this）；}
T&AsDerived（）{return static_cast（*this）；}
};

然后

class DerivedDatabase : public Database<DerivedDatabase>
{
    friend class Database<DerivedDatabase>;
private:
    std::vector<Object1> list_;
};

class DerivedDatabase2 : public Database<DerivedDatabase2>
{
    friend class Database<DerivedDatabase2>;
private:
    std::vector<Object2> list_;
};

class DerivedDatabase:公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};
类DerivedDatabase2：公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};

请注意，
DerivedDatabase
和
DerivedDatabase2
在这里不共享公共基类型

您可以使用分解代码，例如：

template <typename T> class Database
{
// T should have a container named list_
public:
    // retrieve size of the dataset
    int Size() const { return AsDerived().list_.size(); }
private:
    const T& AsDerived() const { return static_cast<const T&>(*this); }
    T& AsDerived() { return static_cast<T&>(*this); }
};

模板类数据库
{
//T应该有一个名为list的容器_
公众：
//检索数据集的大小
int Size（）常量{return AsDerived（）.list_uz.Size（）；}
私人：
const T&AsDerived（）const{return static_cast（*this）；}
T&AsDerived（）{return static_cast（*this）；}
};

然后

class DerivedDatabase : public Database<DerivedDatabase>
{
    friend class Database<DerivedDatabase>;
private:
    std::vector<Object1> list_;
};

class DerivedDatabase2 : public Database<DerivedDatabase2>
{
    friend class Database<DerivedDatabase2>;
private:
    std::vector<Object2> list_;
};

class DerivedDatabase:公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};
类DerivedDatabase2：公共数据库
{
好友类数据库；
私人：
std：：向量列表；
};

请注意，
DerivedDatabase
和
DerivedDatabase2
在这里不共享公共基类型

可能会有帮助。也许会有帮助。也许会有帮助。可能会有帮助。这样，
Size
就不能在
数据库
中有给定的实现。这两个派生数据库本质上是不同的，除了一些常见的函数外，它们的行为完全不同。在解决方案中，大小函数是在派生类中定义的。该函数是否可能在基类中指定，但在每个子类中使用不同的变量类型运行？@iprafols没有理由不能在具有（非模板化）
std::