Velocity Reviews - How to create static array of template class object?

On Jun 30, 4:28 am, flowstudi...@gmail.com wrote:
> I have a template class object that I use as a mesaging queue
> between threads. I use it as a static object that I initialize
> like so:

> foo.h
> class foo{
> static LFQueue<const char*,100> lfqMyQueue;};

> foo.cpp
> LFQueue<const char*,100> Foo::lfqMyQueue;

> This has worked fine for me. The problems that I've run into
> is when I've attempted to get tricky and try and declare a
> number of LFQueue objects in a static array, so that I can
> access a number of queues out of a single object. I tried to
> do it like so:

> foo.h
> class foo{
> static LFQueue<const char*,100> aLFQArray[3];};

> foo.cpp
> LFQueue<const char*,100> Foo::aLFQArray[3];

> This compiles ok, but when I use it, the const char data goes
> out of scope and I get garbage when trying to read from the
> queue.

You're not being very specific, but if the first example really
works (and doesn't just seem to), then this should work as well.
It sounds, however, like you have problems with the lifetime
management of the objects pointed to by the char const*; as long
as you only pass string literals, there should be no problem,
but you can't pass much of anything else without some specific
lifetime management convensions.

Supposing that 1) you've provided correct synchronization in the
LFQueue class and 2) the implementation of std::string in your
compiler is thread safe (usually the case today), then you can
pass std::string without problems. Otherwise, I've had very
good results using a queue with std::auto_ptr at the interface
level (for polymorphic message objects, which can't be copied);
once the "object" is in the queue, the sending thread no longer
has access to it.

> I'm not sure if I failed to set it up right, or if the way the
> queue template class is setup makes this impossible. It's
> almost like the array is static, but the LFQueue elements are
> not?

Which objects? The char const* themselves should be managed by
the queue---if the queue is based on an std::deque (the obvious
and simplest solution), then they won't be static, but rather in
dynamically allocated memory (but std::deque will copy and
maintain them as needed). Obviously, the lifetime of whatever
the char const* points to is your business, which is why I said
that in practice, you can probably only use string literals.
(Or you do a new char[], and the receiver does a delete[]. But
that's just stupid, when you have a perfectly good class with
value semantics, std::string, available.)

> Anyway, if any of you could shed some light on how I could go
> about this given what you see above, that would be great.

Given that from what we see above, we have no idea how LFQueue
works, it's hard to say much. (If, for example, not only does
LFQueue have correct synchronization, but it also is specialized
to do a deep copy of the char const*, then I can't see a reason
why it wouldn't work. I'm willing to bet that this isn't the
case, however.)

> If you need more info I can post the LFQueue Template class
> code, but I wanted to make sure it wasn't something obvious
> with the way this was being declared.

We need both the LFQueue code, and at least a minimal example of
how it is being used (what you are passing, etc.).

--
James Kanze (GABI Software) email:james.kanze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientierter Datenverarbeitung
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34