Can you make an std::list of a templated class.

Quick question.

I was wondering if I had a class that was template would I be able to use that class as the type for an std::list?

i.e.

Code:

---

template <class T>
class TemplatedClass
{
public:

private:
    T var;
} ;


std::list< TemplatedClass > list;

---

Regards

Chad

You have to specify T for TemplatedClass in order to instantiate a std::list.

> std::list<TemplatedClass<int> > my_list;

gg

So the actual type of the std::list has to be defined? Darn. Looks like I have to redesign some things.

Regards

Chad

another alternative is:

Code:

---

class abstractClass
{
};
template <class T>
class TemplatedClass : public abstractClass
{
public:

private:
    T var;
} ;


std::list< abstractClass* > list;

---

Quote:

---

Originally Posted by m37h0d

another alternative is:

Code:

---

class abstractClass
{
};
template <class T>
class TemplatedClass : public abstractClass
{
public:

private:
    T var;
} ;


std::list< abstractClass* > list;

---

---

I thought std::list would splice off the deriving class.

Quote:

---

Originally Posted by chadsxe

I thought std::list would splice off the deriving class.

---

If you mean type slicing, rather than list splicing, then no, since a base class pointer is stored. On the other hand, Codeplug's answer sounds more relevant since you mentioned nothing that would make it seem like inheritance was applicable.

i'm inferring from the OP that he needs to store different types in the list. if this assumption is correct what other alternatives are there?

Quote:

---

Originally Posted by m37h0d

i'm inferring from the OP that he needs to store different types in the list.

---

Maybe, but the original question seemed like a simple novice's mistake. Considering chadsxe's post #3 though, it could be that chadsxe actually wants to define a function template or another class template, or maybe you really are correct, or...

Quote:

---

Originally Posted by m37h0d

if this assumption is correct what other alternatives are there?

---

boost::any is an alternative.

Given m37h0d example would there worries of memory managment in regards to the pointers being stored in the list. Would erasing of elements in the list handle the destroying of the pointers or would there be an issue there.

Regards

Chad

Quote:

---

Originally Posted by chadsxe

Given m37h0d example would there worries of memory managment in regards to the pointers being stored in the list. Would erasing of elements in the list handle the destroying of the pointers or would there be an issue there.

---

If the linked list is supposed to own the objects pointed to, then yes, you have to do a little more work to implement RAII for the object that owns the linked list. Certainly, just erasing the elements of the list would not destroy the objects that those pointers point to.

Usually, that can be solved with smart pointers.
std::tr1::shared_ptr or boost::shared_ptr.
Don't be afraid of it.

if the base class has a virtual destructor then you can iterate over the container and delete each element to properly free the derived class instances.

I have never used boost so excuse me if I ask a dumb question. In regards to boost::any does it only deal with c++ types i.e. flot string bool etc. Can it handle something like a D3DCOLORVALUE.

In my example I would do something to the effect of that correct.

std::list<boost::any> list;

Regards

Chad

boost::any doesn't care what type it deals with. It is designed to work with any and every type.

Quote:

---

Originally Posted by Elysia

boost::any doesn't care what type it deals with. It is designed to work with any and every type.

---

Then this appears to me to be the cleanest way of doing this. Do you agree. I am guessing the code would go something like this.

Code:

---

#include <boost/any.hpp>
template <class T>
class TemplatedClass
{
public:

private:
    T var;
} ;


std::list< boost::any > list;

---

What do you think?

Regards

Chad

Not too familiar with boost::any, since it requires you to know the type you are storing to retrieve it.

Wait, what exactly are you trying to do? Without knowing that we are all just guessing what is the best tool for the job.

Quote:

---

Originally Posted by laserlight

Wait, what exactly are you trying to do? Without knowing that we are all just guessing what is the best tool for the job.

---

I am working on a very very simple scripting system. The templated class was used to represent a variable read in by the scipting system. It holds the name, type, and value. The list is actually stored inside the "Scipt Manager".

Perhaps virtual classes are a good solution for this type of job?
The list stores base classes while exposing virtual functions which the derived classes override and implement.
Otherwise I figure you're going to have to circumvent the whole type system by checking for type and casting it appropriately, which never is a good idea.

Quote:

---

Originally Posted by chadsxe

The templated class was used to represent a variable read in by the scipting system. It holds the name, type, and value.

---

So, in your original model, you wanted to store objects of different instances of the class template in the same std::list, right? What is the motivation for a class template instead of a "normal" Variable class, say a class hierarchy?

Quote:

---

Originally Posted by laserlight

So, in your original model, you wanted to store objects of different instances of the class template in the same std::list, right? What is the motivation for a class template instead of a "normal" Variable class, say a class hierarchy?

---

Well the "Variable class" obviously is going to have to store a few different types of variables. Instead of declaring a type of each variable that I will be using in my simple scripting language in the "Variable class", I figured the templated option would be more efficent. The problem is the ScriptingManager class store variable(s) inside of a list.

Hmmm. Templates and virtual functions does not always play well with each other...

Quote:

---

Originally Posted by chadsxe

Instead of declaring a type of each variable that I will be using in my simple scripting language in the "Variable class", I figured the templated option would be more efficent.

---

As in you are "borrowing" the built-in types of C++? I am not sure how that works with your scripting language, but a possible solution could be to have a VariableType abstract base class, then have a ConcreteVariableType class template inherit from it, since a variable has-a type:

Code:

---

class VariableType
{
public:
    virtual ~VariableType() {}
    // ...
};

template<typename T>
class ConcreteVariableType : public VariableType
{
    // ...
};

---

As such, you would have a std::list<Variable>, but each Variable object would have a (smart) pointer to a VariableType, which could point to a ConcreteVariableType<int>, ConcreteVariableType<double>, etc.

Then again, if your scripting language is so simple, wouldn't it be quite easy to just list all the possible types that the variables have?

Quote:

---

Originally Posted by Elysia

Hmmm. Templates and virtual functions does not always play well with each other...

---

?

for instance? i haven't had any problems with it.

Edit: And by the by, the suggestion offered by LL is probably what you need.

Quote:

---

Templates and virtual functions does not always play well with each other...

---

They play together just fine so long as you don't treat template methods polymorphically.

Quote:

---

for instance? i haven't had any problems with it.

---

Some people expect the following code to print "b:1\nb:0\nd2:0\nd2:2\n" or some other unusual variation. You will not have problems so long as you don't expect the compiler to do magic things.

Soma

Code:

---

#include <iostream>

struct b
{
  template
  <
      unsigned int F
  >
  void t()
  {
      std::cout << "b:" << F << '\n';
  }
  virtual void t1()
  {
      t<0>();
  }
  virtual void t2()
  {
      t<0>();
  }
};

struct d1: b
{
  virtual void t1()
  {
      t<1>();
  }
};

struct d2: b
{
  template
  <
      unsigned int F
  >
  void t()
  {
      std::cout << "d2:" << F << '\n';
  }
  virtual void t2()
  {
      t<2>();
  }
};

struct dc: d1, d2
{
};

int main()
{
  dc t;
  t.d1::t1();
  t.d1::t2();
  t.d2::t1();
  t.d2::t2();
  return(0);
}

---

Quote:

---

Originally Posted by phantomotap

Some people expect the following code to print "b:1\nb:0\nd2:0\nd2:2\n" or some other unusual variation. You will not have problems so long as you don't expect the compiler to do magic things.

Soma

---

that's an odd thing to expect.

Quote:

---

Originally Posted by m37h0d

?

for instance? i haven't had any problems with it.

---

The solution that laserlight suggests is one where such a problem may show up.
Virtual functions just won't work so well with inheritance in such an example, because it doesn't "offer" all the flexibility you might want or need.

Quote:

---

Originally Posted by laserlight

As in you are "borrowing" the built-in types of C++? I am not sure how that works with your scripting language, but a possible solution could be to have a VariableType abstract base class, then have a ConcreteVariableType class template inherit from it, since a variable has-a type:

Code:

---

class VariableType
{
public:
    virtual ~VariableType() {}
    // ...
};

template<typename T>
class ConcreteVariableType : public VariableType
{
    // ...
};

---

As such, you would have a std::list<Variable>, but each Variable object would have a (smart) pointer to a VariableType, which could point to a ConcreteVariableType<int>, ConcreteVariableType<double>, etc.

Then again, if your scripting language is so simple, wouldn't it be quite easy to just list all the possible types that the variables have?

---

Also consider the following example:

Code:

---

class Base
{
public:
        virtual void foo(int)  = 0 {}
};

template<typename T> class Derived: public Base
{
public:
        virtual void foo(int) {}
        virtual void foo(T) {}
};

int main()
{
        Derived<double> Test;
        Base& rTest = Test;
        rTest.foo(10);
        rTest.foo(1.0);
}

---

The first rTest.foo call will work as expected.
But the second one will not! It will simply truncate the double to int and call Derived::foo(int) instead of Derived::foo(double).
Which is why I said they don't play so well together.

If you want or need a template class, you might as well need to use the template type in the parameter list of some functions. And to call those functions, the base class needs to contain them, as well, as virtual functions, or you'll have to cast them to derived classes, which is wrong.
But since the base class isn't templated, it cannot represent those virtual functions in the derived class without overloading them all, and that almost kind of beats the purpose of a template class.

Um, but Elysia, your example is due to the fact that the foo() member function from Base takes an int. We could demonstrate this behaviour without templates:

Code:

---

class Base
{
public:
        virtual void foo(int)  = 0;
};

class Derived: public Base
{
public:
        virtual void foo(int) {}
        virtual void foo(double) {}
};

int main()
{
        Derived Test;
        Base& rTest = Test;
        rTest.foo(10);
        rTest.foo(1.0);
}

---

EDIT:

Quote:

---

Originally Posted by Elysia

If you want or need a template class, you might as well need to use the template type in the parameter list of some functions. And to call those functions, the base class needs to contain them, as well, as virtual functions, or you'll have to cast them to derived classes, which is wrong.
But since the base class isn't templated, it cannot represent those virtual functions in the derived class without overloading them all, and that almost kind of beats the purpose of a template class.

---

I can agree with your general sentiment, but it depends on the requirements and the design.

Quote:

---

Originally Posted by laserlight

Um, but Elysia, your example is due to the fact that the foo() member function from Base takes an int. We could demonstrate this behaviour without templates:

---

Which is my point.
There's just no way to make virtual functions that take T as a parameter without making the base a template class, as well.
And by doing that, we get the problem of what type is stored inside the list, which was the whole point of a non-template generic base class.

what is "wrong" with:

Code:

---

template<typename T>void abstractClass::getter(T& t)
{
    t= (static_cast<concreteClass<T>*>(this))->concreteClass<T>::memberOfTypeT;
}
template<typename T>void abstractClass::setter(T& t)
{
    static_cast<concreteClass<T>*>(this))->concreteClass<T>::memberOfTypeT = t;
}

---

you should get a compile-time error if you mangle the types, no?

Haven't you just reinvented boost::any?

i wouldn't know because i haven't used it, however, i sincerely doubt it because if that's all there is to it then i am underwhelmed by that particular library's cleverness. i take it then, if you think that is analogous to boost::any, that you don't consider that 'wrong'?

Nope, neither your example nor boost::any is wrong, but I don't think it can be as useful in this case, because you need to know the type you are getting, or you get a compile error.

well then clearly that's a design problem ;)

I dunno. Scripting clearly requires some flexible system that needs to work without knowing the exact type.
I wouldn't know how to implement a system to make such a thing work.

Well I just read through all the post and I will take some time to think re-think my design as a whole. I actually might explore the option of dynamically allocating memory. Though I tend to want to stay away from it do to the complexity it adds. Maybe something along the lines of

Code:

---

class Variable
{
public:
        Variable();
        ~Variable();
       
        void AddScriptVariable( const std::string buffer );
        void AddScratchVariable( const std::string name, char type, void *value );

        char GetType();
        std::string GetName();
        void *GetData();

private:
        char m_type; // Type of data stored in the variable.
        std::string m_name; // Name of the variable.
        void *m_data; // Data stored in the variable.
};

---

Also for info sakes my script would no more complicated then the below example.

#begin
btest bool true
ftest float 27.3978
stest string "WEeeeeEEE"
#end

Variable name, then type, then value.


Regards

Chad

Quote:

---

Originally Posted by Elysia

I dunno. Scripting clearly requires some flexible system that needs to work without knowing the exact type.
I wouldn't know how to implement a system to make such a thing work.

---

one might:

Code:

---

class abstractFunctor
{
    public:
        virtual void exec()=0;
};

template<typename input,typename output> class concreteFunctor : public abstractFunctor
{
    protected:
        input& i;
        output& o;
        typedef output (*pfunc)(input);
        pfunc func;
    public:
        concreteFunctor (input& _i,output& _o,pfunc _func):
            i(_i),
            o(_o)
        {
        }
        void exec()
        {
            o = func(i);
        }
};

---

or something to that effect.

Yes, maybe. You might need to hide virtual functions that relies on template types in the parameter list, perhaps through extra abstraction and more generic (simple functions like your exec) functions.

Maybe we should just give up and use Boost.Python. Python already has a list type that does not need to be homogeneous, Boost.Python emulates it.

Quote:

---

If you want or [...] the purpose of a template class.

---

The purpose of a template class is the generation of classes. If the OP needs a stable interface to several mechanically related classes, a template class is exactly what he needs to do the implementation.

Quote:

---

[...]class Variable[...]

---

O_o

You can do a lot with templates, but if you are going to do anything with these types, you'll eventually have to do the work.

If you don't want to do the work, or don't feel capable, you'll have to find an existing scripting library. (whiteflags provided a nice one.)

That said, templates will let you serialize and store the types safely and C++ already tracks the types of things if you let it. I'll give you a simple example. (Which is not up to my usual standard--example memory leaks.)

Soma

Code:

---

#include <iostream>
#include <iterator>
#include <map>
#include <sstream>
#include <stdexcept>
#include <string>
#include <typeinfo>

using namespace std;

struct variable_interface
{
  virtual string get() const = 0;
  virtual void set
  (
      const string & f
  ) = 0;
  virtual istream & in
  (
      istream & f
  ) = 0;
  virtual ostream & out
  (
      ostream & f
  ) const = 0;
  virtual const type_info & type() const = 0;
};

template
<
  typename type_F
>
struct variable: variable_interface
{
  virtual string get() const
  {
      ostringstream v;
      v << m;
      return(v.str());
  }
  virtual void set
  (
      const string & f
  )
  {
      istringstream v(f);
      v.setf(ios::boolalpha);
      type_F t;
      if(!(v >> t))
      {
        throw(runtime_error("bad input"));
      }
      swap(m, t);
  }
  virtual istream & in
  (
      istream & f
  )
  {
      return(f);
  }
  virtual ostream & out
  (
      ostream & f
  ) const
  {
      cout << m;
      return(f);
  }
  virtual const type_info & type() const
  {
      return(typeid(type_F));
  }
  type_F m;
};

template <> struct variable<string>: variable_interface
{
  virtual string get() const
  {
      ostringstream v;
      v << m;
      return(v.str());
  }
  virtual void set
  (
      const string & f
  )
  {
      istringstream v(f);
      string t;
      if(!(getline(v, t)))
      {
        throw(runtime_error("bad input"));
      }
      swap(m, t);
  }
  virtual istream & in
  (
      istream & f
  )
  {
      return(f);
  }
  virtual ostream & out
  (
      ostream & f
  ) const
  {
      cout << m;
      return(f);
  }
  virtual const type_info & type() const
  {
      return(typeid(string));
  }
  string m;
};

istream & operator >>
(
  istream & lhs_f,
  variable_interface & rhs_f
)
{
  return(rhs_f.in(lhs_f));
}

ostream & operator <<
(
  ostream & lhs_f,
  variable_interface & rhs_f
)
{
  return(rhs_f.out(lhs_f));
}

int main()
{
  string input;
  map<string, variable_interface *> state;
  while(getline(cin, input))
  {
      istringstream v(input);
      string name;
      string type;
      string value;
      v >> name;
      v >> type;
      getline(v, value);
      if("bool" == type)
      {
        state[name] = new variable<bool>;
      }
      else if("float" == type)
      {
        state[name] = new variable<float>;
      }
      else if("string" == type)
      {
        state[name] = new variable<string>;
      }
      else
      {
        throw(runtime_error("bad input"));
      }
      state[name]->set(value);
  }
  const map<string, variable_interface *>::const_iterator begin(state.begin());
  const map<string, variable_interface *>::const_iterator end(state.end());
  for(map<string, variable_interface *>::const_iterator cursor(begin); end != cursor; ++cursor)
  {
      cout.setf(ios::boolalpha);
      cout << cursor->first;
      if(typeid(bool) == cursor->second->type())
      {
        cout << " as bool ";
      }
      else if(typeid(float) == cursor->second->type())
      {
        cout << " as float ";
      }
      else if(typeid(string) == cursor->second->type())
      {
        cout << " as string ";
      }
      else
      {
        cout << " as <unknown> ";
      }
      cout << *(cursor->second) << '\n';
  }
  return(0);
}

---