C++组合类型中访问修饰符使用方法-C++-PHP中文网

在C++组合类型中，访问修饰符控制类成员的可见性，private成员仅类内可访问，public成员可被外部访问，protected成员供派生类使用；组合关系下，外层类只能通过内层对象的public接口与其交互，即使内层成员为protected，外层类也无法访问，因protected仅在继承体系中生效，组合不构成继承关系，故外层类与被组合对象间仍需遵循封装原则，通过public方法间接操作，确保安全性与低耦合。

c++组合类型中访问修饰符使用方法

在C++的组合类型中，访问修饰符（

public

登录后复制

、

private

登录后复制

、

protected

登录后复制

）扮演着核心角色，它们决定了类成员的可见性和可访问性。简单来说，它们定义了“谁能看到什么”和“谁能操作什么”。当一个类包含另一个类的对象时（即组合关系），这些修饰符就决定了外部代码，以及包含这个对象的“外层”类，如何与被包含的“内层”对象的成员进行交互。理解这一点，对于构建健壮、可维护的C++系统至关重要。

解决方案

C++的访问修饰符，

public

登录后复制

、

private

登录后复制

和

protected

登录后复制

，在组合类型中的使用方法，其实是其基本规则的延伸，但常常会带来一些独特的思考点。

首先，我们得明确这三个修饰符的基本含义：

public
登录后复制
: 任何外部代码都可以直接访问。
private
登录后复制
: 只有类内部的成员函数和友元可以访问。
protected
登录后复制
: 只有类内部的成员函数、友元以及其派生类的成员函数可以访问。

在组合关系中，一个类（我们称之为“容器类”或“外层类”）包含另一个类的对象（我们称之为“被组合对象”或“内层对象”）作为其成员。此时，访问修饰符的作用体现在两个层面：

立即学习“C++免费学习笔记（深入）”；

被组合对象本身的访问修饰符: 这决定了该对象自身的成员（数据和函数）对外界的可见性。
被组合对象在容器类中的访问修饰符: 这决定了容器类如何访问其内部的被组合对象。

举个例子，假设我们有一个

Engine

登录后复制

类和一个

Car

登录后复制

类。

Car

登录后复制

类“拥有”一个

Engine

登录后复制

对象。

// Engine.h
class Engine {
private:
    int horsepower;
    void igniteSparkPlugs() { /* ... */ }

public:
    Engine(int hp) : horsepower(hp) {}
    void start() {
        igniteSparkPlugs(); // Engine内部可以访问private成员
        // ...
    }
    int getHorsepower() const { return horsepower; }
};

// Car.h
class Car {
private:
    Engine engine; // Engine对象作为Car的private成员
    // ...

public:
    Car(int engineHP) : engine(engineHP) {}

    void drive() {
        // Car类可以访问其private成员engine
        engine.start(); // Car可以调用Engine的public方法
        // engine.igniteSparkPlugs(); // 错误：Car无法访问Engine的private方法
        // ...
    }

    int getEnginePower() const {
        return engine.getHorsepower(); // Car可以调用Engine的public方法
    }
};

// main.cpp
int main() {
    Car myCar(200);
    myCar.drive();
    // myCar.engine.start(); // 错误：main函数无法直接访问Car的private成员engine
    // myCar.engine.getHorsepower(); // 错误：同上
    return 0;
}

登录后复制

从这个例子可以看出：

```
Engine
```
登录后复制
类的
```
private
```
登录后复制
成员（
```
horsepower
```
登录后复制
,
```
igniteSparkPlugs
```
登录后复制
）只能由
```
Engine
```
登录后复制
类自己的方法访问。
```
Engine
```
登录后复制
类的
```
public
```
登录后复制
成员（
```
start
```
登录后复制
,
```
getHorsepower
```
登录后复制
）可以被任何拥有
```
Engine
```
登录后复制
对象访问权限的代码调用。
```
Car
```
登录后复制
类将
```
Engine
```
登录后复制
对象声明为
```
private
```
登录后复制
成员。这意味着只有
```
Car
```
登录后复制
类自己的方法可以访问
```
Engine
```
登录后复制
对象。外部代码（如
```
main
```
登录后复制
函数）无法直接通过
```
myCar.engine
```
登录后复制
来访问它。
当
```
Car
```
登录后复制
类的方法（如
```
drive
```
登录后复制
或
```
getEnginePower
```
登录后复制
）访问
```
Engine
```
登录后复制
对象时，它只能调用
```
Engine
```
登录后复制
对象的
```
public
```
登录后复制
方法。即使
```
Car
```
登录后复制
拥有
```
Engine
```
登录后复制
，它也无法“穿透”
```
Engine
```
登录后复制
自身的封装，去访问
```
Engine
```
登录后复制
的
```
private
```
登录后复制
成员。

说白了，访问修饰符是作用在“点”运算符（

登录后复制

）之前的。

myCar.engine

登录后复制

中的

Engine

登录后复制

是

Car

登录后复制

的成员，其访问权限由

Car

登录后复制

类内部决定。而

engine.start()

登录后复制

中的

start

登录后复制

是

Engine

登录后复制

的成员，其访问权限由

Engine

登录后复制

类内部决定。这两个层面的权限是独立判断的。

如何在C++组合设计中，有效地利用访问修饰符来提升代码的封装性和安全性？

在C++的组合设计中，巧妙运用访问修饰符是构建高内聚、低耦合系统的关键。我个人认为，其核心在于“默认私有，按需开放”的原则，以及对“接口与实现分离”的深刻理解。

首先，将组合成员设为

private

登录后复制

是常态。就像上面的

Car

登录后复制

和

Engine

登录后复制

例子，

Car

登录后复制

内部的

Engine

登录后复制

对象通常不应该直接暴露给外部。为什么？因为

Engine

登录后复制

是

Car

登录后复制

的内部实现细节。如果外部代码可以直接操作

Car

登录后复制

的

Engine

登录后复制

，那么

Car

登录后复制

的内部状态就可能被随意修改，导致

Car

登录后复制

的行为变得不可预测。这破坏了

Car

登录后复制

的封装性，使得

Car

登录后复制

类在未来的维护和修改中变得异常脆弱。想象一下，如果

Car

登录后复制

的

Engine

登录后复制

是

public

登录后复制

的，用户可以直接

myCar.engine.igniteSparkPlugs()

登录后复制

，这显然不是我们希望的。

FashionLabs

AI服装模特、商品图，可商用，低价提升销量神器

查看详情

其次，通过容器类的

public

登录后复制

接口来间接操作被组合对象。当外部代码需要与被组合对象交互时，它应该通过容器类提供的

public

登录后复制

方法来实现。这些

public

登录后复制

方法充当了“守门员”的角色，它们可以进行必要的校验、转换或协调，确保操作的合法性和一致性。例如，

Car

登录后复制

提供了

drive()

登录后复制

方法，这个方法内部会调用

engine.start()

登录后复制

。这样，外部只需要知道如何“驾驶”汽车，而无需关心引擎是如何启动的。这提升了抽象层次，让用户更容易使用，也让

Car

登录后复制

类有更大的自由度去改变其内部引擎的实现，而不会影响到外部代码。

再者，警惕

friend

登录后复制

关键字的使用。虽然

friend

登录后复制

可以突破封装，允许一个类访问另一个类的

private

登录后复制

或

protected

登录后复制

成员，但在组合关系中，这通常是一个“红色警报”。如果发现自己频繁地需要使用

friend

登录后复制

来让容器类访问被组合对象的私有成员，那往往意味着设计上可能存在问题，比如职责划分不清，或者被组合对象没有提供足够友好的

public

登录后复制

接口。

friend

登录后复制

应当被视为一种非常规手段，只在极少数、经过深思熟虑且有充分理由的情况下使用，例如在实现某些特定的设计模式（如迭代器）时。过度使用

friend

登录后复制

会显著降低代码的可维护性和安全性。

最后，利用

const

登录后复制

正确表达意图。如果一个容器类的方法只是需要读取被组合对象的状态，而不应该修改它，那么将相应的访问器方法声明为

const

登录后复制

，并确保通过

const

登录后复制

引用或

const

登录后复制

指针返回被组合对象（如果需要返回的话），可以进一步提升安全性。这能让编译器帮助我们强制执行只读的语义，避免意外的副作用。

C++组合类型中，访问修饰符与继承关系下的

protected

登录后复制

有何不同考量？

这是一个非常好的问题，因为

protected

登录后复制

在继承和组合这两种关系中的表现和意图确实有着显著的区别，常常是C++初学者感到困惑的地方。

在继承关系中，

protected

登录后复制

的意义是“对子类开放，对外界隐藏”。当一个基类成员被声明为

protected

登录后复制

时，它意味着这个成员可以被基类自身以及所有直接或间接派生自这个基类的子类访问。但对于基类及其派生类之外的任何其他代码，这个

protected

登录后复制

成员是不可见的，就像

private

登录后复制

成员一样。

protected

登录后复制

在这里的目的是为了方便子类实现其特有的行为，同时又避免将基类的内部细节完全暴露给外部，从而保持一定的封装性。它建立了一种“家族特权”的概念。

class Base {
protected:
    int baseData;
    void baseMethod() { /* ... */ }
public:
    Base() : baseData(10) {}
};

class Derived : public Base {
public:
    void accessBase() {
        baseData = 20; // OK: Derived可以访问Base的protected成员
        baseMethod();  // OK: Derived可以访问Base的protected方法
    }
};

// main.cpp
int main() {
    Derived d;
    // d.baseData = 30; // 错误：main函数不能访问protected成员
    return 0;
}

登录后复制

然而，在组合关系中，

protected

登录后复制

的考量则完全不同。 当一个类

登录后复制

包含一个类

登录后复制

的对象作为其成员时，

登录后复制

和

登录后复制

之间并没有继承关系。这意味着，即使

登录后复制

的某个成员被声明为

protected

登录后复制

，类

登录后复制

也无法直接访问它。对于类

登录后复制

而言，类

登录后复制

的

protected

登录后复制

成员和

private

登录后复制

成员是等价的——它们都只能由类

登录后复制

自身或其派生类访问。类

登录后复制

只能通过类

登录后复制

的

public

登录后复制

接口来与

登录后复制

的对象进行交互。

我们回到

Car

登录后复制

和

Engine

登录后复制

的例子。如果

Engine

登录后复制

有一个

protected

登录后复制

成员：

class Engine {
protected:
    int engineID; // 假设这是Engine的protected成员
    void internalCheck() { /* ... */ }

private:
    int horsepower;
public:
    Engine(int hp) : horsepower(hp), engineID(100) {}
    void start() { internalCheck(); }
    int getHorsepower() const { return horsepower; }
};

class Car {
private:
    Engine engine;

public:
    Car(int engineHP) : engine(engineHP) {}

    void inspectEngine() {
        // engine.engineID = 200; // 错误：Car无法访问Engine的protected成员
        // engine.internalCheck(); // 错误：Car无法访问Engine的protected方法
        engine.start(); // OK: 通过public接口间接调用internalCheck
    }
};

登录后复制

从代码中可以清晰地看到，