C++:调整基类成员在派生类中的访问属性的其他方法(同名成员和访问声明)

class X{
 public:
   int f();
};            
class Y:public X{
 public:
   int f();
   int g();
};        
void Y::g()
{
  f();   //表示要访问的是派生类中的成员f(),即被调用的函数是Y::f() 
  X::f() //表示要访问基类中的f()
}        
对于派生类的对象的访问，也有相同的结论。例如；
Y obj;
obj.f();    //被访问的函数是Y::f()
如果要访问基类中的声明的名字，则应使用作用域标识符限定，例如；
obj.X::f(); //被访问的函数是X::f() 

#include<iostream>
#include<string>
using namespace std;
class Student{                  //声明基类Student 
  public:
     Student(int number1,string name1,float score1)   //基类的构造函数 
     {
      number = number1;
      name = name1;
      score = score1;
     }
     void print()     //在基类中定义了成员函数print 
     {
      cout<<"number:"<<number<<endl;
      cout<<"name:"<<name<<endl;
      cout<<"score:"<<score<<endl;
     }
  protected:
     int number;      //学号 
     string name;     //姓名 
     float score;     //成绩 
};
class UStudent:public Student{
  public:
     UStudent(int number1,string name1,float score1,string major1):Student(number1,name1,score1)
     {                      //定义派生类的构造函数，缀上基类的构造函数 
      major = major1;
     }
     void print()          //在派生类中重新定义了成员函数print 
     {
      Student::print();    //调用基类Student的成员函数print
      cout<<"major:"<<major<<endl; 
     }
  private:
     string major;
};
int main()
{
  //Student stu(22116,"张志",95);
  //stu.print();               //调用基类中的成员函数print 
  UStudent obj(22116,"张志",95,"信息安全");
  obj.print();                 //调用派生类中的成员函数print
  //obj.Student::print();        //调用基类中的成员函数print 
  return 0;
} 

#include<iostream>
using namespace std;
class A{                 //声明基类A 
 public:
  A(int x1)
  {
   x = x1;
  }
  void print()
  {
   cout<<"x="<<x<<endl;
  }
 private:
  int x;
}; 
class B:private A{       //声明私有派生类B 
 public:
  B(int x1,int y1):A(x1)
  {
   y = y1;
  }
  void print2()      //通过派生类B的函数print2来调用基类A的成员函数print 
  {
   //print(); 
   A::print();    
  } 
 private:
  int y;
};
int main()
{
 B b(10,20);
 b.print2();
 return 0;
}
*/
/*
运行结果是：x=10

如果将派生类中的语句
 void print2(){print()};
改写成语句
 void print2(){A::print()}; 
同时，将主函数main()中的语句
   b.print2();
改写成语句
   b.print();
程序的运行结果不会变。

*/

class B:private A{        
 public:
  B(int x1,int y1):A(x1)
  {
   y = y1;
  }
  A::print;    //访问声明 
 private:
  int y;
}; 
这样，基类A中的print函数就调整为派生类B的公有成员函数，外界可以直接调用它了。           
---------------------------------------------------------------

//例4.12 访问声明的应用 
#include<iostream>
using namespace std;
class A{                 //声明基类A 
 public:
  A(int x1)
  {
   x = x1;
  }
  void print()
  {
   cout<<"x="<<x<<endl;
  }
 private:
  int x;
}; 
class B:private A{       //声明私有派生类B 
 public:
  B(int x1,int y1):A(x1)
  {
   y = y1;
  } 
   A::print;            //访问声明,把基类的公有成员函数print调整为私有派生类的 
                        //公有成员函数 
 private:
  int y;
};
int main()
{
 B b(10,20);
 b.print();            //调用基类的成员函数print 
 return 0;
}

class A{
     private:
       ...
     public:
       int x2;
       ...  
   };   
   class B:private A{
     private:
       ...
     public:
       A::x2;    //把基类中的x2调整为派生类的公有成员 
       ...   
   };

   void A::print;
或 
   A::print();
或
   void A::print();    
都是错误的。

 class A{
    private:
      int x3;
    public:
      int x1;
    protected:
      int x2;    
  };
  class B:private A{
    private:
       A::x3;      //错误
    protected:
       A::x1;      //错误
       A::x2;      //正确 
       A::x3;      //错误
    public:
       A::x1;      //正确
       A::x2;      //错误 
       A::x3;      //错误                    
  };