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

C++私有成员变量可访问函数的详细解读

2021-06-277.4k 阅读

C++ 中的访问控制

在 C++ 编程中，访问控制是一个至关重要的概念，它允许我们控制类成员（包括变量和函数）的可访问性。这种机制有助于实现数据封装，这是面向对象编程（OOP）的基本原则之一。通过数据封装，我们可以隐藏类的内部实现细节，只向外部提供必要的接口，从而提高代码的安全性、可维护性和可扩展性。

访问修饰符

C++ 提供了三种主要的访问修饰符：public、private 和 protected。

  • public：声明为 public 的成员可以从类的外部直接访问。这通常用于定义类的接口，也就是外部代码与类进行交互的方式。
  • private：private 成员只能在类的内部访问。这意味着类的外部代码，包括其他函数和类，都无法直接访问这些成员。这种限制有助于保护类的内部状态和实现细节，防止外部代码对其进行意外修改。
  • protected：protected 成员与 private 成员类似，它们不能从类的外部直接访问。然而，protected 成员可以被派生类（子类）访问。这在实现继承关系时非常有用，因为它允许子类访问基类的某些内部成员，同时仍然限制外部代码的访问。

私有成员变量的作用

私有成员变量在类中扮演着关键角色，它们存储类的内部状态信息。由于这些变量是私有的，外部代码无法直接访问或修改它们，这有助于确保数据的完整性和一致性。例如，考虑一个表示银行账户的类，账户余额应该是一个私有成员变量，只有通过类提供的特定方法（如存款和取款函数）才能对其进行修改。这样可以防止外部代码意外地将余额设置为负数或进行其他非法操作。

私有成员变量的访问途径

虽然私有成员变量不能从类的外部直接访问，但 C++ 提供了几种合法的途径来访问它们，这些途径主要通过类的成员函数来实现。

通过成员函数访问

类的成员函数可以访问类的所有成员，包括私有成员。这是访问私有成员变量的最常见方式。成员函数可以提供对私有成员变量的读取和写入操作，同时可以在这些操作中添加必要的逻辑和验证。

以下是一个简单的示例，展示了如何通过成员函数访问私有成员变量：

#include <iostream>

class Rectangle {
private:
    int width;
    int height;

public:
    // 构造函数
    Rectangle(int w, int h) : width(w), height(h) {}

    // 获取宽度的成员函数
    int getWidth() const {
        return width;
    }

    // 获取高度的成员函数
    int getHeight() const {
        return height;
    }

    // 计算面积的成员函数
    int calculateArea() const {
        return width * height;
    }
};

int main() {
    Rectangle rect(5, 10);
    std::cout << "Width: " << rect.getWidth() << std::endl;
    std::cout << "Height: " << rect.getHeight() << std::endl;
    std::cout << "Area: " << rect.calculateArea() << std::endl;
    return 0;
}

在上述代码中，Rectangle 类有两个私有成员变量 width 和 height。通过 getWidth、getHeight 和 calculateArea 这些公有成员函数，我们可以间接地访问这些私有成员变量。getWidth 和 getHeight 函数用于读取私有成员变量的值，而 calculateArea 函数则利用私有成员变量进行计算并返回结果。

友元函数和友元类

除了成员函数外，C++ 还提供了友元机制，允许特定的函数或类访问另一个类的私有成员。

友元函数

友元函数是在类定义中声明的非成员函数，它被授予访问该类私有成员的权限。友元函数的声明使用 friend 关键字。

以下是一个友元函数的示例：

#include <iostream>

class Point {
private:
    int x;
    int y;

public:
    Point(int a, int b) : x(a), y(b) {}

    // 友元函数声明
    friend void printPoint(const Point& p);
};

// 友元函数定义
void printPoint(const Point& p) {
    std::cout << "Point: (" << p.x << ", " << p.y << ")" << std::endl;
}

int main() {
    Point p(3, 4);
    printPoint(p);
    return 0;
}

在这个例子中，printPoint 函数是 Point 类的友元函数，因此它可以访问 Point 类的私有成员 x 和 y。虽然友元函数提供了一种灵活的访问私有成员的方式，但应该谨慎使用，因为它破坏了类的封装性。

友元类

友元类是指一个类被授予访问另一个类的私有成员的权限。在一个类中声明另一个类为友元，使用 friend 关键字。

以下是一个友元类的示例：

#include <iostream>

class Engine {
private:
    int horsepower;

public:
    Engine(int hp) : horsepower(hp) {}

    // 友元类声明
    friend class Car;
};

class Car {
private:
    std::string model;
    Engine engine;

public:
    Car(const std::string& m, int hp) : model(m), engine(hp) {}

    void displayInfo() {
        std::cout << "Model: " << model << ", Horsepower: " << engine.horsepower << std::endl;
    }
};

int main() {
    Car myCar("Sedan", 200);
    myCar.displayInfo();
    return 0;
}

在上述代码中，Car 类被声明为 Engine 类的友元类，因此 Car 类的成员函数 displayInfo 可以访问 Engine 类的私有成员 horsepower。同样，友元类的使用也应该谨慎，因为它也在一定程度上破坏了类的封装性。

私有成员变量访问函数的设计原则

在设计类时，对于私有成员变量的访问函数，需要遵循一些基本原则，以确保代码的质量和可维护性。

数据验证

访问函数，特别是用于设置私有成员变量值的函数，应该进行数据验证。例如，如果一个私有成员变量表示年龄，设置年龄的函数应该检查输入值是否在合理范围内（如 0 到 120 之间）。

#include <iostream>

class Person {
private:
    int age;

public:
    Person() : age(0) {}

    // 设置年龄的函数，带有数据验证
    void setAge(int a) {
        if (a >= 0 && a <= 120) {
            age = a;
        } else {
            std::cerr << "Invalid age value." << std::endl;
        }
    }

    // 获取年龄的函数
    int getAge() const {
        return age;
    }
};

int main() {
    Person p;
    p.setAge(30);
    std::cout << "Age: " << p.getAge() << std::endl;

    p.setAge(150);
    std::cout << "Age: " << p.getAge() << std::endl;
    return 0;
}

在这个例子中，setAge 函数检查输入的年龄值是否在合理范围内，如果不合理则输出错误信息，并且不修改 age 的值。

封装与抽象

访问函数应该隐藏类的内部实现细节，只提供必要的接口。例如，一个表示栈的类，其私有成员变量可能包括一个数组和一个栈顶指针。栈类的接口函数（如 push 和 pop）应该以抽象的方式提供栈的基本操作，而不暴露内部数组和指针的具体实现。

#include <iostream>
#include <limits>

class Stack {
private:
    int data[100];
    int topIndex;

public:
    Stack() : topIndex(-1) {}

    // 入栈操作
    void push(int value) {
        if (topIndex < 99) {
            data[++topIndex] = value;
        } else {
            std::cerr << "Stack overflow." << std::endl;
        }
    }

    // 出栈操作
    int pop() {
        if (topIndex >= 0) {
            return data[topIndex--];
        } else {
            std::cerr << "Stack underflow." << std::endl;
            return std::numeric_limits<int>::min();
        }
    }

    // 检查栈是否为空
    bool isEmpty() const {
        return topIndex == -1;
    }
};

int main() {
    Stack s;
    s.push(10);
    s.push(20);

    std::cout << "Popped: " << s.pop() << std::endl;
    std::cout << "Popped: " << s.pop() << std::endl;

    std::cout << "Is empty: " << (s.isEmpty()? "Yes" : "No") << std::endl;
    return 0;
}

在这个栈类的实现中，外部代码只需要使用 push、pop 和 isEmpty 这些接口函数，而不需要了解栈内部是如何使用数组和指针来实现的。

一致性和易用性

访问函数的命名和行为应该具有一致性，并且易于使用。例如，获取私有成员变量值的函数通常命名为 get 加上变量名（如 getWidth、getAge），而设置值的函数命名为 set 加上变量名（如 setWidth、setAge）。这种命名约定使得代码易于理解和维护。

同时，访问函数的参数和返回值类型应该清晰明了，避免使用复杂或不直观的类型。例如，对于一个表示颜色的类，获取颜色值的函数可以返回一个简单的枚举类型，而不是一个复杂的结构体。

#include <iostream>

// 定义颜色枚举类型
enum class Color {
    RED,
    GREEN,
    BLUE
};

class Shape {
private:
    Color color;

public:
    Shape(Color c) : color(c) {}

    // 获取颜色的函数
    Color getColor() const {
        return color;
    }

    // 设置颜色的函数
    void setColor(Color c) {
        color = c;
    }
};

int main() {
    Shape s(Color::RED);
    std::cout << "Color: ";
    switch (s.getColor()) {
        case Color::RED:
            std::cout << "RED";
            break;
        case Color::GREEN:
            std::cout << "GREEN";
            break;
        case Color::BLUE:
            std::cout << "BLUE";
            break;
    }
    std::cout << std::endl;

    s.setColor(Color::GREEN);
    std::cout << "New Color: ";
    switch (s.getColor()) {
        case Color::RED:
            std::cout << "RED";
            break;
        case Color::GREEN:
            std::cout << "GREEN";
            break;
        case Color::BLUE:
            std::cout << "BLUE";
            break;
    }
    std::cout << std::endl;
    return 0;
}

在这个例子中，getColor 和 setColor 函数的命名和行为符合常见的约定，并且使用简单的枚举类型来表示颜色，使得代码易于理解和使用。

访问私有成员变量的性能考虑

在设计访问私有成员变量的函数时，性能也是一个需要考虑的因素。

内联函数

对于简单的访问函数，如只返回私有成员变量值的 get 函数，可以将其声明为内联函数。内联函数在编译时会将函数体插入到调用处，避免了函数调用的开销，从而提高性能。

#include <iostream>

class Circle {
private:
    double radius;

public:
    Circle(double r) : radius(r) {}

    // 内联获取半径的函数
    inline double getRadius() const {
        return radius;
    }

    // 计算面积的函数
    double calculateArea() const {
        return 3.14159 * radius * radius;
    }
};

int main() {
    Circle c(5.0);
    std::cout << "Radius: " << c.getRadius() << std::endl;
    std::cout << "Area: " << c.calculateArea() << std::endl;
    return 0;
}

在上述代码中，getRadius 函数被声明为内联函数，这样在调用 c.getRadius() 时，编译器会直接将函数体 return radius; 插入到调用处，减少了函数调用的开销。

避免不必要的复制

在返回私有成员变量时，要注意避免不必要的复制操作。例如，如果私有成员变量是一个大型对象，返回对象的副本会导致性能下降。在这种情况下，可以考虑返回对象的引用或指针。

#include <iostream>
#include <string>

class BigObject {
private:
    std::string data;

public:
    BigObject(const std::string& s) : data(s) {}

    // 返回对象的引用
    const std::string& getData() const {
        return data;
    }
};

int main() {
    BigObject obj("This is a big object");
    const std::string& str = obj.getData();
    std::cout << "Data: " << str << std::endl;
    return 0;
}

在这个例子中，getData 函数返回 data 的引用，而不是副本，这样可以避免不必要的字符串复制操作，提高性能。

总结私有成员变量访问函数的重要性

私有成员变量访问函数在 C++ 编程中具有重要意义。它们是实现数据封装的关键手段，通过限制外部对私有成员变量的直接访问，保护了类的内部状态和实现细节。同时，合理设计的访问函数可以提供清晰的接口，方便外部代码与类进行交互，并且可以在其中添加数据验证、逻辑处理等功能，提高代码的健壮性和可维护性。

在实际编程中，我们应该根据具体需求，遵循设计原则，谨慎地设计和实现私有成员变量的访问函数，同时考虑性能因素，以创建高效、可靠的 C++ 程序。无论是简单的类还是复杂的大型项目，正确使用私有成员变量访问函数都是确保代码质量的重要环节。通过不断实践和学习，我们可以更好地掌握这一技术，编写出更加优秀的 C++ 代码。

以上内容详细解读了 C++ 中私有成员变量可访问函数的各个方面，包括访问途径、设计原则以及性能考虑等，希望能帮助读者深入理解并在实际编程中灵活运用这一重要概念。