内部模板化类 c++

Internal templated class c++

本文关键字：c++ 内部      更新时间：2023-10-16

我正在尝试我的 c++ 课程中的这个小练习，从现在开始我设法做到了这一点。

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

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

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

如您所知，我的迭代器类需要采用与我的 Array 类相同的类型。

我肯定需要更改一些函数签名并在此处和那里添加一些 <\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;
}

谢谢！

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

template <typename T>
class Iterator;

此外，Array<T>::Iterator不是模板，它只是一个内部类。您可以简单地在类中向前声明它，如下所示：

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;
}

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

我将在此处发布我更正和工作的代码，以防它可以帮助其他人。

#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);
}
};
相关文章：