当前位置:   article > 正文

const成员与取地址及const取地址操作符重载_前端 const 地址

前端 const 地址

目录

1.const成员

2.取地址及const取地址操作符重载


1.const成员

将const修饰的“成员函数”称之为const成员函数,const修饰类成员函数,实际修饰该成员函数隐含的this指针,表明在该成员函数中不能对类的任何成员进行修改。

 

  1. class Date
  2. {
  3. public:
  4. Date(int year = 1900, int month = 1, int day = 1)
  5. {
  6. _year = year;
  7. _month = month;
  8. _day = day;
  9. }
  10. void func1()
  11. {}
  12. void func2()const
  13. {}
  14. //1.const成员函数内不可以调用其他的非const成员函数
  15. //2.const成员函数内可以调用其他的const成员函数
  16. void Print()const
  17. {
  18. //fun1() //编译失败
  19. func2();
  20. }
  21. //3.非const成员函数内可以调用其他的const成员函数
  22. void Print()
  23. {
  24. func2();
  25. }
  26. //如果在const成员函数中,一定要修改某个成员变量时
  27. //在定义该变量的时候,使用mutable关键字修改该成员即可
  28. void func3()const
  29. {
  30. _month += 1;
  31. }
  32. private:
  33. int _year;
  34. mutable int _month;
  35. int _day;
  36. };
  37. int main()
  38. {
  39. //普通对象既可以调用普通成员函数,也可以调用const成员函数
  40. Date d1(2022, 11, 20);
  41. d1.func1();
  42. d1.func2();
  43. //const对象:只能调用const成员函数
  44. const Date d2(d1);
  45. //d2.func1();
  46. d2.func2();
  47. }

思考题: 

1.const对象可以调用非const成员函数吗?

答案:不可以;不允许修改const对象中的内容,但是如果允许该对象调用普通的成员函数,在该成员函数中完全可能会修改const对象中的内容,代码不安全

2.非const对象可以调用const成员函数吗?

答案:可以,非const对象是可读可写对象,既可以修改对象中的内容,也可以不修改。

3.const成员函数内可以调用其它的非const成员函数吗?

答案:不可以,const成员函数内部只能调用const成员函数。

        const成员函数:const本质修改this指针,表明该成员函数内部一定不会修改成员变量,是一个只读的成员函数。this的类型:const Date* const

4.非const成员函数内可以调用其他的const成员函数吗? 

答案:可以,非const成员函数中this的类型:Date* const ,即当前对象可修改也可不修改

5.如果在const成员函数中,一定要修改某个成员变量时,在定义该成员变量的时候,使用mutable关键字修改该成员即可

例如:

  1. class Date
  2. {
  3. public:
  4. Date(int year = 1900, int month = 1, int day = 1)
  5. {
  6. _year = year;
  7. _month = month;
  8. _day = day;
  9. }
  10. void func3()const
  11. {
  12. _day+= 1;
  13. }
  14. private:
  15. int _year;
  16. int _month;
  17. mutable int _day;
  18. };
  19. int main()
  20. {
  21. Date d1(2022, 11, 20);
  22. d1.func3();
  23. return 0;
  24. }

可以看出d1对象发生了改变。 

2.取地址及const取地址操作符重载

这两个运算符一般不需要重载,使用编译器生成的默认取地址的重载即可,只有特殊情况,才需要重载,比如想让别人获取到指定的内容,例如:在对对象取地址的同时需要将对象的地址打印出来

     //this的类型:const Date* const
    //注意:在参数列表中不能加任何参数,否则编译器会将&当成按位&来处理
    const Date* operator&()const
    {
        cout << this << endl;
        return this;
    }

this的类型:Date* const

Date* operator&()
    {
        cout << this << endl;
        return this;
    }

  1. class Date
  2. {
  3. public:
  4. Date(int year = 1900, int month = 1, int day = 1)
  5. {
  6. _year = year;
  7. _month = month;
  8. _day = day;
  9. }
  10. Date* operator&()
  11. {
  12. cout << this << endl;
  13. return this;
  14. }
  15. //this的类型:const Date* const
  16. //注意:在参数列表中不能加任何参数,否则编译器会将&当成按位&来处理
  17. const Date* operator&()const
  18. {
  19. cout << this << endl;
  20. return this;
  21. }
  22. private:
  23. int _year;
  24. int _month;
  25. mutable int _day;
  26. };
  27. int main()
  28. {
  29. Date d1(2022, 11, 20);
  30. Date* p = &d1;
  31. const Date d2(d1);
  32. const Date* p2 = &d2;
  33. return 0;
  34. }

 &重载后可以在对对象取地址的同时需要将对象的地址打印出来

 

 

声明:本文内容由网友自发贡献,不代表【wpsshop博客】立场,版权归原作者所有,本站不承担相应法律责任。如您发现有侵权的内容,请联系我们。转载请注明出处:https://www.wpsshop.cn/w/羊村懒王/article/detail/608196
推荐阅读
相关标签
  

闽ICP备14008679号