Необходимо реализовать шаблонный класс Array, и грамотно реализовать push_back

@ВаняБином · Регистрация: 29.08.2014

Студворк — интернет-сервис помощи студентам

Необходимо реализовать шаблонный класс Array, параметризируемый типом хранимых

элементов.

Класс Array представляет собой контейнер элементов типа T, реализованный на основе

динамического массива. Необходимо реализовать следующие методы:

1. Конструктор, получающий максимальное количество хранимых элементов в массиве.

Считается, что после конструирования в массиве не содержится ни один элемент.

2. Деструктор, освобождающий используемую динамическую память.

3. Оператор присваивания.

4. Конструктор копирования.

5. Метод push_back, добавляющий элемент в конец массива.

6. Метод получения и задания элемента массива с заданным индексом через оператор

индексирования. Если индекс выходит за логические границы массива, то должно быть

выброшено исключение.

7. Метод capacity() const, возвращающий общую ёмкость динамического массива.

8. Метод size() const, возвращающий количество заполненных элементов динамического

массива.

9. Метод begin() const, возвращающий начало внутреннего динамического массива.

10.Метод end() const, возвращающий элемент, следующий за последним логическим

элементом массива.

@stima · 03.10.2014, 02:20

C++

#include <iostream>
#include <exception>
 
template <typename T>
class Array
{
    template <typename U>
    friend void swap(Array<U>&, Array<U>&);
 
public:
    typedef std::size_t     size_type;
    typedef T               value_type;
    typedef value_type&     reference;
    typedef const reference const_reference;
 
    //c-like iterator
    typedef T* iterator;
 
    Array() :
        _data(nullptr),
        _size(0),
        _capacity(0)
    {
    }
 
    Array(const Array& other)
    {
        if (!(_data = (value_type*)malloc(other.capacity() * sizeof(value_type))))
        {
            throw std::bad_alloc();
        }
 
        _size = other.size();
        _capacity = other.capacity();
    }
 
    Array& operator=(Array other)
    {
        other.swap(*this);
        return *this;
    }
 
    ~Array()
    {
        _dealloc();
    }
 
    void swap(Array& other)
    {
        std::swap(_data, other._data);
 
        std::swap(_size, other._size);
        std::swap(_capacity, other._capacity);
    }
    
    size_type size() const
    {
        return _size;
    }
 
    size_type capacity() const
    {
        return _capactity;
    }
 
    void push_back(const value_type& value)
    {
        if (_size == 0)
        {
            _alloc(1);
            _capacity = 1;
        }
        else if (_size == _capacity)
        {
            _alloc(_capacity * 2);
            _capacity *= 2;
        }
 
        _data[_size++] = value;
    }
    
    reference at(size_type i)
    {
        if (i >= _size)
            throw std::out_of_range();
 
        return _data[i];
    }
 
    const_reference at(size_type i) const
    {
        if (i >= _size)
            throw std::out_of_range();
 
        return _data[i];
    }
 
    reference operator[](size_type i)
    {
        return _data[i];
    }
 
    const_reference operator[](size_type i) const
    {
        return _data[i];
    }
 
    iterator begin()
    {
        if (_size == 0)
            return end();
 
        return &_data[0];
    }
 
    iterator end()
    {
        if (_capacity == 0)
            return nullptr;
 
        return &_data[_size];
    }
 
private:
    value_type *_data;
 
    size_type _size;
    size_type _capacity;
 
    void _alloc(size_type count)
    {
        if (!(_data = (value_type*)realloc(_data, count * sizeof(value_type))))
        {
            throw std::bad_alloc();
        }
    }
 
    void _dealloc()
    {
        free(_data);
    }
};
 
int main()
{
    int count = 10;
    Array<int> array;
 
    for (int i = 0; i < count; ++i)
    {
        array.push_back(i);
    }
 
    for (Array<int>::iterator it = array.begin(); it != array.end(); ++it)
    {
        std::cout << *it << std::endl;
    }
 
    std::getchar();
 
    return 0;
}

@ВаняБином · 04.10.2014, 23:22 **[ТС]**

stima, Воу!!! Но я бы хотел спросить. А как это все реализвать с помошью new delete ?

delete[] _data; - это понятно !!!

а как реаалок ?

alsav22 · 05.10.2014, 00:37

stima, интересный у тебя конструктор копирования... Память выделил и всё?

@gray_fox · 05.10.2014, 06:00

Сообщение от stima

C++

1 2	typedef value_type& reference; typedef const reference const_reference;

Так получается что reference и const_reference - это int &, т.к. const во 2-м случае применяется к ссылке, а она и так константна.

@stima · 05.10.2014, 14:16

ВаняБином, Через new[] и delete[] можно (1. аллоцируете, 2. копируете, 3. удаляете), но не выгодно, поэтому никто и не использует.

alsav22, gray_fox, 2 часа ночи дали о себе знать.

Подправил:

C++

#include <iostream>
#include <exception>
 
template <typename T>
class Array
{
    template <typename U>
    friend void swap(Array<U>&, Array<U>&);
 
public:
    typedef std::size_t         size_type;
    typedef T                   value_type;
    typedef value_type&         reference;
    typedef const value_type&   const_reference;
 
    //c-like iterator
    typedef T* iterator;
 
    Array() :
        _data(nullptr),
        _size(0),
        _capacity(0)
    {
    }
 
    Array(const Array& other)
    {
        _alloc(other.capacity());
 
        std::copy(_data, other._data, other.size());
        std::copy(_size, other.size());
        std::copy(_capacity, other.capacity());
    }
 
    Array& operator=(Array other)
    {
        other.swap(*this);
        return *this;
    }
 
    ~Array()
    {
        _dealloc();
    }
 
    void swap(Array& other)
    {
        std::swap(_data, other._data);
 
        std::swap(_size, other._size);
        std::swap(_capacity, other._capacity);
    }
    
    size_type size() const
    {
        return _size;
    }
 
    size_type capacity() const
    {
        return _capactity;
    }
 
    void push_back(const value_type& value)
    {
        if (_size == 0)
        {
            _alloc(1);
            _capacity = 1;
        }
        else if (_size == _capacity)
        {
            _alloc(_capacity * 2);
            _capacity *= 2;
        }
 
        _data[_size++] = value;
    }
    
    reference at(size_type i)
    {
        if (i >= _size)
            throw std::out_of_range();
 
        return _data[i];
    }
 
    const_reference at(size_type i) const
    {
        if (i >= _size)
            throw std::out_of_range();
 
        return _data[i];
    }
 
    reference operator[](size_type i)
    {
        return _data[i];
    }
 
    const_reference operator[](size_type i) const
    {
        return _data[i];
    }
 
    iterator begin()
    {
        if (_size == 0)
            return end();
 
        return &_data[0];
    }
 
    iterator end()
    {
        if (_capacity == 0)
            return nullptr;
 
        return &_data[_size];
    }
 
private:
    value_type *_data;
 
    size_type _size;
    size_type _capacity;
 
    void _alloc(size_type count)
    {
        if (!(_data = (value_type*)realloc(_data, count * sizeof(value_type))))
        {
            throw std::bad_alloc();
        }
    }
 
    void _dealloc()
    {
        free(_data);
    }
};
 
int main()
{
    int count = 10;
    Array<int> array;
 
    for (int i = 0; i < count; ++i)
    {
        array.push_back(i);
    }
 
    for (Array<int>::iterator it = array.begin(); it != array.end(); ++it)
    {
        std::cout << *it << std::endl;
    }
 
    std::getchar();
 
    return 0;
}

@ВаняБином · 15.10.2014, 19:59 **[ТС]**

stima, Спасибо! Но я не совсем знаком с аллоками и реаллоками, ведь можно проще !

C++

template<typename T>
class Stack
{
 
public:
 
    Stack(int capacity)
    {
        _capacity = capacity;
        _TopIndex = -1;
        _stack = new T[capacity];
        for(int i = 0; i < _capacity; ++i)
            _stack[i] = T(); 
    }
 
    Stack(const Stack &other)
    {
        _capacity = other._capacity;
        _TopIndex = other._TopIndex;
 
        _stack = new int [_capacity = other._capacity];
 
         for (int i = 0; i < _TopIndex + 1; ++i)
            _stack[i] = other._stack[i];
    }
 
    ~Stack()
    {
        delete [] _stack;
    }
 
    Stack &operator = (const Stack & other)     
    {
        if (this == &other) 
            return *this;
      
         delete [] _stack;
             
         _stack = new int [_capacity = other._capacity];
      _TopIndex = other._TopIndex;
 
         for (int i = 0; i < _TopIndex + 1; ++i)
              _stack[i] = other._stack[i];
   
         return *this;  
    }
 
    bool Empty()
    {
        return _TopIndex == -1;
    }
 
    void push_back(T elem)
    {
        _stack[++_TopIndex] = elem;
    }   
 
    friend std::ostream &operator <<(std::ostream &stream , Stack const &obj)
    {
        stream << "Stack" << ":" << "{";
        for(int i = 0; i < obj._capacity; ++i)
            stream << obj._stack[i] << " ";
        stream << "}";
 
        return stream;
    }
 
    T &Top()
    {
        if(Empty())
            throw std::runtime_error("Without elements");
            
        return _stack[_TopIndex];
    }
 
    void Pop()
    {
        if(Empty())
            throw std::runtime_error("Without elements");
 
        --_TopIndex;
    }
 
    int capacity() const
    {
        return _capacity;
    }
    
    int size() const
    {
        return _TopIndex + 1;
    }
    
    T Get(int pos) const
    {
        return _stack[pos];
    }
 
 
 
private:
    int _TopIndex;
    int _capacity;
    T * _stack;
    
 
};

Необходимо реализовать шаблонный класс Array, и грамотно реализовать push_back

Решение

Решение

@ВаняБином 1 / 1 / 0 Регистрация: 29.08.2014 Сообщений: 18
		1
	Необходимо реализовать шаблонный класс Array, и грамотно реализовать push_back 03.10.2014, 00:06. Показов 7524. Ответов 6 Метки нет (Все метки) Необходимо реализовать шаблонный класс Array, параметризируемый типом хранимых элементов. Класс Array представляет собой контейнер элементов типа T, реализованный на основе динамического массива. Необходимо реализовать следующие методы: 1. Конструктор, получающий максимальное количество хранимых элементов в массиве. Считается, что после конструирования в массиве не содержится ни один элемент. 2. Деструктор, освобождающий используемую динамическую память. 3. Оператор присваивания. 4. Конструктор копирования. 5. Метод push_back, добавляющий элемент в конец массива. 6. Метод получения и задания элемента массива с заданным индексом через оператор индексирования. Если индекс выходит за логические границы массива, то должно быть выброшено исключение. 7. Метод capacity() const, возвращающий общую ёмкость динамического массива. 8. Метод size() const, возвращающий количество заполненных элементов динамического массива. 9. Метод begin() const, возвращающий начало внутреннего динамического массива. 10.Метод end() const, возвращающий элемент, следующий за последним логическим элементом массива. 0

@ВаняБином 1 / 1 / 0 Регистрация: 29.08.2014 Сообщений: 18
	04.10.2014, 23:22 [ТС]	3
	stima, Воу!!! Но я бы хотел спросить. А как это все реализвать с помошью new delete ? delete[] _data; - это понятно !!! а как реаалок ? 0

alsav22 5497 / 4892 / 831 Регистрация: 04.06.2011 Сообщений: 13,587
	05.10.2014, 00:37	4
	stima, интересный у тебя конструктор копирования... Память выделил и всё? 0

	15.10.2014, 19:59

Опции темы