Re: passing ref to ptr again as ref to ptr....

From:

"Bo Persson" <bop@gmb.dk>

Newsgroups:

comp.lang.c++

Date:

Sat, 26 Apr 2008 09:38:04 +0200

Message-ID:

<67g4eqF2ofjurU1@mid.individual.net>

osama178@gmail.com wrote:

On Apr 25, 12:48 pm, "Bo Persson" <b...@gmb.dk> wrote:

osama...@gmail.com wrote:

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

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<class T> in 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*> provides. 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.

No, you will probably not.

On the compiler I use, templates will most often share code for
objects of the same size, as the linker will merge identical code
blocks. For example,

struct two
{
short x;
short y;
};

std::vector<int> v1;
std::vector<long> v2;
std::vector<two> v3;

will only generate one set of code in the resulting .exe file.

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?

Or it will possibly add to the code size by adding another layer. At
least it will add to the complexity of the code.

Bo Persson