Question

好的，我做了一些研究，显然在这个主题上有很多关于SO的重复问题，仅举几例：

等。但我不禁再次提出这个问题，因为

使用c++14 auto - 类型的返回值，我实际上是复制函数体，唯一的区别是const函数限定符。
const版本和非const版本可能会返回彼此完全不兼容的类型。在这种情况下，Scott Meyers的const_cast成语和“私有const函数返回非const”技术都不会起作用。

举个例子：

struct A {
    std::vector<int> examples;
    auto get() { return examples.begin(); }
    auto get() const { return examples.begin(); }
};  // Do I really have to duplicate?
    // My real-world code is much longer
    // and there are a lot of such get()'s

在这种特殊情况下，auto get()会返回iterator而auto get() const会返回const_iterator，而这两者无法相互转换（我知道{{1}在这种情况下，诀窍进行转换，但这不是重点。 erase(it,it)因此不起作用;即使它有效，也需要程序员手动推断const_cast类型，完全违背使用auto的目的。

除了宏之外，真的没办法吗？

Answer 1

好的，所以在经过一些修补之后，我想出了以下两个解决方案，它们允许你保持自动返回类型并且只实现一次getter。它使用了迈耶所做的相反的演员。

C ++ 11/14

此版本只返回已实现函数中的两个版本，或者使用cbegin()，或者如果您没有为您的类型添加该版本，则此版本可以替代cbegin()：{{1基本上转换为常量并使用普通return static_cast<const A&>(*this).examples.begin();函数来获取常量函数。

begin()

C ++ 17 - 替代if constexpr

这个应该更好，因为它只返回一个值，并且在编译时知道获得了哪个值，因此// Return both, and grab the required one struct A { private: // This function does the actual getter work, hiding the template details // from the public interface, and allowing the use of auto as a return type auto get_do_work() { // Your getter logic etc. // ... // ... // Return both versions, but have the other functions extract the required one return std::make_pair(examples.begin(), examples.cbegin()); } public: std::vector<int> examples{ 0, 1, 2, 3, 4, 5 }; // You'll get a regular iterator from the .first auto get() { return get_do_work().first; } // This will get a const iterator auto get() const { // Force using the non-const to get a const version here // Basically the inverse of Meyer's casting. Then just get // the const version of the type and return it return const_cast<A&>(*this).get_do_work().second; } };将知道该怎么做。否则，auto函数的工作方式基本相同。

get()

这可能适用于您的自定义类型，也可能不适用，但它对我有用，并且它解决了代码重复的需要，尽管它使用了辅助函数。但反过来，实际的吸气剂变成了单线，所以这应该是合理的。

以下主要功能用于测试两种解决方案，并按预期工作：

// With if constexpr
struct A
{
private:
    // This function does the actual getter work, hiding the template details
    // from the public interface, and allowing the use of auto as a return type
    template<bool asConst>
    auto get_do_work()
    {
        // Your getter logic etc.
        // ...
        // ...

        if constexpr (asConst)
        {
            return examples.cbegin();

            // Alternatively
            // return static_cast<const A&>(*this).examples.begin();
        }
        else
        {
            return examples.begin();
        }
    }

public:
    std::vector<int> examples{ 0, 1, 2, 3, 4, 5 };

    // Nothing special here, you'll get a regular iterator
    auto get()
    {
        return get_do_work<false>();
    }

    // This will get a const iterator
    auto get() const
    {
        // Force using the non-const to get a const version here
        // Basically the inverse of Meyer's casting, except you get a
        // const_iterator as a result, so no logical difference to users
        return const_cast<A&>(*this).get_do_work<true>();
    }
};

Answer 2

只是一个假设的解决方案，我正在考虑在我们有概念时应用每个地方：使用无朋友功能代替成员函数。

//Forwarding ref concept
template<class T,class U>
concept FRef = std::is_same_v<std::decay_t<T>,std::decay_t<U>>;

struct A{
  std::vector<int> examples;

  friend decltype(auto) get(FRef{T,A}&& aA){
    return std::forward<T>(aA).examples.begin();
      //the std::forward is actualy not necessary here 
      //because there are no overload value reference overload of begin.
    }
  };

Answer 3

struct A {
    std::vector<int> examples;

private:
    template <typename ThisType>
    static auto
    get_tmpl(ThisType& t) { return t.examples.begin(); }

public:
    auto get()       { return get_tmpl(*this); }
    auto get() const { return get_tmpl(*this); }
};

以上情况如何？是的，您仍然需要声明两个方法，但是逻辑可以包含在单个静态模板方法中。通过为返回类型添加模板参数，即使在C ++ 11之前的代码中也可以使用。

避免使用auto关键字复制const和非const的代码？

3 个答案:

C ++ 11/14

C ++ 17 - 替代if constexpr