1 #ifndef _RHEO_SMART_POINTER_H
2 #define _RHEO_SMART_POINTER_H
123 #include "rheolef/compiler.h"
130 template <
class T,
class C>
165 #pragma GCC diagnostic push
166 #pragma GCC diagnostic ignored "-Weffc++"
169 #pragma GCC diagnostic pop
171 counter (
const counter&);
184 template <
class T,
class C>
186 smart_pointer_base<T,C>::counter::counter (
T*
p)
190 template <
class T,
class C>
192 smart_pointer_base<T,C>::counter::~counter ()
196 #pragma GCC diagnostic push
197 #pragma GCC diagnostic ignored "-Weffc++"
198 template <
class T,
class C>
201 smart_pointer_base<T,C>::counter::operator++ ()
205 template <
class T,
class C>
208 smart_pointer_base<T,C>::counter::operator-- ()
210 if (--_n != 0)
return _n;
214 #pragma GCC diagnostic pop
218 template <
class T,
class C>
221 : _count(new_macro(counter(
p)))
224 template <
class T,
class C>
227 : _count(static_cast<counter*>(count))
231 template <
class T,
class C>
238 template <
class T,
class C>
242 if (_count != 0) { --(*_count); }
244 template <
class T,
class C>
249 if (_count != sp._count) {
256 template <
class T,
class C>
263 template <
class T,
class C>
270 template <
class T,
class C>
277 template <
class T,
class C>
284 template <
class T,
class C>
290 if (_count -> _p == 0)
return 0;
291 if (_count -> _n > 1) {
293 T* q = C()(*(_count -> _p));
294 _count = new_macro (counter(q));
298 template <
class T,
class C>
305 template <
class T,
class C>
312 template <
class T,
class C>
325 template <
typename T>
331 template <
typename T>
337 template <
typename T>
340 error_macro (
"no_copy functor called (illegal copy)");
350 template <
typename T>
369 template <
typename T>
388 template <
typename T>
406 #ifdef _RHEO_SMART_POINTER_TST_CC
416 class container_data {
426 container_data (
const container_data& x)
427 : values(new
T[x.
n]),
n(x.
n)
428 {
for (
int i=0; i<
n;i++) values[i]=x.values[i];}
429 container_data& operator= (
const container_data& x) {
432 for (
int i=0; i<
n;i++) values[i]=x.values[i];
436 explicit container_data(
int n1)
437 : values(new
T[n1]),
n(n1) {}
439 ~container_data() {
delete [] values; }
442 const T& operator[](
int i)
const
443 {
return values[i]; }
445 {
return values[i]; }
453 explicit container(
int n = 0);
456 const T& operator[](
int i)
const;
457 T& operator[](
int i);
462 container::container (
int n)
466 container::operator[] (
int i)
const {
468 return data().operator[] (i);
471 container::operator[] (
int i) {
473 return data().operator [] (i);
482 std::cerr <<
"fatal: It is not a true copy semantic." << std::endl;
485 std::cerr <<
"It seems to be a true copy semantic." << std::endl;
int main(int argc, char **argv)
smart_pointer_base(T *p=0)
smart_pointer_base(void *count, internal)
const T & operator*() const
const T * pointer() const
smart_pointer_base(const smart_pointer_base< T, C > &)
int reference_counter() const
const T * operator->() const
smart_pointer_base< T, C > & operator=(const smart_pointer_base< T, C > &)
counter * get_count() const
smart_pointer_clone< T > & operator=(const smart_pointer_clone< T > &x)
smart_pointer_clone(T *p=0)
smart_pointer_clone(const smart_pointer_clone< T > &x)
smart_pointer_clone(void *count, internal i)
smart_pointer_nocopy(const smart_pointer_nocopy< T > &x)
smart_pointer_nocopy(T *p=0)
smart_pointer_nocopy< T > & operator=(const smart_pointer_nocopy< T > &x)
smart_pointer_nocopy(void *count, internal i)
see the smart_pointer page for the full documentation
smart_pointer(void *count, internal i)
smart_pointer(const smart_pointer< T > &x)
smart_pointer< T > & operator=(const smart_pointer< T > &x)
This file is part of Rheolef.
T * operator()(const T &from)
T * operator()(const T &data)
T * operator()(const T &from)