内部模板化 class c++

Question

我正在尝试使用我的 C++ class 进行这个小练习，并且从现在开始我已经设法做到了。

它还没有完全完成，但现在我面临着内部模板的永恒问题class。

我在堆栈和其他网站上看到了很多不同的解决方案，但仍然缺少一些东西。 + 我最后的目标也是理解 "why".

这是一个迭代器内部 class 需要迭代到我的数组。我已经看到一些示例为外部和外部 class 提供了 2 个不同的类型名称，然后使用 typedef，但我不确定实现它的最佳方法是什么。

如您所见，我的迭代器 class 需要采用与我的数组 class.

相同的类型

我肯定需要更改一些函数签名并在各处添加一些 <\T>，但现在我只需要避免所有模板陷阱。

using namespace std;

template <typename T>
class Iterator;

template<typename T>
class Array{

    T* _data;
    size_t _size;
    Iterator* _start;

public:

    class Iterator{
        T* content;

    public:
        explicit Iterator(T* value):content(value){}

        Iterator& operator++(){
            ++content;
            return *this;
        }

        T* operator*(){
            return content;
        }

        bool operator ==(const Iterator& o)const{
            if(content == o.content){
                return true;
            }
            return false;
        }

        bool operator !=(const Iterator& o)const{
            return !(*this == o);
        }
    };


    Array(const size_t s):_size(s){
        _data = new T[_size]();
        _start = new Iterator(_data);
    }

    Array(const Array& o):_size(o._size), _data(o._data), _start(o._start){}

    Array(const std::initializer_list<T>& list):_size(list.size()){
        auto start = list.begin();
        auto fin = list.end();

        _data = new T[_size];

        size_t index = 0;
        while(start != fin){
        _data[index++] = *start++;
        }

        _start = new Iterator(_data);
    }

    virtual ~Array(){
        cout << "~Array" << endl;
        delete[] _data;
    }

    Array<T>& operator= (const Array& o){
        if(this != &o){
            delete[] _data;

            for (size_t i = 0; i < o._size; ++i) {
                _data[i] = o._data[i];
            }
            _size = o._size;
        }

        return *this;
    }

    T& operator[](const size_t index){
        if(index < _size){
            return *_data[index];
        }
    }

    const size_t size()const{
        return _size;
    }

    Iterator begin(){
        return Iterator(_data[0]);
    }

    Iterator end(){
        return Iterator(_data[_size-1]);
    }

};

你能给我一个线索或帮助我解决这个问题吗？

这里是我的基本主线：

#include "Array.h"

int main() {

    Array<string> array({"h","e","l","l","o"});

    for (Array<string>::Iterator i = array.begin(); i != array.end(); ++i)
        cout << *i << endl;

    return 0;
}

谢谢！

Answer 1

全局范围内没有模板Iterator，所以这是错误的：

template <typename T>
class Iterator;

此外，Array<T>::Iterator 不是模板，它只是一个内部 class。您可以像这样在 class 中简单地转发声明它：

template<typename T>
class Array {
public:
    class Iterator;

然后你的代码中有一些错误（例如 end() 应该是最后一个元素之后的 1，你需要两次取消引用迭代器并从指针构造一个）。

这是一个固定版本：

#include <iostream>
#include <string>

using namespace std;

template<typename T>
class Array {

    T* _data;
    size_t _size;
public:
    class Iterator;
private:
    Iterator* _start;

public:

    class Iterator {
        T* content;

    public:
        explicit Iterator(T* value) :content(value) {}

        Iterator& operator++() {
            ++content;
            return *this;
        }

        T* operator*() {
            return content;
        }

        bool operator ==(const Iterator& o)const {
            if (content == o.content) {
                return true;
            }
            return false;
        }

        bool operator !=(const Iterator& o)const {
            return !(*this == o);
        }
    };


    Array(const size_t s) :_size(s) {
        _data = new T[_size]();
        _start = new Iterator(_data);
    }

    Array(const Array& o) :_size(o._size), _data(o._data), _start(o._start) {}

    Array(const std::initializer_list<T>& list) :_size(list.size()) {
        auto start = list.begin();
        auto fin = list.end();

        _data = new T[_size];

        size_t index = 0;
        while (start != fin) {
            _data[index++] = *start++;
        }

        _start = new Iterator(_data);
    }

    virtual ~Array() {
        cout << "~Array" << endl;
        delete[] _data;
    }

    Array<T>& operator= (const Array& o) {
        if (this != &o) {
            delete[] _data;

            for (size_t i = 0; i < o._size; ++i) {
                _data[i] = o._data[i];
            }
            _size = o._size;
        }

        return *this;
    }

    T& operator[](const size_t index) {
        if (index < _size) {
            return *_data[index];
        }
    }

    const size_t size()const {
        return _size;
    }

    Iterator begin() {
        return _start;
    }

    Iterator end() {
        return Iterator(_data + _size);
    }

};

int main() {
    Array<string> array({ "h","e","l","l","o" });

    for (Array<string>::Iterator i = array.begin(); i != array.end(); ++i)
        cout << **i << endl;
}

Answer 2

感谢@rustyx 的帮助，离它不远，但真的谢谢你。

我将post我更正后的工作代码放在这里，以防它能帮助到其他人。

#include <cstdlib>
#include <string>
#include <iostream>

using namespace std;


template<typename T>
class Array{

T* _data;
size_t _size;

public:

    class Iterator{
        T* content;

    public:
        explicit Iterator(T* value):content(value){}

        Iterator& operator++(){
            ++content;
            return *this;
        }

        T& operator*(){
            return *content;
        }

        bool operator ==(const Iterator& o)const{
            if(content == o.content){
                return true;
            }
            return false;
        }

        bool operator !=(const Iterator& o)const{
            return !(*this == o);
        }
    };


Array(const size_t s):_size(s){
    _data = new T[_size]();
}

Array(const Array& o):_size(o._size){
    _data = new T[_size];
    for (size_t i = 0; i < o._size; ++i) {
        _data[i] = o._data[i];
    }
}

Array(const std::initializer_list<T>& list):_size(list.size()){
    auto start = list.begin();
    auto fin = list.end();

    _data = new T[_size];

    size_t index = 0;
    while(start != fin){
        _data[index++] = *start++;
    }

}

virtual ~Array(){
    cout << "~Array" << endl;
    delete[] _data;
}

Array<T>& operator= (const Array& o){
    if(this != &o){
        delete[] _data;

        for (size_t i = 0; i < o._size; ++i) {
            _data[i] = o._data[i];
        }
        _size = o._size;
    }

    return *this;
}

T& operator[](const size_t index){
    if(index < _size){
        return *_data[index];
    }
}

const size_t size()const{
    return _size;
}

Iterator begin(){
    return Iterator(_data);
}

Iterator end(){
    return Iterator(_data + _size);
}

};

内部模板化 class c++

Internal templated class c++

c++

templates

nested

class

internal