# 类的高级成员与静态成员 > [!info] 学习导航 > 返回：[[C++ 学习指南]] > 前置知识：[[计算机系/C++/06 类与对象基础|类与对象基础]] 类的友元函数是定义在类外部，但有权访问类的所有私有（private）成员和保护（protected）成员。尽管友元函数的原型有在类的定义中出现过，但是友元函数并不是成员函数。 友元可以是一个函数，该函数被称为友元函数；友元也可以是一个类，该类被称为友元类，在这种情况下，整个类及其所有成员都是友元。 如果要声明函数为一个类的友元，需要在类定义中该函数原型前使用关键字 **friend**，如下所示： ```cpp class Box { double width; public: double length; friend void printWidth( Box box ); void setWidth( double wid ); }; ``` 声明类 ClassTwo 的所有成员函数作为类 ClassOne 的友元，需要在类 ClassOne 的定义中放置如下声明： ```cpp friend class ClassTwo; ``` 友元函数，不属于这个类的成员函数 友元函数还可以是另一个类中的成员函数 在Cspouse中 ```cpp {void show () const} ``` 在Cperson中 Class Cperson ```cpp {Friend void Cspouse ::Show() const;} ``` 即声明了Cspuse的成员函数Show（）为类Cpeson的友元函数 在正式声明一个类以后，才能去定义类对象 在类Cspouse的数据成员中，不能直接用Cpseon定义对象作为数据成员，只能用Cperson的指针作为数据成员 Cperson husband Cperson wife 编译报错，因为定义对象时需要为这些对象分配存储空间 友元类 可以将一个类声明为另一个类的友元类。如将B类声明A类的友元类，意味着友元类B中的所有成员函数都是A类的友元函数，可以访问A类中的所有成员 ## const 成员函数 1. const 成员函数的定义 语法：fun() const 确实是 const 成员函数的声明方式。 ```cpp class MyClass { public: void nonConstFunc() { /* 可修改成员 */ } void constFunc() const { /* 不可修改成员 */ } }; ``` 默认情况：const 成员函数 不能修改非静态成员变量（直接修改会编译报错）。 ```cpp class MyClass { int value; public: void constFunc() const { value = 42; // 错误！不能修改非静态成员 } }; ``` 如果成员变量被声明为 mutable，则可以在 const 成员函数中修改： ```cpp class MyClass { mutable int counter; // 可被 const 函数修改 public: void constFunc() const { counter++; // 合法 } }; ``` .const 对象只能调用 const 成员函数 规则：const 对象（如 const MyClass obj;）只能调用 const 成员函数。 ```cpp const MyClass obj; obj.constFunc(); // 合法 obj.nonConstFunc(); // 错误！const 对象不能调用非 const 函数 ``` 不能直接调用：const 成员函数内部 不能直接调用非 const 成员函数，因为非 const 函数可能修改成员变量，违反 const 语义。 ```cpp class MyClass { public: void nonConstFunc() { /* 修改成员 */ } void constFunc() const { nonConstFunc(); // 错误！const 函数不能调用非 const 函数 } }; ``` 绕过限制（不推荐）： 通过 const_cast 移除 this 的 const 属性（危险，破坏设计初衷）： ```cpp void constFunc() const { const_cast(this)->nonConstFunc(); // 强制调用，不推荐！ } ``` 不能修饰非成员函数：全局函数或静态成员函数不能用 const 修饰。 问题 答案 const 成员函数语法：`void func() const;` 能否修改非静态成员变量？ 默认不能，除非变量是 mutable const 对象可调用的函数 只能调用 const 成员函数 const 函数能否调用非 const 函数？ 不能（除非强制 const_cast，不推荐） const 能否修饰成员函数？ 可以，且是 const 成员函数的唯一声明方式 ## 对象数组和动态对象 ### 对象数组 对象数组建立时为每个蒜素对象自动调用构造函数 数组撤销时为数组的每个元素对象调用析构函数 数组元素连续存放 ### 对象指针和动态生成对象 一个指向 C++ 类的指针与指向结构的指针类似，访问指向类的指针的成员，需要使用成员访问运算符 **->**，就像访问指向结构的指针一样。与所有的指针一样，您必须在使用指针之前，对指针进行初始化。 在 C++ 中，指向类的指针指向一个类的对象，与普通的指针相似，指向类的指针可以用于访问对象的成员变量和成员函数。 对象指针是指针类型；指针变量建立时不会自动建立所指类对象，也不会调用对象类的构造函数 指针变量撤销时也不会自动删除所指对象，不会调用对象类的析构函数 **动态分配内存** 指向类的指针还可以用于动态分配内存，创建类的对象： **1. 默认行为的问题** 如果 **Clock** 类 **没有默认构造函数**（即所有构造函数都需要参数），直接使用 **new Clock[n]** 会编译报错： ```cpp class Clock { public: Clock(int h, int m, int s) {} // 只有带参构造函数 }; int main() { Clock* p = new Clock[10]; // 错误！需要默认构造函数 } ``` - **原因**：**new[]** 会尝试调用默认构造函数（无参构造函数）初始化数组中的每个元素。 **方法 1：为类添加默认构造函数** ```cpp class Clock { public: Clock() {} // 添加默认构造函数 Clock(int h, int m, int s) {} // 原有带参构造函数 }; int main() { Clock* p = new Clock[10]; // 合法，调用默认构造函数 } ``` - **缺点**：可能需要为成员变量设置默认值（如 **hour=0, minute=0, second=0**）。 **3. 为什么 new[] 不支持直接传递参数？** - **语言设计限制**：**new[]** 的语法设计为统一初始化数组元素，无法为每个元素单独指定参数。 - **替代方案**：使用 **std::vector** 或手动内存管理。 在C++11中引入了**列表初始化（List Initialization）**，允许你用花括号 {} 来初始化数组，甚至在 new 动态分配数组时也可以用。 ```cpp Clock *p = new Clock[2]{{0,0,0}, {1,1,1}}; ``` 静态数组定义：`Clock arr[2] = {{1,1,1}, {0,0,0}};` **替代写法（通用、兼容性好）：** ```cpp Clock* p = new Clock[2]; p[0] = Clock(0, 0, 0); p[1] = Clock(1, 1, 1); ``` 或者用 std::vector（推荐现代C++写法）： ```cpp #include vector clocks = { {0, 0, 0}, {1, 1, 1} }; ``` 动态分配对象时，先在对上申请直接占用的内存空间，再申请得到的内存空间上执行构造函数 动态分配对象数组时，先在堆上申请n个对象的数组直接占用的连续空间，再在申请得到的内存空间上为每个对象分别执行构造函数 如果类对象构造本身需要动态分配，则构造函数过程中也会再次动态申请空间 如果申请失败，抛出异常 删除单个对象时，先执行对象类的析构函数，再释放对象直接占用的空间。 删除对象数组时先执行数组里每个对象的析构函数，再释放对象数组直接占用的空间 **指向类的指针作为函数参数** 指向类的指针可以作为函数参数传递： ```cpp #include class MyClass { public: int data; void display() { std::cout << "Data: " << data << std::endl; } }; // 函数接受指向类的指针作为参数 void processObject(MyClass *ptr) { ptr->display(); } int main() { MyClass obj; obj.data = 42; // 将指向类的指针传递给函数 processObject(&obj); return 0; } ``` ### 对象引用 引用必须在建立时初始化，引用可以作为左值。被引用对象类型可以是基本数据类型和指针类型，也可以是类类型 默认的复制行为是逐个数据成员的复制，默认的赋值行为是逐个数据成员的赋值 大型对象的复制和赋值会产生严重的性能开销，传递引用比传递对象的指针更直观 C++函数返回值返回对象引用，必须确保被引用对象的存在，函数不可返回局部对象的引用，局部对象采用传值方式返回时，编译器内部会再完成局部对象的复制后返回，不会产生问题 ```cpp Cset Union(const Cset &rhs) const; ``` 表示返回集合对象，函数原型中最后的const明确并运算过程中当前集合对象不会被改变，rhs常引用， 再运算过程中不会被改变，结果保存在成员函数Union内局部对象，结束时返回结果集。 不可返回函数内局部对象的引用或指针 ### this 指针 在 C++ 中，**this** 指针是一个特殊的指针，它指向当前对象的实例。 在 C++ 中，每一个对象都能通过 **this** 指针来访问自己的地址。 **this**是一个隐藏的指针，可以在类的成员函数中使用，它可以用来指向调用对象。 当一个对象的成员函数被调用时，编译器会隐式地传递该对象的地址作为 this 指针。 友元函数没有 **this** 指针，因为友元不是类的成员，只有成员函数才有 **this** 指针。 P1.set(0,0,0)=set (const Clock \*this(&P),0,0,0) ### 类成员作用域和生存期 类成员作用域再该定义内和类成员函数定义内游侠，公有成员再类外可通过对象成员或者对象指针访问 类数据成员和成员函数形参同名时，根据最小作用域原则，函数体内同名对象默认代表形参，如果需要访问同名类数据成员，则可以通过类名“”成员或通过this->指针访问类的成员 This->m_iSecond=m_iSecond Cclock::m_iSecond=m_iSecond ## 静态成员和静态成员函数 ![img](data:image/png;base64,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) ### 静态成员 Staic 类型名 数据成员吗 ```cpp static int objectCount; ``` 无论建立多少个该类的对象，都只有一个静态数据成员的存储空间 静态数据成员的访问权限与普通数据成员相同，也分为公有、保护、私有 在类外只能访问公有静态数据成员 访问方式为 类名：：静态数据成员名 静态成员在类的所有对象中是共享的。静态成员必须要有显示的初始化语句，要不然编译器无法通过.我们不能把静态成员的初始化放置在类的定义中，但是可以在类的外部通过使用范围解析运算符 **::** 来重新声明静态变量从而对它进行初始化，如下面的实例所示。静态成员变量在类中仅仅是声明，没有定义，所以要在类的外面定义，实际上是给静态成员变量分配内存。如果不加定义就会报错，初始化是赋一个初始值，而定义是分配内存。 在类内可以直接访问所有点静态数据成员，类的静态数据成员必须在类外进行 ```cpp // 初始化类 Box 的静态成员 int Box::objectCount = 0; ``` 如果只声明了类而未定义对象，则为静态数据成员分配存储空间。 静态放在初始化列表 ```cpp A::A(int i):a(i){} ``` 初始化const成员 A由构造函数初始化，不能有ai 为什么？ Static const b如何初始化？ 根据static来定义，static const b;const int A：：b=10 This 指针常量 常引用做形参 有指针变量成员函数 构造函数必须new 一个完成空间分配 静态成员函数不能访问非静态成员函数 常饮用雷西那个 不能共享一个内存 把形参作为引用，避免了局部作用域 引用没对象的情况 即 `int &func (int &x){return x}`，而非 `int & func{int a;returna}`。 类里面由指针 在析构函数里delete ### 必须使用初始化列表的成员 在C++中，**以下类型的成员必须在构造函数的初始化列表中初始化**，而不能在构造函数体内赋值： 1. **const成员** ```cpp class Person { const int id; public: Person(int i) : id(i) {} // 必须初始化列表 }; ``` 1. **引用成员** ```cpp class Person { int& ref; public: Person(int& r) : ref(r) {} // 必须初始化列表 }; ``` 1. **没有默认构造函数的类类型成员** ```cpp class Date { public: Date(int y, int m, int d); // 没有默认构造函数 }; class Person { Date birthday; public: Person(int y, int m, int d) : birthday(y, m, d) {} // 必须初始化列表 }; ``` 1. **基类没有默认构造函数时** **静态成员初始化** 静态成员变量需要在类外进行初始化： ```cpp class A { static const int b; // 声明 }; const int A::b = 10; // 定义并初始化 ``` **const 成员初始化** const 成员必须在构造函数初始化列表中初始化： ```cpp class A { const int a; public: A(int i) : a(i) {} // 正确：在初始化列表中初始化const成员 // A(int i) { a = i; } // 错误：不能在构造函数体内赋值 }; ``` **this 指针** this 指针是一个指针常量，指向当前对象实例。 **常引用作为形参** 使用常引用作为形参可以避免不必要的拷贝： ```cpp void func(const MyClass& obj) { // 可以读取obj但不能修改 } ``` **指针成员与动态内存分配** 当类包含指针成员时，通常需要： 1. 在构造函数中使用 new 分配内存 2. 在析构函数中使用 delete 释放内存 3. 考虑实现拷贝构造函数和赋值运算符（Rule of Three） ```cpp class MyClass { int* ptr; public: MyClass(int size) { ptr = new int[size]; } ~MyClass() { delete[] ptr; } // 还需要实现拷贝构造函数和赋值运算符 }; ``` **静态成员函数** 静态成员函数只能访问静态成员，不能访问非静态成员： ```cpp class A { static int s; int ns; public: static void staticFunc() { s = 10; // 正确 // ns = 10; // 错误：不能访问非静态成员 } }; ``` **引用返回注意事项** 返回引用时要确保引用对象在函数返回后仍然存在： ```cpp int& goodFunc(int& x) { return x; } // 正确：返回传入的引用 int& badFunc() { int a = 10; return a; // 错误：返回局部变量的引用 } ``` - const 成员一旦定义，**必须在对象创建时就完成初始化**； - 构造函数体内已经晚了，编译器在进入函数体时成员已经初始化完成； - 初始化列表正好是在对象构造阶段初始化成员的唯一机会。 ### 静态成员函数 如果把函数成员声明为静态的，就可以把函数与类的任何特定对象独立开来。静态成员函数即使在类对象不存在的情况下也能被调用，**静态函数**只要使用类名加范围解析运算符 **::** 就可以访问。 静态成员函数只能访问静态成员数据、其他静态成员函数和类外部的其他函数。 静态尘缘函数直属于类 静态成员函数有一个类范围，他们不能访问类的 this 指针。您可以使用静态成员函数来判断类的某些对象是否已被创建。 声明方式 ```cpp Static return_type func_name (paramert) ``` 在类外调用静态成员函数 类名：：静态成员函数名（实参版） **静态成员函数与普通成员函数的区别：** - 静态成员函数没有 this 指针，只能访问静态成员（包括静态成员变量和静态成员函数）。 - 普通成员函数有 this 指针，可以访问类中的任意成员；而静态成员函数没有 this 指针。 对类中静态变量的初始化始终令人迷惑不解。在这总结分享一下。 **类中特殊成员变量的初始化问题：** - 常量变量：必须通过构造函数参数列表进行初始化。 - 引用变量：必须通过构造函数参数列表进行初始化。 - 普通静态变量：要在类外通过"::"初始化。 - 静态整型常量：可以直接在定义的时候初始化。 - 静态非整型常量：不能直接在定义的时候初始化。要在类外通过"::"初始化。 Mutable 和volatil 即使是常对象、长成员函数也可以修改它的值 ```cpp Void show() const { ++count} ``` Private: : mutable int count Volatile ## 类的嵌套定义 内部类名时外部类的类型成员，可直接使用的有效范围时外部类，在其他地方使用，需要在内部类名前添加外部类名：： 外部类名：：内部类名 在类外定义函数也需要 外部类名：：内部类名：：成员函数名 函数体 ## 集合类 ```cpp Enum{MaxSIZE=100} ``` 这段代码定义了一个**匿名枚举类型**，里面只有一个枚举常量： - MaxSIZE 是一个整型常量； - 它的值是 100； - 它的类型其实是 int（因为枚举默认底层类型为 int）。 所以，等价于你写了： 复制编辑 ```cpp const int MaxSIZE = 100; ``` ## `::` 与 `:` 的区别 **1. :: 的用途** **::** 主要用于访问 **类作用域** 或 **命名空间作用域** 中的成员，包括： - **静态成员变量/函数**（属于类本身，而非对象） - **嵌套类型**（如嵌套类、枚举） - **被派生类覆盖的基类成员**（需要显式指定基类作用域） - **全局作用域**（如 **::global_var**） **示例场景：** ```cpp class Base { public: static int static_var; // 静态成员 int instance_var; // 实例成员 void func() {} // 实例成员函数 }; int Base::static_var = 10; // 静态成员必须在类外定义 class Derived : public Base { public: int instance_var = 20; // 覆盖基类的同名成员 void show() { cout << Base::instance_var; // 用::访问基类被覆盖的成员 cout << Base::static_var; // 用::访问静态成员 } }; ``` **关键点**： 只要访问的是 **类作用域内的成员**（而非对象成员），就必须用 **::**，例如： - 静态成员（属于类） - 被覆盖的基类成员（需显式指定基类作用域） - 嵌套类型（如 **Outer::Inner**） **2. . 的用途** **.** 用于访问 **对象实例的成员**（非静态成员变量/函数）： ```cpp Base obj; obj.instance_var = 5; // 访问实例成员变量 obj.func(); // 调用实例成员函数 ``` **关键点**： 如果成员属于某个对象实例（非静态），就必须用 **.**（或 **->** 如果是指针）。 **3. 为什么被覆盖的基类成员要用 ::？** 当派生类定义了与基类同名的成员时，默认会 **隐藏（hide）** 基类的成员。此时： - 直接写 **x** 访问的是派生类的成员。 - 如果要访问 **基类的同名成员**，必须显式指定基类作用域（**Base::x**），因为基类的成员已被隐藏，不再属于当前对象的作用域。 **类比理解：** - 静态成员属于类作用域 → 用 **::** - 被覆盖的基类成员属于基类作用域 → 也用 **::** - 实例成员属于对象 → 用 **.** **4. 静态成员 vs. 被覆盖成员** | **场景** | **为什么用 ::？** | **示例** | | ---------------- | ------------------------------------ | ---------------------- | | 静态成员 | 属于类作用域，而非对象 | **Base::static_var** | | 被覆盖的基类成员 | 基类成员被隐藏，需显式指定基类作用域 | **Base::instance_var** | **5. 总结** | **运算符** | **用途** | **示例** | | ---------- | ------------------------------ | -------------------------- | | **::** | 访问 **类/基类/命名空间** 成员 | **Base::x**, **std::cout** | | **.** | 访问 **对象实例** 的成员 | **obj.x**, **obj.func()** | **核心规则**： - 用 **::** 访问 **类作用域内** 的成员（静态成员、被覆盖的基类成员、嵌套类型）。 - 用 **.** 访问 **对象实例** 的成员（非静态成员变量/函数）。 --- ## 学习导航 - 上一篇：[[计算机系/C++/07 拷贝控制与移动语义|拷贝控制与移动语义]] - 返回目录：[[C++ 学习指南]] - 下一篇：[[计算机系/C++/09 运算符重载|运算符重载]]