anti-k, я там спросонок наговорил бог знает что. Почувствовав угрызения совести, вспомнил, что когда-то пытался написать ну очень простой
умныйленивый) указатель на базе std::map. Но не дописал. Сейчас раскопал, доделал кое-как. Поглядите, может пригодится.
Кликните здесь для просмотра всего текста
| 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
| //SmartPtrIgP.h
using std::map;
using std::pair;
template<class T>
class Sp;
template<class T>
class GC
{
private:
friend class Sp<T>;
std::map< T*, pair<int /*cnt*/, int /*siz*/>> mapa;//array pointers
GC(){}
GC( const GC&);
GC& operator=( GC& );
static GC& getInstance() {
static GC instance;
return instance;
}
void Add(T *rhs)
{
if( mapa.empty())return;
map< T*, pair<int,int>>:: iterator fnd=mapa.end();
fnd=mapa.find(rhs);
if(fnd != mapa.end())
{
((*fnd).second).first++;
}
}
void Add(const T *rhs)
{
Add(rhs);
}
void AddNew(T *rhs,int sz)
{
pair<int, int > prVal(0, sz);
pair<T*, pair<int, int >> pr(rhs,prVal);
mapa.insert(pr);
}
void AddNew(const T *rhs, int sz)
{
AddNew(rhs, sz);
}
bool remove(T *rhs)
{
bool is_empty=false;
if(mapa.empty())return !is_empty;
map< T*, pair<int,int>>:: iterator fnd;
fnd=mapa.find(rhs);
if(fnd != mapa.end())
{
((*fnd).second).first--;
if(((*fnd).second).first==0)
{
is_empty=true;
T *toDel=(*fnd).first;
int sz=((*fnd).second).second;
if(sz==1)delete toDel;
else delete [] toDel;
mapa.erase(fnd);
}
}
return is_empty;
}
public:
T *operator()(const T &rhs)
{
T *ptr = new T(rhs);
AddNew(ptr,1);
return ptr;
}
T *operator[](int rhs)
{
T *ptr = new T[rhs];
AddNew(ptr, rhs);
return ptr;
}
void print_map()
{
cout<<"\n____________pointers_to_arrays__________________\n";
map< T*, pair<int,int>>:: iterator ita=mapa.begin();
for(;ita!=mapa.end();++ita)
{
cout<<(*ita).first<<" "<<((*ita).second).first<<endl;
}
}
size_t get_size(T *rhs)
{
size_t ret=0;
if( mapa.empty())return ret;
map< T*, pair<int,int>>:: iterator fnd=mapa.end();
fnd=mapa.find(rhs);
if(fnd != mapa.end())
{
ret=((*fnd).second).second;
}
return ret;
}
};
template<class T>
class Sp
{
friend class GC<T>;
T *ptr;
public:
static GC<T> &NEW;
int PointersInDataBase()const
{
return NEW.mapa.size();
}
void ptintPtrDBsize()const
{
cout<<endl<<"PointersInDataBase size= "<<PointersInDataBase()<<endl;
}
~Sp()
{
NEW.remove(ptr);
}
Sp()
{
ptr=NULL;
}
Sp(const T &rhs)
{
ptr =const_cast<T*>(&rhs);
NEW.Add(ptr);
}
Sp(T &rhs)
{
ptr = &rhs;
NEW.Add(ptr);
}
Sp(const T *rhs)
{
ptr = const_cast<T*>(rhs);
NEW.Add(ptr);
}
Sp(T *const rhs)
{
ptr = rhs;
NEW.Add(ptr);
}
Sp(const Sp &rhs)
{
ptr = rhs.ptr;
NEW.Add(ptr);
}
Sp &operator=(const Sp &rhs)
{
NEW.remove(ptr);
ptr=rhs.ptr;
NEW.Add(ptr);
return *this;
}
Sp &operator=(T * rhs)
{
if(this.ptr==rhs)return *this;
NEW.remove(ptr);
ptr=const_cast<T*>(rhs);
NEW.Add(ptr);
return *this;
}
const T *operator->()const{return ptr;}
const T &operator*()const{return *ptr;}
T &operator[](int ind){return *(ptr+ind);}
size_t get_size()
{
size_t ret=0;
ret=NEW.get_size(ptr);
return ret;
}
void printVal()
{
size_t sz_ptr=NEW.get_size(ptr);
for(size_t i=0; i<sz_ptr; ++i)
{
cout<<ptr[i]<<endl;
}
if(!sz_ptr)cout<<*ptr<<endl;
}
};
template<typename T>
GC<T> &Sp<T>::NEW= GC<T>::getInstance();//статический экземпляр синглтона Маерса) |
|
//main.cpp
| 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<map>
#include"SmartPtrIgP.h"
#include <vector>
#include <algorithm>
#include <ctime>
//тест класса Sp<T> - указатель с признаками интеллекта,
//со сборщиком реализованным на std::map
//то есть - ну оч-чень ленивый указатель)
using namespace std;
struct A
{
int n;
static bool isExpressed;
static int cnt;
static int del;
static const int N=10000;
double myArray[N];
void arrInit()
{
for(int i=0; i<N; i++)
myArray[i]=i;
}
void arrInit(const double *a)
{
for(int i=0; i<N; i++)
myArray[i]=a[i];
}
A()
{
cnt++;
n=0;
arrInit();
if(isExpressed) cout<<"A()"<<cnt<<endl;
}
A(const int a)
{
cnt++;
n=a;
arrInit();
if(isExpressed)cout<<"A(const int)"<<cnt<<endl;
}
A(const A &a)
{
cnt++;
n=a.n;
arrInit(a.myArray);
if(isExpressed)cout<<"A(const A&)"<<cnt<<endl;
}
~A(){
del++;
if(isExpressed)cout<<"~A()"<<del<<endl;
}
int operator<(const A &rhs)const
{
return n<rhs.n;
}
};
int A::cnt=0;
int A::del=0;
bool A::isExpressed=true;
int compireByPtr(Sp<A> lhs, Sp<A> rhs)
{
return *lhs<*rhs;
}
void localOperationalScope()
{
const int size=1000;
A::isExpressed =false;
A *arr = new A[size];
srand((unsigned)time(NULL));
for(int i=0;i<size;i++){
arr[i].n=rand()%(size-1);
}
vector<A> first;
for(int i=0;i<size;i++)first.push_back(arr[i]);
for(int i=0;i<size;i++)cout<<first[i].n<<" ";
cout<<endl;
clock_t tBegFirst=clock();
sort(first.begin(), first.end());
clock_t tEndFirst=clock ();
clock_t spanF= tEndFirst-tBegFirst;
for(int i=0;i<size;i++)cout<<first[i].n<<" ";
cout<<endl;
cout<<"first elapsed "<<spanF<<endl;
vector<Sp<A>> second;
for(int i=0;i<size;i++)
second.push_back(Sp<A>(arr[i]));
clock_t tBegSecond=clock();
sort(second.begin(), second.end(),compireByPtr);
clock_t tEndSecond=clock();
clock_t spanS=tEndSecond-tBegSecond;
cout<<"second elapsed "<<spanS<<endl;
for(int i=0;i<size;i++)cout<<second[i]->n<<" ";
cout<<"\nfirst processing takes "<<(float)spanF/spanS<<" times more time than second"<<endl;
cout << endl;
}
int main()
{
localOperationalScope();
cout<<"Количество указателей в базе после возврата:"<<endl;
Sp<A> sp_last;//это для вызова метода ptintPtrDBsize()
//но любой локальный указатель не указывающий на динамическую память
//выделенную классом Sp не попадает в базу
sp_last.ptintPtrDBsize();
cin.get();
return 0;
} |
|
Вот кусочек показывающий как с динамической памятью работает.
Кликните здесь для просмотра всего текста
| 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
| //тест с выделением динамической памяти
struct ValType
{
string mess_str;
ValType()
{
mess_str="default";
}
ValType(const char* c_str)
{
mess_str=c_str;
}
ValType(const ValType &rhs)
{
mess_str=rhs.mess_str;
}
friend ostream & operator<<(ostream &os, const ValType &val);
};
ostream & operator << (ostream &os, const ValType &val)
{
os<<val.mess_str;
return os;
}
Sp<ValType> foo(const ValType vt)
{
const Sp<ValType> sp_loc=&vt;
Sp<ValType> sp_dynamic1=Sp<ValType>::NEW(vt);
Sp<ValType> sp_loc_dynamic1=sp_dynamic1;
Sp<ValType> sp_loc_dynamic2=sp_dynamic1;
Sp<ValType> sp_dynamic2=Sp<ValType>::NEW(vt);
Sp<ValType> sp_dynamic3=Sp<ValType>::NEW(vt);
Sp<ValType> sp_dynamic4=Sp<ValType>::NEW(vt);
cout<<"before array ";
sp_loc.ptintPtrDBsize();
Sp<ValType> sp_dynamic_array=Sp<ValType>::NEW[10];
cout<<"sp_dynamic_array.get_size()= "<<sp_dynamic_array.get_size()<<endl;
Sp<ValType> sp_loc_dynamic5=sp_dynamic_array;//локальный указатель установлен на
//созданный массив, - проверка) работает нормально
cout<<"sp_loc_dynamic5.get_size()= "<<sp_loc_dynamic5.get_size()<<endl;
string n="0";
for(size_t i=0; i<sp_dynamic_array.get_size(); ++i)//задаём значенияобъектов в массиве
{
n[0]='0'+i;
sp_dynamic_array[i].mess_str="mess "+n;
}
cout<<endl<<endl;
sp_dynamic_array.printVal();//печатаем что получилось
cout<<"\nFinnaly before return and destructors call:"<<endl;
sp_loc.NEW.print_map();
cout<<"before return"<<endl;
sp_loc.ptintPtrDBsize();
return sp_loc_dynamic5;
}
int main()
{
ValType vt("Obj");
const Sp<ValType> sp_loc=&vt;
sp_loc.ptintPtrDBsize();
cout<<"befor the call"<<endl;
Sp<ValType> sp_loc1=foo(vt);//локальный указатель становится массивом
//то есть старое значение удаляется и создаётся новое
cout<<"after return"<<endl;
sp_loc1.printVal();
sp_loc.NEW.print_map();
sp_loc.ptintPtrDBsize();
system("pause");
return 0;
} |
|
(
Сообщение было отмечено anti-k как решение
Сообщение от anti-k
