#include <iostream>
using namespace std;
#include <string>class Basic
{
public:string m_name;Basic();Basic(string name);Basic(Basic& bc);~Basic();Basic& operator=(const Basic& bc) {cout << "Basic::operator=()\n";this->m_name = bc.m_name;return *this;}
};
Basic::Basic()
{cout <<"Basic::Basic()"<<endl;
}
Basic::Basic(string name)
{m_name = name ;cout <<"Basic::Basic(string)"<<"name:"<<m_name<<endl;
}
Basic::Basic(Basic &bc)
{this->m_name = bc.m_name;cout <<"Basic::Basic(Basic&)"<<"name:"<<bc.m_name<<endl;
}Basic::~Basic()
{cout<<"this is "<<m_name << "Basic::~Basic()"<<endl;;
}class Derived:public Basic
{
public:int m_dx;Derived();Derived(string name);//m_name~Derived();void show();
};
Derived::Derived()
{cout <<"Derived::Derived()"<<endl;
}
Derived::Derived(string name):Basic(name)
{cout <<"Derived::Derived(string)"<<"name:"<<m_name<<endl;
}
Derived::~Derived()
{cout <<"this is "<<m_name <<"Derived::~Derived()"<<endl;;
}
void Derived::show()
{cout<<"name: "<<m_name<<endl;
}
void test()
{Derived dc1("dc1");cout<<""<<endl;Derived dc2("dc2");//m_bxcout<<""<<endl;dc1 = dc2 ;//Basic::operator=() 调用了基类的operator= ，并正确地对Derived::m_name进行了赋值。 看起来是operator=被继承了？分析见下5补充。    cout<<"next is dc1.show():  ";dc1.show();cout<<""<<endl;
}
int main() {test();while(1);
}
/**
Basic::Basic(string)name:dc1
Derived::Derived(string)name:dc1Basic::Basic(string)name:dc2      //生成派生类对象时，先调用基类的构造函数
Derived::Derived(string)name:dc2  //在调用自身的构造函数Basic::operator=()  //调用了基类的operator= ，并正确地对Derived::m_name进行了赋值。 　　　　　　　　　　　 //测试时，假如把基类的operator=实现为空函数，那么Derived对象也不能对Derived::m_name进行重新赋值。除非再手动实现Derived的operator=。　　　　　　　　　　　 //operator= 只有一个，Drived中如果手动实现了，将会覆盖基类的=。就是说，不会执行基类的operator=。

next is dc1.show(): name: dc2 this is dc2Derived::~Derived() //析构和构造的调用顺序刚好相反。先调用自身的析构函数，再调用基类的析构函数。 this is dc2Basic::~Basic() this is dc2Derived::~Derived()//在一个函数体中，先实现的对象后释放。 this is dc2Basic::~Basic() **/

class Basic
{
public:int m_number;string m_name ;char m_sex;//'m' 'w'Basic(int n ,string name , char s);
};
Basic::Basic(int n,string name ,char s):m_number(n),m_name(name),m_sex(s)
{
//     this->m_name = name;
//     this->m_number = n;
//     this->m_sex = s;
}class Derived:public Basic
{
public:int m_age;string m_addr;Derived(int n,string name,char s,int a, string addr);
};
Derived::Derived(int n,string name,char s,int a, string addr):Basic(n,name,s),m_age(a),m_addr(addr)
{}

//下面的实验说明
// 1. 一般的operator=不会被继承。
// 2.通过使用“using 某类::operator某运算符”语句，就可以“继承”基类中的运算符了。而如果没有加上该语句，编译会出错。
// 3.msdn和C++的国际标准《ISO/IEC 14882》都说了operator=不能被继承，但是通过在vs2010中的实验，在派生类没有自定义operator=的情况下，派生了会执行基类中的拷贝式operator=。// 【对于派生类增加的变量赋值,系统默认给定，具体例子见下面的补充说明】
#include <iostream>
using namespace std ;class A1
{
public:int operator=(int a){return 8;}int operator+(int a){return 9;}int operator=(A1 &a){cout<<"operator=(A1 &a)"<<endl;return 0;}
};class B1 : public A1
{
public:int operator-(int a){return 7;}#if 1using A1::operator= ;
#endif};void test_common()
{B1 v;cout << (v + 2) << endl; // OK, print 9cout << (v - 2) << endl; // OK, print 7
cout << (v = 2) << endl; // 如果class B1加了 using A1::operator= ; ，强行“继承”了A1的operator=，则结果为8.// 否则：  error C2679: 二进制“=”: 没有找到接受“int”类型的右操作数的运算符(或没有可接受的转换)。
}void test_copy()
{B1 v2;B1 v3;v2 = v3 ;//打印效果： operator=(A1 &a)//并且拷贝性质的operator=，从效果上看，能够被继承。//拷贝性质的operator=，如果基类未对其显式地定义，始终还是能被编译器隐式的定义。
}
int main()
{        test_common();test_copy();while(1);return 0;
}

//下面的实验说明
// 1. 一般的operator=不会被继承。
// 2.通过使用“using 某类::operator某运算符”语句，就可以“继承”基类中的运算符了。而如果没有加上该语句，编译会出错。
// 3.msdn和C++的国际标准《ISO/IEC 14882》都说了operator=不能被继承，
// 但是通过在vs2010中的实验说明：虽然说不能够继承，但是也会调用执行基类中的拷贝式operator=。
// 4.那么执行了基类的operator=，但是基类operator=没有办法对派生类增加的成员变量赋值，剩下的操作就由系统默认给定（按对象的内存地址依次复制）。
//
#include <iostream>
using namespace std ;
/
class A1
{
public:int operator=(int a){return a;}A1& operator=(const A1 &a);A1(int val);int GetVal();
private:int m_x;
};A1::A1(int val):m_x(val)
{}int A1::GetVal()
{return this->m_x;
}A1& A1::operator=(const A1 &a)
{cout<<"operator=(A1 &a)"<<endl;this->m_x = a.m_x *10 ;//注意*10是为了看效果return *this;
}
/
class B:public  A1
{
private:int m_b;
public:B(int vala,int valb);int GetValB(){return m_b;}
};B::B(int vala,int valb):A1(vala),m_b(valb)
{}
/////
void test_inheritance()
{B  v(11,44);cout<<"get value:"<<v.GetVal()<<endl;//11
B v2(22,33);cout<<"get value:"<<v2.GetVal()<<endl;//22cout<<"get valueB:"<<v2.GetValB()<<endl;//33
v2 = v  ; // operator=(A1 &a) cout<<"get value:"<<v2.GetVal()<<endl;// 110   执行了基类的operator=cout<<"get valueB:"<<v2.GetValB()<<endl;// 44  这里是系统默认生产的。// 打印operator=(A1 &a) 说明给派生类赋值时，执行了 基类operator= 。// 虽然执行了基类的operator=，但是基类operator=没有办法对派生类增加的成员变量赋值，剩下的操作就由系统默认给定（按对象的内存地址依次复制）。// [基类operator=为什么在这里会执行，是不是和构造函数的相同，必然会执行呢？答案是否定的，当B自定义了operator=之后，不会执行基类中的operator=。]
}
int main()
{        test_inheritance();while(1);return 0;
}