как можно реализовать перегрузку ввода/вывода для массива в шаблонном классе?

Question

Нужно написать шаблонный класс для взаимодействия с динамическими массивами разных типов(тип данных). Кода было настолько много, что я удивлен как не стал шизиком, уж извините за подробности, но целую неделю я рву волосы на голове из-за этого. Собственно само задание: написать шаблонный класс для работы с динамическими массивами + перегрузка операторов ввода-вывода(консольного), ввода-вывода(файлового), а так же перегрузка оператора "=". Данная версия кода единственная что осталась, самая примитивная и "короткая", но хотя бы что-то да и выводит. Можете уже ставить "-1" на вопрос за столь длинное вступление.

#include <iostream>

using namespace std;

template<class T>
class MyClass {

private:

    T* ptr;
    int size;


public:

    MyClass(int sizeOfArray) : size(0) {

        this->size = sizeOfArray;
        ptr = new T[size];

    }

    friend ostream& operator<<(ostream& out, const MyClass& object){

        out << *object.ptr;
        return out;

    }
};


int main() {


}

Проблема находится в том, что как бы я не пытался хитро поставить циклы, изворотливо обратиться не через "связи" object`а, передать готовый массив, сгенерировать его по правилам пользователя - всегда выходят гигантских размеров ошибки. Вероятно это я настолько тупой юзверь в теме "шаблонных перегрузок" поэтому и обратился на этот форум. С ув.

Answer 1

#include <iostream>

using namespace std;

template<class T>
class MyClass {

private:

    T* ptr;
    int size;


public:


    MyClass(int sizeOfArray) : size(0) {

        this->size = sizeOfArray;
        ptr = new T[size];

    }

    friend istream& operator>>(istream& in, const MyClass& object){
        for (int i = 0; i < object.size;++i)
        {
            in >> object.ptr[i];
        }
        return in;

    }

    friend ostream& operator<<(ostream& out, const MyClass& object){
        for (int i = 0; i < object.size;++i)
        {
            out << object.ptr[i] << ' ';
        }
        return out;

    }
};


int main() {
    MyClass<int> test(5);
    cin >> test;
    cout << test;

    MyClass<string> test1(5);
    cin >> test1;
    cout << test1;
}

Answer 2

Если ещё актуально, то вот. В универе пару лет назад делал такое же задание, только более глобальнее.

#include <iostream>
#include <ctime>

using namespace std;

template <typename T>
class D_A
{
public:
    D_A();
    D_A(int const&);
    D_A(D_A const&);
    ~D_A();

    void operator+(T const&);
    D_A<T> operator+(D_A const&) const;
    D_A<T> operator-(T const&) const;
    void operator-=(T const&);
    void operator+=(T const&);
    void operator=(D_A const&);
    bool operator==(D_A const&) const;

    T& operator[](T const&);
    T _size() const;
    T *_ptr() const;
    void print();
    void push_back(T const&);
    void pop_back();
    void remove(int const&);

private:
    int size;
    T* ptr;

    friend ostream& operator<< <T> (ostream&, D_A const&);
    friend istream& operator>> <T> (istream&, D_A&);
};

template <typename T>
D_A<T>::D_A()
{
    size = 10;
    ptr = new T[size]{};
}

template <typename T>
D_A<T>::D_A(int const& size)
{
    this->size = size;
    ptr = new T[this->size]{};
    if (typeid(T) == typeid(int))
    {
        for (auto i = 0; i < this->size; i++)
        {
            ptr[i] = rand() % 15 + 1;
        }
    }
    else
    {
        char letter = 'a';
        for (int i = 0; i < size; i++)
        {
            if (!isalpha(letter)) letter = 'a';
            ptr[i] = letter;
            letter += 1;
        }
    }
}

template <typename T>
D_A<T>::D_A(D_A const& tmp)
{
    size = tmp.size;
    ptr = new T[size];

    for (auto i = 0; i < size; i++)
    {
        ptr[i] = tmp.ptr[i];
    }
}

template <typename T>
D_A<T>::~D_A()
{
    delete[] ptr;
}

template <typename T>
void D_A<T>::operator=(D_A const& tmp)
{
    if (size != tmp.size)
    {
        delete[] ptr;
        size = tmp.size;
        ptr = new T[size];
    }

    for (auto i = 0; i < size; i++)
    {
        ptr[i] = tmp.ptr[i];
    }
}

template<typename T>
bool D_A<T>::operator==(D_A const& temp) const
{
    if (size != temp.size)
        return false;

    for (auto i = 0; i < size; i++)
    {
        if (ptr[i] != temp.ptr[i])
            return false;
    }

    return true;
}

template <typename T>
void D_A<T>::operator+(T const& key)
{
    D_A<T> temp(*this);

    delete[] ptr;
    size += 1;
    ptr = new T[size];

    for (auto i = 0; i < size; i++)
    {
        ptr[i] = temp.ptr[i];
    }

    ptr[size - 1] = key;
}

template <typename T>
D_A<T> D_A<T>::operator+(D_A<T> const& temp) const
{
    D_A<T> tmp(size + temp.size);

    for (auto i = 0; i < size; i++)
    {
        *(tmp.ptr + i) = *(ptr + i);
    }
    for (auto i = 0; i < temp.size; i++)
    {
        *(tmp.ptr + size + i) = *(temp.ptr + i);
    }

    return tmp;
}

template<typename T>
D_A<T> D_A<T>::operator-(T const& index) const
{
    if (index >= 0 && index <= size)
    {
        D_A<T> tmp(*this);

        for (auto i = index; i < tmp.size - 1; i++)
        {
            tmp.ptr[i] = tmp.ptr[i + 1];
        }
        tmp.size--;

        return tmp;
    }
}

template<typename T>
void D_A<T>::operator-=(T const & index)
{
    if (index >= 0 && index <= size)
    {
        for (auto i = index; i < size - 1; ++i)
        {
            ptr[i] = ptr[i + 1];
        }
        size--;

        D_A <T> temp(*this);

        delete[] ptr;
        ptr = new T[size];
        for (auto i = 0; i < size; i++)
        {
            ptr[i] = temp.ptr[i];
        }
    }
}

template<typename T>
void D_A<T>::operator+=(T const & index)
{
    D_A<T> tmp(*this);

    delete[] ptr;
    size += 1;
    ptr = new T[size];

    for (auto i = 0; i < tmp.size; i++)
    {
        ptr[i] = tmp.ptr[i];
    }

    ptr[size - 1] = index;
}

template <typename T>
T &D_A<T>::operator[](T const& index)
{
    if (index >= 0 && index <= size)
    {
        return ptr[index];
    }
}

template <typename T>
void D_A<T>::print()
{
    for (auto i = 0; i < size; i++)
    {
        std::cout << "[" << ptr[i] << "] ";
    }
}

template<typename T>
void D_A<T>::push_back(T const& key)
{
    D_A<T> tmp(*this);

    delete[] ptr;
    size += 1;
    ptr = new T[size];

    for (auto i = 0; i < size - 1; i++)
    {
        ptr[i] = tmp.ptr[i];
    }

    ptr[size - 1] = key;
}

template<typename T>
void D_A<T>::pop_back()
{
    remove(size);
}

template <typename T>
void D_A<T>::remove(int const& index)
{
    if (index >= 0 && index <= size)
    {
        for (auto i = index; i < size - 1; ++i)
        {
            ptr[i] = ptr[i + 1];
        }
        size--;

        D_A <T> temp(*this);

        delete[] ptr;
        ptr = new T[size];
        for (auto i = 0; i < size; i++)
        {
            ptr[i] = temp.ptr[i];
        }
    }
}

template <typename T>
T D_A<T>::_size() const
{
    return size;
}

template<typename T>
T *D_A<T>::_ptr() const
{
    return ptr;
}

template <typename T>
istream &operator>>(istream& input, D_A<T>& temp)
{
    for (auto i = 0; i < temp.size; i++)
    {
        input >> temp.ptr[i];
    }
    return input;
}

template <typename T>
ostream &operator<<(ostream& output, D_A<T> const& temp)
{
    for (auto i = 0; i < temp.size; i++)
    {
        output << "[" << temp.ptr[i] << "] ";
    }
    output << endl;
    return output;
}

БЛОГ НА HUSL

как можно реализовать перегрузку ввода/вывода для массива в шаблонном классе?

Ответы (2 шт):