 |
C++Talk.NET
C++ language newsgroups
|
| View previous topic :: View next topic |
| Author |
Message |
Guest
|
 Posted: Wed Oct 18, 2006 9:10 am Post subject: Completely emulate a pointer using templates |
 |
|
Hello!
I would like to write a pointer to type template that behaves exactly and
completely like normal pointers, which I will use as starting point for
other kinds of pointers that hold extra data (for example, one of my aims
is to have 64bit pointers on a 32bit machine, and ignore the highmost
32bits of the address, while still keeping it in structures and function
parameters, so I can start to migrate my 32bit OS to 64bit, although I
don't have a 64bit CPU, and make it behave like a 64bit system where only
the first 4GB space is really used (the highmost 32 bits are allocated but
simply always ignored)).
While I am fluent with various assembly languages, I'm not so much with C++,
but I'd like to learn. So far my efforts brought me to:
template<typename Type> struct Pt {
private:
void* Address; // on my machine, a void* is 32 bit
//void* Unused; // later I will add this member, to double the sizeof(Pt)
public:
// Default Constructor
Pt() {
}
// Copy Constructor
Pt(const Pt& Object) {
Address=Object.Address;
}
Pt& operator = (const Type* Address) {
this->Address=(void*)Address;
return(*this);
}
operator Type* () {
return((Type*)Address);
}
Type& operator * () const {
return(*(Type*)Address);
}
Type& operator [] (const int Subscript) const {
return(((Type*)Address)[Subscript]);
}
Type* operator -> () const {
return(Address);
}
Pt& operator + (const int Offset) {
*((Type*)Address)+=Offset;
return(*this);
}
Pt& operator - (const int Offset) {
*((Type*)Address)-=Offset;
return(*this);
}
// No need for a Destructor
//~Pt() {
//}
};
for each type, so far I typedef'ed the corresponding pointer this way:
typedef MyType* MyTypePt;
but from now on I will do it this other way instead:
typedef Pt<MyType> MyTypePt;
and expect identical functionality, but with twice as big pointers (when
I will uncomment that "Unused" member, of course).
Will this work ALWAYS? Have I missed the overloading of some important
operator? So far things seem to work, but I'm not sure that some subtle
bugs haven't appeared somewhere.
Could anybody, please, be so kind to fix eventual errors and address me
to the eventual extensions I need to make, in order to complete my pointer
emulation via template?
Thanks!
Mario |
|
| Back to top |
|
 |
Kai-Uwe Bux
Guest
|
| Posted: Wed Oct 18, 2006 9:10 am Post subject: Re: Completely emulate a pointer using templates |
|
|
mario.rossi (AT) REMOVETHISTOMAILMENOT (DOT) com wrote:
| Quote: |
Hello!
I would like to write a pointer to type template that behaves exactly and
completely like normal pointers, which I will use as starting point for
other kinds of pointers that hold extra data (for example, one of my aims
is to have 64bit pointers on a 32bit machine, and ignore the highmost
32bits of the address, while still keeping it in structures and function
parameters, so I can start to migrate my 32bit OS to 64bit, although I
don't have a 64bit CPU, and make it behave like a 64bit system where only
the first 4GB space is really used (the highmost 32 bits are allocated but
simply always ignored)).
While I am fluent with various assembly languages, I'm not so much with
C++, but I'd like to learn. So far my efforts brought me to:
template<typename Type> struct Pt {
private:
void* Address; // on my machine, a void* is 32 bit
|
Why not Type* ?
| Quote: | //void* Unused; // later I will add this member, to double the
sizeof(Pt)
public:
// Default Constructor
Pt() {
}
// Copy Constructor
Pt(const Pt& Object) {
Address=Object.Address;
|
What is Object.Address? Did you mean &Object or boost::addressof( Object ) ?
| Quote: | }
Pt& operator = (const Type* Address) {
|
Why the const? Do you define only pointers to const objects? Did you mean:
Type* const Address // const pointer to Type
as opposed to:
const Type* // pointer to const Type
| Quote: | this->Address=(void*)Address;
return(*this);
}
operator Type* () {
return((Type*)Address);
}
Type& operator * () const {
return(*(Type*)Address);
}
Type& operator [] (const int Subscript) const {
return(((Type*)Address)[Subscript]);
}
Type* operator -> () const {
return(Address);
}
Pt& operator + (const int Offset) {
*((Type*)Address)+=Offset;
return(*this);
}
Pt& operator - (const int Offset) {
*((Type*)Address)-=Offset;
return(*this);
}
// No need for a Destructor
//~Pt() {
//}
};
for each type, so far I typedef'ed the corresponding pointer this way:
typedef MyType* MyTypePt;
but from now on I will do it this other way instead:
typedef Pt<MyType> MyTypePt;
and expect identical functionality, but with twice as big pointers (when
I will uncomment that "Unused" member, of course).
Will this work ALWAYS? Have I missed the overloading of some important
operator? So far things seem to work, but I'm not sure that some subtle
bugs haven't appeared somewhere.
Could anybody, please, be so kind to fix eventual errors and address me
to the eventual extensions I need to make, in order to complete my pointer
emulation via template?
|
One omission: you should provide comparison operators ==, !=, <, >, <=, >=.
If you want to make those emulate pointer behavior, then you should also
specialize std::less< Pt<T> > to get a total ordering for the use with
standard containers.
Another omission is exemplified by this piece of code:
struct X {};
struct Y : public X {};
int main ( void ) {
Pt<Y> y_ptr ;
Pt<X> x_ptr ( y_ptr );
Y* y_raw;
X* x_raw ( y_raw );
}
Best
Kai-Uwe Bux |
|
| Back to top |
|
|
|
|
You cannot post new topics in this forum
You cannot reply to topics in this forum
You cannot edit your posts in this forum
You cannot delete your posts in this forum
You cannot vote in polls in this forum
|
|
FAQ
Search
Memberlist
Usergroups
Register
Profile
Log in to check your private messages
Log in
