Basic class templating in C++

I have to two class,

class CFoo
{
   public:
      static CFoo& GetInstance()
      {
         static CFoo instance;
         return instance;
      }

      int GetValue(){
         return value;
      }

   private:
      CFoo(){
         value = 0;
         ltr = 'a';
      }

      int value;
      char ltr;
};

class CBar
{
   public:
      static CBar& GetIns开发者_Python百科tance(){
         static CBar instance;
         return instance;
      }

      float GetValue(){
         return value;
      }

   private:
      CBar(){
         value = 0.4;
         ltr = 2;
      }

      float value;
      int ltr;
};

Is it possible just to create a class template for this two class , the difference is just the data types. And since the class is a singleton, how can I invoke when I create a template class for this two class? And please give example code for the basic template class.

Please advice.

Many thanks.

---

Generally, when you want to generalize similar classes like this, you can do so by replacing each of the types with type parameters. So, for example, here you would declare a type parameter for the type of value and a type parameter for the type of ltr.

This, obviously, looks something like:

template <typename ValueT, LtrT>
class C
{
    // ...
};

Then it's just a matter of replacing the concrete types in the class with the type parameters, so value and ltr would be declared as (inside of the class template definition):

ValueT value;
LtrT ltr;

In order to make this class template more easily usable, you can create some typedefs (outside of the class template definition):

typedef C<int, char> CFoo;
typedef C<float, int> CBar;

You also need a way to initialize the member variables. Your best bet is to make the constructor take arguments with which to initialize the member variables (inside of the class template definition):

C(const ValueT& initial_value, const LtrT& initial_ltr)
    : value(initial_value), ltr(initial_ltr) { }

Since you are trying to use a singleton, this won't work with your current (broken) implementation of GetInstance() because the function-scope static needs to be initialized in the function body. You can work around this by declaring the singleton instance as a static class member variable (inside of the class template definition):

C singleton;

then you will need to define and initialize this in one of your source files; you will need to have one definition for each instantiation of C that you use, so for the two you have here you would need:

template<> CFoo CFoo::singleton(0, 'a');
template<> CBar CBar::singleton(0.4, 2);

When you put it all together, it will look something like this (I've dumbed it down to use only a single type and value for the sake of brevity):

template <typename T>
struct S
{
public:
    S(const T& initial_value) : value(initial_value) { }

    const T& GetValue() const { return value; }

    static const S& GetInstance() { return singleton; }

private:
    // since it's a singleton, make it noncopyable
    S(const S&);
    void operator=(S);

    T value;
    static S singleton;
};

typedef S<int> SInt;

template<> SInt SInt::singleton(42);

int main()
{
    int value = SInt::GetInstance().GetValue(); 
}

Finally, and most importantly, please consider not using a singleton. Singletons are almost always A Bad Idea. It's impossible to tell what you are trying to accomplish from your stripped down example, but you should definitely try to find some other way to do it.