How to create static array of template class object?

Discussion in 'C++' started by flowstudioLA@gmail.com, Jun 30, 2008.

  1. Guest

    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. 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
    , Jun 30, 2008
    #1
    1. Advertising

  2. James Kanze Guest

    On Jun 30, 4:28 am, 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:
    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
    James Kanze, Jun 30, 2008
    #2
    1. Advertising

Want to reply to this thread or ask your own question?

It takes just 2 minutes to sign up (and it's free!). Just click the sign up button to choose a username and then you can ask your own questions on the forum.

Share This Page