复制、const 和 non-const、getter 的优雅解决方案？ [复制]

Question

当你拥有它时你不讨厌它

class Foobar {
public:
    Something& getSomething(int index) {
        // big, non-trivial chunk of code...
        return something;
    }

    const Something& getSomething(int index) const {
        // big, non-trivial chunk of code...
        return something;
    }
}

我们不能用另一种方法实现这两种方法，因为您不能从const 版本调用非const 版本（编译器错误）。 需要演员才能从非const 调用const 版本。

有没有真正优雅的解决方案，如果没有，最接近的解决方案是什么？

Answer 1

我记得在一本 Effective C++ 书籍中，这样做的方法是通过从其他函数中丢弃 const 来实现非常量版本。

它不是特别漂亮，但很安全。由于调用它的成员函数是非常量的，因此对象本身也是非常量的，并且允许丢弃 const。

class Foo
{
public:
    const int& get() const
    {
        //non-trivial work
        return foo;
    }

    int& get()
    {
        return const_cast<int&>(const_cast<const Foo*>(this)->get());
    }
};

Answer 2

'const' 的概念是有原因的。对我来说，它建立了一个非常重要的合同，基于该合同编写程序的进一步指令。但是您可以在以下几行中做一些事情：-

1. 让您的成员“可变”
2. 将“getters”设为常量
3. 返回非常量引用

有了这个，如果您需要在使用 getter 的地方维护 const 功能以及非常量用法（危险），可以在 LHS 上使用 const 引用。但是现在程序员有责任维护类不变量。

正如之前在 SO 中所说，丢弃最初定义的 const 对象的 const 并使用它是 U.B.所以我不会使用演员表。同样将非 const 对象设为 const，然后再次丢弃 const 看起来不太好。

我在一些团队中看到的另一个编码准​​则是：-

• 如果一个成员变量需要在类外修改，总是 通过非常量成员函数返回指向它的指针。
• 没有成员函数可以返回非常量引用。只有常量 允许从 const 成员函数中引用。

这使得整个代码库有一定的一致性，调用者可以清楚地看到哪些调用可以修改成员变量。

Answer 3

我敢建议使用预处理器：

#define ConstFunc(type_and_name, params, body) \
    const type_and_name params const body \
    type_and_name params body

class Something
{
};

class Foobar {
private:
    Something something;

public:
    #define getSomethingParams \
    ( \
        int index \
    )

    #define getSomethingBody \
    { \
        return something; \
    }

    ConstFunc(Something & getSomething, getSomethingParams, getSomethingBody)
};

Answer 4

怎么样：

template<typename IN, typename OUT>
OUT BigChunk(IN self, int index) {
    // big, non-trivial chunk of code...
    return something;
}

struct FooBar {
    Something &getSomething(int index) {
        return BigChunk<FooBar*, Something&>(this,index);
    }

    const Something &getSomething(int index) const {
        return BigChunk<const FooBar*, const Something&>(this,index);
    }
};

显然，您仍然会有目标代码重复，但没有源代码重复。与 const_cast 方法不同，编译器会检查你的方法的两个版本的 const 正确性。

您可能需要将 BigChunk 的两个有趣实例声明为类的朋友。这是对朋友的一个很好的使用，因为朋友功能隐藏在靠近朋友的地方，所以不存在无约束耦合的风险（哦，呃！）。但我现在不会尝试这样做的语法。随意添加。

BigChunk 可能需要尊重自我，在这种情况下，上述定义顺序不会很好地工作，需要一些前向声明来解决它。

此外，为了避免在标头中发现 BigChunk 并决定实例化并调用它，即使它在道德上是私有的，您可以将整个文件移到 FooBar 的 cpp 文件中。在匿名命名空间中。带内部联动。还有一个牌子上写着“小心豹子”。

Answer 5

为什么不直接将公共代码提取到一个单独的私有函数中，然后让其他两个调用它？

Answer 6

const 对该对象的引用是有意义的（您限制了对该对象的只读访问），但如果您需要允许非const 引用，您不妨将会员公众。

我相信这是一个 la Scott Meyers（高效 C++）。

Answer 7

尝试通过重构代码来消除 getter。如果只有极少数其他事物需要Something，请使用友元函数或类。

一般来说，Getter 和 Setter 会破坏封装，因为数据是公开的。使用朋友只向少数人公开数据，因此可以提供更好的封装。

当然，这并不总是可行的，因此您可能会被吸气剂卡住。至少，大部分或所有“重要的代码块”应该在一个或多个私有函数中，由两个 getter 调用。

Answer 8

我会将 const 转换为非常量（第二个选项）。