模板与继承

template<class T>

class MyStack

{

     T data[100];

    int top;

   int maxsize;

public：

  MyStack():top(-1){}

~MyStack() {}

void push(const T& x);

T Top();

};

int main()

{

  MyStack<int> mys; 

}

继承：

 继承运行在保持原有类特性的基础上进行扩展，增加功能。产生新的类，称派生。

多态性 

继承：可以访问继承来的基类的公有属性和保护属性

class 派生类名：访问限定符 基类型名1，《，访问限定符 基类名2，.....，访问限定符 基类名 n》

{

    《private：

                 成员表 1；》  //派生类增加或替代的私有成员

《public:

                     成员表2；》  //派生类增加或替代的公有成员

《protected:

                   成员表 3;》  //派生类增加或替代的保护成员

}; //分号不可少

class A

{

    private:   int ax;

   protected:int ay;

  public:    int az;

 public:

A() {ax=ay=az=0;}

};

class B:public A   //private A   也不能访问基类的私有

{

private:  int bx;

A aa;    //将A的对象a设置为私有属性，只能直接访问其中的公有属性，与继承的基类可访问其中保护属性不同

protected: int by;

public:   int bz;

public:B() {bx=by=bz=1;}

void fun()

{

  ax=10; //不能访问基类的私有

ay=20;

az=30;

}

}

}

int main()

{

   B b;

b.bz=100;

b.az=100;

b.ay=100; //外部函数不可以访问保护属性

b.aa.az=100;

b.aa.ay=100;// 不可以通过非基类的对象访问保护属性

}

  当派生类和基类属性同名时，派生类方法优先访问派生类的属性,如果需要使基类属性，如下

class A

{

public:

  int ax;

}

class B:public A

{

  public:

   int ax;

void fun()

{

      A::ax=10;   //使用作用域   

}

}

 方法重名冲突处理方法与属性相同，与函数重载不同，即是

 派生类与基类：

      在任何需要基类对象的地方都可以用公有派生类的对象来替代，这条规则称赋值兼容规则。

c++面向对象编程中一条重要规则就是：公有继承意味着“是一个”。

 1.派生类对象可以赋值给基类的对象，这时是把派生类对象从对应基类中继承来的隐藏对象赋值给基类对象。反过来不行，因为派生类的新成员无值可赋。

2.可以将一个派生类中的对象的地址赋给其基类的指针变量，但只能通过这个指针访问派生类中由基类继承来的隐藏对象，不能访问派生类中的新成员，同样也不能反过来做。

3.派生类对象可以初始化基类的引用。引用是别名，但是这个别名只能包含派生类对象中的由基类继承来的隐藏对象。

class object
{
   private:
  int value;
public:
object(int x=0):value(x){cout<<"Create object: "<<this<<endl;}
~object(){}
object(const object& obj):value:(obj.value){}

};
class Base:public object
{
private:
    int num;
public:
    Base(int x=0):num(x),Object(x+10){;}  //赋值构造和析构具有继承关系
    ~Base() {}
Base(const Base& base):num(base.num),object(base)   //拷贝构造不具有继承关系
{
   cout<<"copy base: "<<this<<endl;
}
Base& operator=(const Base& base)
{
    if(this!=&base)
{
       *(object*)this=base;   //将This转换成object类型
           num=base.num;

}
}
};
int main()
{
     Object obj(100);
       Base base(10);
    obj=base;   //就是将派生类中的基类的隐藏对象赋值给基类的隐藏对象
Object* op=&base;   //只能将base中的object基类继承对象内存空间指针赋值给object*
Object& obj=base;    //可以将base中的object基类继承对象赋值给object引用


}