Необходимо реализовать шаблонный класс 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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
#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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
#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++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
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;
    
 
};

Новые блоги и статьи Все статьи Все блоги /
Использование Linq2Db в проектах C# .NET UnmanagedCoder 21.05.2025 Среди множества претендентов на корону "идеального ORM" особое место занимает Linq2Db — микро-ORM, балансирующий между мощью полноценных инструментов и легковесностью ручного написания SQL. Что. . .	Реализация Domain-Driven Design с Java Javaican 20.05.2025 DDD — это настоящий спасательный круг для проектов со сложной бизнес-логикой. Подход, предложенный Эриком Эвансом, позволяет создавать элегантные решения, которые точно отражают реальную предметную. . .	Возможности и нововведения C# 14 stackOverflow 20.05.2025 Выход версии C# 14, который ожидается вместе с . NET 10, приносит ряд интересных нововведений, действительно упрощающих жизнь разработчиков. Вы уже хотите опробовать эти новшества? Не проблема! Просто. . .	Собеседование по Node.js - вопросы и ответы Reangularity 20.05.2025 Каждому разработчику рано или поздно приходится сталкиватся с техническими собеседованиями - этим стрессовым испытанием, где решается судьба карьерного роста и зарплатных ожиданий. В этой статье я. . .	Cython и C (СИ) расширения Python для максимальной производительности py-thonny 20.05.2025 Python невероятно дружелюбен к начинающим и одновременно мощный для профи. Но стоит лишь заикнуться о высокопроизводительных вычислениях — и энтузиазм быстро улетучивается. Да, Питон медлительнее. . .
Безопасное программирование в Java и предотвращение уязвимостей (SQL-инъекции, XSS и др.) Javaican 19.05.2025 Самые распространёные векторы атак на Java-приложения за последний год выглядят как классический "топ-3 хакерских фаворитов": SQL-инъекции (31%), межсайтовый скриптинг или XSS (28%) и CSRF-атаки. . .	Введение в Q# - язык квантовых вычислений от Microsoft EggHead 19.05.2025 Microsoft вошла в гонку технологических гигантов с собственным языком программирования Q#, специально созданным для разработки квантовых алгоритмов. Но прежде чем погружаться в синтаксические дебри. . .	Безопасность Kubernetes с Falco и обнаружение вторжений Mr. Docker 18.05.2025 Переход организаций к микросервисной архитектуре и контейнерным технологиям сопровождается лавинообразным ростом векторов атак — от тривиальных попыток взлома до многоступенчатых кибератак, способных. . .	Аугментация изображений с Python AI_Generated 18.05.2025 Собрать достаточно большой датасет для обучения нейронной сети — та ещё головная боль. Часами вручную размечать картинки, скармливать их ненасытным алгоритмам и молиться, чтобы модель не сдулась при. . .	Исключения в Java: советы, примеры кода и многое другое Javaican 18.05.2025 Исключения — это объекты, созданные когда программа сталкивается с непредвиденной ситуацией: файл не найден, сетевое соединение разорвано, деление на ноль. . . Список можно продолжать до бесконечности. . . .

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

Решение

Решение

@ВаняБином 1 / 1 / 0 Регистрация: 29.08.2014 Сообщений: 18

	Необходимо реализовать шаблонный класс Array, и грамотно реализовать push_back 03.10.2014, 00:06. Показов 8212. Ответов 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 [ТС]
	stima, Воу!!! Но я бы хотел спросить. А как это все реализвать с помошью new delete ? delete[] _data; - это понятно !!! а как реаалок ? 0

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

Опции темы