[已解决]使用接口（基类）访问模板类中的数据怎么写才漂亮?

Croper

本来以为很简单一个问题。。突然发现我纠结到了。

比如说这里有一个模板类A：

1. template <typename T>
   
2. class A{
   
3. public:
   
4.         //....其他数据成员
   
5. 
   
6.         T data;  //某个数据成员
   
7. 
   
8.         //..其他成员函数
   
9. };
   

复制代码

为了方便访问它，写了一个接口类，并让模板类继承：

1. //接口类
   
2. struct IA {
   
3. 
   
4.         //virtual IA* copy() =0;
   
5.         //virtual int id() =0;
   
6.         //...其他接口..blalblabla..
   
7. };
   
8. 
   
9. //模板类
   
10. template <typename T>
    
11. class A :public IA {
    
12. public:
    
13.         //....其他数据成员
    
14. 
    
15.         T data;  //某个数据成员
    
16. 
    
17.         //..其他成员函数
    
18. };

复制代码

这个时候，我想通过IA来访问类A中的数据成员data。
类A是模板类，那么这个接口只能写成模板函数。。。
但是模板函数是不能写成虚函数的，想来想去，只想出两种方法：

1. //接口类
   
2. struct IA {
   
3. private:
   
4.         virtual void* _GetData() = 0;  //返回类型改为void*，这样能写成虚函数
   
5. public:
   
6.         template <typename T>          //然后再包装一下
   
7.         T GetData() {
   
8.                 return *static_cast<T*>(_GetData());
   
9.         }
   
10. };
    
11. 
    
12. //模板类
    
13. template <typename T>
    
14. class A :public IA {
    
15. public:
    
16.         T data;  //需要的数据成员
    
17.         void* _GetData() override {     //这是继承的函数
    
18.                 return &data;
    
19.         }
    
20. };

复制代码

这样写的问题是，即使模板函数GetData的类型和模板类不一致且无法转化，也不会报错，
而且类型之间的互相转化也是直接二进制数据强制转化，这肯定不是所期望的

1. //接口类
   
2. struct IA {
   
3. public:
   
4.         template <typename T>
   
5.         T GetData();
   
6. };
   
7. 
   
8. //模板类
   
9. template <typename T>
   
10. class A :public IA {
    
11. public:
    
12.         T data;  //需要的数据成员
    
13. };
    
14. 
    
15. template<typename T>
    
16. T IA::GetData()
    
17. {
    
18.         return dynamic_cast<A<T>*>(this)->data;  //将this指针转化为A<T>的指针
    
19. };

复制代码

这样首先是不符合设计模式了，抽象类（底层）依赖具体实现（高层）。
另外，同样无法做到double与int的相互转化。

所以还有什么好点的写法么。。？

最佳答案

月排行榜 / 总排行榜

人造人

2020-1-6 20:56:22

我仔细想了想，这个问题应该无解，至少我无解
这个问题要求C++能够记住类型信息，也就是要求C++能够正确读取 void *
试想一下，在new一个对象的时候保存这个对象的类型，然后把new出来的对象给void 指针保存，在使用的时候用之前保存的类型信息对void指针解引用
但是C++好像不能读取void *，我百度不到如何保存类型信息

跳转到最佳答案楼层

人造人

我仔细想了想，这个问题应该无解，至少我无解
这个问题要求C++能够记住类型信息，也就是要求C++能够正确读取 void *
试想一下，在new一个对象的时候保存这个对象的类型，然后把new出来的对象给void 指针保存，在使用的时候用之前保存的类型信息对void指针解引用
但是C++好像不能读取void *，我百度不到如何保存类型信息

bin554385863

看不懂你想表达什么意思

Croper

就是我现在想通过接口类访问模板类中的数据data，
但是找不到一个好的实现方法能满足要求：
1、接受的变量和模板类的类型不匹配且无法相互转化时能报错(就像你给一个string赋一个vector时会报错一样)
2、最好接受的变量和模板类的能互相转化的时候时能正常转化（比如一个double类型的变量能够接受一个整数并隐式转化）
3、符合一般来说面向对象的设计原则。

人造人

"类A是模板类，那么这个接口只能写成模板函数。。。
但是模板函数是不能写成虚函数的"

我不明白你说的这句话是什么意思
通过IA来访问类A中的数据成员data
可以在IA中加一个纯虚函数呀，不过IA也要用模板
写成下面这样，是你想要的吗？

1. #include <iostream>
   
2. 
   
3. //接口类
   
4. template <typename T>
   
5. struct IA {
   
6. public:
   
7.         virtual IA* copy() =0;
   
8.         virtual uint64_t id() =0;
   
9.         //...其他接口..blalblabla..
   
10. 
    
11.         virtual T GetData() = 0;
    
12. };
    
13. 
    
14. //模板类
    
15. template <typename T>
    
16. class A:public IA<T> {
    
17. public:
    
18.         IA<T>* copy() {
    
19.                 return new A<T>(*this);
    
20.         }
    
21.         uint64_t id() {
    
22.                 return uint64_t(this);
    
23.         }
    
24.         T GetData() {
    
25.                 return this->data;
    
26.         }
    
27.         //...其他接口..blalblabla..
    
28. 
    
29.         //....其他数据成员
    
30. 
    
31.         T data;  //某个数据成员
    
32. 
    
33.         //..其他成员函数
    
34. };
    
35. 
    
36. int main()
    
37. {
    
38.         A<double> a;
    
39. 
    
40.         return 0;
    
41. }
    

复制代码

人造人

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. //接口类
   
5. template <typename T>
   
6. struct IA {
   
7. public:
   
8.         virtual IA* copy() =0;
   
9.         virtual uint64_t id() =0;
   
10.         //...其他接口..blalblabla..
    
11. 
    
12.         virtual T GetData() = 0;
    
13. };
    
14. 
    
15. //模板类
    
16. template <typename T>
    
17. class A:public IA<T> {
    
18. public:
    
19.         A(const T &n): data(n) {
    
20.         }
    
21. 
    
22.         IA<T>* copy() {
    
23.                 return new A<T>(*this);
    
24.         }
    
25.         uint64_t id() {
    
26.                 return uint64_t(this);
    
27.         }
    
28.         T GetData() {
    
29.                 return this->data;
    
30.         }
    
31.         //...其他接口..blalblabla..
    
32. 
    
33.         //....其他数据成员
    
34. 
    
35.         T data;  //某个数据成员
    
36. 
    
37.         //..其他成员函数
    
38. };
    
39. 
    
40. int main()
    
41. {
    
42.         IA<double> *a = new A<double>(123.45);
    
43.         IA<int> *b = new A<int>(123456);
    
44.         IA<std::string> *c = new A<std::string>("abcd");
    
45.         std::cout << "id: " << a->id() << std::endl;
    
46.         std::cout << "data: " << a->GetData() << std::endl;
    
47.         std::cout << "id: " << b->id() << std::endl;
    
48.         std::cout << "data: " << b->GetData() << std::endl;
    
49.         std::cout << "id: " << c->id() << std::endl;
    
50.         std::cout << "data: " << c->GetData() << std::endl;
    
51. 
    
52.         std::cout << std::endl;
    
53. 
    
54.         IA<double> *na = a->copy();
    
55.         IA<int> *nb = b->copy();
    
56.         IA<std::string> *nc = c->copy();
    
57.         std::cout << "id: " << na->id() << std::endl;
    
58.         std::cout << "data: " << na->GetData() << std::endl;
    
59.         std::cout << "id: " << nb->id() << std::endl;
    
60.         std::cout << "data: " << nb->GetData() << std::endl;
    
61.         std::cout << "id: " << nc->id() << std::endl;
    
62.         std::cout << "data: " << nc->GetData() << std::endl;
    
63.         delete na;
    
64.         delete nb;
    
65.         delete nc;
    
66. 
    
67.         return 0;
    
68. }
    

复制代码

1. id: 2660434001472
   
2. data: 123.45
   
3. id: 2660433999552
   
4. data: 123456
   
5. id: 2660433984144
   
6. data: abcd
   
7. 
   
8. id: 2660434001952
   
9. data: 123.45
   
10. id: 2660434000192
    
11. data: 123456
    
12. id: 2660433983136
    
13. data: abcd
    
14. 请按任意键继续. . .

复制代码

bin554385863

1. #include <iostream>
   
2. #include <sstream>
   
3. class A_base
   
4. {
   
5.     private:
   
6.         int a;
   
7.     public:
   
8.         A_base(const int &b = 0):a(b){}
   
9.         void showdata() const
   
10.         {
    
11.             std::cout << a;
    
12.         }
    
13.         virtual ~A_base() { std::cout << "调用A_base成功" << std::endl; }
    
14. };
    
15. template <typename T>
    
16. class A : public A_base
    
17. {
    
18.     private:
    
19.         T b;
    
20.     public:
    
21.         A(const T c = 0) : b(c), A_base(int(c)){}
    
22.         void showdata()
    
23.         {
    
24.             std::cout << "基类数据: ";
    
25.             A_base::showdata();
    
26.             std::cout << std::endl;
    
27.             std::cout << "子类数据: " << b << std::endl;
    
28.         }
    
29.         ~A() { std::cout << "调用A成功" << std::endl; }
    
30. };
    
31. int main(int argc, char const *argv[])
    
32. {
    
33.     A<float> a = 3.014159;
    
34.     a.showdata();
    
35.     std::cout << std::endl;
    
36.     return 0;
    
37. }
    

复制代码

====================================================
Microsoft Windows [版本 10.0.18363.535]
(c) 2019 Microsoft Corporation。保留所有权利。

E:\Users\admin\Documents\VScode\Code>c:\Users\admin\.vscode\extensions\ms-vscode.cpptools-0.26.2\debugAdapters\bin\WindowsDebugLauncher.exe --stdin=Microsoft-MIEngine-In-vtfeiqkt.yjn --stdout=Microsoft-MIEngine-Out-txf35s5p.zl2 --stderr=Microsoft-MIEngine-Error-w31u0pzy.i0y --pid=Microsoft-MIEngine-Pid-meui1qcz.std --dbgExe=D:\MinGW\bin\gdb.exe --interpreter=mi
基类数据: 3
子类数据: 3.01416

调用A成功
调用A_base成功

E:\Users\admin\Documents\VScode\Code>  

人造人

bin554385863 发表于 2020-1-7 12:42
====================================================
Microsoft Windows [版本 10.0.18363.535]
(c) ...

在C++中没有Java中的接口概念，抽象类可以模拟Java中的接口。

用抽象类模拟接口：抽象类中只有纯虚函数，没有成员变量和其他函数。

https://blog.csdn.net/qq_41093451/article/details/79645435

我不记得在哪里看过一句话
“C++中，一个类中如果只有纯虚函数，那么这个类就是接口”
这很可能不是原话，我就是这样理解的


“在C++中，含有纯虚拟函数的类称为抽象类”
也就是说含有纯虚函数的类是抽象类，如果一个类中只有纯虚函数，那就是接口
https://baike.so.com/doc/6213661-6426933.html

Croper

我大概还是没说清楚。。
我想要的是这种效果：

1. IA *p = new A<int>(5);
   
2. cout << p->GetData<int>() << endl;       //输出5
   
3. p = new A<string>("fishc.com")
   
4. cout << p->GetData<string>() << endl;    //输出fishc.com
   
5. 
   
6. string s = p->GetData<string>();         //正确赋值
   
7. int i = p->GetData<int>();               //报错：string没有默认的转化为int的函数

复制代码

Croper

中午又想出两个办法，基本解决，但还是感觉有点绕：

方法1，引入一个中间模板类，让A去继承这个中间模板类

1. #include <string>
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. //中间类
   
6. template <typename T>
   
7. struct IA_templ {
   
8.         virtual T GetData() = 0;
   
9. };
   
10. 
    
11. 
    
12. //接口类
    
13. struct IA {
    
14. 
    
15. public:
    
16.         template <typename T>         
    
17.         T GetData() {
    
18.                 return dynamic_cast<IA_templ<T>*>(this)->GetData();
    
19.         }
    
20.         virtual ~IA() {};
    
21. };
    
22. 
    
23. 
    
24. //模板类
    
25. template <typename T>
    
26. class A :public IA,public IA_templ<T> {   
    
27.         T data;  //需要的数据成员
    
28. public:
    
29.         A(const T& t) :data(t) {};
    
30.         T GetData() override {     //这是继承的函数
    
31.                 return data;
    
32.         }
    
33. };
    
34. 
    
35. int main() {
    
36.         IA *p = new A<int>(5);
    
37.         cout << p->GetData<int>() << endl;       //输出5
    
38.         p = new A<string>("fishc.com");
    
39.         cout << p->GetData<string>() << endl;    //输出fishc.com
    
40. 
    
41.         string s = p->GetData<string>();         //正确赋值
    
42.         int i = p->GetData<int>();               //报错：string没有默认的转化为int的函数
    
43.         system("pause");
    
44. }

复制代码

大概符合要求吧,虽然这个接口类已经不是"接口类"了。。。

人造人

Croper 发表于 2020-1-7 14:15
中午又想出两个办法，基本解决，但还是感觉有点绕：

方法1，引入一个中间模板类，让A去继承这个中间模板 ...

你为什么非要在GetData后面指定类型？
int i = p->GetData<int>();

人造人

Croper 发表于 2020-1-7 14:15
中午又想出两个办法，基本解决，但还是感觉有点绕：

方法1，引入一个中间模板类，让A去继承这个中间模板 ...

1. p = new A<string>("fishc.com");

复制代码

在创建出这个对象的时候已经指定过了呀

Croper

人造人 发表于 2020-1-7 15:06
你为什么非要在GetData后面指定类型？
int i = p->GetData();

因为返回类型不同啊。。C++又没有办法根据返回类型重载。。。

Croper

方法二是想自己做虚函数表的。。。。
但是发现成员函数指针的转换不是一般地让人头大。。。研究中。。。

Croper

bin554385863 发表于 2020-1-7 12:42
====================================================
Microsoft Windows [版本 10.0.18363.535]
(c) ...

你这根本就不是重载啊- -

人造人

Croper 发表于 2020-1-7 15:13
因为返回类型不同啊。。C++又没有办法根据返回类型重载。。。

我明白你的意思了，我研究研究

bin554385863

Croper 发表于 2020-1-7 15:17
你这根本就不是重载啊- -

....你不是只要能访问数据就可以了吗

人造人

bin554385863 发表于 2020-1-7 18:06
....你不是只要能访问数据就可以了吗

他在玩设计模式

bin554385863

(⊙o⊙)

人造人

这样可以吗？
你既然想在GetData后面指定类型，那为什么不能在GetData后面先加.access然后再加类型
GetData后面不能加类型，因为GetData函数不能用模板

写这个代码的时候遇到了一些概念上的问题

1. class IA
   
2. {
   
3. public:
   
4.         virtual ~IA() = 0;
   
5.         virtual uint64_t id() = 0;
   
6.         virtual data_t get_data() = 0;
   
7. };
   
8. 
   
9. // 没办法，子类要求这个函数
   
10. IA::~IA()
    
11. {
    
12. }

复制代码

子类要求IA有一个析构函数，IA中的函数必须都是纯虚函数
子类还要求这个析构函数有实现代码，然后就写成了上面这样
这样的IA还能称得上是接口吗？我百度不到结果

1. #include <iostream>
   
2. #include <string>
   
3. 
   
4. class data_t
   
5. {
   
6. public:
   
7.         template <typename T>
   
8.         data_t(const T &n, void (*free_pointer)(void *)): value(new T(n)), free_pointer(free_pointer)
   
9.         {
   
10.         }
    
11.         ~data_t()
    
12.         {
    
13.                 // 当前类不知道这个指针指向的类型，无法删除这个指针，让创建者(创建当前对象的代码)来删除
    
14.                 // 我尝试过在当前类中保存指针的类型，但是失败了
    
15.                 this->free_pointer(this->value);
    
16.         }
    
17.         template <typename T>
    
18.         T access()
    
19.         {
    
20.                 return *static_cast<T *>(this->value);
    
21.         }
    
22. 
    
23. private:
    
24.         void *value;
    
25.         void (*free_pointer)(void *p);
    
26. };
    
27. 
    
28. class IA
    
29. {
    
30. public:
    
31.         virtual ~IA() = 0;
    
32.         virtual uint64_t id() = 0;
    
33.         virtual data_t get_data() = 0;
    
34. };
    
35. 
    
36. // 没办法，子类要求这个函数
    
37. IA::~IA()
    
38. {
    
39. }
    
40. 
    
41. template <typename T>
    
42. class A: public IA
    
43. {
    
44. public:
    
45.         A(const T &n): data(n) {}
    
46.         uint64_t id()
    
47.         {
    
48.                 return uint64_t(this);
    
49.         }
    
50.         data_t get_data()
    
51.         {
    
52.                 return data_t(data, this->free_pointer);
    
53.         }
    
54. private:
    
55.         T data;
    
56. 
    
57.         static void free_pointer(void *p)
    
58.         {
    
59.                 delete static_cast<T *>(p);
    
60.         }
    
61. };
    
62. 
    
63. int main(void)
    
64. {
    
65.         IA *p = new A<int>(5);
    
66.         std::cout << p->id() << std::endl;
    
67.         std::cout << p->get_data().access<int>() << std::endl;
    
68. 
    
69.         delete p;
    
70.         p = new A<std::string>("fishc.com");
    
71.         std::cout << p->id() << std::endl;
    
72.         std::cout << p->get_data().access<std::string>() << std::endl;
    
73. 
    
74.         std::string s = p->get_data().access<std::string>();
    
75.         //int i = p->get_data().access<std::string>();
    
76.         delete p;
    
77. 
    
78.         return 0;
    
79. }
    

复制代码