passing ref to ptr again as ref to ptr....

[osama178]

Let's say I have this code

--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

};

class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue::P op(refToPtr); //--------------------(2)
}

};
Why doesn't the statement in -------(2) compile?

[osama178]

On Apr 24, 1:37 pm, osama...@gmail. com wrote:

Let's say I have this code

--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

};

class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue::P op(refToPtr); //--------------------(2)
}

};

Why doesn't the statement in -------(2) compile?

And I did have the

template<class Tin front of SpecialClass. Sorry!. I just posted a
snippet here.

[Kai-Uwe Bux]

os******@gmail. com wrote:

On Apr 24, 1:37 pm, osama...@gmail. com wrote:

>Let's say I have this code

--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

};

class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue:: Pop(refToPtr); //--------------------(2)
}

};

Why doesn't the statement in -------(2) compile?

Because T*& and void*& are different types with no automatic conversions
between them.

And I did have the

template<class Tin front of SpecialClass. Sorry!. I just posted a
snippet here.

Why do you run your own code for queue? It seems as though std::queue<T*>
might be what you are looking for.
Best

Kai-Uwe Bux

[osama178]

On Apr 24, 7:14 pm, Kai-Uwe Bux <jkherci...@gmx .netwrote:

osama...@gmail. com wrote:

On Apr 24, 1:37 pm, osama...@gmail. com wrote:

Let's say I have this code

--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

};

class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue::P op(refToPtr); //--------------------(2)
}

};

Why doesn't the statement in -------(2) compile?

Because T*& and void*& are different types with no automatic conversions
between them.

And I did have the

template<class Tin front of SpecialClass. Sorry!. I just posted a
snippet here.

Why do you run your own code for queue? It seems as though std::queue<T*>
might be what you are looking for.

Best

Kai-Uwe Bux

I am implementing a lockless queue, which I don't think the
std::queue<T*pr ovides. To avoid template-induced code bloat, I am
implementing a generic the queue using void* pointers. But to gain
type-safety, I am implementing a templated interface-class.

Now what is confusing me is that this function works
SpecialQueue::P ush(T* ptr) { GenericQueue::P ush(ptr); }

and it converts T* to void* no problem.

But when I do

SpecialQueue::P op(T*& refPtr) { GenericQueue::P op(refPtr); }

Now let's say I instantiate an object

SpecialQueue<in tspQ();
int a = 10;
int p = &a;
spQ.Pop(p);

It gives me this error:

"cannot convert parameter 1 from 'int *' to 'void *&'"

[osama178]

On Apr 24, 7:14 pm, Kai-Uwe Bux <jkherci...@gmx .netwrote:

osama...@gmail. com wrote:

On Apr 24, 1:37 pm, osama...@gmail. com wrote:

Let's say I have this code

--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

};

class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue::P op(refToPtr); //--------------------(2)
}

};

Why doesn't the statement in -------(2) compile?

Because T*& and void*& are different types with no automatic conversions
between them.

Sorry. Why don't we need automatic type conversion from T* to void*
but need it from T*& to void*&.
I am still learning C++, so please excuse my ignorance.

[Pete Becker]

On 2008-04-25 12:32:38 -0400, os******@gmail. com said:

>
Sorry. Why don't we need automatic type conversion from T* to void*
but need it from T*& to void*&.
I am still learning C++, so please excuse my ignorance.

You need the type conversion in both cases. The difference is that the
first conversion is part of the language, and the second one is not.

void f0(void*);
void g(int *pi)
{
f0(pi); // okay: automatic conversion from int* to void*
}

void f1(void*&);
void h(int *&rpi)
{
f1(rip); // error: no conversion from int*& to void*&
}

--
Pete
Roundhouse Consulting, Ltd. (www.versatilecoding.com) Author of "The
Standard C++ Library Extensions: a Tutorial and Reference
(www.petebecker.com/tr1book)

[Bo Persson]

os******@gmail. com wrote:

On Apr 24, 7:14 pm, Kai-Uwe Bux <jkherci...@gmx .netwrote:

>osama...@gmail .com wrote:

>>On Apr 24, 1:37 pm, osama...@gmail. com wrote:
Let's say I have this code

>>>--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

>>>};

>>>class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue ::Pop(refToPtr) ; //--------------------(2)
}

>>>};

>>>Why doesn't the statement in -------(2) compile?

Because T*& and void*& are different types with no automatic
conversions between them.

>>And I did have the

>>template<clas s Tin front of SpecialClass. Sorry!. I just posted
a snippet here.

Why do you run your own code for queue? It seems as though
std::queue<T*m ight be what you are looking for.

Best

Kai-Uwe Bux

I am implementing a lockless queue, which I don't think the
std::queue<T*pr ovides. To avoid template-induced code bloat, I am
implementing a generic the queue using void* pointers.

And you believe you can outsmart the compiler?

I wouldn't bet on that. ;-)
Bo Persson

[osama178]

On Apr 25, 12:48 pm, "Bo Persson" <[e-mail] te:

osama...@gmail. com wrote:

On Apr 24, 7:14 pm, Kai-Uwe Bux <jkherci...@gmx .netwrote:

osama...@gmail. com wrote:
On Apr 24, 1:37 pm, osama...@gmail. com wrote:
Let's say I have this code

>>--------------------
class GenericQueue
{
public:
bool Pop(void*& refToPtr); // //--------------------(1)

>>};

>>class SpecialQueue: private GenericQueue
{
public:
bool Pop(T*& refToPtr)
{
return
GenericQueue: :Pop(refToPtr); //--------------------(2)
}

>>};

>>Why doesn't the statement in -------(2) compile?

Because T*& and void*& are different types with no automatic
conversions between them.

>And I did have the

>template<cla ss Tin front of SpecialClass. Sorry!. I just posted
a snippet here.

Why do you run your own code for queue? It seems as though
std::queue<T*mi ght be what you are looking for.

Best

Kai-Uwe Bux

I am implementing a lockless queue, which I don't think the
std::queue<T*pr ovides. To avoid template-induced code bloat, I am
implementing a generic the queue using void* pointers.

And you believe you can outsmart the compiler?

I wouldn't bet on that. ;-)

Bo Persson

Why not?

If you instantiate GenericQueue a dozen times, you'll have a dozen
copies of its code. But if you use GenericQueue for storing void*
pointers instead, make its ctor, copy ctor, and assig operator
private, you'll prevent clients from making instances of it AND you'll
have only one version of the code. And the templated interface class
will implement its functionality in-terms-of GenericQueue
functionality and provide for type safety. The code in the interface
class is substantially less than that of the GenericQueue and will not
result in as much code bloat. No?

Of course I'll have to account for the fact that a pointer to an
object might have been pushed onto multiple stacks.

[osama178]

On Apr 25, 1:09 pm, osama...@gmail. com wrote:

On Apr 25, 12:48 pm, "Bo Persson" <[e-mail] te:

osama...@gmail. com wrote:

On Apr 24, 7:14 pm, Kai-Uwe Bux <jkherci...@gmx .netwrote:
>osama...@gmail .com wrote:
>>On Apr 24, 1:37 pm, osama...@gmail. com wrote:
>>>Let's say I have this code

>>>--------------------
>>>class GenericQueue
>>>{
>>>public:
>>> bool Pop(void*& refToPtr); // //--------------------(1)

>>>};

>>>class SpecialQueue: private GenericQueue
>>>{
>>>public:
>>> bool Pop(T*& refToPtr)
>>> {
>>> return
>>>GenericQueue ::Pop(refToPtr) ; //--------------------(2)
>>> }

>>>};

>>>Why doesn't the statement in -------(2) compile?

>Because T*& and void*& are different types with no automatic
>conversions between them.

>>And I did have the

>>template<clas s Tin front of SpecialClass. Sorry!. I just posted
>>a snippet here.

>Why do you run your own code for queue? It seems as though
>std::queue<T*m ight be what you are looking for.

>Best

>Kai-Uwe Bux

I am implementing a lockless queue, which I don't think the
std::queue<T*pr ovides. To avoid template-induced code bloat, I am
implementing a generic the queue using void* pointers.

And you believe you can outsmart the compiler?

I wouldn't bet on that. ;-)

Bo Persson

Why not?

If you instantiate GenericQueue a dozen times, you'll have a dozen
copies of its code. But if you use GenericQueue for storing void*
pointers instead, make its ctor, copy ctor, and assig operator
private, you'll prevent clients from making instances of it AND you'll
have only one version of the code. And the templated interface class
will implement its functionality in-terms-of GenericQueue
functionality and provide for type safety. The code in the interface
class is substantially less than that of the GenericQueue and will not
result in as much code bloat. No?

Of course I'll have to account for the fact that a pointer to an
object might have been pushed onto multiple stacks.

The idea is from Scott Myer's "Effective C++", Item 42 - Use Private
Inheritance Judiciously.

[Ivan Vecerina]

<os******@gmail .comwrote in message
news:39******** *************** ***********@i36 g2000prf.google groups.com...
: I am implementing a lockless queue, which I don't think the
: std::queue<T*pr ovides. To avoid template-induced code bloat, I am
: implementing a generic the queue using void* pointers. But to gain
: type-safety, I am implementing a templated interface-class.

This is a common optimization technique indeed (used back in early
C++ times). But keep in mind that, nowadays, some compilers/linkers
are able to automatically eliminate redundant copies of the same
code, such as those resulting from multiple template instantiations.

: Now what is confusing me is that this function works
:
:
: SpecialQueue::P ush(T* ptr) { GenericQueue::P ush(ptr); }
:
: and it converts T* to void* no problem.

Indeed: the compiler passes a *copy* of ptr to the generic function.
During this copy, it can make an implicit conversion from T* to void*.

: But when I do
:
: SpecialQueue::P op(T*& refPtr) { GenericQueue::P op(refPtr); }
....
: It gives me this error:
:
: "cannot convert parameter 1 from 'int *' to 'void *&'"

Mind the fact that the int* and void* may have different
in-memory representations (even though this is not the case
on the common processor architectures that you and I use).
You can force the behavior you are looking for by using an
explicit cast:
SpecialQueue::P op(T*& refPtr)
{ GenericQueue::P op(reinterpret_ cast<void*&>(re fPtr)); }
However, this will result in undefined behavior, even though
problems will only happen in "exotic" platforms. It will work
perfectly fine on most architectures, but is not portable.

In proper and portable C++, you would need to write:
bool SpecialQueue::P op(T*& refPtr)
{
void * ptr; // I assume this is an output-only parameter
bool const result = GenericQueue::P op(&ptr);
refPtr = static_cast<T*> (ptr); // ok, works if the
// previously pushed pointer was indeed a T* or NULL
// ( any T* can be converted to void* and then back )
return result;
}
As you see, C++ only allows the implicit conversions that are safe.
(except for those (many) that were inherited from C...)

Cheers -Ivan
--
http://ivan.vecerina.com/contact/?subject=NG_POST <- email contact form
Brainbench MVP for C++ <http://www.brainbench.com