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

Возвращение ссылки на указатель использование её как левостороннего значения - C++

Восстановить пароль Регистрация
 
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
05.09.2013, 12:20     Возвращение ссылки на указатель использование её как левостороннего значения #1
Есть шаблон:

C++
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
//-------------------------------------------------------
template<class T> 
struct ts {
private:
    void* data;
public:
    ts(T* pt) : data(pt) { }
    
    T& get_data() { return *static_cast<T*>(data); }
 
// интересующий меня метод:
 
    T*& elem()  { 
        return static_cast<T*>(data);       
    }
    
};
//-------------------------------------------------------
Нужно чтобы работал такой код:

C++
1
2
3
4
5
6
7
8
9
10
    ts<int> t(new int(10));
    t.get_data() = 20;
    cout << t.get_data() << endl;
 
    *t.elem() = 25;
    cout << t.get_data() << endl;
    
// переназначение t.data
    t.elem() = new int(30);
    cout << t.get_data() << endl;
Помогите пожалуйста понять как это реализовать! Почему не компилируется:
C++
1
2
3
4
5
6
7
//-------------------------------------------------------
    T*& elem()  { 
        return static_cast<T*>(data);       
    }
    
};
//-------------------------------------------------------
а

C++
1
2
3
4
5
6
7
8
9
//-------------------------------------------------------
    T*& elem()  { 
 
        T* temp=static_cast<T*>(data);
        return temp;    
    }
    
};
//-------------------------------------------------------
компилируется, но не позволяет переназначить указатель void* ts::data ?
Similar
Эксперт
41792 / 34177 / 6122
Регистрация: 12.04.2006
Сообщений: 57,940
05.09.2013, 12:20     Возвращение ссылки на указатель использование её как левостороннего значения
Посмотрите здесь:

C++ Указатели и ссылки. Имя массива как указатель
Про возвращение значения... C++
C++ Про возвращение значения 2...
возвращение ненулевого значения C++
Возвращение значения в классе C++
После регистрации реклама в сообщениях будет скрыта и будут доступны все возможности форума.
Raali
572 / 276 / 12
Регистрация: 06.07.2013
Сообщений: 917
Завершенные тесты: 1
05.09.2013, 13:19     Возвращение ссылки на указатель использование её как левостороннего значения #2
Цитата Сообщение от Cynacyn Посмотреть сообщение
T*& elem()
почему не T * elem()
хотя не понятен смысл возврата указателя void
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
05.09.2013, 13:28  [ТС]     Возвращение ссылки на указатель использование её как левостороннего значения #3
Цитата Сообщение от Raali Посмотреть сообщение
почему не T * elem()
хотя не понятен смысл возврата указателя void
мне нужно возвращать именно указатель void* data, чтобы иметь возможно удалять, обнулять и переназначать его

если использовать T* elem() тогда будет возвращаться копия указателя data, которая хоть и содержит тот же адрес что и data, но если эту копию переназначить, data останется неизменным
к тому же, если использовать T* elem():
C++
1
t.elem() = new int(30);
компилятор выдает:
C++
1
2
3
4
1>------ Построение начато: проект: EmptyConsole01, Конфигурация: Debug Win32 ------
1>  code.cpp
1>code.cpp(42): error C2106: =: левый операнд должен быть левосторонним значением
========== Построение: успешно: 0, с ошибками: 1, без изменений: 0, пропущено: 0 ==========
Raali
572 / 276 / 12
Регистрация: 06.07.2013
Сообщений: 917
Завершенные тесты: 1
05.09.2013, 13:30     Возвращение ссылки на указатель использование её как левостороннего значения #4
остается T** elem() {return (T**)(&data);}
Kuzia domovenok
 Аватар для Kuzia domovenok
1882 / 1737 / 116
Регистрация: 25.03.2012
Сообщений: 5,907
Записей в блоге: 1
05.09.2013, 13:31     Возвращение ссылки на указатель использование её как левостороннего значения #5
да сделай ты его публичным, наконец то!
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
05.09.2013, 14:12  [ТС]     Возвращение ссылки на указатель использование её как левостороннего значения #6
Цитата Сообщение от Raali Посмотреть сообщение
остается T** elem() {return (T**)(&data);}
да, это работает, но всё дело в том, что весь смысл в "красивом" и понятном коде.

C++
1
2
3
4
5
6
7
    T** elem()  { 
         
        return (reinterpret_cast<T**>(&data));      
 
//--------------
*t.elem() = new int(30); // не очень красиво
    }
Цитата Сообщение от Kuzia domovenok Посмотреть сообщение
да сделай ты его публичным, наконец то!
Я то сделаю, но вопрос же останется (:
Мне интересно, возможно ли это. Мне интересно почему нельзя сделать так
C++
1
2
3
T*& elem()  { 
        return static_cast<T*>(data);       
    }
Добавлено через 29 минут
Или почему не работает:
C++
1
2
3
    T*& elem()  { 
        return reinterpret_cast<T*&>(&data);       
    }
Raali
572 / 276 / 12
Регистрация: 06.07.2013
Сообщений: 917
Завершенные тесты: 1
05.09.2013, 14:38     Возвращение ссылки на указатель использование её как левостороннего значения #7
а если вот так
C++
1
2
3
     T*& elem()  { 
        return static_cast<T*&>(&data);       
    }
то разве не работает?
Croessmah
Модератор
Эксперт С++
 Аватар для Croessmah
11823 / 6802 / 769
Регистрация: 27.09.2012
Сообщений: 16,870
Записей в блоге: 2
Завершенные тесты: 1
05.09.2013, 14:42     Возвращение ссылки на указатель использование её как левостороннего значения #8
Цитата Сообщение от Cynacyn Посмотреть сообщение
но всё дело в том, что весь смысл в "красивом" и понятном коде.
Охренеть какая красота... зачем вообще класс тогда?
Понамешали шаблоны/void, а если я туда запихну указатель на какой-нибудь класс? Вы уверены, что прокатит?
Raali
572 / 276 / 12
Регистрация: 06.07.2013
Сообщений: 917
Завершенные тесты: 1
05.09.2013, 14:52     Возвращение ссылки на указатель использование её как левостороннего значения #9
вообще вот так вот работает, проверил только что

C++
1
2
3
    T*& elem()  { 
        return (T*&)data;       
    };
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
05.09.2013, 15:23  [ТС]     Возвращение ссылки на указатель использование её как левостороннего значения #10
Цитата Сообщение от Croessmah Посмотреть сообщение
Охренеть какая красота... зачем вообще класс тогда?
Понамешали шаблоны/void, а если я туда запихну указатель на какой-нибудь класс? Вы уверены, что прокатит?
Класс нужен для оптимизации размера контейнера, в котором только один data-член
C++
1
void** data = new void*[3]
;
чтобы везде подряд в коде не писать data[0], data[1], data[2] и не вызывать путаницы.

Что должно прокатить? Разве не без разницы на что указывает адресс, хранящийся в void*?

Добавлено через 6 минут
подробней, зачем это всё:
Страуструп. Принципы и практика использования С++. Глава 19. Упражнение 16.
Иногда желательно, чтобы пустой вектор был как можно более маленьким.
Например, можно интенсивно использовать класс vector< vector< vec
tor<int> > >, в котором большинство векторов пусто. Определите вектор так,
чтобы выполнялось условие sizeof (vector<int>)==sizeof (int*), т.е. что-
бы класс вектора состоял только из указателя на массив элементов, количества
элементов и указателя space.
Jupiter
Каратель
Эксперт C++
6542 / 3962 / 226
Регистрация: 26.03.2010
Сообщений: 9,273
Записей в блоге: 1
Завершенные тесты: 2
05.09.2013, 17:23     Возвращение ссылки на указатель использование её как левостороннего значения #11
Цитата Сообщение от Cynacyn Посмотреть сообщение
Класс нужен для оптимизации размера контейнера, в котором только один data-член
так в чем тут сакральный смысл использования void* ?
MoreAnswers
Эксперт
37091 / 29110 / 5898
Регистрация: 17.06.2006
Сообщений: 43,301
05.09.2013, 20:33     Возвращение ссылки на указатель использование её как левостороннего значения
Еще ссылки по теме:

C++ Возвращение ссылки или указателя на закрытый элемент класса.
C++ Возвращение ссылки на локальную переменную
Возвращение значения в функции, ссылки, вычислить корни квадратного уравнения C++

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

Или воспользуйтесь поиском по форуму:
Cynacyn
 Аватар для Cynacyn
33 / 33 / 0
Регистрация: 02.05.2013
Сообщений: 109
05.09.2013, 20:33  [ТС]     Возвращение ссылки на указатель использование её как левостороннего значения #12
Цитата Сообщение от Jupiter Посмотреть сообщение
так в чем тут сакральный смысл использования void* ?

Изначально класс контейнера содержит 4 члена:
C++
1
2
3
4
5
6
7
8
9
10
11
/*
инвариант:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
A alloc; // распределитель памяти
T* elem; // элементы вектора
int size; // количество элементов
int space; // количество памяти
Я не придумал другого способа сохранить минимальный размер пустого вектора, как использовать указатель
void** data;
где
data[0] - элементы вектора
data[1] - количество элементов
data[2] - количество памяти
а распределитель памяти не будет шаблонным.
Чтобы не писать в коде тут и там data[n], я решил использовать класс который бы обеспечивал доступ к указателям хранящимся в void** data, для этого мне нужен был метод, который бы возвращал data[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
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
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
// Принципы и практика использования C++ Глава 19
// Principles and Practice Using C++ Chapter 19
#include <iostream> 
#include <memory>  
#include <utility> 
 
using std::cout;
using std::allocator;
using std::out_of_range;
using std::string;
using std::stringstream;
//using std::swap;
using std::auto_ptr;
//------------------------------------------------------------------------------
 
template<class T, class A>
struct vvector_base {
    typedef ptrdiff_t difference_type ;
    typedef size_t size_type ;
 
    A alloc;
    T* elem;
    int sz;
    int space;
    vvector_base() : sz(0), elem(0), space(0) 
    {
        //cout << this << " vvector_base::vvector_base()" << endl; 
    }
    vvector_base(const A& a, int e,  int n) : alloc(a), elem(alloc.allocate(n)), sz(e), space(n)
    {
        //cout << this << " vvector_base::vvector_base(const A& a, int n)" << endl; 
    }
    vvector_base(const vvector_base&);
    vvector_base& operator=(const vvector_base&);
    ~vvector_base() 
    { 
        //cout << this << " vvector_base::~vvector_base()" << endl; 
        alloc.deallocate(elem,space); 
    }
 
};
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector_base<T,A>::vvector_base(const vvector_base& arg)
    :   sz(arg.sz), space(arg.space), elem(alloc.allocate(arg.space))
{
    //cout << this << " vvector_base::vvector_base(const vvector_base& arg)" << endl; 
    
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector_base<T,A>& vvector_base<T,A>::operator=(const vvector_base& arg) {
    //cout << this << " vvector_base& vvector_base::operator=(const vvector_base& arg)" << endl; 
 
    if(&arg==this) return *this; // self-assignment
 
    if(arg.space <= space) {
        for(int i=0; i<arg.sz; i++)
            alloc.construct(&elem[i],arg.elem[i]);
        sz = arg.sz;
        return *this;
    }
    
    auto_ptr<T> p(alloc.allocate(arg.space));
 
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    
    alloc.deallocate(elem,space);
    elem = p.release();
    sz = arg.sz;
    space = arg.space;
    return *this;
 
}
//------------------------------------------------------------------------------
 
template<class T, class A = allocator<T> >
class vvector : private vvector_base<T,A> {
/*
invariant:
    для 0<=n<sz elem[n] является n-м элементом
    sz<=space
    если sz<space, то после elem[sz-1] есть место
    для (space-sz) элементов типа T 
*/
 
    void copy(const vvector& arg); // copy elements value. don't carry about its size
 
public:
    vvector() 
    {
        //cout << this << " \tvvector::vvector()" << endl; 
    }
    explicit vvector(int s, const T& val = T()) // constructor; key-word "explicit"  have been added to prevent implicit conversion
    {
        sz = s;
        space = s;
        elem = alloc.allocate(s);
        for(int i=0;i<sz;i++)
            alloc.construct(&elem[i], val);
        //cout << this << " \tvvector::vvector(int s)" << endl; 
    }
  
    vvector(const vvector&);                       // copy constructor: define copy
    vvector& operator=(const vvector&);
  
    ~vvector() { // destructor
        //cout << this << " \tvvector::~vvector()" << endl;
    } 
             
    
    T& operator[](int n) {return elem[n];} // access without range checking
    const T& operator[](int n) const {return elem[n];} // access without range checking
    
    T& at(int n); // access with range checking
    const T& at(int n) const; // access with range checking
 
    int size() const { return sz; }               // the current size
    int capacity() const {return space; }
 
    void reserve(int newalloc);
    void resize(int newsize, T value = T());
    void push_back(T value);
};
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::copy(const vvector& arg) {
    for(int i=0; i<arg.sz; i++) 
        alloc.construct(&elem[i],arg.elem[i]);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>::vvector(const vvector& arg)
// allocate elements, then initialize them by copying
{
    //cout << this << " \t\tvvector::vvector(const vvector& arg)" << endl;
    sz = arg.sz;
    space = arg.sz;
    elem = alloc.allocate(arg.sz);
    copy(arg);
}
 
//------------------------------------------------------------------------------
template<class T, class A>
vvector<T,A>& vvector<T,A>::operator=(const vvector& arg) {
    //cout << this << " \t\tvvector::operator=(const vvector& v)" << endl;
    if(this==&arg) return *this;
 
    if(arg.sz<=space) {
        copy(arg);
        sz=arg.sz;
        return *this;
    }
    auto_ptr<T> p(alloc.allocate(arg.space));
    for(int i=0; i<arg.sz; i++)
        alloc.construct(&p.get()[i],arg.elem[i]);
    for(int i=0; i<sz; i++)
        alloc.destroy(&elem[i]);
    alloc.deallocate(elem,space);
    elem = p.release();
    space = sz = arg.sz;
    return *this;
}
 
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::reserve(int newalloc) {
 
    //cout << this << " \t\tvvector::reserve(int newalloc), newalloc==" << newalloc << endl;
    if(newalloc<=space) return;
 
    vvector_base<T,A> b(alloc,sz,newalloc);
    for(int i=0; i<sz; i++) 
        alloc.construct(&b.elem[i],elem[i]);
    for(int i=0; i<sz; i++) 
        alloc.destroy(&elem[i]);
    
    std::swap<vvector_base<T,A>>(*this,b);
    //cout << "vvector<T,A>::reserve, space == " << space << endl;
    
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::resize(int newsize, T value) {
    //cout << this << " \t\tvvector::resize(int newsize, T value)" << endl;
    if(newsize<0) return;
    if(!newsize) {
        for(int i=0; i<sz; i++) 
            alloc.destroy(&elem[i]);
        alloc.deallocate(elem,space);
        sz = 0;
        space = 0;
        elem = 0;
    }
    else {
        reserve(newsize);
        for(int i=sz; i<newsize; i++) 
            alloc.construct(&elem[i], value);
        for(int i=newsize; i<sz; i++) 
            alloc.destroy(&elem[i]);
        sz = newsize;
    }
}
 
//------------------------------------------------------------------------------
template<class T, class A>
void vvector<T,A>::push_back(T value) {
    //cout << this << " \t\tvvector::push_back(T value), size==" << sz << "; space==" << space << endl;
    if(!space) reserve(8);
    else if (sz==space) reserve(2*space);
    alloc.construct(&elem[sz], value);
    ++sz;
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
T& vvector<T,A>::at(int n) {
    
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
template<class T, class A> 
const T& vvector<T,A>::at(int n) const {
    if(n<0 || sz<=n) { 
        string s = "wrong index: ";
        stringstream ss;
        ss << n;
        s += ss.str();
        throw out_of_range(s);
    }
    return elem[n];
 
}
 
//------------------------------------------------------------------------------
Yandex
Объявления
05.09.2013, 20:33     Возвращение ссылки на указатель использование её как левостороннего значения
Ответ Создать тему
Опции темы

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