C++ class 中私有 getter 和 setter 的成员函数？

Question

我正在学习 C++，我需要知道在私有 setter 和 getter 方面编写 class 的成员函数是否是个好主意，还是应该使用原始私有数据？

我有这个 class：

    class Complex{
    public:

        Complex();
        Complex(const double &real_part);
        Complex(const double &real_part, const double &imaginary_part);

        Complex& operator += (const Complex &addend);
        Complex& operator *= (const Complex &multiplier);
        
        Complex operator ~ ();
        Complex operator - ();

        Complex& operator -= (Complex &subtrahend);
        Complex& operator /= (Complex &divisor);

    private:

        double real_part_, imaginary_part_;
        double re() const {return real_part_;};
        double im() const {return imaginary_part_;};
        void set_real_part(const double real_part){real_part_ = real_part;};
        void set_imaginary_part(const double imaginary_part){imaginary_part_ = imaginary_part;};
    

    friend double Re(Complex &z){return z.re();};
    friend double Im(Complex &z){return z.im();};
    };

    // Constructors

    Complex::Complex(){
        set_real_part(0);
        set_imaginary_part(0);
    }
    
    Complex::Complex(const double &real_part){
        set_real_part(real_part);
        set_imaginary_part(0);
    }
    Complex::Complex(const double &real_part, const double &imaginary_part){
        set_real_part(real_part);
        set_imaginary_part(imaginary_part);
    }
    
    /////////////////Members///////////////
    
    //Basic perators
    
    Complex &Complex::operator +=(const Complex &other){
        set_real_part(re() + other.re());
        set_imaginary_part(im() + other.im());
        return *this;
    }
    
    Complex &Complex::operator *=(const Complex &other){
        double real_part = re()*other.re() - im()*other.im();
        double imaginary_part = re()*other.im() + im()*other.re();
        set_real_part(real_part);
        set_imaginary_part(imaginary_part);
        return *this;
    }
    
    //Conjugate and inverse
    
    Complex Complex::operator ~(){
        Complex other(re(),-im());
        return other;
    }
    
    Complex Complex::operator -(){
        Complex other(-re(),-im());
        return other;
    }
    
    // Inverse operations
    
    Complex &Complex::operator -=(Complex &other){
        *this += -other;
        return *this;
    }
    
    Complex &Complex::operator /=(Complex &other){
        *this *= ~other;
        other *= ~other;
        set_real_part(re()/other.re());
        set_imaginary_part(im()/other.re());
        return *this;
    }

Friend 函数用于使用 getter，例如， Re(z)而不是z.re() ，所以我可以在 function 中编写一个表达式。

另外，如果您能给予评论，将不胜感激。

Answer 1

任何标记为private的内容都只能由 class 实现访问。 因此，您可以（并且应该）删除这些功能：

    double re() const {return real_part_;};
    double im() const {return imaginary_part_;};
    void set_real_part(const double real_part){real_part_ = real_part;};
    void set_imaginary_part(const double imaginary_part){imaginary_part_ = imaginary_part;};

任何可以调用这些函数的代码已经可以访问real_part_和imaginary_part_ ，因此可以直接使用它们。

至于您关于语法应该是Re(im)还是im.re()的问题，这在很大程度上是个人喜好问题。 语法im.re()在 C++ 代码库中更常见，尽管让Re(im)反映数学语法的优势很好。 我不认为其中任何一个明显正确或明显错误。

Answer 2

呼吁对此的核心指导方针。

“如果 class 具有不变量，则使用 class；如果数据成员可以独立变化，则使用 struct。”

换句话说，如果您的数据成员有一个需要满足的约束，请将它们设为私有并公开函数以修改它们以维护此约束。 此处给出的示例是Date class：

class Date {
public:
    // validate that {yy, mm, dd} is a valid date and initialize
    Date(int yy, Month mm, char dd);
    // ...
private:
    int y;
    Month m;
    char d;    // day
};

您不希望用户能够将日期设置为 100，因为这不是有效日期，因此将成员设为私有并有一个名为 Advance 的 function 将日期advance移动 100 天，这也将更新月份并且可能年份存储在 object 中。

对于诸如复数之类的东西，实部和虚部是相互独立的，所以我只使用一个普通的结构并像这样公开值

struct Complex
{
    double real, imag;
};

需要维护的样板更少，更易于阅读。 这种特殊情况还有一个好处是它是一个聚合类型，所以你不需要定义任何构造函数，你可以像这样实例化

Complex z1{3, 4};
auto z2 = Complex{3, 4};
auto z3 = Complex{ .real = 3, .imag = 4}; // C++20, and the best in my opinion

您仍然可以将所需的所有运算符实现为免费功能，例如

Complex operator+(const Complex& lhs, const Complex& rhs) {
    return Complex{lhs.real + rhs.real, lhs.imag + rhs.imag};
}

double& real(const Complex& lhs) { return lhs.real; }

这可以是不需要friend船来实现的免费功能。

您需要哪种情况并不总是很清楚，但是如果您发现自己为所有数据成员编写 getter 和 setter，您可能只需要一个结构。