Smart Pointer help

[Protoman]

Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaration of `SmrtPtrDB' with no type" error.

Code:

SmrtPtr.hpp

#pragma once

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
delete this;
}
}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}
T& operator*(){ret urn *ptr;}
T* operator->(){return ptr;}
T** operator&(){ret urn &ptr;}
private:
static SmrtPtrDB<TData Base;
bool isInvalid()
{
for(;;)
if(!DataBase.st atus())
return true;
else return false;
}
T* ptr;
};
SmrtPtrDB.hpp

#pragma once
#include "SmrtPtr.hp p"

template<class T>
class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);
int status(){return num;}
private:
int num;
};

Could you help me out on this? I'm not even sure if I'm coding the
non-intrusive reference counting correctly. Thanks!!!!!

[Marco Wahl]

Protoman wrote:

Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaration of `SmrtPtrDB' with no type" error.

Code:

SmrtPtr.hpp

#pragma once

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
delete this;
}
}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}
T& operator*(){ret urn *ptr;}
T* operator->(){return ptr;}
T** operator&(){ret urn &ptr;}
private:
static SmrtPtrDB<TData Base;
bool isInvalid()
{
for(;;)
if(!DataBase.st atus())
return true;
else return false;
}
T* ptr;
};
SmrtPtrDB.hpp

#pragma once
#include "SmrtPtr.hp p"

template<class T>
class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);
int status(){return num;}
private:
int num;
};

Could you help me out on this? I'm not even sure if I'm coding the
non-intrusive reference counting correctly. Thanks!!!!!

You use the name 'SmrtPtrDB' in file 'SmrtPtr.hpp' before any
declaration.

HTH

[TB]

Protoman skrev:

Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaration of `SmrtPtrDB' with no type" error.

Code:

<snip>

>
SmrtPtrDB.hpp

#pragma once
#include "SmrtPtr.hp p"

template<class T>
class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);

void sub() { num--; }

--
TB @ SWEDEN

[Kai-Uwe Bux]

Protoman wrote:

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
delete this;
}
}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}
T& operator*(){ret urn *ptr;}
T* operator->(){return ptr;}
T** operator&(){ret urn &ptr;}
private:
static SmrtPtrDB<TData Base;
bool isInvalid()
{
for(;;)
if(!DataBase.st atus())
return true;
else return false;
}
T* ptr;
};

Is there a particular reason that you do not use whitespace?

I corrected several minor typos. Your error message arises since you use
SmrtPtrDB before defining it. Put both classes in the same file:

template<class T>
class SmrtPtrDB{
public:

SmrtPtrDB () :num (0) {}

~SmrtPtrDB () {}

void add() { num++; }

void sub() { num--; }

int status() { return num; }

private:

int num;

};

template<class T>
class SmrtPtr {
public:

explicit SmrtPtr ( T* obj )
: ptr ( obj )
{
DataBase.add() ;
for (;;) {
if ( isInvalid() ) {
delete this;
}
}
/*
What is this loop supposed to accomplish? Why would it terminate?
*/
}

SmrtPtr ( const SmrtPtr<T>& rhs)
:ptr (rhs.obj)
{
DataBase.add();
}

~SmrtPtr() {
delete ptr;
DataBase.sub();
}

T& operator*() { return *ptr; }

T* operator->() { return ptr; }

T** operator&() { return &ptr; }

private:

static SmrtPtrDB<TData Base;
/*
static? Why do you want to have one counter per type. One would expect a
counter per object.
*/
bool isInvalid()
{
for (;;) {
if (!DataBase.stat us() ) {
return true;
} else {
return false;
}
}
/*
This loop will never loop more than once.
*/
}

T* ptr;

};
What is this smart-pointer class supposed to accomplish?

Best

Kai-Uwe Bux

[Earl Purple]

Protoman wrote:

Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaration of `SmrtPtrDB' with no type" error.

Code:

SmrtPtr.hpp

#pragma once

non-standard pragma.

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)

reasonable so far although most smart-pointers have an implicit
constructor from the pointer type. Allows you to do this:

SmrtPtr< T getT()
{
return new T( params );
}

{
DataBase.add();

for(;;) // never ending loop, there is no "break"
{
if(isInvalid())

delete this;
}

delete this can be used only on classes created on the heap (i.e. with
new). Most smart pointers are created on the stack. Self-deletion would
be undefined. Note that this line will not cause loop termination.

}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}

T& operator*(){ret urn *ptr;}
T* operator->(){return ptr;}

These two should possibly be const functions. Not that they will return
pointers to const. (If you want that you use SmrtPtr< const T >) but
because it allows you to use these on temporaries.

T** operator&(){ret urn &ptr;}

very unusual to overload this.

private:
static SmrtPtrDB<TData Base;

There will be a DataBase for each type T, not for each object being
pointed to.

bool isInvalid()

another non-const function that probably should be const.

{
for(;;)

this loop at least will end beacuse you return in the middle.

if(!DataBase.st atus())
return true;
else return false;
}

If you are going to test a boolean condition then return the result
directly, thus:

return !Database.statu s();

T* ptr;
};
SmrtPtrDB.hpp

#pragma once
#include "SmrtPtr.hp p"

template<class T>
class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);
int status(){return num;}
private:
int num;
};

Could you help me out on this? I'm not even sure if I'm coding the
non-intrusive reference counting correctly. Thanks!!!!!

But you're reference counting the wrong thing. If you're not actually
going to use tr1::shared_ptr / boost::shared_p tr or Loki then at least
look up the source for boost or Loki to see how it's done. If their
code in places looks rather complex, that is because writing a good
non-intrusive smart-pointer is not as trivial as it first seems.
(Actually some of the complexity in boost comes from sharing code with
other types of smart-pointer. Much of the complexity also comes from
custom-deleters, automatic type-conversion and portability across
libraries).

[Protoman]

Earl Purple wrote:

Protoman wrote:

Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaration of `SmrtPtrDB' with no type" error.

Code:

SmrtPtr.hpp

#pragma once

non-standard pragma.

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)

reasonable so far although most smart-pointers have an implicit
constructor from the pointer type. Allows you to do this:

SmrtPtr< T getT()
{
return new T( params );
}

{
DataBase.add();

for(;;) // never ending loop, there is no "break"
{
if(isInvalid())

delete this;
}

delete this can be used only on classes created on the heap (i.e. with
new). Most smart pointers are created on the stack. Self-deletion would
be undefined. Note that this line will not cause loop termination.

}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}

T& operator*(){ret urn *ptr;}
T* operator->(){return ptr;}

These two should possibly be const functions. Not that they will return
pointers to const. (If you want that you use SmrtPtr< const T >) but
because it allows you to use these on temporaries.

T** operator&(){ret urn &ptr;}

very unusual to overload this.

private:
static SmrtPtrDB<TData Base;

There will be a DataBase for each type T, not for each object being
pointed to.

bool isInvalid()

another non-const function that probably should be const.

{
for(;;)

this loop at least will end beacuse you return in the middle.

if(!DataBase.st atus())
return true;
else return false;
}

If you are going to test a boolean condition then return the result
directly, thus:

return !Database.statu s();

T* ptr;
};
SmrtPtrDB.hpp

#pragma once
#include "SmrtPtr.hp p"

template<class T>
class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);
int status(){return num;}
private:
int num;
};

Could you help me out on this? I'm not even sure if I'm coding the
non-intrusive reference counting correctly. Thanks!!!!!

But you're reference counting the wrong thing. If you're not actually
going to use tr1::shared_ptr / boost::shared_p tr or Loki then at least
look up the source for boost or Loki to see how it's done. If their
code in places looks rather complex, that is because writing a good
non-intrusive smart-pointer is not as trivial as it first seems.
(Actually some of the complexity in boost comes from sharing code with
other types of smart-pointer. Much of the complexity also comes from
custom-deleters, automatic type-conversion and portability across
libraries).

OK, now I'm getting errors like:

4 C:\Dev-Cpp\9.cpp expected nested-name-specifier before "namespace"
6 C:\Dev-Cpp\SmrtPtrDB.h pp class `SmrtPtrDB' does not have any field
named `num'
8 C:\Dev-Cpp\SmrtPtrDB.h pp `num' undeclared (first use this function)

Here's the code:

SmrtPtr.hpp

#pragma once
#include "SmrtPtrDB. hpp"

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
{
this->~SmrtPtr();
break;
}
}
}
SmrtPtr(const SmrtPtr<T>& rhs):ptr(rhs.ob j){DataBase.add ()}
~SmrtPtr(){dele te ptr; DataBase.sub()}
T& operator*()cons t{return *ptr;}
T* operator->()const{retu rn ptr;}
T** operator&()cons t{return &ptr;}
private:
static SmrtPtrDB DataBase;
bool isInvalid()cons t
{
for(;;)
return!DataBase .status();
}
T* ptr;
};

SmrtPtrDB.hpp

#pragma once

class SmrtPtrDB
{
public:
SmrtPtrDB():num (0){}
~SmrtPtrDB(){}
void add(){num++;}
void sub(){num--);
int status(){return num;}
private:
int num;
};

9.cpp //main

#include <iostream>
#include <cstdlib>
#include "SmrtPtr.hp p"
using namespace std;

int main()
{
SmrtPtr<intptr( new int);
SmrtPtr<intptr2 (ptr);
delete ptr2;
system("PAUSE") ;
return EXIT_SUCCESS;
}

I have no idea what's the problem now. Thanks!!!!

[Ian Collins]

Protoman wrote:

Earl Purple wrote:

>>Protoman wrote:

>>>Here's a non intrusive reference counting smart pointer class I'm
working on; I keep getting a "22 C:\Dev-Cpp\SmrtPtr.hpp ISO C++ forbids
declaratio n of `SmrtPtrDB' with no type" error.

>
I have no idea what's the problem now. Thanks!!!!

You use non-standard pragmas, omit whitespace and don't fix the typos
identified in previous responses?

--
Ian Collins.

[Earl Purple]

Protoman wrote:

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
{
this->~SmrtPtr();
break;
}
}
}

You should only explicitly call a destructor when you have constructed
with placement new. Why should your smart-pointer have been constructed
this way?

You haven't really fixed your problem.

Just look at boost and loki to see how to write smart-pointers. And
then only write your own if you really need something that boost and
loki don't already support.

[Protoman]

Earl Purple wrote:

Protoman wrote:

template<class T>
class SmrtPtr
{
public:
explicit SmrtPtr(T* obj):ptr(obj)
{
DataBase.add();
for(;;)
{
if(isInvalid())
{
this->~SmrtPtr();
break;
}
}
}

You should only explicitly call a destructor when you have constructed
with placement new. Why should your smart-pointer have been constructed
this way?

You haven't really fixed your problem.

Just look at boost and loki to see how to write smart-pointers. And
then only write your own if you really need something that boost and
loki don't already support.

I'm writing this for the learning experience, not b/c I need it.

[Frederick Gotham]

Protoman posted:

>Just look at boost and loki to see how to write smart-pointers. And
then only write your own if you really need something that boost and
loki don't already support.

I'm writing this for the learning experience, not b/c I need it.

With that attitude you'll become a very proficient programmer indeed.
--

Frederick Gotham