指向对象数据成员的指针和指向对象成员函数的指针

指向对象数据成员的指针比较简单:

int *p1;

p1 = &t1.hour;(因为.的优先级比&大，所以，会先运行.)

指向对象成员函数的指针

在定义指向普通函数指针的时候，我们可能会像这样

void (*p)();
p = fun;
(*p)();

但是在指向对象成员函数指针的时候，就不能这样定义了，必须要进行严格的区分。

void (Time::*p2)();//注意(Time::*p2)的括号不能省略

另外需要注意的一点是：

成员函数入口地址的写法是

&类名::成员函数名

不应该写成p3 = &t1.get_time;

下面可以看下谭书上写的代码：

#include 
using namespace std;
class Time{
    public :
        Time(int,int,int);
        int hour;
        int minute;
        int sec;
        void get_time(); 
};

Time::Time(int h,int m,int s){
    hour = h;
    minute = m;
    sec = s;
}

void Time::get_time(){
    cout<get_time();
    void(Time::* p3)();
    p3 = & (Time::get_time);
    //不能像下面这样赋值
    //p3 = &(t1.get_time);
    //p3 = & (p2->get_time);
    (t1.*p3)(); //调用对象t1中p3所指的成员函数(即t1.get_Time())
    return 0;
} 

this指针

谭书上的概念：

this它是指向本类对象的指针，它的值是当前被调用的成员函数所在的对象的起始地址。

理解的比较好的是下面谭书中的描述

2. 关于 *this的使用

   *this就是表示被调用的成员函数所在的对象。

共用数据的保护

const关键字在类中的使用

谭书中对const讲解的似乎有些反逻辑。

自己总结了下，并列出以下几点：

1. const在类对象中的使用

   下面是个简单的const定义出来的 常对象 。

   #include 
   using namespace std;
   
   class Time{
       public :
           Time(int,int,int);
           int hour;
           int minute;
           int sec;
           void get_time(); 
   };
   
   Time::Time(int h,int m,int s){
       hour = h;
       minute = m;
       sec = s;
   }
   
   void Time::get_time(){
       cout<

   下面我们可以看看这个常对象可以调用什么。

   #include 
   using namespace std;
   
   class Time{
       public :
           Time(int,int,int);
           int hour;
           int minute;
           int sec;
           void get_time(); 
   };
   
   Time::Time(int h,int m,int s){
       hour = h;
       minute = m;
       sec = s;
   }
   
   void Time::get_time(){
       cout<

   发现常对象可以使用普通数据成员，但是不能使用普通成员函数，并且不能对普通数据成员进行修改，那么记忆的方式可以认为是 常对象是部分只读的(普通成员函数没办法读取，因为不知道这个普通成员函数中是否修改了普通数据成员，只能一刀切了)。

   那么，我想要读取这个普通成员函数怎么办，如果这样说法，是做不到的，特别是在所谓的普通成员函数中修改了数据成员的。但是如果，没有修改数据成员的，我们直接在这个成员函数后面加上const就ok了。就像下面的代码：

   #include 
   using namespace std;
   
   class Time{
       public :
           Time(int,int,int);
           int hour;
           int minute;
           int sec;
           void get_time(); 
           void get_const_time() const;
   };
   
   Time::Time(int h,int m,int s){
       hour = h;
       minute = m;
       sec = s;
   }
   
   void Time::get_time(){
       cout<

   在末尾加了const的函数称为常成员函数。这个函数一样，既然能被常对象调用，而常对象本身不能修改数据成员，那么常成员函数能被常对象调用，当然也不能修改数据成员，同样，也不能调用普通成员函数。也是只读。

   这里记住一点，我一旦 const对象了，我就是要保证我不能修改数据成员，那么谁会容易修改数据成员，当然是成员函数，那么我不知道这个成员函数是否修改了数据成员，那么就直接不让用，如果非要使用，你就必须给我加上不能修改数据成员的限制，然后就是引出常成员函数。

   当然，为了方便，常成员函数非要修改某些数据成员，我们也可以做，在这个数据成员上加上 mutable关键字，声明为可变的数据成员。

   #include 
   using namespace std;
   
   class Time{
       public :
           Time(int,int,int);
           int hour;
           int minute;
           int sec;
           mutable int wa;
           void get_time(); 
           void get_const_time() const;
   };
   
   Time::Time(int h,int m,int s){
       hour = h;
       minute = m;
       sec = s;
       wa = 3;
   }
   
   void Time::get_time(){
       cout<

2. const定义的数据成员（常数据成员）

   初始化

   直接用const修饰的数据成员，叫做常数据成员，既然是常，那么就是不可变的，那么必须要有个初始化的值(不然报错)。 既然是数据成员，那么会有一个初始化的问题，这个初始化应该在哪里呢，在c11之前，不能在类中直接赋值，那么我们要在构造函数中赋值，但是常数据成员能在构造函数中赋值吗？当然是不行的，记住，常数据成员只有一种初始化方式，就是使用参数初始化表。

   能被谁调用

   既然初始化结束了，那么谁能使用呢？ 想要使用这个常数据成员，目前无非就四个，一个是普通成员函数，一个是常成员函数，还有一个是常对象直接.去访问，和普通对象直接点去访问。

   #include 
   using namespace std;
   
   class Time{
       public :
           Time(int,int,int);
           int hour;
           int minute;
           int sec;
           mutable int wa;
           void get_time(); 
           void get_const_time() const;
           const int num;
   };
   
   //这个构造函数中必须包含 这个常数据成员 num的初始化，不然编译不过，而这个初始化必须使用参数初始化表
   Time::Time(int h,int m,int s):num(10){
       hour = h;
       minute = m;
       sec = s;
       wa = 3;
   }
   
   void Time::get_time(){
       //普通成员函数访问常数据成员
       cout<

   这里发现都是能够使用的，想想也知道，这就是个相当于常量的东西，我要做的只是让它不改变。这里检测一个常量是否要改变那非常简单，所以没有其它限制。

3. const定义的成员函数(常成员函数)

   上面基本上体会的差不多了。明确一个点，const就是为了让东西不改变，常对象是为了让数据成员不改变，常成员函数也是限制数据成员不改变，所以常对象只能调用常成员函数，不能调用普通函数，因为不知道是否改变了数据成员，那么基于这个限制，所有的限制就是为了防止数据成员不变，这就简单了。

   普通函数能调用常成员函数吗，当然能，因为这里面数据成员不变呀。普通对象能调用吗，当然也能呀，还是因为调用的时候我就是使用常成员函数呀，而常成员函数已经保证数据成员不变。

   那么常成员函数中能调用普通成员函数吗，当然不行呀，因为数据成员改不改由普通成员函数决定，到底改没改，编译器不知道呀。

Time * const ptrl  = &tl;

const char * ptr;

Box::Box(const Box&b){//const可加可不加，最好加上

}

#include 
using namespace std;

class Time{
    public :
        Time(int,int,int);
        Time(const Time & time);
        int hour;
        int minute;
        int sec;
        void get_time(); 

};

//这个构造函数中必须包含 这个常数据成员 num的初始化，不然编译不过，而这个初始化必须使用参数初始化表
Time::Time(int h,int m,int s){
    hour = h;
    minute = m;
    sec = s;
    cout<<"构造函数调用"<hour = time.hour;
    this->minute = time.minute;
    this->sec = time.sec;
    cout<<"复制构造函数调用"< g++ -fno-elide-constructors .对象的复制.cpp
PS C:c> .a.exe
构造函数调用
构造函数调用
复制构造函数调用
12

friend void display(Time &);

    #include 
    using namespace std;

    class Time{

        public :
            Time(int,int,int);
             friend void  display(Time &); //这里 不受 public private等限制 随便放置位置
        private:
            int hour;
            int minute;
            int sec;
    };

Time::Time(int h,int m,int s){
    hour = h ;
    minute = m;
    sec = s;
}

void display(Time &t){ 
    cout<

 #include 
 using namespace std;
 class Date;
 class Time{

     public :
        Time(int,int,int);
        void  display(Date &);
     private:
         int hour;
         int minute;
         int sec;
 };

class Date{
    public:
        Date(int,int,int);
        friend void Time::display(Date &);
    private:
        int month;
        int day;
        int year;
        void fun(){
            cout<<"我是一个测试"<

class Building;
class goodGay
{
public:

    goodGay();
    void visit();

private:
    Building *building;
};

class Building
{
    //告诉编译器 goodGay类是Building类的好朋友，可以访问到Building类中私有内容
    friend class goodGay;

public:
    Building();

public:
    string m_SittingRoom; //客厅
private:
    string m_BedRoom;//卧室
};

Building::Building()
{
    this->m_SittingRoom = "客厅";
    this->m_BedRoom = "卧室";
}

goodGay::goodGay()
{
    building = new Building;
}

void goodGay::visit()
{
    cout << "好基友正在访问" << building->m_SittingRoom << endl;
    cout << "好基友正在访问" << building->m_BedRoom << endl;
}

void test01()
{
    goodGay gg;
    gg.visit();

}

int main(){

    test01();

    system("pause");
    return 0;
}

 #include 
 using namespace std;

 class Complex
 {
 private:
     double real;
     double image;
 public:
     Complex(){
         real = 0;image = 0;
     };
     Complex(double r,double i){
         real = r;image = i;
     }
     friend Complex operator +(Complex &cl,Complex &c2);
     void display();
 };

 Complex operator +(Complex &c1,Complex &c2){
     return Complex(c1.real+c2.real,c1.image+c2.image);
 }

 void Complex::display(){
     cout<<"("<

Complex(double r){real = r;imag = 0;}

operator double(){
    return real;
}

 #include 
 using namespace std;

class Complex{
    public:
        Complex(){
            real = 0;
            imag = 0;
        }
        Complex(double r){
            real = r;
            imag = 0;
        }
        Complex(double r,double i){
            real = r;
            imag = i;
        }
        friend Complex operator+(Complex c1,Complex c2);
        void display();
    private:
        double real;
        double imag;
};

Complex operator+(Complex c1,Complex c2){
    return Complex(c1.real+c2.real,c1.imag+c2.imag);
}

void Complex::display(){
    cout<<"("<

 #include 
 using namespace std;

class Complex{
    public:
        Complex(){
            real = 0;
            imag = 0;
        }
        //转换构造函数
        Complex(double r){
            real = r;
            imag = 0;
        }
        Complex(double r,double i){
            real = r;
            imag = i;
        }
        //类型转换函数
        operator double(){
            return real;
        }
        friend Complex operator+(Complex c1,Complex c2);
        void display();
    private:
        double real;
        double imag;
};

Complex operator+(Complex c1,Complex c2){
    return Complex(c1.real+c2.real,c1.imag+c2.imag);
}

void Complex::display(){
    cout<<"("<

#include 
#include 
using namespace std;
class Student
{
public:
    Student(int n,char nam[10]){
        num = n;
        name = nam;
    }
    void display(){
        cout<<"num: "<

#include 
#include 
using namespace std;

class Teacher{
    public:
        Teacher(char* nam,int a ,char* t){
            name  = nam;
            age =a;
            title = t;
        }
        void display(){
            cout<<"name:"<

class Graduate:public Teacher,public Student{
    public :
        Graduate(char* nam,int a ,char s,char * t,float sco,float w):Teacher(nam,a,t),
        Student(nam,s,sco),wage(w){}
        void show(){
            //这里设定作用域
            cout<<"name:"<

#include 
using namespace std;

class N{
    public:
        int a;
        void display(){
            cout<

那么，明确一下好了，如果直接拿N去明确：

又会导致这个错误。
这里有问题的是，无法知道到底使用的是哪个派生类中的a，有可能这个数值已经发生改变，所以，需要直接使用N的直接派生类 A或者B来进行指出。

但是如果类简单还好，一旦类的关系复杂，会导致空间占用大，而且编码完全变成了一种奇怪的约定。比如这里，谁知道你是用B的数据还是A的数据呢，本来就是同一个数据。
所以，这里，出来了虚基类。
谭书上的描述：

C++提供虚基类的方法，使得在继承间接共同基类时只保留一份成员。

可以理解一种指针。
看下谭书中的方法
class 派生类名: virtual继承方式 基类名
#include 
using namespace std;

class N{
    public:
        int a;
        void display(){
            cout<
					
版权声明
所有资源都来源于爬虫采集,如有侵权请联系我们,我们将立即删除