C++底子精讲-07

怀念夏天  论坛元老 | 2025-4-15 07:25:47 | 显示全部楼层 | 阅读模式
打印 上一主题 下一主题
楼主

主题 1869|帖子 1869|积分 5607

1. const对象

1.概念：在 C++ 中，const 用于定义常量对象，一旦对象被初始化，其值就不能再改变。因为 const 对象只能被创建、撤销和只读访问，写操作是不允许的。
2.根本利用
  1. #include <iostream>
  2. #include <cstring>
  4. namespace myspace1
  5. {
  6.     using std::endl;
  7.     using std::cout;
  8.     using std::cin;
  9.     using std::string;
  10. }
  12. using namespace myspace1;
  14. class Person
  15. {
  16. public:
  17.     Person() :_age(0), _name(new char[strlen("张三") + 1])
  18.     {
  19.         cout << "无参构造" << endl;
  20.         strcpy(_name, "张三");
  21.     }
  22.     Person(int age,  const char* name) :_age(age), _name(new char[strlen(name) + 1])
  23.     {
  24.         cout << "有参构造" << endl;
  25.         strcpy(_name, name);
  26.     }
  27.     void setAge(int age)
  28.     {
  29.         _age = age;
  30.     }
  31.     void print()
  32.     {
  33.         cout << "age=" << _age << endl;
  34.         cout << "name=" << _name << endl;
  35.     }
  36.     //const成员函数,不能修改对象的数据成员
  37.     void print() const
  38.     {
  39.         cout << "age=" << _age << endl;
  40.         cout << "name=" << _name << endl;
  41.     }
  42.     ~Person()
  43.     {
  44.         delete[] _name;
  45.         cout << "析构函数" << endl;
  46.     }
  47. private:
  48.     int _age;
  49.     char* _name;
  50. };
  54. int main(void)
  55. {
  56.     //普通对象
  57.     Person p1(1,"张大");
  58.     p1.print();
  59.     p1.setAge(10);
  60.     p1.print();
  62.     //const 对象只能被创建、撤销和只读访问，写操作是不允许的
  63.     const Person p2(2, "张二");
  64.     //p2.setAge(20)   //不允许
  65.     //p2.print();     //不允许
  66.     p2.print();        //调用的是void print() const
  68.     return 0;
  69. }
复制代码

3.总结
const对象与const成员函数的规则：
(1）当类中有const成员函数和非const成员函数重载时，const对象会调用const成员函数，非const对象会调用非const成员函数；
(2)当类中只有一个const成员函数时，无论const对象还黑白const对象都可以调用这个版本；
(3)当类中只有一个非const成员函数时，const对象就不能调用非const版本。
发起：如果一个成员函数中确定不会修改数据成员，就把它定义为const成员函数。
2. 指向对象的指针

  1. int main(void)
  2. {
  3.     //在栈上开辟空间
  4.     Person p1(1, "一号");
  5.     Person* p2 = &p1;  //指向p1的指针；
  7.     Person* p3 = nullptr;  //空指针；
  9.     //在堆上开辟空间
  10.     Person* p4 = new Person(2, "二号");
  11.     delete p4;
  12.     p4 = nullptr;
  14.     Person* p5 = new Person();
  15.     p5->setAge(20);  
  16.     p5->print();
  17.     (*p5).setAge(30);
  18.     (*p5).print();
  20.     delete p5;
  21.     p5 = nullptr;
  23.     return 0;
  24. }
复制代码
3. 对象数组

  1. #include <iostream>
  2. #include <cstring>
  4. namespace myspace1
  5. {
  6.     using std::endl;
  7.     using std::cout;
  8.     using std::cin;
  9.     using std::string;
  10. }
  12. using namespace myspace1;
  14. class Person
  15. {
  16. public:
  17.     Person() :_age(0), _name(new char[strlen("张三") + 1])
  18.     {
  19.         cout << "无参构造" << endl;
  20.         strcpy(_name, "张三");
  21.     }
  22.     Person(int age,  const char* name) :_age(age), _name(new char[strlen(name) + 1])
  23.     {
  24.         cout << "有参构造" << endl;
  25.         strcpy(_name, name);
  26.     }
  27.     void setAge(int age)
  28.     {
  29.         _age = age;
  30.     }
  31.     void print()
  32.     {
  33.         cout << "age=" << _age << endl;
  34.         cout << "name=" << _name << endl;
  35.     }
  36.     //const成员函数,不能修改对象的数据成员
  37.     void print() const
  38.     {
  39.         cout << "age=" << _age << endl;
  40.         cout << "name=" << _name << endl;
  41.     }
  42.     ~Person()
  43.     {
  44.         delete[] _name;
  45.         cout << "析构函数" << endl;
  46.     }
  47. public:
  48.     int _age;
  49.     char* _name;
  50. };
  54. int main(void)
  55. {
  56.     // 方式一：使用无参/默认构造函数创建对象数组
  57.     cout << "使用默认构造函数创建对象数组:" << endl;
  58.     Person p1[3];
  59.     for (int i = 0; i < 3; i++) {
  60.         p1[i].print();
  61.     }
  63.     // 方式二：使用有参构造函数初始化对象数组
  64.     cout << "使用有参构造函数初始化对象数组:" << endl;
  65.     Person p2[3] = {
  66.         Person(20, "李四"),
  67.         Person(21, "王五"),
  68.         Person(22, "赵六")
  69.     };
  70.     for (int i = 0; i < 3; ++i) {
  71.         p2[i].print();
  72.     }
  74.     // 方式三：动态分配对象数组
  75.     cout << "动态分配对象数组:" << endl;
  76.     Person* p3 = new Person[2];
  77.     p3[0].setAge(25);
  78.     strcpy(p3[0]._name, "孙七");
  79.     p3[1].setAge(26);
  80.     strcpy(p3[1]._name, "周八");
  81.     for (int i = 0; i < 2; ++i) {
  82.         p3[i].print();
  83.     }
  84.     // 释放动态分配的内存
  85.     delete[] p3;
  87.     return 0;
  88. }
复制代码
4. c++中const常见用法总结

4.1 修饰常量

  1. //只有读权限，没有写权限
  2. const int a = 10;    //==int const a=10;
  3. //a = 20;  不可以修改
复制代码
4.2 修饰指针

  1. int main(void)
  2. {
  3.    
  4.     int a = 10;
  5.     int b = 20;
  7.     //1.指向常量的指针
  8.     const int* p1 = &a;  //==int const* p1 = &a;
  9.     //*p1 = 100;   不可以为通过指针修改a的值；
  10.     p1 = &b;  //可以修改指针p1的指向
  12.     //2.常量指针;可以通过指针修改变量的值，但是指针的指向不可以变；
  13.     int* const p2 = &a;
  14.     *p2 = 20;
  15.     //p2 = &b;  错误
  17.     //3.指向常量的常量指针：指针的指向和所指向的值都不能改变
  18.     const int* const p3 = &a;
  19.     // *p3 = 20; // 错误，不能通过指针修改所指向的值
  20.    // p3 = &b; // 错误，不能改变指针的指向
  21.     return 0;
  22. }
复制代码
4.3 修饰函数参数

const 用于修饰函数参数时，能够包管在函数内部不会修改该参数的值。
  1. void fun(const int a)
  2. {
  3.     //a = 100;   错误
  4.     cout << "a=" <<a<< endl;
  5. }
  7. int main(void)
  8. {
  9.     int a = 10;
  10.     fun(a);
  11.     return 0;
  12. }
复制代码
4.4 修饰函数返回值

const 修饰函数返回值时，表明返回值是一个常量，不能被修改。
  1. //const 修饰函数返回值时，表明返回值是一个常量，不能被修改。
  2. int const fun()
  3. {
  4.    
  5.     int a = 10;
  6.     return a;           
  7. }
  9. int main(void)
  10. {
  11.     //fun() = 100;  错误，不可以修改
  12.     return 0;
  13. }
复制代码
4.5 修饰成员函数

const 修饰类的成员函数时，表明该成员函数不会修改对象的状态
  1. class MyClass {
  2. private:
  3.     int _value;
  4. public:
  5.     MyClass(int val) : _value(val) {}
  7.     // 常量成员函数
  8.     int getValue() const {
  9.         // value = 20; // 错误，不能在常量成员函数中修改成员变量
  10.         return _value;
  11.     }
  12. };
复制代码
4.6 const对象

const 对象是指那些一经创建，其状态（即成员变量的值）就不能被修改的对象
  1. class MyClass {
  2. public:
  3.     int _value;
  4.     MyClass(int v) : _value(v) {}
  5. };
  7. int main() {
  8.     const MyClass obj(10);
  9.     // obj.value = 20; // 错误，不能修改 const 对象的成员变量
  10.     cout << "Value: " << obj._value << endl;
  11.     return 0;
  12. }
复制代码
5. 赋值运算符函数（增补）

5.1 概念

  1. Point pt1(1, 2), pt2(3, 4);
  2. pt1 = pt2;//赋值操作
复制代码
在执行 pt1 = pt2; 该语句时， pt1 与 pt2 都存在，以是不存在对象的构造，这要与 Point pt2 =pt1; 语句区分开，这是差别的。以是当 = 作用于对象时，需要调用的是赋值运算符函数。
格式：
  1. 类名& operator=(const 类名 &)
复制代码
  1. class Point {
  2. private:
  3.     int _ix;
  4.     int _iy;
  5. public:
  6.     Point(int x = 0, int y = 0) : _ix(x), _iy(y) {}
  8.     //默认赋值运算符重载函数
  9.     Point& operator=(const Point& rhs)
  10.     {
  11.         
  12.         _ix = rhs._ix;
  13.         _iy = rhs._iy;
  14.    
  15.         return *this;
  16.     }
  18.     void print() const {
  19.        cout << "(" << _ix << ", " << _iy << ")" <<endl;
  20.     }
  21. };
  23. int main() {
  24.     Point p1(1, 2);
  25.     Point p2(3, 4);
  27.     p2 = p1;
  28.     p2.print();
  30.     return 0;
  31. }
复制代码
5.2 默认赋值运算符函数局限

（1）当类中包含指针数据成员且该指针指向堆上分配的内存时，默认的赋值运算符函数（编译器主动生成的）就无法满意需求，这可能会导致浅拷贝题目，进而引发内存泄漏或悬空指针等错误。
（2）默认的赋值运算符执行的是浅拷贝，也就是只复制指针的值，而不复制指针所指向的内存。这会造成两个对象的指针成员指向同一块内存，当此中一个对象被销毁时，它会释放这块内存，而另一个对象的指针就会变成悬空指针。另外，如果两个对象都实验释放同一块内存，会导致重复释放，引发未定义行为。
  1. class Person
  2. {
  3. public:
  4.     //构造函数
  5.     Person(const int* age) :_age(new int(*age))
  6.     {
  7.         cout << "构造函数" << endl;
  8.     }
  9.     //打印函数
  10.     void print()const
  11.     {
  12.         cout << "age=" << *_age << endl;
  13.     }
  14.     //析构函数
  15.     ~Person()
  16.     {
  17.         delete _age;
  18.         cout << "析构函数" << endl;
  19.     }
  20. private:
  21.     int* _age;
  22. };
  24. int main(void)
  25. {
  26.     int age1 = 20;
  27.     int age2 = 30;
  29.     Person p1(&age1);
  30.     p1.print();
  32.     Person p2(&age2);
  33.     p2.print();
  35.     p2 = p1;
  36.     return 0;
  37. }
复制代码
题目分析：
当执行 p2 = p1; 时，会调用编译器主动生成的默认赋值运算符。默认赋值运算符执行的是浅拷贝，即只复制指针的值，而不复制指针所指向的内存。这会导致 p1 和 p2 的 _age 指针指向同一块内存。由于浅拷贝，当 p2 对象被销毁时，会释放 _age 所指向的内存。此时，p1 的 _age 指针就会变成悬空指针。当 p1 对象被销毁时，再次释放同一块内存，会导致重复释放，引发未定义行为。
5.3 解决办法

为相识决浅拷贝的题目，需要自定义赋值运算符函数，实现深拷贝。深拷贝会为新对象分配新的内存，并将原对象的数据复制到新的内存中。
  1. class Person
  2. {
  3. public:
  4.     //构造函数
  5.     Person(const int* age) :_age(new int(*age))
  6.     {
  7.         cout << "构造函数" << endl;
  8.     }
  9.     //打印函数
  10.     void print()const
  11.     {
  12.         cout << "age=" << *_age << endl;
  13.     }
  14.     //自定义赋值运算符函数
  15.     Person& operator=(const Person& rhs)
  16.     {
  17.         //自我赋值检查
  18.         if (this != &rhs) {
  20.             //释放当前_age空间；
  21.             delete _age;
  22.             _age = nullptr;
  23.             _age = new int(*rhs._age);
  24.         
  25.         }
  26.         return *this;
  27.     }
  28.     //析构函数
  29.     ~Person()
  30.     {
  31.         delete _age;
  32.         cout << "析构函数" << endl;
  33.     }
  34. private:
  35.     int* _age;
  36. };
  38. int main(void)
  39. {
  40.     int age1 = 20;
  41.     int age2 = 30;
  43.     Person p1(&age1);
  44.     p1.print();
  46.     Person p2(&age2);
  47.     p2.print();
  49.     p2 = p1;
  50.     return 0;
  51. }
复制代码
若你有自行定义某些特殊成员函数，编译器会为类主动生成以下 6 个默认函数：

  • 默认构造函数
  • 析构函数
  • 拷贝构造函数
  • 拷贝赋值运算符
  • 移动构造函数（C++11 及以后）
  • 移动赋值运算符（C++11 及以后）
注意：拷贝构造函数、赋值运算符函数、析构函数，如果需要手动定义此中的一个，那么另外两个也需要手动定义。 三合成原则

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。

本帖子中包含更多资源

您需要 登录 才可以下载或查看，没有账号？立即注册

x
回复

使用道具 举报

0 个回复

倒序浏览
返回列表

快速回复

高级模式
B Color Image Link Quote Code Smilies
您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

怀念夏天

论坛元老
这个人很懒什么都没写!

楼主热帖

标签云

AI 运维 CIO 存储 服务器
微信订阅号
微信服务号
微信客服
小程序
H5
关于我们 商务合作 网站地图
©Copyright 2022-2024 杭州祥升科技有限公司 版权所有 浙ICP备20004199号
快速回复 返回顶部 返回列表