Форум программистов, компьютерный форум, киберфорум
Наши страницы
С++ для начинающих
Войти
Регистрация
Восстановить пароль
 
Рейтинг: Рейтинг темы: голосов - 14, средняя оценка - 4.86
rar14
28 / 22 / 2
Регистрация: 14.04.2009
Сообщений: 448
#1

Лаба №5 Создание контейнерного класса - C++

21.04.2009, 13:48. Просмотров 1941. Ответов 7
Метки нет (Все метки)


http://www.cyberforum.ru/cpp-beginners/thread1731125.html
0
Надоела реклама? Зарегистрируйтесь и она исчезнет полностью.
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
21.04.2009, 13:48
Я подобрал для вас темы с готовыми решениями и ответами на вопрос Лаба №5 Создание контейнерного класса (C++):

Подскажите пример контейнерного класса-массив и список
Помогите пожалуйста. Стандарные библиотеки типа list, CObject, AtlArray не надо...

Итератор для своего контейнерного класса-списка
Здравствуйте. Есть класс List, и мне надо помимо стандартных методов приделать...

Использование контейнерного класса <list>. Вывод элементов
Подскажите, пожалуйста , как вывести элементы класса list, если он состоит из...

Организовать хранение данных с применением контейнерного класса set
День добрый! Информационная система содержит сведения об отправлении поездов...

Написать программу "Моя записная книжка" с применением контейнерного класса map
Предусмотреть возможность работы с произвольным числом записей,поиска записи по...

7
ISergey
Maniac
Эксперт С++
1407 / 918 / 148
Регистрация: 02.01.2009
Сообщений: 2,744
Записей в блоге: 1
21.04.2009, 14:46 #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
#include <iostream>
#include <cassert>
using namespace std;
 
template<typename T>
class x_array{
    typedef unsigned int uint;
public:
    x_array():_array(0),_size(0){ }
    x_array(const x_array &rhs):_array(0),_size(0){ *this = rhs; }
    x_array(const uint &newSize):_array(new T[newSize]),_size(newSize) { memset(_array, 0, sizeof(T)*_size); }
    ~x_array()
    {
        if(_array)
        {
            delete [] _array;
            _array = 0;
            _size  = 0;
        }
    }
    T *pointer() { return _array; }
    const T *const_pointer() const { return _array; }
    const uint size()    const { return _size;}
    bool is_empty() const { return _size == 0; }
 
    const T &operator[] (uint index) const
    {
        assert(index < _size);
        return _array[index];
    }
    T &operator[] (uint index)
    {
        assert(index < _size);
        return _array[index];
    }
 
    void push_back(const T &elem)
    {
        if(_array == 0){
            ++_size;
            _array = new T[_size];
            _array[_size - 1] = elem;
            return;
        }
 
        T *old = _array;
        _array = new T[_size + 1];
        for(uint i = 0; i < _size; ++i)
            _array[i] = old[i];
        _array[_size] = elem;
        ++_size;
        delete[] old;
    }
    x_array &operator = (const x_array &rhs)
    {
        if(_array != 0)
            delete[] _array;
 
        _array = new T[rhs._size];
        _size  = rhs._size;
        for(uint i = 0; i < _size; ++i)
            _array[i] = rhs._array[i];
        return *this;
    }
private:
    T  *_array;
    uint _size;
};
int main() 
{
    x_array<int> arr;
    arr.push_back(1); cout<<arr.size()<<endl;
    arr.push_back(2); cout<<arr.size()<<endl;
    arr.push_back(3); cout<<arr.size()<<endl;
    arr.push_back(4); cout<<arr.size()<<endl<<endl;
 
    cout<<arr[0]<<endl 
        <<arr[1]<<endl 
        <<arr[2]<<endl 
        <<arr[3]<<endl<<endl;;
 
    arr[0] = 10;
    arr[1] = 20;
    arr[2] = 30; 
    arr[3] = 40;
 
    cout<<arr[0]<<endl 
        <<arr[1]<<endl 
        <<arr[2]<<endl 
        <<arr[3]<<endl<<endl;
 
    x_array<int> arr2(arr); cout<<arr2.size()<<endl<<endl;
    cout<<arr2[0]<<endl 
        <<arr2[1]<<endl 
        <<arr2[2]<<endl 
        <<arr2[3]<<endl<<endl;
 
    x_array<int> arr3(30); cout<<arr3.size()<<endl<<endl;
    cout<<arr3[29]<<endl;
    //cout<<arr3[30]<<endl;//!Bug
    return 0;
}
0
rar14
28 / 22 / 2
Регистрация: 14.04.2009
Сообщений: 448
21.04.2009, 16:23  [ТС] #3
Спасибо. Буду разбираться.
0
rar14
28 / 22 / 2
Регистрация: 14.04.2009
Сообщений: 448
24.04.2009, 14:38  [ТС] #4
Извините, отвлекся на пару дней. Физикой занимался.

А вы не могли бы принципиальные строчки кода прокомментировать. А то не до конца понятно, что происходит.
И вот такие строчки, тоже прокомментировать - x_array &operator = (const x_array &rhs). А то не понимаю что за &operator = ...
Спасибо.
0
ISergey
Maniac
Эксперт С++
1407 / 918 / 148
Регистрация: 02.01.2009
Сообщений: 2,744
Записей в блоге: 1
24.04.2009, 15:37 #5
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
#include <iostream>
#include <cassert>//для assert
using namespace std;
 
template<typename T>
class x_array{
    typedef unsigned int uint;//теперь в коде вместо unsigned int можно просто писать uint
public:
    x_array():_array(0),_size(0){
    //:_array(0),_size(0)
        //это равносильно
        //_array = 0;
        //_size  = 0;
    }
    x_array(const x_array &rhs):_array(0),_size(0){ 
        *this = rhs;//вот здесь вызываем x_array &operator = (const x_array &rhs)
    }
    x_array(const uint &newSize):_array(new T[newSize]),_size(newSize) {
        //:_array(new T[newSize]),_size(newSize)
        //_array(new T[newSize]) тоже самое что и
        //_array = new T[newSize];
        //_size(newSize) -> _size = newSize
 
        memset(_array, 0, sizeof(T)*_size); //заполняем массив нолями
        //тоесть
        //for(unsigned int i = 0; i < _size; ++i)
        //      _array[i] = 0;
    }
    ~x_array()
    {
        if(_array)//эсли _array был создан
        {
            //то 
            delete [] _array;//удалить нафиг
            _array = 0;//указатель в ноль
            _size  = 0;//размер массива в 0
        }
    }
 
    //T *pointer() { return _array; }
    //возвращает указатель на массив
    //гдето в коде можно написать
    //x_array<int> xarr(10);
    //int *arr = xarr.pointer();
    //и потом работать с arr как с обычным массивом
    //но если изменить arr то изменится xarr::_array;
    T *pointer() { return _array; }
 
    //смотреть выше, но такой указатель нельзя менять.
    const T *const_pointer() const { return _array; }
 
    //вернет размер массива
    const uint size()        const { return _size;}
 
    //вернет true если массив пустой , иначе false
    bool is_empty() const { return _size == 0; }
 
    //при помощи этого оператора мы можем 
    //работать с обектом класса x_array как и с 
    //обычным массивом, тоесть в коде
    //x_array<int> xarr(10);
    //cout<<xarr[1]<<endl;
    const T &operator[] (uint index) const
    {
        assert(index < _size);//эсли выход за границы массива то выдать ошибку
        //можно просто так сделать
        //if(index < _size) cout<< "Error" << endl;
        return _array[index];
    }
 
    //см. выше. теперь можно и изменять массив
    //x_array<int> xarr(10);
    //xarr[1] = 10;
    T &operator[] (uint index)
    {
        assert(index < _size);
        return _array[index];
    }
 
    //ф. добавления элемента
    void push_back(const T &elem)
    {
        if(_array == 0){//эсли масси небыл создан
            ++_size;// _size == 1
            _array = new T[_size];//создать
            _array[_size - 1] = elem;//_array[i] = n;
            return;//выйти из push_back
        }
        //массив уже создан
 
 
        T *old = _array;//запоменаем указатель
 
        _array = new T[_size + 1];//выделяем память на 1 больше
 
        for(uint i = 0; i < _size; ++i)
            _array[i] = old[i];//копируем
 
        _array[_size] = elem;//_array[i] = n;
 
        ++_size;
 
        delete[] old;//удаляем старый массив
    }
 
    //оператор копирования 
    x_array &operator = (const x_array &rhs)
    {
        if(_array != 0)//эсли массив создан то
            delete[] _array;//удалить
 
        //дальше думаю понятно
        _array = new T[rhs._size];
        _size  = rhs._size;
        for(uint i = 0; i < _size; ++i)
            _array[i] = rhs._array[i];
        return *this;
    }
private:
    T  *_array;//сам массив(будущий)
    uint _size;//размер массива
};
Думаю так понятнее.

Про оператор копирования смотри здесь ну и это не помешает Overloadable operators

И вот маленький пример

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
#include <iostream>
using namespace std;
 
class Employee{
public:
    //оператор копирования для самого класса
    Employee &operator = (const Employee& r){
        cout<<"Employee &operator = (const Employee& r)"<<endl;
        return *this;
    }
 
    //дальше перегружиные
 
    //для int
    Employee &operator = (const int r){
        cout<<"Employee &operator = (const int r)"<<endl;
        return *this;
    }
 
    //для float
    Employee &operator = (const float r){
        cout<<"Employee &operator = (const float r)"<<endl;
        return *this;
    }
 
    //для char
    Employee &operator = (const char r){
        cout<<"Employee &operator = (const char r)"<<endl;
        return *this;
    }
 
    //для char*
    Employee &operator = (const char* r){
        cout<<"Employee &operator = (const char* r)"<<endl;
        return *this;
    }
};
int main() 
{
    Employee a;
    Employee b;
 
    a = b;              //Employee &operator = (const Employee& r)
 
    a = int(10);        //Employee &operator = (const int r)
    a = float(10.2f);   //Employee &operator = (const float r)
    a = char('f');      //Employee &operator = (const char r)
    a = "string";       //Employee &operator = (const char* r)
    return 0;
}
0
rar14
28 / 22 / 2
Регистрация: 14.04.2009
Сообщений: 448
25.04.2009, 00:41  [ТС] #6
Большое спасибо. Я, как раз, сегодня, для глубокого изучения C++, приобрел книгу Бьерна Страуструпа. Буду разбираться.
0
Monte-Cristo
2794 / 1380 / 107
Регистрация: 07.03.2009
Сообщений: 4,446
25.04.2009, 01:22 #7
Цитата Сообщение от rar14 Посмотреть сообщение
Большое спасибо. Я, как раз, сегодня, для глубокого изучения C++, приобрел книгу Бьерна Страуструпа. Буду разбираться.
А что Страуструп - это серьезно? По-моему, создатель языка - это не показатель.

p.s: если честно, то мне совершенно не нравится как он пишет.
0
rar14
28 / 22 / 2
Регистрация: 14.04.2009
Сообщений: 448
25.04.2009, 04:05  [ТС] #8
Хм. А что вы можете посоветовать?
0
25.04.2009, 04:05
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
25.04.2009, 04:05
Привет! Вот еще темы с решениями:

Построение описания класса, создание и уничтожение объектов этого класса
Построить описание класса, содержащего информацию о почтовом адресе...

Создание объекта класса с полем являющимся объектом другого класса
Bill a; cin&gt;&gt;a;//тут я ввел с помощью перегруженного оператора ElementSpiska...

Создание класса-списка на основе кода со списком без класса
Здравствуйте. Не могли бы вы показать, как оформить этот код в виде класса....

Явное создание экземпляра класса и явная специализация шаблона класса
Всем добрый день! Не могу разобраться - эти две технологии дают один и тот же...


Искать еще темы с ответами

Или воспользуйтесь поиском по форуму:
8
Ответ Создать тему
Опции темы

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