错误：在函数返回类型中推导出类类型“元组”答案

【问题标题】：error: deduced class type 'tuple' in function return type错误：在函数返回类型中推导出类类型“元组”
【发布时间】：2021-03-07 23:56:56
【问题描述】：

我在做什么

我在 3 年后开始练习 C++。我需要快速广泛地学习，所以我试图解决的这个例子对你来说可能看起来很奇怪。

我正在使用c++20、gcc 10.2。

我想做一个 pythonic 枚举函数

接受任何container<T>
产量std::tuple<int, T>
T 是容器中项目的类型

我想尝试应用 pythonic range 作为 enumerate which 的参数

接受(int start, int end, int step)
产量int i 从start 到end 每step

范围（不是我的代码，我只添加了step 功能）

template <typename T>
class range_iterator;

template <typename T>
class range_impl
{
    const T start_;
    const T stop_;
    const T step_;

public:
    range_impl(T start, T stop, T step) : start_{start}, stop_{stop}, step_{step} {};
    range_impl(T start, T stop) : start_{start}, stop_{stop}, step_{1} {};
    range_impl(T stop) : start_{0}, stop_{stop}, step_{1} {};

    range_iterator<T> begin() const
    {
        return range_iterator<T>{start_, step_};
    }

    range_iterator<T> end() const
    {
        return range_iterator<T>{stop_, step_};
    }
};

template <typename T>
class range_iterator
{
    T current_;
    const T step_;

public:
    range_iterator(T init, T step) : current_{init}, step_{step} {};

    range_iterator<T> &operator++()
    {
        current_ += step_;
        return *this;
    }

    bool operator!=(const range_iterator<T> &rhs) const
    {
        return current_ != rhs.current_;
    }

    T operator*() const
    {
        return current_;
    }
};

template <typename T>
range_impl<T> range(const T start, const T stop, const T step)
{
    return range_impl<T>(start, stop, step);
}

template <typename T>
range_impl<T> range(const T start, const T stop)
{
    return range_impl<T>(start, stop);
}

template <typename T>
range_impl<T> range(const T stop)
{
    return range_impl<T>(stop);
}

可以像下面这样使用

#include <iostream>
int main()
{
    for(auto i: range(0, 100 2)
    {
        std::cout << i << std::endl;
    }
}

问题代码：枚举

template <typename T>
class enumerate_iterator;

// Here, T should be a type of a container that contains type X 
template <typename T>
class enumerate_impl
{
    T impl;

public:
    enumerate_impl<T>(T impl) : impl{impl} {/* empty */};

    enumerate_iterator begin() const
    {
        return enumerate_iterator{impl.begin()};
    }

    enumerate_iterator end() const
    {
        return enumerate_iterator{impl.end()};
    }
};


// Here, T should be a type of a iterator, I think. Confused myself.
template <typename T>
class enumerate_iterator
{

    T iterator;
    int i;

public:
    enumerate_iterator(T iterator) : iterator{iterator}, i{0} {/* empty body */};

    enumerate_iterator<T> &operator++()
    {
        i++;
        iterator++;
        return *this;
    }

    bool operator!=(const enumerate_iterator<T> &rhs) const
    {
        return iterator != rhs.iterator;
    }

    std::tuple operator*() const
    {
        return {i, *iterator};
    }
};

template <typename T>
enumerate_impl<T> enumerate(T impl)
{
    return enumerate_impl<T>{impl};
}

预期用途

#include <iostream>
int main()
{
    for (auto &[i, j] : enumerate(range(0, 100, 2)))
    {
        std::cout << i << " " << j << std::endl;
    }
}

遇到错误（实际上有很多编译错误，但我想在其他方面尝试更多）。

utility.cpp:186:20: error: deduced class type 'tuple' in function return type
  186 |         std::tuple operator*() const

我猜这是在抱怨you didn't tell me what type the tuple contains。但问题是，我不知道T iterator 包含什么类型。我怎么告诉return type is std::tuple<int, type T contains>？

感谢您阅读这个冗长的问题。

【问题讨论】：

"不是我的代码" 那是糟糕的代码。它甚至不是一个有效的 C++ 范围。如果您实际上不能将迭代器与任何东西一起使用，那么拥有迭代器是没有意义的。

标签： c++ tuples c++20

【解决方案1】：

我认为，对于enumerate_iterator，您可能希望其模板类型T 成为“基本元素类型”，而不是某种复合“迭代类型”。

例如，如果您选择使用原始内存指针实现迭代，则 enumerate_iterator 的名为 iterator 的数据成员将具有类型 T*（而不是其当前的 T 类型）。

然后，在这种情况下，operator*() 的定义将被编程为返回类型为 std::tuple<int,T>

【讨论】：