在C++中实现带static_cast的begin/end迭代器遇编译错误求助

错误原因分析 #

你当前的begin()/end()/data()函数存在两个核心问题：

1. 类型逻辑错误：master.begin()返回的是std::array<Wrapper*, N>::iterator迭代器对象，而非指针类型。你试图将其强制转换为T**再返回T*，完全违背了迭代器的设计逻辑。
2. 不安全的指针转换：即使master.data()返回的Wrapper**，也不能直接转换为T**——父类指针的指针与子类指针的指针属于不兼容类型，强制转换会导致未定义行为，且不符合范围for循环对迭代器的要求（迭代器解引用需返回T*）。

解决方案 #

方案一：自定义迭代器（兼容C++11及以上） #

实现一个包装原数组迭代器的自定义迭代器，在解引用时自动完成Wrapper*到T*的转换，满足范围for循环的迭代器要求：

#include <array>
#include <iterator>

struct Wrapper
{
    int var1 = 0;
};

struct WrapperBig: public Wrapper
{
    int var2 = 0;
};

template <class T, int N>
class ArrayCasted final
{
public:
    // 自定义随机访问迭代器
    class Iterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = T*;
        using difference_type = std::ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;

        explicit Iterator(typename std::array<Wrapper*, N>::iterator it) : m_it(it) {}

        // 解引用时完成类型转换
        value_type operator*() const { return static_cast<T*>(*m_it); }
        value_type operator->() const { return static_cast<T*>(*m_it); }

        // 迭代器操作符重载
        Iterator& operator++() { ++m_it; return *this; }
        Iterator operator++(int) { auto temp = *this; ++m_it; return temp; }
        Iterator& operator--() { --m_it; return *this; }
        Iterator operator--(int) { auto temp = *this; --m_it; return temp; }

        Iterator operator+(difference_type n) const { return Iterator(m_it + n); }
        Iterator operator-(difference_type n) const { return Iterator(m_it - n); }
        difference_type operator-(const Iterator& other) const { return m_it - other.m_it; }
        Iterator& operator+=(difference_type n) { m_it += n; return *this; }
        Iterator& operator-=(difference_type n) { m_it -= n; return *this; }

        // 比较操作符
        bool operator==(const Iterator& other) const { return m_it == other.m_it; }
        bool operator!=(const Iterator& other) const { return m_it != other.m_it; }
        bool operator<(const Iterator& other) const { return m_it < other.m_it; }
        bool operator>(const Iterator& other) const { return m_it > other.m_it; }
        bool operator<=(const Iterator& other) const { return m_it <= other.m_it; }
        bool operator>=(const Iterator& other) const { return m_it >= other.m_it; }

    private:
        typename std::array<Wrapper*, N>::iterator m_it;
    };

    // 常量迭代器
    class ConstIterator
    {
    public:
        using iterator_category = std::random_access_iterator_tag;
        using value_type = const T*;
        using difference_type = std::ptrdiff_t;
        using pointer = value_type*;
        using reference = value_type&;

        explicit ConstIterator(typename std::array<Wrapper*, N>::const_iterator it) : m_it(it) {}

        value_type operator*() const { return static_cast<const T*>(*m_it); }
        value_type operator->() const { return static_cast<const T*>(*m_it); }

        ConstIterator& operator++() { ++m_it; return *this; }
        ConstIterator operator++(int) { auto temp = *this; ++m_it; return temp; }
        ConstIterator& operator--() { --m_it; return *this; }
        ConstIterator operator--(int) { auto temp = *this; --m_it; return temp; }

        ConstIterator operator+(difference_type n) const { return ConstIterator(m_it + n); }
        ConstIterator operator-(difference_type n) const { return ConstIterator(m_it - n); }
        difference_type operator-(const ConstIterator& other) const { return m_it - other.m_it; }
        ConstIterator& operator+=(difference_type n) { m_it += n; return *this; }
        ConstIterator& operator-=(difference_type n) { m_it -= n; return *this; }

        bool operator==(const ConstIterator& other) const { return m_it == other.m_it; }
        bool operator!=(const ConstIterator& other) const { return m_it != other.m_it; }
        bool operator<(const ConstIterator& other) const { return m_it < other.m_it; }
        bool operator>(const ConstIterator& other) const { return m_it > other.m_it; }
        bool operator<=(const ConstIterator& other) const { return m_it <= other.m_it; }
        bool operator>=(const ConstIterator& other) const { return m_it >= other.m_it; }

    private:
        typename std::array<Wrapper*, N>::const_iterator m_it;
    };

    explicit ArrayCasted(std::array<Wrapper*, N>& p) : master(p) {}

    int size() const { return static_cast<int>(master.size()); }
    T* operator[](int index) { return static_cast<T*>(master[index]); }
    const T* operator[](int index) const { return static_cast<const T*>(master[index]); }

    // 返回自定义迭代器
    Iterator begin() noexcept { return Iterator(master.begin()); }
    Iterator end() noexcept { return Iterator(master.end()); }
    ConstIterator begin() const noexcept { return ConstIterator(master.begin()); }
    ConstIterator end() const noexcept { return ConstIterator(master.end()); }
    ConstIterator cbegin() const noexcept { return ConstIterator(master.cbegin()); }
    ConstIterator cend() const noexcept { return ConstIterator(master.cend()); }

private:
    std::array<Wrapper*, N>& master;
};

// 测试代码
int main()
{
    Wrapper* w1 = new Wrapper();
    std::array<Wrapper*, 2> values {w1, w1};

    ArrayCasted<WrapperBig, 2> casted {values};

    // 传统for循环正常运行
    for (int i=0; i<casted.size(); ++i)
    {
        WrapperBig* current = casted[i];
        current->var2 = -1;
    }

    // 范围for循环现在可以正常编译运行
    for (WrapperBig* current : casted)
    {
        current->var2 = -1;
    }

    delete w1;
    return 0;
}

方案二：C++20范围视图（代码更简洁） #

如果你的项目支持C++20，可以利用std::views::transform直接生成转换后的视图，无需手动实现迭代器：

#include <array>
#include <ranges>

struct Wrapper
{
    int var1 = 0;
};

struct WrapperBig: public Wrapper
{
    int var2 = 0;
};

template <class T, int N>
class ArrayCasted final
{
public:
    explicit ArrayCasted(std::array<Wrapper*, N>& p) : master(p) {}

    int size() const { return static_cast<int>(master.size()); }
    T* operator[](int index) { return static_cast<T*>(master[index]); }
    const T* operator[](int index) const { return static_cast<const T*>(master[index]); }

    // 利用transform视图自动转换类型
    auto begin() noexcept { 
        return master | std::views::transform([](Wrapper* ptr) { 
            return static_cast<T*>(ptr); 
        }) | std::views::begin; 
    }
    auto end() noexcept { 
        return master | std::views::transform([](Wrapper* ptr) { 
            return static_cast<T*>(ptr); 
        }) | std::views::end; 
    }
    auto begin() const noexcept { 
        return master | std::views::transform([](const Wrapper* ptr) { 
            return static_cast<const T*>(ptr); 
        }) | std::views::begin; 
    }
    auto end() const noexcept { 
        return master | std::views::transform([](const Wrapper* ptr) { 
            return static_cast<const T*>(ptr); 
        }) | std::views::end; 
    }

private:
    std::array<Wrapper*, N>& master;
};

注意：VS2019需要开启/std:c++20编译选项才能支持此方案。

关键说明 #

• 避免直接转换指针的指针（如Wrapper**→T**），这种转换属于不安全的类型转换，会导致未定义行为。
• 自定义迭代器方案兼容所有C11及以上编译器，适合需要兼容性的场景；C20视图方案代码更简洁，适合现代C++项目。

内容的提问来源于stack exchange，提问作者Juan JuezSarmiento