当前位置：首页 > news >正文

《C++》面向对象编程--类（补充）

news 2025/7/26 10:50:44

文章目录

一、构造函数补充
- 1.1初始化列表
- 1.2explicit关键字
二、 static成员
- 2.1基本概念
- 2.2static成员变量
- 2.3static成员函数
- 2.4static const成员
三、友元
- 3.1基本概念
- 3.2友元函数
- 3.3友元类
四、内部类
- 4.1基本概念
- 4.2基本语法
- 4.3内部类特点

一、构造函数补充

1.1初始化列表

class Student {
public:// 使用初始化列表Student(int id, string name) : m_id(id), m_name(name) {// 构造函数体，从第一个冒号开始，后续都为逗号。}
private:int m_id;string m_name;
};

注意：
每个成员变量在初始化列表中最多只能出现一次。

1.2explicit关键字

explicit是C++中的一个关键字，它用于修饰类的单参数构造函数，用来防止编译器进行隐式的类型转换。在没有explicit的情况下，C++编译器会自动执行隐式类型转换，这有时会导致意想不到的结果。

#include<iostream>
using namespace std;class MyString {
public:MyString(int size) { // 允许从int隐式转换为MyString// 分配size大小的空间}
};void printString(const MyString& str) {// 打印字符串
}int main() {printString(10); // 编译器会自动将10转换为MyString对象return 0;
}

printString(10)会隐式调用MyString(int)构造函数创建一个临时对象，这可能不是程序员的本意。通过在构造函数前加上explicit关键字，可以禁止这种隐式转换：

class MyString {
public:explicit MyString(int size) { // 禁止隐式转换// 分配size大小的空间}
};void printString(const MyString& str) {// 打印字符串
}int main() {// printString(10); // 错误！不能隐式转换printString(MyString(10)); // 正确，显式转换return 0;
}

二、 static成员

2.1基本概念

static成员是属于类本身的成员，而不是类的某个特定对象。所有类的对象共享同一个static成员。

2.2static成员变量

class Counter {
public:static int count;  // 声明（类内）Counter() { count++; }~Counter() { count--; }
};int Counter::count = 0;  // 定义和初始化（类外）

它的特点有：

类外定义：必须在类外定义和初始化（除const static整型）
共享性：所有对象共享同一个static变量

访问方式：

Counter c1;
cout << c1.count;      // 通过对象访问
cout << Counter::count; // 通过类名访问

2.3static成员函数

class MathUtils {
public:static double square(double x) {return x * x;}static double add(double a, double b) {return a + b;}
};

它的特点有：

无this指针：不能访问非static成员
直接调用：

 double result = MathUtils::square(5.0);

限制：

①不能是虚函数

②不能使用const限定

2.4static const成员

class Circle {
public:static const double PI = 3.1415926;  // 类内初始化double area(double r) {return PI * r * r;}
};const double Circle::PI;  // 类外定义（C++17起可省略）

三、友元

3.1基本概念

友元是C++提供的一种打破封装性的特殊机制，它允许外部函数或类访问另一个类的私有成员。

3.2友元函数

class Box {
private:double width;public:friend void printWidth(Box box);  // 声明友元函数Box(double w) : width(w) {}
};// 定义友元函数（不是成员函数）
void printWidth(Box box) {// 可以访问私有成员widthcout << "Width: " << box.width << endl;
}int main() {Box box(10.0);printWidth(box);  // 输出: Width: 10return 0;
}

它的特点有：

友元函数不是类的成员函数
可以访问类的所有成员（包括private和protected）
不受访问限定符影响（可以放在public/private/protected任意区域）

3.3友元类

class A {
private:int secret;public:friend class B;  // 声明B是A的友元类A(int s) : secret(s) {}
};class B {
public:void showA(A& a) {// 可以访问A的私有成员cout << "A's secret: " << a.secret << endl;}
};int main() {A a(42);B b;b.showA(a);  // 输出: A's secret: 42return 0;
}

它的特点有：

友元关系是单向的（B是A的友元 ≠ A是B的友元）
友元关系不传递（A友元B，B友元C ≠ A友元C）
友元关系不能继承

四、内部类

4.1基本概念

内部类是指定义在另一个类内部的类。它在C++中是一个非常有用的特性，可以帮助我们更好地组织代码和实现封装。

4.2基本语法

class Outer {
public:class Inner {  //内部类定义public:void display() {cout << "This is inner class" << endl;}};void useInner() {Inner inner;inner.display();}
};