How to create static array of template class object?

[flowstudioLA@gmail.com]

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*,100lfqMyQ ueue;
};
foo.cpp
LFQueue<const char*,100Foo::l fqMyQueue;

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*,100aLFQAr ray[3];
};
foo.cpp
LFQueue<const char*,100Foo::a LFQArray[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. 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?

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. 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.

Many thanks!
Haley

[James Kanze]

Re: How to create static array of template class object?

On Jun 30, 4:28 am, flowstudi...@gm ail.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*,100lfqMyQ ueue;};

foo.cpp
LFQueue<const char*,100Foo::l fqMyQueue;

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*,100aLFQAr ray[3];};

foo.cpp
LFQueue<const char*,100Foo::a LFQArray[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.kan ze@gmail.com
Conseils en informatique orientée objet/
Beratung in objektorientier ter Datenverarbeitu ng
9 place Sémard, 78210 St.-Cyr-l'École, France, +33 (0)1 30 23 00 34