C++ 无法在初始化时将 Student* 转换为 DYNVECTOR<Student,24>::Node*

Question

我正在尝试为我已经实现的动态向量 class 创建一个迭代器，

问题是，当我尝试初始化一些学生 class 进行测试时，我不断收到此错误在迭代器的某些赋值上的目的，我无法弄清楚为什么我有这个错误浪费了很多时间在它上面而且不可能弄清楚为什么会发生这个错误..

这是代码

some edit

这是我尝试使用的主要函数，它从我的 class

中获取迭代器

some edit

就在 DYNVECTOR class 的 intiliaze 中，主要是我的代码失败了，我继续得到错误：

错误：无法在初始化中将 'Student*' 转换为 'DYNVECTOR <Student, 24>::Node*' Iter(T *N) : _pointer(N) { }

编辑：请大家关注这部分： inputIterator begin() { return inputIterator(pa);} 这就是导致错误的原因，推回功能和其他功能的功能仍在进行中，但这不是导致此错误的原因。

Answer 1

首先，当你处理对象时，这样做是不好的做法：

DYNVECTOR<Student, 24> students;

应该是：

DYNVECTOR<Student*, 24> students;

其次，您从未为 DYNVECTOR 创建构造函数，您希望如何创建对象？？

Answer 2

问题

inputIterator begin() { return inputIterator(pa);}

正在调用 inputIterator 的构造函数

Iter(T *N ) : _pointer(N) { }

带有指向T、T *的指针。 Iter 很高兴接受 T *，但它试图将 T * 存储到 _pointer 中，而 _pointer 被定义为

Node *_pointer;

这不是 T *。分配失败，因为类型不匹配。

天真的解决方案

使类型匹配。这意味着您必须传入 Node *。坏消息：DYNARRAY 没有任何 Node * 可以提供。天真的解决方案失败了。

正确的解决方案

扔掉Node。如果你有一个链表，Node 很有用。你没有链表。杀死它。让它死掉。收拾残局。

class DYNVECTOR
{
    // no nodes
    class Iter // directly uses T pointers
    {
    public:
        Iter(T *N) :
                _pointer(N) // types match now        
        {
        }
        T& operator*() const
        {
            return *_pointer; // simpler without Node, no?
        }
        T* operator->() const
        {
            return _pointer; // simple
        }
        Iter& operator++()
        {
            _pointer++; // dead simple
            return *this;
        }
        Iter operator++(int)
        {
            Iter tmp = *this; 
            _pointer++; // yawn-city
            return tmp;
        }
        bool operator==(Iter const &rhs) const
        {
            return _pointer == rhs._pointer; // unchanged
        }
        bool operator!=(Iter const &rhs) const
        {
            return _pointer != rhs._pointer; // unchanged
        }
    private:
        T *_pointer; // T *, not Node *

    };
private:
    size_t someCap, length; //, initCap; don't see the point of initCap
    T *pa; // unchanged
public:
    typedef Iter inputIterator;
    DYNVECTOR():
        someCap(Capacity), // Still not sure what Capacity is for, so I used
                           // it here instead of magic number 24
        length(0),
        pa(new T[someCap])
    {
        // used initializer list instead.
    }

    inputIterator begin()
    {
        return inputIterator(pa); // unchanged
    }
    inputIterator end()
    {
        return inputIterator(&pa[length]);  // iterator to one past the end.
                                            // just like std::vector
    }
    template<class Iter>
    DYNVECTOR(const Iter &begin, const Iter &end): // far more versatile if const references
        DYNVECTOR() // delegate basic set-up to default constructor
    {
        for (Iter pointer = begin; pointer != end; pointer++) // loop unchanged
        {
            push_back(*pointer);
        }
    }
    // make uncopyable (for now anyway) See Rule of Three 
    // linked below for why
    DYNVECTOR(const DYNVECTOR & ) = delete;
    DYNVECTOR& operator=(const DYNVECTOR & ) = delete;
    
    ~DYNVECTOR() // for my own testing. left as example
    {
        delete[] pa; // clean up allocated storage
    }
    
    void push_back(const T & newb) // for my own testing. left as example
    {
        if (length == someCap) // need more space
        {
            int newCap = someCap * 2; // double the size
            // you might need to do something different like 
            // int newCap = someCap + Capacity;
            // There's no way for me to know. 
            // The rest should be right though.
            T* newArr = new T[newCap]; // allocate bigger array
            for (size_t index = 0; index < length; index++)
            { // copy old array into new
                newArr[index] = pa[index];
            }
            delete[] pa; // discard old array
            pa = newArr; // use new array
            someCap = newCap; // update capacity
        }
        pa[length] = newb; // insert new item
        length++; // update counter
    }
};

Documentation on the Rule of Three and friends。除非您了解这些规则，否则您无法编写复杂而高效的 C++。学习它们或让自己成为黑客。

C++ 无法在初始化时将 Student* 转换为 DYNVECTOR<Student,24>::Node*

C++ cannot convert Student* to DYNVECTOR<Student,24>::Node* in initialization

c++

vector

dynamic

dynamic-arrays

问题

天真的解决方案

正确的解决方案