05this指针/const对象和const函数/析构函数

**引用类型的成员---不要返回局部变量的引用**

#include <iostream>
    using namespace std;
    class A
    {
        int& x;
        public:
        /*  赋予了局部变量的引用*/
        A(int x = 0):x(x)
        {
        }
        int& getX()
        {
            return x;
        }
    };
    int main()
    {
        A a(200);
        /*  结果出现以下匪夷所思的输出*/
        cout << a.getX() << endl; // 200
        cout << a.getX() << endl; // 0
    }
#this指针
**1. 概念**
指向当前对象的指针

*   在`构造函数中`这个指针代表`正在被构建的对象`的`地址`

*   在`成员函数中`这个指针指向`正在调用这个函数的对象`的`地址`
    a.show();    b.show();

**2. 应用**

*   区分函数的参数 和 成员变量重名问题
*   作为函数的参数 或 参数值相关
*   作为函数的返回值 或 返回值相关

应用一: `区分函数的参数`
    
    class Time
    {
        int hour;
        int min;
        int sec;
        public:
        /*  前面讲过初始化列表可以区分成员变量和参数*/
        /*  使用this指针也可以做到相同效果*/
        Time(int hour,int min, int sec)
        {
            this->hour = hour;
            this->min = min;
            this->sec =sec;
        }
    };

应用二: `作为函数的参数或参数值相关`

应用三: `作为函数的返回值或返回值相关`

#include <iostream>
    using namespace std;
    /*  这里必须要声明类型和全局函数show*/
    class Date;
    void show(Date* date);
    class Date
    {
        public:
        int year;
        int mon;
        int day;
        public:
        Date()
        {
            year = 2017;
            mon = 1;
            day = 6;
        }
        void show()
        {
            ::show(this);
        }
        Date& addday()
        {
            ++day;
            return *this;
        }
    }; 
    void show(Date* date)
    {
        cout << date->year << '-' << date->mon << '-' << date->day << endl;
    }
    int main()
    {
        Date date;
        date.show(); // 2017-1-6
        date.addday().addday();
        date.show(); // 2017-1-8
        /*  这里要理解因为addday的返回值是一个引用类型,所以以上连续性操作起了作用*/
        /*  如果addday的返回值不是引用而是值攒肚,则38行输出2017-1-7*/
    }

#const对象和const函数
**1. 概念**
加了const修饰的对象叫`const对象`
--->const对象要初始化,除非提供构造函数(只要有构造函数不管函数干了什么,编译就能通过)
加了const修饰的成员函数叫`const函数`
--->在参数列表后面加const

**2. const对象 和 const函数之间的关系**
`const对象只能调用const函数`
`非const对象优先调用非const函数`,如果没有非const函数,则调用const函数
const函数和非const函数可以形成重载关系

**3. const函数和成员之间的关系**
`const函数只能读成员变量的值,不能修改成员变量的值`
`const函数只能调用const函数,不能调用非const函数`
如果非要对成员变量进行修改动作,则使用mutable修饰

**4. 例子代码**

#include <iostream>
    using namespace std;
    class A
    {
        public:
        int x;
        mutable int y;
        A()
        {
        }
        void test()
        {
        }
        void show()const
        {
            cout << "const show()" << endl;
            cout << x << '/' << y << endl;
            y = 10;
            // x = 10;  编译报错,const函数不能改变成员变量值
            // test(); 编译报错,const函数只能调用const函数
        }
        /*  const函数 和 非const函数可以形成重载*/
        void show()
        {
            cout << "show()" << endl;
        }
    };
    int main()
    {
        const A a;
        a.show();   // const show() const对象只能调用const函数
        A bl
        b.show(); // show() 非const对象优先调用非const函数
    }

#析构函数
**1. 概念**
和类同名,但函数名前有一个~,并且没有返回值类型和参数
析构函数会在`对象销毁之前自动被调用一次`,当然也可以手工调用(手工调用要注意防止double free的问题).
一般用来释放资源或内存的
**2. 举例**

#include <iostream>
    using namespace std;
    class Date
    {
        int year;
        int mon;
        int day;
        int* pdate = new int;
        public:
        Date()
        {
            cout << "Date()" << endl;
        }
        ~Date()
        {
            cout << "Date()" << endl;
            /*  析构函数主要用来释放堆空间*/
            delete pdate;
        }
    };
    void foo()
    {
        Date date;
        /*  析构函数可以手动调用,但这样往往会出现double free错误,要谨慎使用*/
        // date.~Date();
    }
    int main()
    {
        foo();
    }

**3. 什么时候需要自定义析构函数?**

*   堆内存释放 或 资源释放时

例子代码

#include <iostream>
    using namespace std;
    class Array
    {
        int len;
        int size;
        int *dates;
        public:
        /*  在构造申请堆内存*/
        Array(int len)
        :len(len),size(0)
        {
            dates = new int[len];
        }
        ~Array()
        {
            delete[] dates;
        }
    };
    void foo()
    {
        Array *pa = new Array(5);
        /* ... */
        delete pa;
    }
    int main()
    {
        foo();
    }

#new delete 比 malloc free多做了什么?
**1. new比malloc多做了什么?**

*   如果对象的成员是类类型,则自动构建
*   自动调用构造函数
*   自动处理类型转换

**2. delete比free多做了什么?**

*   自动调用析构函数

**3. 例子代码**
 
    #include <iostream>
    using namespace std;
    class Date
    {
        int year;
        int mon;
        int day;
        publuc:
        Date()
        {
            year = 2017;
            mon = 1;
            day = 7;
            cout << "Date()" << endl;
        }
        ~Date()
        { 
            cout << "~Date()" << endl;
        }
    };
    class Emp
    {
        string name;
        Date date;
        public:
        Date()
        {
            name = "tom";
            cout << "Emp()" << endl;
        }
        ~Date()
        {
            cout << "~Emp()" << endl;
        }
    };
    int main()
    {
        
        //Emp *e = static_cast<Emp*>(malloc(sizeof(Emp)));
        //free(e);
        /*  以上代码无输出  因为malloc不会自动调用构造函数 free不会调用析构函数*/
        Emp *e = new Emp;
        delete e;
        /*输出结果:
            Date();
            Emp();
            ~Emp();
            ~Date();
        */
    }

huangfu Blog

导航

最近发表

友情链接