关于类属类的派生类是不是一定是类属类的问题.

lordbyorn

《面向对象程序设计基础》高等教育出版社
P282是有一句话：
    程序9。2。5则以类属类为基类，这时派生类必定也是类属类。派生类的形式类属参数表中必须包含基类的所有形式类属参数。

我认为是不正确的。

1. 
   
2. 下面我给个例子（我自己思考出来的）：
   
3. quene.h:
   
4. 
   
5. #include<stdio.h>
   
6. template<class TYPE>
   
7. class Queue{
   
8. 
   
9. protected:
   
10.         int head,tail,size;
    
11.         int (*traver)(TYPE&);
    
12.         TYPE* buf;
    
13.        
    
14. public:
    
15.          Queue(int init_size,int (*init_traver)(TYPE&)){  
    
16.                 size=init_size;
    
17.                 buf=new TYPE[size];
    
18.                 if(!buf){cerr<<"ERROR"<<endl;exit(0);}
    
19.                 head=0;
    
20.                 tail=0;
    
21.                 traver=init_traver;
    
22.         }
    
23.         Queue(int (*init_traver)(TYPE&)){
    
24.                 Queue<TYPE>(256,init_traver);
    
25.         }
    
26. 
    
27.         ~Queue(){
    
28.         delete[] buf;
    
29.         }
    
30.        
    
31.         int is_full(){
    
32.                 if((tail+1)%size==head)return 1;
    
33.                 return 0;
    
34.         }
    
35. 
    
36.         int is_empty(){
    
37.                 if(head==tail)return 1;
    
38.                 return 0;
    
39.         }
    
40.         int del(TYPE &elem){
    
41.                 if(is_empty())return 0;
    
42.                 elem=buf[head++];
    
43.                 head%=size;
    
44.                 return 1;
    
45.         }
    
46.         int add(const TYPE &elem){
    
47.                 cerr<<"ADDING"<<endl;
    
48.                 if(is_full()){cerr<<"FULL"<<endl;return 0;}
    
49.                 //getchar();
    
50.                 //buf[tail++]=elem;
    
51.                 getchar();
    
52.                 tail++;
    
53.                 tail%=size;
    
54.                 return 1;
    
55.         }
    
56.         int visit(){
    
57.                 int cursor;
    
58.                 cursor=head;
    
59.                 while(cursor!=tail){
    
60.                         cerr<<"TRAVERING"<<endl;
    
61.                         traver(buf[cursor++]);
    
62.                         cursor%=size;
    
63.                 }
    
64.         return 1;
    
65.         }
    
66. };
    
67. 这是一个类属类。
    
68. #include<iostream.h>
    
69. 
    
70. #include "queue.hpp"
    
71. 
    
72. 
    
73. 
    
74. struct Worker{
    
75. 
    
76.         int status;
    
77. 
    
78.         int timer;
    
79. 
    
80.         };
    
81. 
    
82. [color=red]class Miner: public Queue<struct Worker>{//注意！！！[/color]
    
83. 
    
84. 
    
85. 
    
86. public:
    
87. 
    
88.         [color=red]Miner(int (*init_traver)(struct Worker&)):Queue<struct Worker>(init_traver){//注意！！！[/color]
    
89. 
    
90.         return ;
    
91. 
    
92.         }
    
93. 
    
94.         int ch_status(int status){
    
95. 
    
96.                 buf[head].status=status;
    
97. 
    
98.                 return 1;
    
99. 
    
100.         }
     
101. 
     
102. 
     
103. 
     
104.         int ch_time(long time){
     
105. 
     
106.                 buf[head].timer=time;
     
107. 
     
108.                 return 1;
     
109. 
     
110.         }
     
111. 
     
112. 
     
113. 
     
114.         int insert(struct Worker comer){
     
115. 
     
116.                 int temp;
     
117. 
     
118.                 temp=tail;
     
119. 
     
120.                 if(is_full())return 0;
     
121. 
     
122. 
     
123. 
     
124.                 for(;(temp!=head)&&buf[(temp-1)%size].timer>comer.timer; ){
     
125. 
     
126.                         buf[temp]=buf[(temp-1)%size];
     
127. 
     
128.                         temp=(temp-1)%size;
     
129. 
     
130.                 }
     
131. 
     
132.                 buf[temp]=comer;
     
133. 
     
134.                 tail=(tail+1)%size;
     
135. 
     
136.                 ln++;
     
137. 
     
138.                 return 1;
     
139. 
     
140.         }
     
141. 
     
142.         int status(){
     
143. 
     
144.                 return buf[head].status;
     
145. 
     
146.         }
     
147. 
     
148.         long time(){
     
149. 
     
150.                 return buf[head].timer;
     
151. 
     
152.         }
     
153. 
     
154. };
     

复制代码

大家看看。
quene是一个类属类。
Miner是quene的派生类。但是，Miner是一个普通类。
派生类根本没有形式类属参数表！
关键是，我在构造Miner是已经把quene实例化了。
我觉得编程一定要懂得内在的原理！
（不知道在其它书上是不是已经解决了这个问题？？）

辛苦！改了N次才保留缩进，去掉表情符号！！！

viper

可是严格说这是从template的一个实例派生出来的类，不是从template
派生出来的。

lordbyorn

是啊。不这样做是解决不了的啊。
因为信息不够。
这样做至少也提供了一条途径吧。

无双

类属类是什么意思先

偶好久没有研究语法了
可否告知一起研究

lordbyorn

就是template,模板

viper

其实明白了以后，怎么解释都容易。但是没有明白以前，看到别人写的文字就发懵。我想，那本书打算说的是下面这种情况：

1. 
   
2. template <class T>
   
3. class Base
   
4. {
   
5.     T _data;
   
6. public:
   
7.     Base(const T& data)
   
8.     {
   
9.         _data = data;
   
10.     };
    
11. };
    
12. 
    
13. 
    
14. template <class T>
    
15. class Derived : public Base<T>
    
16. {
    
17. public:
    
18.     Derived(const T& data)
    
19.         : Base<T>(data)
    
20.         {
    
21.         }
    
22. };
    
23. 
    
24. int
    
25. main()
    
26. {
    
27.     Derived<int> myobject(0);
    
28.     return 0;
    
29. }
    

复制代码

你开始贴出来的程序的 Miner 类呢，就相当于我这个简单例子里的 Derived 魔板的一个实例 Derived<int>。
对吗？

lordbyorn

其中有不同之处的.
1、我不用自己实例化了，
2、怎样继承是个问题。
3、我的Miner只处理一种数据类型，我为什么要用template？所以我就要在继承的时候实例化。

viper

我是这么理解的：
1、你实际上是早一点自己实例化了。
2、继承的时候有什么问题？
3、实例化化的类跟普通类没有什么不同，所以你实际上继承了一个普通的类。

lordbyorn

你不要对照我的例子,编一个看看.

无双

没有说模板类的子类就一定要是模板类啊

你可以实例化它
也可以继续使用模板的形式