Question

我有一个类A，其成员是指向另一个类std::vector的对象的B指针。我的类返回一个指向特定索引处对象的const指针。现在，如果我想修改对象，那么最好的方法是什么？

我可以在类A中编写get / set方法，它最终将使用类B的get / set方法，但它是代码的重复。使用friend关键字修改私人成员是一种好习惯吗？

或者，我可以将课程A设为friend类B，然后它可以修改B的私有成员，以避免重复代码。

或者，我可以删除返回指针上的const。

class B;

class A {
    std::vector<B*> m_list;
public:
    const B* getB(int index) {
        return m_list[index];
    }
};

class B {
private:
    int a;
    float b;
    long c;

    long getC() {
        return C;
    }

    int getA() {
        return a;
    }

    float getB() {
        return b;
    }

    /*
    set_methods
    */
};

Answer 1

Constness and friendship是两个完全不同且不相关的东西。

如果A是B的朋友，则无关紧要。对于您是否想要封装B内A成员的访问权限，或者您是否希望允许调用者直接访问B getters / setters，这只是您的设计选择

就修改对象而言，任何getter都应该声明为const，因此可以在const和非const对象上调用它们（因为它们不会被＃39} ; t修改他们正在读取的对象），但如果您希望能够修改对象的成员，那么您必须通过非const指针访问该对象（或非 - const参考）：

class B;

class A {
private:
    std::vector<B*> m_list;

public:
    // this can be called on a non-const A, and
    // the B members can be read and modified...
    B* getB(int index) {
        return m_list[index];
    }

    // this can be called only on a const A, and
    // the B members can be read but not modified...
    const B* getB(int index) const {
        return m_list[index];
    }

    /* optional:

    int getB_A(int index) const {
        return getB(index)->getA();
    }

    float getB_B(int index) const {
        return getB(index)->getB();
    }

    long getC(int index) const {
        return getB(index)->getC();
    }

    void setB_A(int index, int value) {
        getB(index)->setA(value);
    }

    void setB_B(int index, float value) {
        getB(index)->setB(value);
    }

    void setB_C(int index, long value) {
        getB(index)->setC(value);
    }

    */
};

class B {
private:
    int a;
    float b;
    long c;

public:
    int getA() const {
        return a;
    }

    float getB() const {
        return b;
    }

    long getC() const {
        return c;
    }

    void setA(int value) {
        a = value;
    }

    void setB(float value) {
        b = value;
    }

    void setC(long val) {
        c = val;
    }
};

或者：

class B;

class A {
private:
    std::vector<B*> m_list;

public:
    // this can be called on a non-const A, and
    // the B members can be read and modified...
    B* getB(int index) {
        return m_list[index];
    }

    // this can be called only on a const A, and
    // the B members can be read but not modified...
    const B* getB(int index) const {
        return m_list[index];
    }

    int getB_A(int index) const {
        return getB(index)->a;
    }

    float getB_B(int index) const {
        return getB(index)->b;
    }

    long getC(int index) const {
        return getB(index)->c;
    }

    void setB_A(int index, int value) {
        getB(index)->a = value;
    }

    void setB_B(int index, float value) {
        getB(index)->b = value;
    }

    void setB_C(int index, long value) {
        getB(index)->c = value;
    }
};

class B {
private:
    int a;
    float b;
    long c;

    friend class A;
};

修改类c ++中的成员对象

1 个答案: