C++ 为什么可以'；我不能分拣这个集装箱吗？

请不要介意没有插入fnc，数据是硬编码的。它的主要目的是为这个容器正确地实现迭代器

//file Set.h
#pragma once

template<class T>
class Set
{
    template<class T>
    friend ostream& operator<<(ostream& out, const Set<T>& obj);
private:
    T** myData_;
    std::size_t mySize_;
    std::size_t myIndex_;
public:

    Set();
    class iterator : public std::iterator<std::random_access_iterator_tag, T*>
    {
    private:

        T** itData_;

    public:

        iterator(T** obj)
        {
            itData_ = obj;

        }

        T operator*() const
        {
            return **itData_;
        }
        /*Comparing values of two iterators*/
        bool operator<(const iterator& obj)
        {
            return **itData_ < **obj.itData_;
        }

        /*Substracting two iterators*/
        difference_type operator-(const iterator& obj)
        {
            return itData_ - obj.itData_;
        }

        /*Moving iterator backward for value*/
        iterator operator-(const int value)
        {
            return itData_ - value;
        }

        /*Adding two iterators*/
        difference_type operator+(const iterator& obj)
        {
            return itData_ + obj.itData_;
        }

        /*Moving iterator forward for value*/
        iterator operator+(const int value)
        {
            return itData_ + value;
        }

        bool operator!=(const iterator& obj)
        {
            return (itData_ != obj.itData_);
        }

        bool operator==(const iterator& obj)
        {
            return (itData_ == obj.itData_);
        }

        T** operator++()
        {
            return ++itData_;
        }

        T** operator--()
        {
            return --itData_;
        }
    };

    iterator begin() const
    {
        return myData_;
    }

    iterator end() const
    {
        return myData_ + myIndex_;
    }
};

template<class T>
ostream& operator<<(ostream& out, const Set<T>& obj)
{
    for (int i = 0;i < 3; ++i)
    {
        out << *obj.myData_[i] << "\n";
    }
    return out;
}

//file Set_impl.h
#pragma once
#include "stdafx.h"
#include "Set.h"

template<class T>
Set<T>::Set()
{
    mySize_ = 3;
    myIndex_ = 3;
    myData_ = new T*[mySize_];
    myData_[0] = new T(3);
    myData_[1] = new T(1);
    myData_[2] = new T(2);
}

//main
include "stdafx.h"
#include "Set_impl.h"

int _tmain(int argc, _TCHAR* argv[])
{
    Set<int> a;
    Set<int>::iterator beg_ = a.begin();
    Set<int>::iterator end_ = a.end();
    std::sort(beg_,end_);//WONT SORT THIS RANGE
    cin.get();
    return 0;
}

//文件集.h
#布拉格语一次
样板
类集
{
样板
friend ostream&operator不幸的是，您的代码完全是一团糟

禁止其编译的原因可能是：

class iterator : public std::iterator<std::random_access_iterator_tag, T*>

我可以通过将这些更改为：

class iterator : public std::iterator<std::random_access_iterator_tag, T>

（除了许多其他变化，因为GCC似乎不太喜欢这一点）


它们应该返回一个对迭代器本身的引用（同样，返回值很可能没有被库使用）。
不幸的是，您的代码是一团乱麻

禁止其编译的原因可能是：

class iterator : public std::iterator<std::random_access_iterator_tag, T*>

我可以通过将这些更改为：

class iterator : public std::iterator<std::random_access_iterator_tag, T>

（除了许多其他变化，因为GCC似乎不太喜欢这一点）


它们应该返回对迭代器本身的引用（同样，返回值很可能未被库使用）。
这不是一个完整的答案，因此我将其作为注释：迭代器的运算符*应该返回集合的引用类型，而不是值。否则，现在可以使用sort（）修改迭代器的值“指向”。@Eric在您建议的更改后，我只得到一个错误：错误5错误C2440:“返回”：无法从“double”转换为“double&”，知道原因吗？这不是一个完整的答案，所以我将其作为注释保留：迭代器的运算符*应该返回集合的引用类型，而不是值。否则，现在就可以使用sort（）了若要修改迭代器“指向”的值。@Eric在您建议的更改后，我只得到一个错误：错误5错误C2440:“返回”：无法从“double”转换为“double&”，知道原因吗？@buff但T**operator++和operator--它们确实返回对自身的引用。这将是：
迭代器和operator++（）{++itData_u;返回*this；}“< /代码> @叔叔，但结果是相同的，只是没有转换，所以我不知道它是否更好地指定您提出的方式，但我只是不要求争论。不，将有隐式转换的方式，你这样做。考虑用法：<代码>迭代器A，B；A= ++B；<代码> +++< /代码>返回<代码> T** < /代码>，然后它m在将其分配给<代码> < < /代码>之前，首先将其隐式转换回<代码>迭代器< /代码>。（此外，在中间，您将内部实现细节泄露给外部世界。）那太糟糕了。我可以很容易地将它编译并输出1、2、3。-恐怕需要一个通灵师才能知道现在可能出了什么问题。也许可以问另一个问题？（对于迭代修复编码错误来说有点糟糕，像这样的论坛可能更合适。）@但是T**operator++和operator--它们确实返回对自身的引用。这将是：
iterator&operator++（）{++itData_uu; return*this；}“< /代码> @叔叔，但结果是相同的，只是没有转换，所以我不知道它是否更好地指定您提出的方式，但我只是不要求争论。不，将有隐式转换的方式，你这样做。考虑用法：<代码>迭代器A，B；A= ++B；<代码> +++< /代码>返回<代码> T** < /代码>，然后它m在将其分配给<代码> < < /代码>之前，首先将其隐式转换回<代码>迭代器< /代码>。（此外，在中间，您将内部实现细节泄露给外部世界。）那太糟糕了。我可以很容易地将它编译并输出1、2、3。-恐怕需要一个通灵师才能知道现在可能出了什么问题。也许可以问另一个问题？（对于迭代修复编码错误来说有点糟糕，像这样的论坛可能更合适。）
    /*Comparing values of two iterators*/
    bool operator<(const iterator& obj)
    {
        return **itData_ < **obj.itData_;
    }

    T** operator++()
    {
        return ++itData_;
    }

    T** operator--()
    {
        return --itData_;
    }