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

Разреженный массив на основе массива указателей - C++

Восстановить пароль Регистрация
 
visokii
 Аватар для visokii
-2 / 0 / 0
Регистрация: 23.06.2010
Сообщений: 8
23.06.2010, 20:55     Разреженный массив на основе массива указателей #1
Имеется код, вполне работоспособный.
только я не могу этот класс сделать универсальным
из-за const int amount_element(100);
Подскажите как переменную amount_element вставить в класс,
чтобы количество элементов можно было задавать в конструкторе.


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
#include <iostream>
using namespace std;
 
const int amount_element(100);    //количество элементов массива
 
//******************************************************************
template <class D>
class SpArray //: public BaseArray<D>  
{
public:
    SpArray();
   ~SpArray();
 
    void Store(D,int);                // функция заполнения массива
    D Find(int);                        // функция извлечения из массива
private: 
    D *sheet[amount_element];  //собственно массив указателей   
    
};
 
//******************************************************************
template <class D>
SpArray<D>::SpArray()
{    
    cout<<"           -> CONSTRUCTOR."<<endl;  
    register int t;
    for(t=0; t < amount_element; t++) {sheet[t] = NULL;}
}
 
 
//******************************************************************
template <class D>
SpArray<D>::~SpArray()
{
    cout<<"           -> DESTRUCTOR."<<endl;   
    register int t;
    for(t=0; t < amount_element; t++) 
    {
        if(sheet[t] != NULL)
        {
            delete sheet[t];
            cout<<"delete "<<t<<" element array"<<endl; 
        }
    }
}
 
 
//******************************************************************
template <class D>
void SpArray<D>::Store(D i,int index)  // Г¬Г*ГЈГ*çèГ*
{
    sheet[index] = new D(i);    
}
 
 
//******************************************************************
template <class D>
D SpArray<D>::Find(int index)
{    
    return *sheet[index];
}
 
//******************************************************************
 
 
typedef struct Data
{
    char name[200];
    int var;
}DATA;
 
 
 
DATA GetStr(char str[],int v)   //функция заполнения структуры DATA
{
    DATA Temp;
    strcpy(Temp.name, str);
    Temp.var = v;
    return Temp;
}
 
 
void main()
{
 
    SpArray<DATA> TEXT;
    DATA A1;
 
    A1 = GetStr("Dyplo blya!!!",910);
    TEXT.Store(A1,10);
    A1 = GetStr("Propidor!!!!!",912);
    TEXT.Store(A1,12);
    A1 = GetStr("Da blya!!!!!!",914);
    TEXT.Store(A1,14);
    A1 = GetStr("pidor blya!!!",916);
    TEXT.Store(A1,16);    
 
    A1 = TEXT.Find(12);
    cout<<A1.name<<" - "<<A1.var<<endl;
    A1 = TEXT.Find(14);
    cout<<A1.name<<" - "<<A1.var<<endl;
    A1 = TEXT.Find(16);
    cout<<A1.name<<" - "<<A1.var<<endl;
    A1 = TEXT.Find(10);
    cout<<A1.name<<" - "<<A1.var<<endl;
 
    SpArray<int> NUMB;
    int Var;
 
    Var = 202;
    NUMB.Store(Var,2);
    Var = 404;
    NUMB.Store(Var,4);
    Var = 666;
    NUMB.Store(Var,6);
    Var = 808;
    NUMB.Store(Var,8);
 
    Var = NUMB.Find(2);
    cout<<Var<<" - "<<endl;
    Var = NUMB.Find(4);
    cout<<Var<<" - "<<endl;
    Var = NUMB.Find(6);
    cout<<Var<<" - "<<endl;
    Var = NUMB.Find(8);
    cout<<Var<<" - "<<endl;
}
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
ISergey
Maniac
Эксперт С++
 Аватар для ISergey
1331 / 864 / 50
Регистрация: 02.01.2009
Сообщений: 2,622
Записей в блоге: 1
23.06.2010, 21:06     Разреженный массив на основе массива указателей #2
Так
C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
 
template<unsigned SIZE>
class Employee{
public:
    unsigned size() const { return Size; }
private:
    int arr[SIZE];
 
    static const unsigned Size = SIZE;
};
 
int main() {
 
    Employee<10> e1;
    Employee<20> e2;
 
    std::cout << e1.size() << '\n' << e2.size() << '\n';
    return 0;
}
http://codepad.org/l75jwTbY

Или полностью все динамически создавай..
C++
1
D **sheet;  //собственно массив указателей
visokii
 Аватар для visokii
-2 / 0 / 0
Регистрация: 23.06.2010
Сообщений: 8
23.06.2010, 21:14  [ТС]     Разреженный массив на основе массива указателей #3
хорошо сейчас попробую.
visokii
 Аватар для visokii
-2 / 0 / 0
Регистрация: 23.06.2010
Сообщений: 8
11.02.2012, 14:51  [ТС]     Разреженный массив на основе массива указателей #4
Всё таки решил выложить может кому пригодиться:



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
/* ================      Серёга Корп.     ===================
             */
#include <windows.h>
 
template <class D,unsigned amount_element>
class SpArray 
{
public:
    SpArray();
  ~SpArray();
 
    void WRITE(D,int);                    // записывает в массив
    D    READ(int);                         // читает элемент массива
    bool EXITS(int);                       // проверка записана ли ячейка   да-true  нет-false
private:
    D   *sheet[amount_element+1];  // массив указателей типа D (+1 для ячейки ошибки) 
    void error(char *error);              // выват Ашипки
};
 
//***********************   SpArray  *******************************
template <class D,unsigned amount_element>
SpArray<D,amount_element>::SpArray()
{    
    for(register int t=0; t < amount_element+1; t++) 
    {
        sheet[t] = NULL;
    }
}
 
//***********************  ~SpArray  *******************************
template <class D,unsigned amount_element>
SpArray<D,amount_element>::~SpArray()
{
    for(register int t=0; t < amount_element+1; t++) 
    {
    if(sheet[t] != NULL)  { delete sheet[t];}
    }
}
 
//************************  WRITE  *********************************
template <class D,unsigned amount_element>
void SpArray<D,amount_element>::WRITE(D i,int index)  // магазин
{ 
    if(sheet[index]!=NULL) delete sheet[index];   // это если надо записать в записанную ячейку 
 
        if(index > amount_element)                    // если индекс больше допустимого
    { 
        error("пипец какой, а ты посмотрел сколько елементов в массиве?");
    }
    else 
    {
        if(index < 0)                               // если индекс меньше допустимого
        {
            error("там ячеек массива никто не придумал!!!");
        }
        else
        {
            sheet[index] = new D(i);              // если всё в порядке
        }
    }
}
 
//************************  READ   *********************************
template <class D,unsigned amount_element>
D SpArray<D,amount_element>::READ(int index)
{    
    if(index > amount_element)                    // если индекс больше допустимого
    { 
        error("пипец какой, а ты посмотрел сколько елементов в массиве?");
    }
    else 
    {
        if(index < 0)                               // если индекс меньше допустимого
        {
            error("там ячеек массива никто не придумал!!!");
        }
        else
        {
            if(sheet[index]==NULL) { error("Читаешь чего нет!!! Ишак убаный"); }
            return *sheet[index]; 
        }
    }
    return *sheet[amount_element+1];              // здесь возвратит NULL                     
}
 
//************************  EXITS  *********************************
template <class D,unsigned amount_element>
bool SpArray<D,amount_element>::EXITS(int index)
{
    if(sheet[index]==NULL) { return false; }
    return true;
}
 
//************************  DELETE  ********************************
template <class D,unsigned amount_element>
void SpArray<D,amount_element>::DEL(int t)
{
    if(sheet[t] != NULL)  { delete sheet[t];}
}
 
//************************    error   ******************************
template <class D,unsigned amount_element>
void SpArray<D,amount_element>::error(char *error)
{
    MessageBox( NULL, error, "class_sparray", MB_OK | MB_ICONERROR);
}
 
 
//******************************************************************
/*
    SpArray<TYPE,30> ARRAY;    // создание массива типа TYPE из 30 элементов
    TYPE A1;                   // 
                               // 
    ARRAY.WRITE(A1,12);        // записывает в 12-ю ячейку А1 
    ARRAY.READ(A1,12);         // читает из 12-ой ячейки 
    ARRAY.EXITS(12);           // состояние 12-ой ячейки return true - записана,  false - пустая
    ARRAY.DEL(12);             // удаление 12-ой ячейки из памяти
*/
Yandex
Объявления
11.02.2012, 14:51     Разреженный массив на основе массива указателей
Ответ Создать тему
Опции темы

Текущее время: 15:42. Часовой пояс GMT +3.
КиберФорум - форум программистов, компьютерный форум, программирование
Powered by vBulletin® Version 3.8.9
Copyright ©2000 - 2016, vBulletin Solutions, Inc.
Рейтинг@Mail.ru