cast required for void** to int**

[andrew_nuss]

Hi,

I have a template array class on T with specialization for bloat when T
is void*. Thus when T is really an int*, my base ptr is physically a
void** and needs to be converted to an int**.

This doesn't work:

void** base = ...;
int** ibase = static_cast<int**>(base); // illegal

and this is bad practice:

void** base = ...;
int** ibase = reinterpret_cast<int**>(base);

What am I supposed to do? I've been warned away from all use of
reinterpret_cast on the moderated group, and this seems to be a newbie
question.

Andy

[Victor Bazarov]

an*********@yahoo.com wrote:

I have a template array class on T with specialization for bloat when
T is void*. Thus when T is really an int*, my base ptr is physically
a void** and needs to be converted to an int**.

"Needs"?

Let me get this...

template<class Tclass myarray;

template<class myarray<void*{
// some implementation
void** m_storage;
public:
void* operator[](int i) { return m_storage[i]; }
};

template<class Tclass myarray<T*: public myarray<void*{
// what's here?
public:
T* operator[](int i) { return static_cast<T*>(m_storage[i]); }
};

Is that what you're doing? No problem yet, right?

>
This doesn't work:

void** base = ...;
int** ibase = static_cast<int**>(base); // illegal

Why are you trying to convert void** to int**?

and this is bad practice:

void** base = ...;
int** ibase = reinterpret_cast<int**>(base);

What am I supposed to do? I've been warned away from all use of
reinterpret_cast on the moderated group, and this seems to be a newbie
question.

Perhaps you've chosen a bad algorithm. It's a dead end, and you just
don't want to admit it to yourself?

Post more code.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Ivan Vecerina]

<an*********@yahoo.comwrote in message
news:11*********************@i3g2000cwc.googlegrou ps.com...
: I have a template array class on T with specialization for bloat when
T
: is void*. Thus when T is really an int*, my base ptr is physically a
: void** and needs to be converted to an int**.
:
: This doesn't work:
:
: void** base = ...;
: int** ibase = static_cast<int**>(base); // illegal
:
: and this is bad practice:
:
: void** base = ...;
: int** ibase = reinterpret_cast<int**>(base);
:
: What am I supposed to do?

In theory, a void* may have a different in-memory representation
than int* -- even though conversions between the types are well
defined:
int i = 5;
void* p = &i;
*(int*)p = 6; // ok, i is now 6
**(int**)&p = 7; // undefined behavior !!

So if you want strictly portable code, you need to make sure
that the common implementation with void* arrays is always
addressed as a void* array.
: I've been warned away from all use of
: reinterpret_cast on the moderated group, and this seems to be a newbie
: question.

Specializing a template to use a common implementation is not
that much of a newbie question. It used to be more commonly
done a few years ago.
Note that some compilers/linkers today will automatically 'merge'
identical functions, and automatically take care of eliminating
the code bloat that you are trying to avoid.
hth -Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form

[andrew_nuss]

Victor Bazarov wrote:

Post more code.

template <typename T>
class PrivateArray {
T* ar;

public:
T* Ptr (int i) const
{
return ar+i;
}
};

template <typename T>
class Array : public PrivateArray<T{

public:
T& operator [] (int i) const
{
return *Ptr(i);
}
};

// specialize
template <typename T>
class Array<T*{
PrivateArray<void*ar;

public:

T& operator [] (int i) const
{
return *static_cast<T*>(ar.Ptr(i)); // illegal???
}
};

[andrew_nuss]

Victor Bazarov wrote:

Why are you trying to convert void** to int**?

The difference is that my operator[] function must return a reference
which is like a pointer to a pointer in this case. I want to avoid the
need to offer both set and get apis, but use ar[N] on both lhs and rhs.

The following snippet doesn't work for exactly the same reason that I'm
stuck:

void** p = ...;
int index = ...;
int*& val = static_cast<int*&>(p[index]); // illegal

Of course, reinterpret_cast and C-style casts work fine, but they're
bad practice?!

Andy

[Ivan Vecerina]

<an*********@yahoo.comwrote in message
news:11**********************@i3g2000cwc.googlegro ups.com...
: The following snippet doesn't work for exactly the same reason that
I'm
: stuck:
:
: void** p = ...;
: int index = ...;
: int*& val = static_cast<int*&>(p[index]); // illegal
:
: Of course, reinterpret_cast and C-style casts work fine,
: but they're bad practice?!

This is not a matter of good or bad practice, nor is it
about the use of reinterpret_cast itself.
It is a matter of knowing that your program is formally correct
and portable, because it obeys the rules of the C++ language.

Depending on what code you are working on, it might be
acceptable or not to break the rule. But if you intend your
code to be secure, maintainable, and portable, you probably
do not want to take this responsibility.
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form

[Victor Bazarov]

an*********@yahoo.com wrote:

Victor Bazarov wrote:

>Post more code.

template <typename T>
class PrivateArray {
T* ar;

public:
T* Ptr (int i) const
{
return ar+i;
}

Supposedly, 'ar' is somehow allocated making 'i' a valid index...

};

template <typename T>
class Array : public PrivateArray<T{

public:
T& operator [] (int i) const
{
return *Ptr(i);
}
};

// specialize
template <typename T>
class Array<T*{
PrivateArray<void*ar;

public:

T& operator [] (int i) const

Wait... If this is an array of pointers to T, why are you returing
a reference to T here? Shouldn't you return a reference to a _pointer_
to T?

{
return *static_cast<T*>(ar.Ptr(i)); // illegal???
}

I think you're missing one indirection here somewhere. But, let's say
you got it right:

T*& operator[] (int i) const { ...

How are you going to use it?

};

Please post the code where this array of pointers is going to be used.
Only the use patterns will dig out correct interfaces.

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[Old Wolf]

an*********@yahoo.com wrote:

>
This doesn't work:

void** base = ...;
int** ibase = static_cast<int**>(base); // illegal

and this is bad practice:

void** base = ...;
int** ibase = reinterpret_cast<int**>(base);

What am I supposed to do?

Well, I don't really understand why you are doing this, so I can't
answer that question.

But, a void ** can only point to a void *. Nothing else. It isn't
a generic pointer-to-pointer type. The only generic pointer type
is void* itself.

You could perhaps store your int* as void* in the first place and
then you can point to them with the void** ; or perhaps you
could use void * for base, rather than void ** (and remember to
keep your indirection level correct).

If your system happens to have void ** and int ** as being the
same size and representation, then you can "get away with"
a reinterpret cast. But your code would break when you port
to a platform where this guarantee doesn't hold.

[andrew_nuss]

Victor Bazarov wrote:

>

I think you're missing one indirection here somewhere. But, let's say
you got it right:

T*& operator[] (int i) const { ...

How are you going to use it?

};

Please post the code where this array of pointers is going to be used.
Only the use patterns will dig out correct interfaces.

Assuming that somehow we create a template Array<Twith following
unspecialized interface:

template <typename T>
class Array {
T* base; // if T==int*, then base==int**

public:
T& operator (int index) const
{
return base[index];
// ok as is, but not if we do specialization using
Array<void*>
}
};

Then I can use it with T=int* as follows once I solve the
specialization problem:

void Swap (Array<int*>& ar, int a, int b)
{
int* p = ar[a];
ar[a] = ar[b];
ar[b] = p;
}

[Victor Bazarov]

an*********@yahoo.com wrote:

Victor Bazarov wrote:

>>

I think you're missing one indirection here somewhere. But, let's
say you got it right:

T*& operator[] (int i) const { ...

How are you going to use it?

>>};

Please post the code where this array of pointers is going to be
used. Only the use patterns will dig out correct interfaces.

Assuming that somehow we create a template Array<Twith following
unspecialized interface:

template <typename T>
class Array {
T* base; // if T==int*, then base==int**

public:
T& operator (int index) const
{
return base[index];
// ok as is, but not if we do specialization using
Array<void*>

Why would you do your specialisation using Array<void*>? I am
still in the fog about this "premise".

}
};

Then I can use it with T=int* as follows once I solve the
specialization problem:

void Swap (Array<int*>& ar, int a, int b)
{
int* p = ar[a];
ar[a] = ar[b];
ar[b] = p;
}

What a weird way to swap... Why don't you use 'std::swap' and
do

std::swap(ar[a], ar[b]);

? But in any case, why would you keep an array of 'int*'? I
can understand an array of pointers to some base class to be used
polymorphically, but int*?

Are you just being hypothetical here?

V
--
Please remove capital 'A's when replying by e-mail
I do not respond to top-posted replies, please don't ask

[andrew_nuss]

Victor Bazarov wrote:

an*********@yahoo.com wrote:
Why would you do your specialisation using Array<void*>? I am
still in the fog about this "premise".

I was hoping to avoid bloat in the constructor and destructor which are
fairly involved. The program could have many instances of T such as
int*, char*, etc. If there was some safe way to internally hold the
representation of T* as void** then there would be no code bloat for
all T where T is a T*.

>
What a weird way to swap... Why don't you use 'std::swap' and
do

That was just an example to show that the operator[] needs to return a
reference since the array access is being used as both lhs-value and
rhs-value.

? But in any case, why would you keep an array of 'int*'? I
can understand an array of pointers to some base class to be used
polymorphically, but int*?

Are you just being hypothetical here?

Yes, just being hypothetical.

[Michal Nazarewicz]

an*********@yahoo.com writes:

Victor Bazarov wrote:
// specialize
template <typename T>
class Array<T*{
PrivateArray<void*ar;

public:

T& operator [] (int i) const
{
return *static_cast<T*>(ar.Ptr(i)); // illegal???
}
};

I don't quit understand the code but maybe:

#v+
template <typename Tclass Array<T*{
PrivateArray<T*ar;
public:
T& operator [] (int i) const { return *(ar.Ptr(i)); }
};
#v-

I mean: why do you need an array of "void*" instead of array of "T*"?

--
Best regards, _ _
.o. | Liege of Serenly Enlightened Majesty of o' \,=./ `o
..o | Computer Science, Michal "mina86" Nazarewicz (o o)
ooo +--<mina86*tlen.pl>--<jid:mina86*jabber.org>--ooO--(_)--Ooo--

[Earl Purple]

an*********@yahoo.com wrote:

I was hoping to avoid bloat in the constructor and destructor which are
fairly involved. The program could have many instances of T such as
int*, char*, etc. If there was some safe way to internally hold the
representation of T* as void** then there would be no code bloat for
all T where T is a T*.

I assume you are trying to implement a typed pointer array where
underneath you store them all as void*.

When it comes to providing iterators you now what to implement such as
a pointer so you are casting your array of void* to an array of T*.

Because the casting is all done secretly by your template you know that
what you are doing is safe.

You might, by the way, consider implementing the iterators as pointer
wrappers.