MK
摩柯社区 - 一个极简的技术知识社区
AI 面试

C++类访问控制的深层意义

2022-01-226.2k 阅读

C++类访问控制的基本概念

在C++编程中，类访问控制是一项关键特性，它决定了类成员（包括数据成员和成员函数）的可访问性。C++提供了三种访问修饰符：public、private和protected，这些修饰符在类定义中用于指定成员的访问级别。

public访问修饰符

public修饰的成员可以从类的外部直接访问。这意味着任何函数，无论是类的成员函数还是外部函数，都能够访问public成员。这通常用于定义类的接口，使得外部代码可以与类进行交互。例如：

class Rectangle {
public:
    // 公共成员函数，用于设置矩形的宽和高
    void setDimensions(int width, int height) {
        this->width = width;
        this->height = height;
    }
    // 公共成员函数，用于计算矩形的面积
    int calculateArea() {
        return width * height;
    }
private:
    int width;
    int height;
};

int main() {
    Rectangle rect;
    rect.setDimensions(5, 10); // 调用公共成员函数
    int area = rect.calculateArea(); // 调用公共成员函数
    return 0;
}

在上述代码中，setDimensions和calculateArea函数是public的，因此在main函数中可以通过Rectangle类的对象rect来调用它们。这样外部代码就能够通过这些公共接口来操作Rectangle类的内部状态（即width和height），而无需直接访问私有数据成员。

private访问修饰符

private修饰的成员只能在类的内部被访问，即只能被类的成员函数访问。外部函数，包括main函数，都无法直接访问private成员。这种访问控制机制主要用于隐藏类的实现细节，保护类的数据完整性。例如，继续以上面的Rectangle类为例，width和height数据成员是private的，外部代码无法直接访问它们：

class Rectangle {
public:
    void setDimensions(int width, int height) {
        this->width = width;
        this->height = height;
    }
    int calculateArea() {
        return width * height;
    }
private:
    int width;
    int height;
};

int main() {
    Rectangle rect;
    // rect.width = 5; // 错误，无法访问private成员
    // rect.height = 10; // 错误，无法访问private成员
    rect.setDimensions(5, 10);
    int area = rect.calculateArea();
    return 0;
}

如果尝试在main函数中直接访问width或height，编译器会报错，因为它们是private成员。这样就确保了只有通过setDimensions这样的公共接口来修改width和height，从而可以在接口函数中添加必要的验证逻辑，保证数据的合理性。

protected访问修饰符

protected修饰的成员与private成员类似，在类的内部可以被访问。但是，protected成员还有一个特殊性质，即它们可以被派生类（子类）访问。这在实现继承关系时非常有用，使得基类可以将一些成员设置为protected，既防止外部代码直接访问，又允许派生类根据需要进行访问和扩展。例如：

class Shape {
protected:
    int x;
    int y;
public:
    void setPosition(int a, int b) {
        x = a;
        y = b;
    }
};

class Circle : public Shape {
public:
    int radius;
    int calculateArea() {
        return 3.14 * radius * radius;
    }
    void setCircle(int a, int b, int r) {
        setPosition(a, b);
        radius = r;
    }
};

int main() {
    Circle circle;
    // circle.x = 5; // 错误，外部无法访问protected成员
    // circle.y = 10; // 错误，外部无法访问protected成员
    circle.setCircle(5, 10, 3);
    int area = circle.calculateArea();
    return 0;
}

在这个例子中，Shape类的x和y成员是protected的。Circle类继承自Shape类，在Circle类的成员函数setCircle中可以访问x和y，通过调用setPosition函数来设置它们的值。而在main函数中，无法直接访问circle对象的x和y成员。

类访问控制在数据封装中的作用

数据封装是面向对象编程的核心概念之一，它将数据和操作数据的函数封装在一起，形成一个独立的单元，即类。类访问控制是实现数据封装的重要手段，通过合理设置成员的访问级别，可以有效地隐藏数据的内部表示，只提供必要的接口供外部使用。

隐藏实现细节

通过将数据成员设置为private，类可以隐藏其内部的数据结构和存储方式。例如，一个栈（Stack）类可能使用数组或链表来实现数据的存储，但外部代码并不需要知道具体的实现细节。外部只需要通过栈类提供的公共接口，如push（压入元素）、pop（弹出元素）和isEmpty（判断栈是否为空）等函数来操作栈。这样，即使栈的内部实现发生改变，只要接口保持不变，外部使用栈的代码就无需修改。

class Stack {
public:
    void push(int value) {
        if (top < capacity - 1) {
            data[++top] = value;
        }
    }
    int pop() {
        if (top >= 0) {
            return data[top--];
        }
        return -1; // 假设栈为空时返回 -1
    }
    bool isEmpty() {
        return top == -1;
    }
private:
    int data[100];
    int top = -1;
    const int capacity = 100;
};

int main() {
    Stack stack;
    stack.push(10);
    stack.push(20);
    int value = stack.pop();
    bool empty = stack.isEmpty();
    return 0;
}

在这个栈类的实现中，data数组、top变量和capacity常量都是private的，外部代码无法直接访问。外部代码只能通过push、pop和isEmpty这些公共接口来使用栈，从而实现了栈的实现细节的隐藏。

数据保护

类访问控制可以防止外部代码对数据成员进行不合理的修改，从而保护数据的完整性。例如，在一个表示日期的类中，日期的年、月、日数据成员应该满足一定的取值范围。如果将这些数据成员设置为private，并通过公共的设置函数来修改它们，就可以在设置函数中添加验证逻辑。

class Date {
public:
    void setDate(int year, int month, int day) {
        if (year >= 1900 && year <= 2100 && month >= 1 && month <= 12 && day >= 1 && day <= 31) {
            this->year = year;
            this->month = month;
            this->day = day;
        } else {
            // 可以选择抛出异常或者进行其他处理
        }
    }
    int getYear() {
        return year;
    }
    int getMonth() {
        return month;
    }
    int getDay() {
        return day;
    }
private:
    int year;
    int month;
    int day;
};

int main() {
    Date date;
    date.setDate(2023, 10, 15);
    int year = date.getYear();
    int month = date.getMonth();
    int day = date.getDay();
    return 0;
}

在上述代码中，year、month和day是private数据成员，外部代码只能通过setDate函数来设置它们的值。setDate函数中添加了对输入值的验证，确保日期的合法性，从而保护了数据的完整性。

类访问控制与继承

在C++的继承体系中，类访问控制扮演着重要的角色，它决定了基类成员在派生类中的访问权限。

继承中的访问权限变化

当一个类从另一个类继承时，基类的成员在派生类中的访问权限会根据继承方式和基类成员本身的访问修饰符而发生变化。继承方式主要有三种：public继承、private继承和protected继承。

  1. public继承：在public继承中，基类的public成员在派生类中仍然是public的，基类的protected成员在派生类中仍然是protected的，而基类的private成员在派生类中仍然是不可访问的（即使通过派生类的成员函数也无法访问）。例如：
class Base {
public:
    int publicData;
protected:
    int protectedData;
private:
    int privateData;
};

class Derived : public Base {
public:
    void accessMembers() {
        publicData = 10; // 合法，public成员在派生类中仍为public
        protectedData = 20; // 合法，protected成员在派生类中仍为protected
        // privateData = 30; // 错误，private成员在派生类中不可访问
    }
};

int main() {
    Derived derived;
    derived.publicData = 5; // 合法，public成员在外部可访问
    // derived.protectedData = 10; // 错误，protected成员在外部不可访问
    // derived.privateData = 15; // 错误，private成员在外部不可访问
    return 0;
}
  1. private继承：在private继承中，基类的public和protected成员在派生类中都变成private的，而基类的private成员在派生类中仍然是不可访问的。这意味着通过private继承，派生类将基类的所有非private接口都变成了私有的，外部代码无法直接访问这些从基类继承来的接口。例如：
class Base {
public:
    int publicData;
protected:
    int protectedData;
private:
    int privateData;
};

class Derived : private Base {
public:
    void accessMembers() {
        publicData = 10; // 合法，public成员在派生类中变为private
        protectedData = 20; // 合法，protected成员在派生类中变为private
        // privateData = 30; // 错误，private成员在派生类中不可访问
    }
};

int main() {
    Derived derived;
    // derived.publicData = 5; // 错误，public成员在外部不可访问
    // derived.protectedData = 10; // 错误，protected成员在外部不可访问
    // derived.privateData = 15; // 错误，private成员在外部不可访问
    return 0;
}
  1. protected继承：在protected继承中，基类的public成员在派生类中变成protected的，基类的protected成员在派生类中仍然是protected的，而基类的private成员在派生类中仍然是不可访问的。这种继承方式使得基类的公共接口在派生类及其子类中可用，但对外部代码隐藏。例如：
class Base {
public:
    int publicData;
protected:
    int protectedData;
private:
    int privateData;
};

class Derived : protected Base {
public:
    void accessMembers() {
        publicData = 10; // 合法，public成员在派生类中变为protected
        protectedData = 20; // 合法，protected成员在派生类中仍为protected
        // privateData = 30; // 错误，private成员在派生类中不可访问
    }
};

class SubDerived : public Derived {
public:
    void subAccessMembers() {
        publicData = 5; // 合法，public成员在SubDerived中为protected
        protectedData = 10; // 合法，protected成员在SubDerived中为protected
    }
};

int main() {
    Derived derived;
    // derived.publicData = 5; // 错误，public成员在外部不可访问
    // derived.protectedData = 10; // 错误，protected成员在外部不可访问
    // derived.privateData = 15; // 错误，private成员在外部不可访问

    SubDerived subDerived;
    // subDerived.publicData = 5; // 错误，public成员在外部不可访问
    // subDerived.protectedData = 10; // 错误，protected成员在外部不可访问
    return 0;
}

利用访问控制实现代码复用与扩展

通过合理使用继承和类访问控制，可以实现代码的复用和扩展。例如，当我们有一个基础的图形类Shape，它包含一些通用的属性和方法，如位置等。我们可以通过public继承派生出不同的具体图形类，如Circle、Rectangle等。在派生类中，可以根据需要访问和扩展基类的protected成员，同时保持基类的private成员的封装性。

class Shape {
protected:
    int x;
    int y;
public:
    void setPosition(int a, int b) {
        x = a;
        y = b;
    }
};

class Circle : public Shape {
public:
    int radius;
    int calculateArea() {
        return 3.14 * radius * radius;
    }
    void setCircle(int a, int b, int r) {
        setPosition(a, b);
        radius = r;
    }
};

class Rectangle : public Shape {
public:
    int width;
    int height;
    int calculateArea() {
        return width * height;
    }
    void setRectangle(int a, int b, int w, int h) {
        setPosition(a, b);
        width = w;
        height = h;
    }
};

int main() {
    Circle circle;
    circle.setCircle(5, 10, 3);
    int circleArea = circle.calculateArea();

    Rectangle rectangle;
    rectangle.setRectangle(5, 10, 5, 10);
    int rectangleArea = rectangle.calculateArea();
    return 0;
}

在这个例子中，Circle和Rectangle类通过public继承从Shape类获取了x和y位置属性以及setPosition方法，并且在各自的类中扩展了自己特有的属性（如radius、width和height）和方法（如calculateArea）。同时，Shape类的x和y属性被设置为protected，既保证了外部代码无法直接访问，又允许派生类根据需要进行访问和操作。

类访问控制在多态中的影响

多态是面向对象编程的另一个重要特性，它允许通过基类的指针或引用来调用派生类的函数。类访问控制在多态的实现中也有一定的影响。

虚函数与访问控制

在C++中，虚函数是实现多态的关键。当一个函数在基类中被声明为虚函数，并且在派生类中被重写时，通过基类指针或引用调用该函数时，会根据对象的实际类型来决定调用哪个函数。在这个过程中，访问控制仍然起作用。例如：

class Base {
public:
    virtual void print() {
        std::cout << "Base::print()" << std::endl;
    }
};

class Derived : public Base {
public:
    void print() override {
        std::cout << "Derived::print()" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    basePtr->print(); // 调用Derived::print()
    delete basePtr;
    return 0;
}

在这个例子中，Base类的print函数被声明为虚函数，Derived类重写了print函数。通过Base类指针basePtr指向Derived类对象，并调用print函数时，实际调用的是Derived类的print函数，实现了多态。这里print函数在基类和派生类中都是public的，确保了外部代码可以通过指针调用该函数。

如果将Derived类的print函数的访问修饰符改为private，会发生什么情况呢？

class Base {
public:
    virtual void print() {
        std::cout << "Base::print()" << std::endl;
    }
};

class Derived : public Base {
private:
    void print() override {
        std::cout << "Derived::print()" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    // basePtr->print(); // 错误，Derived::print()是private的
    delete basePtr;
    return 0;
}

此时，通过basePtr调用print函数会导致编译错误，因为Derived类的print函数是private的，外部代码无法访问。虽然虚函数机制仍然存在，但由于访问控制的限制，无法通过基类指针调用到Derived类的print函数。

访问控制与动态绑定

动态绑定是多态的核心机制，它在运行时根据对象的实际类型来确定调用哪个函数。访问控制会影响动态绑定的可用性。例如，当通过基类指针或引用调用一个虚函数时，编译器会检查该函数在指针或引用的静态类型（即基类类型）中的访问权限。如果在基类中该函数是可访问的，才会进一步根据对象的动态类型（即实际指向的派生类类型）来确定最终调用的函数。

class Base {
protected:
    virtual void protectedPrint() {
        std::cout << "Base::protectedPrint()" << std::endl;
    }
};

class Derived : public Base {
public:
    void protectedPrint() override {
        std::cout << "Derived::protectedPrint()" << std::endl;
    }
};

int main() {
    Base* basePtr = new Derived();
    // basePtr->protectedPrint(); // 错误，protectedPrint()在Base中是protected的，外部无法访问
    delete basePtr;
    return 0;
}

在这个例子中，protectedPrint函数在Base类中是protected的，虽然Derived类重写了该函数并将其设置为public，但由于在Base类中它是protected的，通过Base类指针在外部代码中调用protectedPrint函数仍然会导致编译错误。这表明访问控制在动态绑定过程中起到了限制作用，确保只有符合访问权限的函数调用才是合法的。

友元函数与友元类对访问控制的突破

在某些情况下，我们可能需要允许特定的函数或类访问另一个类的私有或保护成员，这时就可以使用友元函数或友元类。

友元函数

友元函数是一种特殊的函数，它不是类的成员函数，但可以访问类的私有和保护成员。要声明一个友元函数，需要在类定义中使用friend关键字。例如：

class Rectangle {
private:
    int width;
    int height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    friend int calculateArea(Rectangle rect);
};

int calculateArea(Rectangle rect) {
    return rect.width * rect.height;
}

int main() {
    Rectangle rect(5, 10);
    int area = calculateArea(rect);
    return 0;
}

在上述代码中，calculateArea函数被声明为Rectangle类的友元函数，因此它可以访问Rectangle类的私有成员width和height。这样，即使width和height是私有的，calculateArea函数仍然能够直接操作它们来计算矩形的面积。

友元类

友元类是指一个类可以被声明为另一个类的友元，友元类的所有成员函数都可以访问被友元类的私有和保护成员。例如：

class Rectangle;

class AreaCalculator {
public:
    int calculateArea(Rectangle rect);
};

class Rectangle {
private:
    int width;
    int height;
public:
    Rectangle(int w, int h) : width(w), height(h) {}
    friend class AreaCalculator;
};

int AreaCalculator::calculateArea(Rectangle rect) {
    return rect.width * rect.height;
}

int main() {
    Rectangle rect(5, 10);
    AreaCalculator calculator;
    int area = calculator.calculateArea(rect);
    return 0;
}

在这个例子中，AreaCalculator类被声明为Rectangle类的友元类。因此，AreaCalculator类的calculateArea函数可以访问Rectangle类的私有成员width和height。虽然友元提供了一种突破访问控制的方式，但应该谨慎使用，因为它在一定程度上破坏了类的封装性。只有在确实有必要让特定的函数或类访问私有成员时，才使用友元机制。

类访问控制的最佳实践

在实际编程中，合理使用类访问控制可以提高代码的安全性、可维护性和可扩展性。以下是一些类访问控制的最佳实践。

最小化公共接口

尽量减少类的public成员，只暴露那些外部代码必须使用的接口。这样可以降低外部代码对类内部实现的依赖，使得类的内部实现可以在不影响外部代码的情况下进行修改和优化。例如，对于一个表示银行账户的类，只需要提供deposit（存款）、withdraw（取款）和getBalance（获取余额）等必要的公共接口，而不需要将账户的内部数据结构（如存储交易记录的方式）暴露给外部。

class BankAccount {
private:
    double balance;
public:
    BankAccount(double initialBalance = 0.0) : balance(initialBalance) {}
    void deposit(double amount) {
        if (amount > 0) {
            balance += amount;
        }
    }
    bool withdraw(double amount) {
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }
    double getBalance() {
        return balance;
    }
};

int main() {
    BankAccount account(1000.0);
    account.deposit(500.0);
    bool success = account.withdraw(300.0);
    double balance = account.getBalance();
    return 0;
}

保护内部数据

将数据成员设置为private或protected，通过公共的访问器（getter）和修改器（setter）函数来访问和修改数据。这样可以在访问器和修改器函数中添加验证逻辑，保护数据的完整性。例如，在一个表示人的年龄的类中，年龄应该是一个非负整数，通过设置private的年龄成员和提供带有验证逻辑的setAge函数来确保年龄的合理性。

class Person {
private:
    int age;
public:
    void setAge(int a) {
        if (a >= 0) {
            age = a;
        }
    }
    int getAge() {
        return age;
    }
};

int main() {
    Person person;
    person.setAge(30);
    int age = person.getAge();
    return 0;
}

谨慎使用友元

友元虽然提供了一种灵活的访问控制方式，但由于它破坏了类的封装性，应该谨慎使用。只有在确实需要让特定的函数或类访问私有成员，且没有其他更好的解决方案时，才使用友元。例如，在一些紧密相关的类之间，如一个图形渲染类和一个图形数据存储类，可能需要使用友元来实现高效的数据交互，但在其他情况下，应优先考虑通过公共接口来实现类之间的通信。

根据继承关系合理设置访问权限

在设计继承体系时，根据派生类对基类成员的使用需求，合理选择继承方式和设置基类成员的访问权限。如果希望派生类能够扩展和访问基类的某些成员，将这些成员设置为protected，并选择合适的继承方式（如public继承）。如果不希望派生类直接访问基类的某些实现细节，将这些成员设置为private。例如，在一个动物类和它的派生类狗类、猫类的继承体系中，动物类的一些通用行为（如呼吸、进食）可以设置为protected或public，而动物类的一些内部生理结构相关的成员可以设置为private，防止派生类直接访问和修改。

class Animal {
protected:
    void breathe() {
        std::cout << "Animal is breathing" << std::endl;
    }
private:
    int internalOrganStatus;
public:
    void eat() {
        std::cout << "Animal is eating" << std::endl;
    }
};

class Dog : public Animal {
public:
    void bark() {
        breathe();
        std::cout << "Dog is barking" << std::endl;
    }
};

int main() {
    Dog dog;
    dog.eat();
    dog.bark();
    return 0;
}

在这个例子中，Animal类的breathe函数设置为protected，使得Dog类可以在其成员函数bark中调用breathe函数，同时Animal类的internalOrganStatus设置为private，防止Dog类直接访问。

通过遵循这些最佳实践，可以充分发挥类访问控制的优势，编写出更加健壮、可维护和安全的C++程序。类访问控制不仅仅是一种语法规则，更是一种设计理念，它贯穿于整个面向对象编程的过程中，对于构建高质量的软件系统起着至关重要的作用。无论是小型项目还是大型复杂的软件架构，合理运用类访问控制都是实现良好设计的关键因素之一。在实际编程中，开发者需要根据具体的需求和场景，仔细权衡不同访问控制策略的利弊，以达到最优的设计效果。同时，随着代码的不断演进和功能的增加，对类访问控制的设计也需要进行持续的审查和优化，确保代码的质量和可维护性始终保持在较高水平。

在处理复杂的业务逻辑和系统架构时，类访问控制可以帮助我们更好地划分模块之间的边界，明确各个模块的职责和接口。例如，在一个企业级应用中，可能有数据访问层、业务逻辑层和表示层等不同的模块。通过合理设置类的访问权限，可以防止业务逻辑层直接访问数据访问层的内部数据结构，而是通过定义良好的公共接口进行交互，这样不仅提高了系统的安全性，也使得各个模块可以独立地进行开发、测试和维护。当数据访问层的实现方式发生改变时（如从使用关系型数据库切换到使用NoSQL数据库），只要公共接口不变，业务逻辑层和表示层的代码无需进行大量修改。

此外，在团队协作开发中，类访问控制也有助于规范团队成员对代码的访问和修改。明确的访问控制规则可以避免团队成员无意中破坏类的封装性，导致代码的可维护性下降。同时，清晰的接口定义和访问权限设置也使得新加入的团队成员能够更快地理解代码的结构和功能，提高团队的开发效率。

在学习和掌握C++类访问控制的过程中，开发者需要不断实践和总结经验。通过分析优秀的开源代码库中的类设计，学习其中合理的访问控制策略，可以提升自己的设计能力。同时，自己动手编写各种类型的项目，尝试不同的访问控制方案，在实践中发现问题并解决问题，也是深入理解和掌握类访问控制的有效途径。只有真正理解了类访问控制的深层意义，并将其灵活运用到实际编程中，才能编写出高质量、可维护且具有良好扩展性的C++程序。