Форум программистов, компьютерный форум CyberForum.ru

Оператор копирования для объектов - C++

Войти
Регистрация
Восстановить пароль
Другие темы раздела
C++ C++ исправить ошибки http://www.cyberforum.ru/cpp-beginners/thread1150005.html
Помогите исправит ошибки=) #include <iostream> #include <stdio.h> #include <math.h> #include <conio.h> #include <time.h> using namespace std; int mas; int i,j,m,n,s,l,d;
C++ На входе строка любой длины, на выходе получить строку в обратном порядке дело было на собеседовании : задали такую задачу. На входе строка любой длины , на выходе получить строку в обратном порядке (ABC... ->...CBA ) я переволновался и написал такой код) и объяснить нечего не смог ((( как вы думаете это правильное решение? #include "stdafx.h" #include "iostream" #include "string.h" using namespace std; int _tmain(int argc, _TCHAR* argv) { http://www.cyberforum.ru/cpp-beginners/thread1150000.html
Задача коммивояжера - выход за пределы массива C++
Бьет ошибку! Я так понимаю где-то выход за пределы массива! Народ гляньте кто, а то я уже ничего не вижу! Может свежий взгляд увидит как исправить #include <vcl.h> #include <tchar.h> #include <stdio.h> #include <conio.h> //
C++ Найти два последовательных члена последовательности, среднее арифметическое которых ближе всего к определенному числу
Здравствуйте, помогите сделать задание, ни как не могу в него вникнуть: Компоненты файла f – целые (отличные от нуля) числа: х, y1, ... yn. Вывести на экран два последовательных члена этой последовательности, среднее арифметическое которых ближе всего к х. Выполнить задания для текстового и бинарного файлов.
C++ Заполнить двумерный массив 7x7 http://www.cyberforum.ru/cpp-beginners/thread1149931.html
Заполнить двумерный массив 7x7 следующим видом: Добавлено через 15 минут Спасибо, уже сделал, кому нужно, вот) //---------------------------------TwIx----------------------------------------- #include <iostream> #include <math.h> #include <stdlib.h> #include <vcl.h>
C++ Написать простую булевую функцию написать реализацию самой простой функции вычисления нелинейности одной булевой функции. Для отладки этой функции надо будет писать программу, в которой задавать какую-нибудь конкретную функцию, например, линейную или произведение переменных, а также выводить результат в файл для проверки. подробнее

Показать сообщение отдельно
DrOffset
6925 / 4118 / 942
Регистрация: 30.01.2014
Сообщений: 6,915
21.04.2014, 14:11     Оператор копирования для объектов
Цитата Сообщение от higimo Посмотреть сообщение
простите, что так наглею, но не могли бы вы в качестве примера описать ещё метод .push(). Никак не получается построить аналогию смотря на ваш код и std::vector. Заранее спасибо.
Можно как-то так:
Кликните здесь для просмотра всего текста
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
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
#include <algorithm>
#include <memory>
#include <cstdlib>
#include <stdexcept>
#include <new>
 
template <typename T>
class Array
{
public:
    typedef T *       pointer_type;
    typedef T         value_type;
 
    typedef T *       iterator;
    typedef T const * const_iterator;
 
private:
    struct Memory
    {
        pointer_type start;
        pointer_type finish;
        pointer_type end_of_storage;
 
        Memory() : start(), finish(), end_of_storage() {}
    };
 
public:
    ~Array()
    {
        destroy(mem_.start, mem_.finish);
        deallocate(mem_.start, mem_.end_of_storage - mem_.start);
    }
 
    Array & operator=(Array const & x)
    {
        if(&x != this)
        {
            const size_t xlen = x.size();
            if(xlen > capacity())
            {
                pointer_type tmp = allocate_and_copy(xlen, x.begin(), x.end());
 
                destroy(mem_.start, mem_.finish);
                deallocate(mem_.start, mem_.end_of_storage - mem_.start);
 
                mem_.start = tmp;
                mem_.end_of_storage = mem_.start + xlen;
            }
            else if(size() >= xlen)
            {
                destroy(std::copy(x.begin(), x.end(), begin()), end());
            }
            else
            {
                std::copy(x.mem_.start, x.mem_.start + size(), mem_.start);
                std::uninitialized_copy(x.mem_.start + size(), x.mem_.finish, mem_.finish);
            }
            mem_.finish = mem_.start + xlen;
        }
        return *this;
    }
 
    iterator begin()
    {
        return mem_.start;
    }
    const_iterator begin() const
    {
        return mem_.start;
    }
    const_iterator end() const
    {
        return mem_.finish;
    }
    iterator end()
    {
        return mem_.finish;
    }
 
    size_t capacity() const
    {
        return size_t(mem_.end_of_storage - mem_.start);
    }
    size_t size() const
    {
        return size_t(mem_.finish - mem_.start);
    }
    size_t max_size() const
    {
        return size_t(-1u) / sizeof(T);
    }
 
    void push_back(value_type const & x)
    {
        if(mem_.finish != mem_.end_of_storage)
        {
            construct(mem_.finish, x);
            ++mem_.finish;
        }
        else
        {
            insert_impl(end(), x);
        }
    }
 
    iterator insert(iterator pos, value_type const & x)
    {
        const size_t n = std::distance(pos, begin());
        if(mem_.finish != mem_.end_of_storage && pos == end())
        {
            construct(mem_.finish, x);
            ++mem_.finish;
        }
        else
        {
            insert_impl(pos, x);
        }
        return mem_.start + n;
    }
 
    value_type & operator[](size_t n)
    {
        return *(mem_.start + n);
    }
    value_type const & operator[](size_t n) const
    {
        return *(mem_.start + n);
    }
 
private:
    pointer_type allocate(size_t n, const void * = 0)
    {
        if(n == 0)
        {
            return 0;
        }
        pointer_type ret = static_cast<T *>(std::malloc(n * sizeof(T)));
        if(!ret)
        {
            throw std::bad_alloc();
        }
        return ret;
    }
    void deallocate(pointer_type p, size_t)
    {
        std::free(static_cast<void*>(p));
    }
 
    pointer_type allocate_and_copy(size_t n, const_iterator first, const_iterator last)
    {
        pointer_type result = allocate(n);
        try
        {
            std::uninitialized_copy(first, last, result);
            return result;
        }
        catch(...)
        {
            deallocate(result, n);
            throw;
        }
    }
 
    void construct(pointer_type p, const T & val)
    {
        ::new(static_cast<void *>(p)) T(val);
    }
    void construct(pointer_type p)
    {
        ::new(static_cast<void *>(p)) T();
    }
    void destroy(pointer_type p)
    {
        p->~T();
    }
    void destroy(iterator first, iterator last)
    {
        for(; first != last; ++first)
        {
            destroy(first);
        }
    }
    size_t check_len(size_t n, char const * s) const
    {
        if(max_size() - size() < n)
            throw std::length_error(s);
 
        const size_t len = size() + std::max(size(), n);
        return (len < size() || len > max_size()) ? max_size() : len;
    }
 
    void insert_impl(iterator pos, T const & x)
    {
        if(mem_.finish != mem_.end_of_storage)
        {
            construct(mem_.finish);
            ++mem_.finish;
            std::copy_backward(pos, mem_.finish - 2, mem_.finish - 1);
            *pos = x;
        }
        else
        {
            const size_t len = check_len(1, "Array::insert");
            const size_t elems_before = pos - begin();
            pointer_type new_start  = allocate(len);
            pointer_type new_finish = new_start;
 
            try
            {
                construct(new_start + elems_before, x);
                new_finish = 0;
 
                new_finish = std::uninitialized_copy(mem_.start, pos, new_start);
                ++new_finish;
                new_finish = std::uninitialized_copy(pos, mem_.finish, new_finish);
            }
            catch(...)
            {
                if(!new_finish)
                {
                    destroy(new_start + elems_before);
                }
                else
                {
                    destroy(new_start, new_finish);
                }
                deallocate(new_start, len);
                throw;
            }
            destroy(mem_.start, mem_.finish);
            deallocate(mem_.start, mem_.end_of_storage - mem_.start);
 
            mem_.start  = new_start;
            mem_.finish = new_finish;
            mem_.end_of_storage = new_start + len;
        }
    }
 
    Memory mem_;
};

Реализация боевая, в том смысле, что здесь учтены и безпасность исключений и порядок операций требующихся при конструировании внутри массива.
 
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2017, vBulletin Solutions, Inc.
Рейтинг@Mail.ru