C++进阶学习（5）继承中的重名成员与静态成员

一、重名成员

派生类定义了与基类同名的成员，在派生类中访问同名成员时屏蔽了基类的同名成员
在派生类中使用基类的同名成员，显式地使用类名限定符：

类名 :: 成员 

1.重名数据成员

例：
class  base
  { public :
           int  a ,  b ;  
  } ;
class  derived : public  base
  { public :  
         int  b ,  c ; 
  } ;
void  f ()
{ derived  d ;
   d . a = 1 ;
   d . base :: b = 2 ;
   d . b = 3 ;
   d . c = 4 ;
};

基类成员的作用域延伸到所有派生类
派生类的重名成员屏蔽基类的同名成员

2.重名成员函数

#include<iostream>	
using namespace std ;
class A
{ public:	  
       int a1, a2 ;
      A( int i1=0, int i2=0 ) { a1 = i1; a2 = i2; }
      void print() 
         { cout << "a1=" << a1 << '\t' << "a2=" << a2 << endl ; }
};
class B : public A
{ public:	
       int b1, b2 ;
       B( int j1=1, int j2=1 ) { b1 = j1; b2 = j2; }
       void print()		//定义同名函数
         { cout << "b1=" << b1 << '\t' << "b2=" << b2 << endl ; }
      void printAB()
        { A::print() ;		//派生类对象调用基类版本同名成员函数
           print() ;		//派生类对象调用自身的成员函数
       }
};
int main()
{ B  b ;        b.A::print();	b.printAB();  }

通过继承，类B具有两个同名成员函数
void A::print(); // void print( A * this );
void B::print(); // void print( B * this );

派生类也是基类，基类指针可以指向
派生类对象
派生类中定义与基类同名的成员函数，
称为重载成员函数

二、派生类中访问静态成员

基类定义的静态成员，将被所有派生类共享

根据静态成员自身的访问特性和派生类的继承方式，在类层次体系中具有不同的访问性质

派生类中访问静态成员，用以下形式显式说明：

类名 :: 成员

​ 或通过对象访问 对象名 . 成员

#include<iostream>
using namespace std ;
class B
{ public:
    static void Add() { i++ ; }//静态成员函数
    static int i;//静态数据成员
    void out() { cout<<"static i="<<i<<endl; }
};
int B::i=0;
class D : private B
{ public:    
      void f() 
       { i=5;//i 是类D的私有静态数据成员类中可见
         Add();//Add()是类D的私有静态成员函数类中可调用
         B::i++;//访问B类的静态成员
         B::Add();
       }
};
int main()
{ B x;  D y;
  x.Add();
  x.out();
  y.f();
  cout<<"static i="<<B::i<<endl;//访问B类的静态数据成员
  cout<<"static i="<<x.i<<endl;//通过B类对象访问静态数据成员
  //cout<<"static i="<<y.i<<endl;
}

注意

1. 类D中的i是一个普通的变量，而不是静态数据成员。因为在类D中定义的i是通过继承自类B的，而不是在类D中重新声明的静态数据成员。

2. 在类D中的成员函数f()中，对i的操作是针对类D中的普通变量i，而不是类B中的静态数据成员i。因此，i=5;、Add();、B::i++;、B::Add(); 这些操作都是针对类D中的i。

3. 在main()函数中，通过类D的对象y调用f()函数时，会对类D中的i进行操作，而不会对类B中的静态数据成员i进行操作。