如何从 const 方法生成非常量方法？

Question

编写了这样的代码

class Bar;

class Foo {
public:
  const Bar* bar() const { /* code that gets a Bar somewhere */ }

  Bar* bar() {
    return const_cast< Bar* >(
      static_cast< const Foo* >(this)->bar());
  }
};

在努力实现 const 正确性的同时，我经常发现自己为许多方法（如 bar()） 。编写这些手动调用 const 方法的非常量方法是乏味的；此外，我觉得我在重复自己——这让我感觉很糟糕。

我可以做什么来减轻这项任务？ （不允许使用宏和代码生成器。）

编辑：除了 litb 的解决方案之外，我也喜欢我自己的解决方案。 :)

Answer 1

另一种方法可能是编写一个调用该函数（使用 CRTP）的模板并从中继承。

template<typename D>
struct const_forward {
protected:
  // forbid deletion through a base-class ptr
  ~const_forward() { }

  template<typename R, R const*(D::*pf)()const>
  R *use_const() {
    return const_cast<R *>( (static_cast<D const*>(this)->*pf)() );
  }

  template<typename R, R const&(D::*pf)()const>
  R &use_const() {
    return const_cast<R &>( (static_cast<D const*>(this)->*pf)() );
  }
};

class Bar;

class Foo : public const_forward<Foo> {
public:
  const Bar* bar() const { /* code that gets a Bar somewhere */ }
  Bar* bar() { return use_const<Bar, &Foo::bar>(); }
};

请注意，该调用没有性能损失：由于成员指针作为模板参数传递，因此可以像往常一样内联调用。

Answer 2

使用以下技巧：

class Bar;
class Foo {
public:  
  Bar* bar() { 
    // non-const case
    /* code that does something */ 
  }  
  const Bar* bar() const {    
      return This().bar();  // use non-const case
   }

private:
  //trick: const method returns non-const reference
  Foo & This() const { return const_cast<Foo &>(*this); } 
};

请注意，可以将唯一函数 This 用于任何常量/非常量函数。

没有 static_cast 的替代解决方案（但我更喜欢第一个）：

class Bar;
class Foo {
public:  
  const Bar* bar() const { /* code that does something */ }  
  Bar* bar() { return const_cast<Bar*>(cthis().bar()); } // use const case
private:
  const Foo & cthis() const { return *this; } 
};

Answer 3

你可以这样做：

class Bar;

class Foo {
public:
  const Bar* bar() const { return getBar(); }

  Bar* bar() {
   return getBar();
  }

  private:
    Bar* getBar() const {/* Actual code */ return NULL;}
};

Answer 4

我个人的感觉是，如果你经常这样做，那么你的设计就有点可疑了。有时我不得不做类似的事情，我通常会让方法访问的东西可变。

Answer 5

我以前也经历过这种痛苦——本质上，你试图告诉编译器常量通过 bar()“传播”。不幸的是，据我所知，没有办法自动执行此操作......您只需手动编写该函数的第二个版本。

Answer 6

仅供参考 - OP 发布的代码是 Scott Meyers 的“Effective C++ - 第三版”中给出的首选方法。请参阅第 3 项。

Answer 7

这个答案是我经过一番思考后自己得出的。但是，我认为我可以使用 litb 答案中的想法来改进它，我稍后会发布该答案。所以到目前为止我的解决方案如下所示：

class ConstOverloadAdapter {
protected:

  // methods returning pointers 

  template< 
    typename R, 
    typename T >
  R* ConstOverload(
    const R* (T::*mf)(void) const) {
      return const_cast< R* >(
        (static_cast< const T* >(this)->*mf)());
    }

  // and similar templates for methods with parameters 
  // and/or returning references or void
};

class Bar;

class Foo : public ConstOverloadAdapter {
public:
  const Bar* bar() const { 
    /* implementation */ }

  Bar* bar(void* = 0) {  // the dummy void* is only needed for msvc
                         // since it cannot distinguish method overloads
                         // based on cv-type. Not needed for gcc or comeau.
    return ConstOverload(&Foo::bar); }
};

Answer 8

假设您接受常量正确性作为一种技术，那么我认为这意味着您更喜欢编译器检查的常量正确性而不是简洁性。因此，您希望编译器检查两件事：

1. 当“this”是非常量时，调用者可以安全地修改您返回的指针的引用数。
2. 当“this”是const时，无论你做什么工作都不会对“this”执行任何非常量操作。

如果 const 版本调用非常量版本，则不会得到 (2)。如果非常量版本调用 const 版本并 const_casts 结果，则不会得到 (1)。例如，假设 Bar 实际上是 char，并且您编写的代码最终返回（在某些情况下）字符串文字。这将编译（并且 -Wwrite-strings 不会给出警告），但您的调用者最终会得到一个指向字符串文字的非常量指针。这与“您更喜欢编译器检查的常量正确性”相矛盾。

如果它们都调用辅助成员函数 Bar *getBar() const，那么您将同时得到 (1) 和 (2)。但是，如果可以编写该辅助函数，那么当修改从 const Foo 返回的 Bar 完全没问题时，为什么要首先搞乱 const 和非 const 版本呢？有时，实现的某些细节可能意味着您正在实现具有两个访问器的接口，即使您只需要一个。否则，要么无法编写帮助程序，要么这两个函数只能由单个帮助程序替换。

只要代码大小不是问题，我认为实现 (1) 和 (2) 的最佳方法是让编译器实际考虑这两种情况：

struct Bar { int a; };
struct Foo {
          Bar *bar()       { return getBar<Bar>(this); }
    const Bar *bar() const { return getBar<const Bar>(this); }

    Bar *bar2() const { return getBar<Bar>(this); } // doesn't compile. Good.
    Bar *bar3() const { return getBar<const Bar>(this); } // likewise

    private:
    template <typename B, typename F>
    static B *getBar(F *self) {
        // non-trivial code, which can safely call other functions with 
        // const/non-const overloads, and we don't have to manually figure out
        // whether it's safe to const_cast the result.
        return &self->myBar;
    }
    Bar myBar;
};

如果代码很简单，例如 operator[]< /code> 它访问对象拥有的一些数组，然后我只需复制代码。在某些时候，上面的函数模板比​​重复的编码工作量要少，此时就使用模板。

我认为 const_cast 方法虽然聪明且看似标准，但没有帮助，因为它选择简洁而不是编译器检查的 const 正确性。如果方法中的代码很简单，那么您可以复制它。如果它不是微不足道的，那么您或代码维护人员就很难看到 const_cast 实际上是有效的。

Answer 9

您的代码意味着 const bar() 实际上正在创建并返回一个新的 Bar，如果您做了那么多，我发现这很奇怪。

对我来说，一个更大的问题是成员函数中的常量仅限于引用和非指针成员。当您拥有（非常量）指针成员时，const 函数可以更改它们，即使它在盒子上声明为 const。

如果您的 Bar 实例是成员变量，请考虑返回引用。

Answer 10

Bar 的常量会影响 Foo 的常量吗？或者您这样做只是因为无法区分 const Bar* 与 Bar* 版本？如果是后一种情况，我只需一个返回 Bar* 的 bar() 即可完成它。毕竟，无论如何，接受 const Bar* 的东西也可以接受 Bar* 。不要忘记， bar() 方法的常量性是关于 Foo 的，而不是关于 Bar 的。

另外，如果您同时提供 const 和非 const Bar* 并且很高兴让 Foo 成为非 const，无论愿意与否，那么 Foo 的常量性（以及 bar() 方法）显然不是那么重要，您只需填写 const 和非 const 版本即可。在这种情况下，如果您允许非常量版本，再次只提供/仅/该版本，const 的消费者会很乐意接受非常量。只是，你在那里使用 const 和非常量的方式，看起来对程序没有太大影响。

如果您希望 const Foo 对象能够返回 const 和非常量 Bar，那么只需将 bar() 设置为 const 并返回一个非常量 Bar 即可。

我不知道，我必须看到更多才能给出真正的答案。

但请仔细考虑一下，哪些常量是真正相关的，以及您的程序是否需要 const Foos 和非 const Foos。无论愿意与否，都允许所有可能性，看起来您还没有考虑清楚该程序需要什么。

Answer 11

一张图胜过一万字，所以：

const Item*
Storage::SearchItemBySomething( const Something &something ) const
{
    const Item* pData = NULL;

    // Algorythm for searching.

    return pData;
}

Item*
Storage::SearchItemBySomething( const Something &something )
{
    return (Item*) ((const Storage*)this)->_SearchItemBySomething(something);
}

从实际代码复制并更改。一般的想法是，您实现 const 方法，然后编写使用第一个方法的非 const 方法。您需要将“this”指针转换为“const”，并且需要从返回的“const Item*”中丢弃“const”。

您可以将 C 样式转换替换为 C++ 样式转换

• static_cast( ... )
• const_cast(this)