templates & classes

Discussion in 'C++' started by chameleon, Feb 22, 2007.

  1. chameleon

    chameleon Guest

    I have 2 classes with exactly the same members (all static except
    dtor/ctor).
    Classes have different implementantion in only one static member
    function and first class has one more member function.

    How can I write this code with templates?
    First of all: Thought to write code with templates is correct?

    members of classes are static because refer to devices. There is no
    reason to be non-static.

    Thanks.

    2 classes follow:
    ------------------
    class ALDevices
    {
    static std::vector<std::string> lstDevices;
    // AND MOOOOOORE STATICs SHARED IN 2 CLASSES!

    public:
    ALDevices(); // IMPLEMENTENT DIFFERENT IN 2 CLASSES
    static void closeDevice(); // IMPLEMENTENT DIFFERENT IN 2 CLASSES

    static int getTotalDevices() { return lstDevices.size(); }
    // AND MOOOOOORE STATICs SHARED IN 2 CLASSES!

    static ALCcontext *getActiveContext() { return context; } // DOEN'T
    EXIST AT ALL IN SECOND CLASS
    };
    ------------------
    class ALCaptureDevices
    {
    static std::vector<std::string> lstDevices;
    // AND MOOOOOORE STATICs SHARED IN 2 CLASSES!

    public:
    ALCaptureDevices(); // IMPLEMENTENT DIFFERENT IN 2 CLASSES
    static void closeDevice(); // IMPLEMENTENT DIFFERENT IN 2 CLASSES

    static int getTotalDevices() { return lstDevices.size(); }
    // AND MOOOOOORE STATICs SHARED IN 2 CLASSES!
    };
    ------------------
     
    chameleon, Feb 22, 2007
    #1
    1. Advertising

  2. chameleon

    Markus Moll Guest

    Hi

    chameleon wrote:
    > I have 2 classes with exactly the same members (all static except
    > dtor/ctor).
    > Classes have different implementantion in only one static member
    > function and first class has one more member function.
    >
    > How can I write this code with templates?
    > First of all: Thought to write code with templates is correct?
    >
    > members of classes are static because refer to devices. There is no
    > reason to be non-static.


    Two suggestions:
    1. Redesign your program ;-)
    2. Build a class template parameterized by a single type, put all
    duplicated members in here. Derive both your classes from the
    instantiations of this class template for the respective class.

    Markus
     
    Markus Moll, Feb 22, 2007
    #2
    1. Advertising

  3. chameleon

    Pete Becker Guest

    chameleon wrote:
    > I have 2 classes with exactly the same members (all static except
    > dtor/ctor).
    > Classes have different implementantion in only one static member
    > function and first class has one more member function.
    >
    > How can I write this code with templates?
    > First of all: Thought to write code with templates is correct?
    >


    Seems like overkill. Put all the common stuff into a class, and write
    two derived classes.

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 22, 2007
    #3
  4. chameleon

    chameleon Guest

    O/H Pete Becker Ýãñáøå:
    > chameleon wrote:
    >> I have 2 classes with exactly the same members (all static except
    >> dtor/ctor).
    >> Classes have different implementantion in only one static member
    >> function and first class has one more member function.
    >>
    >> How can I write this code with templates?
    >> First of all: Thought to write code with templates is correct?
    >>

    >
    > Seems like overkill. Put all the common stuff into a class, and write
    > two derived classes.


    The problem here is that: All common stuff is static members.
    I want 2 template instantiations, so, 2 static member instances.

    If I derive 2 classes from one, both classes share common static members.
     
    chameleon, Feb 22, 2007
    #4
  5. chameleon wrote:
    > O/H Pete Becker Ýãñáøå:
    >> chameleon wrote:
    >>> I have 2 classes with exactly the same members (all static except
    >>> dtor/ctor).
    >>> Classes have different implementantion in only one static member
    >>> function and first class has one more member function.
    >>>
    >>> How can I write this code with templates?
    >>> First of all: Thought to write code with templates is correct?
    >>>

    >>
    >> Seems like overkill. Put all the common stuff into a class, and write
    >> two derived classes.

    >
    > The problem here is that: All common stuff is static members.


    Why is it a problem?

    > I want 2 template instantiations, so, 2 static member instances.


    Why?

    > If I derive 2 classes from one, both classes share common static
    > members.


    So?

    V
    --
    Please remove capital 'A's when replying by e-mail
    I do not respond to top-posted replies, please don't ask
     
    Victor Bazarov, Feb 22, 2007
    #5
  6. chameleon

    Pete Becker Guest

    chameleon wrote:
    > O/H Pete Becker Ýãñáøå:
    >> chameleon wrote:
    >>> I have 2 classes with exactly the same members (all static except
    >>> dtor/ctor).
    >>> Classes have different implementantion in only one static member
    >>> function and first class has one more member function.
    >>>
    >>> How can I write this code with templates?
    >>> First of all: Thought to write code with templates is correct?
    >>>

    >>
    >> Seems like overkill. Put all the common stuff into a class, and write
    >> two derived classes.

    >
    > The problem here is that: All common stuff is static members.
    > I want 2 template instantiations, so, 2 static member instances.
    >
    > If I derive 2 classes from one, both classes share common static members.


    They share whatever you put in the base class, and they don't share
    whatever you put in the derived classes. If it's not shared, don't put
    it in the base.

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 22, 2007
    #6
  7. chameleon

    Fei Liu Guest

    Victor Bazarov wrote:
    > chameleon wrote:
    >> O/H Pete Becker Ýãñáøå:
    >>> chameleon wrote:
    >>>> I have 2 classes with exactly the same members (all static except
    >>>> dtor/ctor).
    >>>> Classes have different implementantion in only one static member
    >>>> function and first class has one more member function.
    >>>>
    >>>> How can I write this code with templates?
    >>>> First of all: Thought to write code with templates is correct?
    >>>>
    >>> Seems like overkill. Put all the common stuff into a class, and write
    >>> two derived classes.

    >> The problem here is that: All common stuff is static members.

    >
    > Why is it a problem?
    >
    >> I want 2 template instantiations, so, 2 static member instances.

    >
    > Why?
    >
    >> If I derive 2 classes from one, both classes share common static
    >> members.

    >
    > So?
    >
    > V

    The description of the OP's problem requires that 2 classes do not share
    the storage of those static members. In this case, derivation won't
    work. static class members can often be thought of as class member as
    opposed to object member. The code as it is posted by the OP is fine. I
    don't believe template will create any new solution. Check the example
    code below:

    #include <iostream>
    using namespace std;

    struct base{
    static int x;
    static int getx(){ return x;}
    };

    struct d1 : base {
    static int getx(){ return x+1; }
    static int xx(){ return x*x; }
    };

    struct d2 : base {
    };

    int base::x = 10;

    int main(){
    d1 a; d2 b;

    cout << "d1::x = " << d1::getx() << " d2::x = " << d2::getx() << endl;
    cout << "a.x = " << a.getx() << " b.x = " << b.getx() << endl;
    a.x = 5;
    cout << "d1::x = " << d1::getx() << " d2::x = " << d2::getx() << endl;
    cout << "a.x = " << a.getx() << " b.x = " << b.getx() << endl;
    d1::x = 15;
    cout << "d1::x = " << d1::getx() << " d2::x = " << d2::getx() << endl;
    cout << "a.x = " << a.getx() << " b.x = " << b.getx() << endl;

    return 0;
    }
     
    Fei Liu, Feb 22, 2007
    #7
  8. chameleon

    Pete Becker Guest

    Fei Liu wrote:
    > The description of the OP's problem requires that 2 classes do not share
    > the storage of those static members. In this case, derivation won't
    > work.


    Of course it will. The things that aren't shared don't go in the base class.

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 22, 2007
    #8
  9. chameleon

    John Carson Guest

    "chameleon" <> wrote in message
    news:MIlDh.3628$
    > O/H Pete Becker Ýãñáøå:
    >> chameleon wrote:
    >>> I have 2 classes with exactly the same members (all static except
    >>> dtor/ctor).
    >>> Classes have different implementantion in only one static member
    >>> function and first class has one more member function.
    >>>
    >>> How can I write this code with templates?
    >>> First of all: Thought to write code with templates is correct?
    >>>

    >>
    >> Seems like overkill. Put all the common stuff into a class, and write
    >> two derived classes.

    >
    > The problem here is that: All common stuff is static members.
    > I want 2 template instantiations, so, 2 static member instances.
    >
    > If I derive 2 classes from one, both classes share common static
    > members.


    You can easily work around that with templates. A simple example follows.

    template <int n>
    class Base
    {
    static int x;
    public:
    static void Setx(int a_x)
    {
    x = a_x;
    }
    static int Getx()
    {
    return x;
    }
    };

    template <int n>
    int Base<n>::x;

    class Derived1: public Base<0>
    {
    };

    class Derived2: public Base<1>
    {
    };


    int main()
    {
    Derived1 d1;
    Derived2 d2;

    d1.Setx(1);
    d2.Setx(2);

    cout << "Static member x of d1 is " << d1.Getx() << endl;
    cout << "Static member x of d2 is " << d2.Getx() << endl;

    return 0;
    }

    --
    John Carson
     
    John Carson, Feb 23, 2007
    #9
  10. chameleon

    Alan Johnson Guest

    John Carson wrote:
    > "chameleon" <> wrote in message
    > news:MIlDh.3628$
    >> O/H Pete Becker Ýãñáøå:
    >>> chameleon wrote:
    >>>> I have 2 classes with exactly the same members (all static except
    >>>> dtor/ctor).
    >>>> Classes have different implementantion in only one static member
    >>>> function and first class has one more member function.
    >>>>
    >>>> How can I write this code with templates?
    >>>> First of all: Thought to write code with templates is correct?
    >>>>
    >>> Seems like overkill. Put all the common stuff into a class, and write
    >>> two derived classes.

    >> The problem here is that: All common stuff is static members.
    >> I want 2 template instantiations, so, 2 static member instances.
    >>
    >> If I derive 2 classes from one, both classes share common static
    >> members.

    >
    > You can easily work around that with templates. A simple example follows.
    >
    > template <int n>
    > class Base
    > {
    > static int x;
    > public:
    > static void Setx(int a_x)
    > {
    > x = a_x;
    > }
    > static int Getx()
    > {
    > return x;
    > }
    > };
    >
    > template <int n>
    > int Base<n>::x;
    >
    > class Derived1: public Base<0>
    > {
    > };
    >
    > class Derived2: public Base<1>
    > {
    > };
    >
    >
    > int main()
    > {
    > Derived1 d1;
    > Derived2 d2;
    >
    > d1.Setx(1);
    > d2.Setx(2);
    >
    > cout << "Static member x of d1 is " << d1.Getx() << endl;
    > cout << "Static member x of d2 is " << d2.Getx() << endl;
    >
    > return 0;
    > }
    >


    Your solution is correct, but requires assigning each derived class a
    unique int. You could instead just directly use the derived class as
    the template to the base:

    template <class Derived>
    class Base
    {
    static int x;
    public:
    static void Setx(int a_x)
    {
    x = a_x;
    }
    static int Getx()
    {
    return x;
    }
    };

    template <class Derived>
    int Base<Derived>::x;

    class Derived1: public Base<Derived1>
    {
    };

    class Derived2: public Base<Derived2>
    {
    };

    --
    Alan Johnson
     
    Alan Johnson, Feb 23, 2007
    #10
  11. chameleon

    John Carson Guest

    "Alan Johnson" <> wrote in message
    news:erlj7a$sl1$
    > John Carson wrote:
    >> "chameleon" <> wrote in message
    >> news:MIlDh.3628$
    >>> O/H Pete Becker Ýãñáøå:
    >>>> chameleon wrote:
    >>>>> I have 2 classes with exactly the same members (all static except
    >>>>> dtor/ctor).
    >>>>> Classes have different implementantion in only one static member
    >>>>> function and first class has one more member function.
    >>>>>
    >>>>> How can I write this code with templates?
    >>>>> First of all: Thought to write code with templates is correct?
    >>>>>
    >>>> Seems like overkill. Put all the common stuff into a class, and
    >>>> write two derived classes.
    >>> The problem here is that: All common stuff is static members.
    >>> I want 2 template instantiations, so, 2 static member instances.
    >>>
    >>> If I derive 2 classes from one, both classes share common static
    >>> members.

    >>
    >> You can easily work around that with templates. A simple example
    >> follows. template <int n>
    >> class Base
    >> {
    >> static int x;
    >> public:
    >> static void Setx(int a_x)
    >> {
    >> x = a_x;
    >> }
    >> static int Getx()
    >> {
    >> return x;
    >> }
    >> };
    >>
    >> template <int n>
    >> int Base<n>::x;
    >>
    >> class Derived1: public Base<0>
    >> {
    >> };
    >>
    >> class Derived2: public Base<1>
    >> {
    >> };
    >>
    >>
    >> int main()
    >> {
    >> Derived1 d1;
    >> Derived2 d2;
    >>
    >> d1.Setx(1);
    >> d2.Setx(2);
    >>
    >> cout << "Static member x of d1 is " << d1.Getx() << endl;
    >> cout << "Static member x of d2 is " << d2.Getx() << endl;
    >>
    >> return 0;
    >> }
    >>

    >
    > Your solution is correct, but requires assigning each derived class a
    > unique int. You could instead just directly use the derived class as
    > the template to the base:
    >
    > template <class Derived>
    > class Base
    > {
    > static int x;
    > public:
    > static void Setx(int a_x)
    > {
    > x = a_x;
    > }
    > static int Getx()
    > {
    > return x;
    > }
    > };
    >
    > template <class Derived>
    > int Base<Derived>::x;
    >
    > class Derived1: public Base<Derived1>
    > {
    > };
    >
    > class Derived2: public Base<Derived2>
    > {
    > };



    Yes, much nicer. I like it :)

    --
    John Carson
     
    John Carson, Feb 23, 2007
    #11
  12. chameleon

    Fei Liu Guest

    Pete Becker wrote:
    > Fei Liu wrote:
    >> The description of the OP's problem requires that 2 classes do not
    >> share the storage of those static members. In this case, derivation
    >> won't work.

    >
    > Of course it will. The things that aren't shared don't go in the base
    > class.
    >

    It will what? The storage of derived classes is shared in base. The CRTP
    solution posted in this thread is very nice though.
     
    Fei Liu, Feb 23, 2007
    #12
  13. chameleon

    Pete Becker Guest

    Fei Liu wrote:
    > Pete Becker wrote:
    >> Fei Liu wrote:
    >>> The description of the OP's problem requires that 2 classes do not
    >>> share the storage of those static members. In this case, derivation
    >>> won't work.

    >>
    >> Of course it will. The things that aren't shared don't go in the base
    >> class.
    >>

    > It will what?


    "In this case, derivation won't work."

    "Of course it will.

    What, specifically, do you claim "won't work"? Whatever is defined in
    the base class is part of the base class, and whatever is defined in the
    derived classes is part of the derived classes. So if you want the
    derived classes to hold something in common, put it in the base class.
    If you want the derived classes to hold independent things, put them in
    the derived classes. The result is that the derived classes both have
    whatever is in the base class, and each has whatever is defined for it.

    struct base
    {
    static int i;
    static void f();
    };

    struct derived1: base
    {
    static int j;
    static void g();
    };

    struct derived2: base
    {
    static int k;
    static void h();
    };

    Now, base has two members, i and f. derived1 has four members. It
    inherits i and f from base, and it has the two in its definition, j and
    g. derived2 has four members. It also inherits i and f from base, and it
    has two in its definition, k and h.

    So, once again: the members that are the same for both derived types
    should be defined in base, and the members that are different should be
    defined in their respective derived classes.

    > The storage of derived classes is shared in base. The CRTP
    > solution posted in this thread is very nice though.
    >


    Using templates where inheritance is more appropriate isn't "nice."

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 23, 2007
    #13
  14. chameleon

    Fei Liu Guest

    Pete Becker wrote:
    > Fei Liu wrote:
    >> Pete Becker wrote:
    >>> Fei Liu wrote:
    >>>> The description of the OP's problem requires that 2 classes do not
    >>>> share the storage of those static members. In this case, derivation
    >>>> won't work.
    >>>
    >>> Of course it will. The things that aren't shared don't go in the base
    >>> class.
    >>>

    >> It will what?

    >
    > "In this case, derivation won't work."
    >
    > "Of course it will.
    >
    > What, specifically, do you claim "won't work"? Whatever is defined in
    > the base class is part of the base class, and whatever is defined in the
    > derived classes is part of the derived classes. So if you want the
    > derived classes to hold something in common, put it in the base class.
    > If you want the derived classes to hold independent things, put them in
    > the derived classes. The result is that the derived classes both have
    > whatever is in the base class, and each has whatever is defined for it.


    Clearly you don't understand the OP's spec, hint it's a device driver.
    Your logical representation fails to meet the requirement of the
    physical model.

    >
    > struct base
    > {
    > static int i;
    > static void f();
    > };
    >
    > struct derived1: base
    > {
    > static int j;
    > static void g();
    > };
    >
    > struct derived2: base
    > {
    > static int k;
    > static void h();
    > };
    >
    > Now, base has two members, i and f. derived1 has four members. It
    > inherits i and f from base, and it has the two in its definition, j and
    > g. derived2 has four members. It also inherits i and f from base, and it
    > has two in its definition, k and h.
    >
    > So, once again: the members that are the same for both derived types
    > should be defined in base, and the members that are different should be
    > defined in their respective derived classes.
    >
    >> The storage of derived classes is shared in base. The CRTP solution
    >> posted in this thread is very nice though.
    >>

    >
    > Using templates where inheritance is more appropriate isn't "nice."
    >


    Again you demonstrate that you do not understand the OP's problem.
     
    Fei Liu, Feb 23, 2007
    #14
  15. chameleon

    Pete Becker Guest

    Fei Liu wrote:
    > Pete Becker wrote:
    >> Fei Liu wrote:
    >>> Pete Becker wrote:
    >>>> Fei Liu wrote:
    >>>>> The description of the OP's problem requires that 2 classes do not
    >>>>> share the storage of those static members. In this case, derivation
    >>>>> won't work.
    >>>>
    >>>> Of course it will. The things that aren't shared don't go in the
    >>>> base class.
    >>>>
    >>> It will what?

    >>
    >> "In this case, derivation won't work."
    >>
    >> "Of course it will.
    >>
    >> What, specifically, do you claim "won't work"? Whatever is defined in
    >> the base class is part of the base class, and whatever is defined in
    >> the derived classes is part of the derived classes. So if you want the
    >> derived classes to hold something in common, put it in the base class.
    >> If you want the derived classes to hold independent things, put them
    >> in the derived classes. The result is that the derived classes both
    >> have whatever is in the base class, and each has whatever is defined
    >> for it.

    >
    > Clearly you don't understand the OP's spec, hint it's a device driver.
    > Your logical representation fails to meet the requirement of the
    > physical model.
    >


    On the contrary: I have read it carefully, and suggested an approach
    that will do exactly what he said he wants.

    Once again: what, specifically, do you claim "won't work"? No more
    handwaving. Point out the exact problem, so that readers of this thread
    will have a chance at understanding what it is that you think can't be
    done through inheritance.

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 23, 2007
    #15
  16. chameleon

    John Carson Guest

    "Pete Becker" <> wrote in message
    news:
    > Fei Liu wrote:
    >> Pete Becker wrote:
    >>> Fei Liu wrote:
    >>>> Pete Becker wrote:
    >>>>> Fei Liu wrote:
    >>>>>> The description of the OP's problem requires that 2 classes do
    >>>>>> not share the storage of those static members. In this case,
    >>>>>> derivation won't work.
    >>>>>
    >>>>> Of course it will. The things that aren't shared don't go in the
    >>>>> base class.
    >>>>>
    >>>> It will what?
    >>>
    >>> "In this case, derivation won't work."
    >>>
    >>> "Of course it will.
    >>>
    >>> What, specifically, do you claim "won't work"? Whatever is defined
    >>> in the base class is part of the base class, and whatever is
    >>> defined in the derived classes is part of the derived classes. So
    >>> if you want the derived classes to hold something in common, put it
    >>> in the base class. If you want the derived classes to hold
    >>> independent things, put them in the derived classes. The result is
    >>> that the derived classes both have whatever is in the base class,
    >>> and each has whatever is defined for it.

    >>
    >> Clearly you don't understand the OP's spec, hint it's a device
    >> driver. Your logical representation fails to meet the requirement of
    >> the physical model.
    >>

    >
    > On the contrary: I have read it carefully, and suggested an approach
    > that will do exactly what he said he wants.
    >
    > Once again: what, specifically, do you claim "won't work"? No more
    > handwaving. Point out the exact problem, so that readers of this
    > thread will have a chance at understanding what it is that you think
    > can't be done through inheritance.



    Speaking for myself, I didn't think much about the OP's spec, I just wanted
    to answer the OP's question (just stating a fact here, not making a case).

    My read was that the OP was mainly interested in code re-use. Thus the OP
    didn't want identical lists of members in the derived classes. Using a
    template to create two distinct bases was a way to get all those members
    into the derived classes and make the static variables distinct, while only
    typing them once (just why the OP wanted distinct static variables I don't
    know).

    --
    John Carson
     
    John Carson, Feb 24, 2007
    #16
  17. chameleon

    Pete Becker Guest

    John Carson wrote:
    > "Pete Becker" <> wrote in message
    > news:
    >> Fei Liu wrote:
    >>> Pete Becker wrote:
    >>>> Fei Liu wrote:
    >>>>> Pete Becker wrote:
    >>>>>> Fei Liu wrote:
    >>>>>>> The description of the OP's problem requires that 2 classes do
    >>>>>>> not share the storage of those static members. In this case,
    >>>>>>> derivation won't work.
    >>>>>> Of course it will. The things that aren't shared don't go in the
    >>>>>> base class.
    >>>>>>
    >>>>> It will what?
    >>>> "In this case, derivation won't work."
    >>>>
    >>>> "Of course it will.
    >>>>
    >>>> What, specifically, do you claim "won't work"? Whatever is defined
    >>>> in the base class is part of the base class, and whatever is
    >>>> defined in the derived classes is part of the derived classes. So
    >>>> if you want the derived classes to hold something in common, put it
    >>>> in the base class. If you want the derived classes to hold
    >>>> independent things, put them in the derived classes. The result is
    >>>> that the derived classes both have whatever is in the base class,
    >>>> and each has whatever is defined for it.
    >>> Clearly you don't understand the OP's spec, hint it's a device
    >>> driver. Your logical representation fails to meet the requirement of
    >>> the physical model.
    >>>

    >> On the contrary: I have read it carefully, and suggested an approach
    >> that will do exactly what he said he wants.
    >>
    >> Once again: what, specifically, do you claim "won't work"? No more
    >> handwaving. Point out the exact problem, so that readers of this
    >> thread will have a chance at understanding what it is that you think
    >> can't be done through inheritance.

    >
    >
    > Speaking for myself, I didn't think much about the OP's spec, I just wanted
    > to answer the OP's question (just stating a fact here, not making a case).
    >


    Indeed. And you may have noticed that I didn't jump in and insist that
    you're wrong. In fact, I suspect that a template may be the right answer
    to the question that wasn't asked. But given the original problem
    statement, all that's needed is to hoist one data member and one member
    function into the derived class, and that doesn't call for a template.
    Low-level design follows from actual specifications, not from guesses.

    --

    -- Pete
    Roundhouse Consulting, Ltd. (www.versatilecoding.com)
    Author of "The Standard C++ Library Extensions: a Tutorial and
    Reference." (www.petebecker.com/tr1book)
     
    Pete Becker, Feb 24, 2007
    #17
    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.
Similar Threads
  1. Fred
    Replies:
    1
    Views:
    606
    Neredbojias
    Sep 26, 2005
  2. John Harrison

    using templates in templates

    John Harrison, Jul 31, 2003, in forum: C++
    Replies:
    8
    Views:
    386
    Torsten Curdt
    Jul 31, 2003
  3. JKop
    Replies:
    3
    Views:
    480
  4. Tom McCallum

    Templates within templates

    Tom McCallum, Aug 4, 2004, in forum: C++
    Replies:
    2
    Views:
    370
    tom_usenet
    Aug 4, 2004
  5. recover
    Replies:
    2
    Views:
    816
    recover
    Jul 25, 2006
Loading...

Share This Page