C++中带参数、拷贝构造函数的继承问题。

converse

关于operator = 的问题,我记不得在哪里看过说把这个函数声明成virtual的时候需要注意一些什么了,改天我头脑清醒一点的时候再找找,昨晚熬夜看球精神有点恍惚了

2eye

写了一个测试operator=的小程序，对结果有点不解

1. 
   
2. #include <iostream>
   
3. using namespace std;
   
4. 
   
5. class A{
   
6. public:
   
7.         A(int i) :m_i(i){}
   
8.         A& operator=( A& other);
   
9.         void print() { cout<<"m_i: "<<m_i<<endl; }
   
10. private:
    
11.         int m_i;
    
12. };
    
13. 
    
14. A& A::operator=( A& other )
    
15. {       
    
16.         cout<<"from A's operator=()"<<endl;
    
17.         m_i = other.m_i;
    
18.         return *this;
    
19. }
    
20. 
    
21. class B : public A{
    
22. public:
    
23.         B(int i1, int i2) :A(i1),new_data(i2){}
    
24.         void print();
    
25. private:
    
26.         int new_data;
    
27. };
    
28.        
    
29. void B::print()
    
30. {
    
31.         A::print();
    
32.         cout<<"new_data: "<<new_data<<endl;
    
33. }
    
34. 
    
35. int main()
    
36. {
    
37.         B b1(10,20);
    
38.         B b2(40,50);
    
39.         cout<<"before operator=()"<<endl;
    
40.         b2.print();
    
41.         cout<<endl<<"Call operator=()"<<endl<<endl;
    
42.         b2 = b1;
    
43.         b2.print();
    
44.        
    
45.         return 0;
    
46. }
    

复制代码

输出为：

1. 
   
2. before operator=()
   
3. m_i: 40
   
4. new_data: 50
   
5. 
   
6. Call operator=()
   
7. 
   
8. from A's operator=()
   
9. m_i: 10
   
10. new_data: 20
    
11. 
    

复制代码

既然是调用的A中定义的operator=()，但是A中的operator=()明明没有复制new_data,也不可能知道A的派生类有那些数据需要复制，怎么得到的结果还恰恰正好是对的。难道又继承了A的，编译器还自动加了复制新数据的内容？或者是编译器自动生成了B的operator=的代码，这个代码里调用了基类中（如果有的话）的operator=().

2eye

>>>>如Base(int){}，但是派生类却没有Derive(int)这样的构造函数；为什么不能继承这个函数。
>>没懂,这两个函数函数名称都不一样了,如何能够在调用int的derive构造的时候找不到定义就去找base里面的呢?这个显然是不合理的.

我的意思是说，从语意上讲，派生来的构造函数至少在一大部分是与基类一样的。那么就算我没有定义Derive(int)，编译器也该知道我是想调用Base(int)来初始化派生类的基类部分吧。呵呵，好像要求高了点。

wolfshadowkd

构造函数好像不能被继承吧？

net_robber

原帖由 2eye 于 2006-4-19 23:39 发表
写了一个测试operator=的小程序，对结果有点不解
[code]
#include <iostream>
using namespace std;

class A{
public:
        A(int i) :m_i(i){}
        A& operator=( A& other);
        void print() {  ...

这个方法是正确的

在子类的构造函数之前构造

2eye

原帖由 net_robber 于 2006-4-20 19:58 发表

这个方法是正确的

在子类的构造函数之前构造

啥意思，没看懂

柳五随风

原帖由 converse 于 2006-4-19 23:21 发表
关于operator = 的问题,我记不得在哪里看过说把这个函数声明成virtual的时候需要注意一些什么了,改天我头脑清醒一点的时候再找找,昨晚熬夜看球精神有点恍惚了:)

operator= is not inherited.  You can verify this by attempting to inherit an operator= some time.  It definitely does not work.  This might cause you to believe that declaring them to be virtual is meaningless, but this is not the case.

If class A has:

        virtual A& operator=(const A&);

and Class B derived from A has

        virtual A& operator=(const A&);

Then the following code will invoke B's operator=:

        A a;
        B b;
        A &r = b;

        r=a; // virtually invokes B's operator=

So, you would want to make operator= any time you thought you might be doing polymorphic assigment through a reference....

Note however that both assignment operators have to have the same signature.  The utility of A& B::operator=(const A&) is unclear, and probably not significant.  The important thing to remember is that

        B& B::operator=(const B&);

Does not override, nor virtually substitute for

        A& A::operator=(const A&);

So, usually, there is not much point in making operator= virtual.

我帮你把表情禁用了,这样方便查看--converse

[ 本帖最后由 converse 于 2006-4-21 12:58 编辑 ]