Re: passing ref to ptr again as ref to ptr....
On Apr 26, 9:38 am, "Bo Persson" <b...@gmb.dk> wrote:
osama...@gmail.com wrote:
[...]
I am implementing a lockless queue, which I don't think
the std::queue<T*> provides.
You'd have to see the documentation for your implementation, but
by default, std::queue is lockless, since there are no locks (or
threads) in the standard. Most of the implementations I'm
familiar with do not use locks even in multithreaded
environments.
If you mean that you intent to implement a queue which can be
used without locks in a multithreaded environment, be aware that
you'll need some implementation dependent code; it can't be done
in standard C++.
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. ;-)
Why not?
If you instantiate GenericQueue a dozen times, you'll have a
dozen copies of its code.
No, you will probably not.
If the types are different, and the compiler is conform, he
probably will.
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.
I certainly hope not. That wouldn't be conform. (I presume, of
course, that the compiler will only do so if the objects are
PODs as well. Otherwise, the code won't be identical.)
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.
Despite the fact that the member functions of v1, v2 and v3 are
guaranteed to have different addresses?
None of the compilers I use do this (at least not to my
knowledge).
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.
It was a more or less standard technique back when templates
first appeared, and memory was a bit scarcer. Even today, it
might be used to reduce coupling; all of the complicated parts
of the implementation are non-template, and so don't have to be
in the header. (I use it in a couple of my classes, but more
for historical reasons than anything else---the original
implementation dates back to a time when memory was scarcer. In
fact, the original implementation often dates back to
<generic.h>, when you definitely moved as much as possible out
of the "template", since the "template" was in fact an
impossible to debug macro.)
--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orient=E9e objet/
Beratung in objektorientierter Datenverarbeitung
9 place S=E9mard, 78210 St.-Cyr-l'=C9cole, France, +33 (0)1 30 23 00 34