模板和类的财产 [英] Template and class heritance
问题描述
下面的代码不会产生我想要的。
The code below does not produce what I want.
#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
template<typename T> class Parent;
template<typename T> class Child1;
template<typename T> class Child2;
template<typename T> T fcn_default(const Parent<T> &obj, const T &phit){
return 3.2 + phit;
}
template<typename T> T fcn_mod1 (const Child1<T> &obj, const T &phit){
return 1.2 + phit;
}
template<typename T> T fcn_mod2 (const Child2<T> &obj, const T &phit){
return 2.2 + phit;
}
template<typename T> class Parent{
public:
Parent() {
fcn_ptr = &fcn_default;
}
T do_something(const T &phit){
return this->fcn_ptr(*this, phit);
}
T (*fcn_ptr)(const Parent &, const T &);
};
template<typename T> class Child1 : public Parent<T>{
public:
Child1() {
}
T (*fcn_ptr)(const Child1 &, const T &);
};
template<typename T> class Child2 : public Parent<T>{
public:
Child2() {
}
T (*fcn_ptr)(const Child2 &, const T &);
};
typedef double lrtType;
int main(){
std::vector< Parent<lrtType> * > objects;
Child1<lrtType> *test11 = new Child1<lrtType>();
objects.push_back(test11);
Child1<lrtType> *test12 = new Child1<lrtType>();
test12->fcn_ptr = &fcn_mod1;
objects.push_back(test12);
Child2<lrtType> *test2 = new Child2<lrtType>();
test2->fcn_ptr = &fcn_mod2;
objects.push_back(test2);
for (size_t i = 0; i < objects.size(); ++i) {
std::cout << objects[i]->do_something(2) << std::endl;
}
cout << "test" << endl;
}
它产生：
5.2
5.2
5.2
test
b $ b
我期待：
And I was expecting:
5.2
3.2
4.2
test
我的理解是向量 objects 父，因此调用自己的方法，而不是孩子的方法。
My understanding is that the vector objects is of type Parent and therefore calls its own methods and not the children's ones.
我已经几乎破解它使用好奇地重复模板模式，但我有一个最后一个问题在向量对象初始化期间。
I have nearly cracked it using "Curiously recurring template pattern" but I have a last problem during the initialization of the vector objects.
#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
template<class Child, typename T> class Parent;
template<typename T> class Child1;
template<typename T> class Child2;
template<typename T> T fcn_mod1 (const Child1<T> &obj, const T &phit){
return 1.2 + phit;
}
template<typename T> T fcn_mod2 (const Child2<T> &obj, const T &phit){
return 2.2 + phit;
}
template<class Child, typename T> class Parent{
public:
Parent() {
fcn_ptr = &Parent::fcn_default;
}
T do_something(const T &phit){
return static_cast<Child*>(this)->fcn_ptr(static_cast<Child*>(this), phit);
}
T (*fcn_ptr)(const Child &, const T &);
private:
static T fcn_default(const Child &obj, const T &phit){
return 3.2 + phit;
}
};
template<typename T> class Child1 : public Parent<Child1<T>,T>{
public:
Child1() {
}
T (*fcn_ptr)(const Child1 &, const T &);
};
template<typename T> class Child2 : public Parent<Child2<T>,T>{
public:
Child2() {
}
T (*fcn_ptr)(const Child2 &, const T &);
};
typedef double lrtType;
int main(){
std::vector< Parent<lrtType> * > objects;
Child1<lrtType> *test11 = new Child1<lrtType>();
objects.push_back(test11);
Child1<lrtType> *test12 = new Child1<lrtType>();
test12->fcn_ptr = &fcn_mod1;
objects.push_back(test12);
Child2<lrtType> *test2 = new Child2<lrtType>();
test2->fcn_ptr = &fcn_mod2;
objects.push_back(test2);
for (size_t i = 0; i < objects.size(); ++i) {
std::cout << objects[i]->do_something(2) << std::endl;
}
cout << "test" << endl;
}
** +++++ UPDATE +++++ **
** +++++ UPDATE +++++ **
如果我添加一个成员到一个子类，我不能从 fcn_mod2 中访问它。也许虚拟函数可以帮助？
If I add a member to a child class, I can not have access to it from within fcn_mod2 for instance. Maybe the virtual functions can help?
#include <iostream>
#include <vector>
#include <cstdlib>
using namespace std;
template<typename T> class Parent;
template<typename T> class Child1;
template<typename T> class Child2;
template<typename T> T fcn_default(const Parent<T> &obj, const T &phit){
return 3.2 + phit;
}
template<typename T> T fcn_mod1 (const Parent<T> &obj, const T &phit){
return 1.2 + phit;
}
template<typename T> T fcn_mod2 (const Parent<T> &obj, const T &phit){
return 2.2 + phit + param2*0.001;
}
template<typename T> class Parent{
public:
Parent() {
fcn_ptr = &fcn_default;
}
T do_something(const T &phit){
return this->fcn_ptr(*this, phit);
}
T (*fcn_ptr)(const Parent &, const T &);
};
template<typename T> class Child1 : public Parent<T>{
public:
Child1() {
}
};
template<typename T> class Child2 : public Parent<T>{
public:
Child2() {
}
T param2;
};
typedef double lrtType;
int main(){
std::vector< Parent<lrtType> * > objects;
Child1<lrtType> *test11 = new Child1<lrtType>();
objects.push_back(test11);
Child1<lrtType> *test12 = new Child1<lrtType>();
test12->fcn_ptr = &fcn_mod1;
objects.push_back(test12);
Child2<lrtType> *test2 = new Child2<lrtType>();
test2->fcn_ptr = &fcn_mod2;
test2->param2 = 4;
objects.push_back(test2);
for (size_t i = 0; i < objects.size(); ++i) {
std::cout << objects[i]->do_something(2) << std::endl;
}
cout << "test" << endl;
}
推荐答案
您的子类包含与 Parent 类中同名的其他函数指针字段。这通常不是你想要的，因为这些类在其中有两个指针。为什么不在父类中只使用一个指针。
所以，你应该删除子类中的函数指针。
The problem that you have is that your child classes contain an other function pointer fields of the same name as the one in your Parent class. That is usually not what you want, since these classes will have two pointers in them. Why not simply use only one pointer in the parent class.
So, you should delete the function pointers in the child classes.
你的第二个解决方案中的下一个问题是你试图使用运行时虚拟分派（ Parent 的向量）与编译时间virtualdispatch （奇怪的重复模板模式）。这是不可能的。如果你想要运行时虚拟分派，那么你必须使用 函数。
The next problem you have in your second solution is that you try to use runtime virtual dispatch (the vector of Parents) with compile time "virtual" dispatch (the curiously recurring template pattern). This is just not possible. If you want runtime virtual dispatch, then you have to use virtual functions.
如果没有使用函数指针的特殊原因，只有虚拟方法，即：
If there is no special reason for using function pointers, just use virtual methods only, i.e.:
template<typename T> class Parent{
public:
virtual T fcn(const Parent<T> &obj, const T &phit){ return 3.2 + phit; }
};
template<typename T> class Child1 : public Parent<T>{
public:
T fcn(const Parent<T> &obj, const T &phit) override { return 2.2 + phit; }
};
template<typename T> class Child2 : public Parent<T>{
public:
T fcn(const Parent<T> &obj, const T &phit) override { return 1.2 + phit; }
};
这应该在你的场景中工作。如果这不是您想要的，请澄清您的问题。
That should work in your scenario. If this is not what you want, please clarify your question.
这篇关于模板和类的财产的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！
