C++ partial member function - hjälp!

#include <iostream>
#include <vector>
#include <typeinfo>

struct sa
{
  //Massa skumma ctors
};

struct sb
{
  //Massa skumma ctors
};

class cfactory
{
  //Här hamnar de beronde på typ
  std::vector<sa*> vSA_;
  std::vector<sb*> vSB_;
public:

    //Skapar object av typen T och med argumenten A.
    //Returnerar nullptr ifall T inte finns i "factory"...
    template <typename T, typename ...A>
    T *create(A&&... args);

};

//Standard för de som inte finns
template <typename T, typename ...A>
T *cfactory::create(A&&... args)
{
  std::cout << "cfactory::create: T = " << typeid(T).name() << std::endl;
  return (T*)nullptr; 
}



//Den här och nästa funktion undrar jag hur man definerar korrekt.

//För "sa"
template <typename ...A>
sa *cfactory::create(A&&... args)
{
  std::cout << "cfactory::create: T = " << typeid(T).name() << std::endl;
  sa *s = new sa(std::forward<A>(args)...);
  vSA_.push_back( s );
  return s;
}

//För "sb"
template <typename ...A>
sb *cfactory::create(A&&... args)
{
  std::cout << "cfactory::create: T = " << typeid(T).name() << std::endl;
  sb *s = new sb(std::forward<A>(args)...);
  vSB_.push_back( s );
  return s;
}



int main()
{
  cfactory factory;
  factory.create<int>(5); //Anropar standrad funktionen och det fungerar solklart! 

  //Så vill jag få till någon i den här stilen
  sb *sb_ = factory.create<sb>(/*   BLa bla bla osv m.m.*/);
  sa *sa_ = factory.create<sa>(/*   BLa bla bla osv m.m.*/);
  return -1;
};

#include <iostream>
#include <string>
#include <vector>
#include <typeinfo>

struct sa
{
  //Massa skumma ctors
};

struct sb
{
  std::string a_;
  int b_;

  //Massa skumma ctors
  sb(const std::string& a) : a_(a){}
  sb(int b) : b_(b){}
  sb(const std::string& a, int b) : a_(a), b_(b){}


};

class cfactory
{
  std::vector<sa*> vSA_;
  std::vector<sb*> vSB_;
public:

    void out()
    {
      for(auto p:vSB_)
        std::cout << p->a_ <<" " << p->b_ << std::endl;
    }

    template <typename T>
    T* create_obj(T *obj);

    template <typename T, typename ...A>
    T* create(A&&... args);
};



template <typename T, typename ...A>
T* cfactory::create(A&&... args)
{
  return create_obj( new T(std::forward<A>(args)... ));
}

template <>
sa* cfactory::create_obj(sa *obj)
{
  vSA_.push_back(obj);
  std::cout << "Fungerar för sa! " << std::endl;
  return obj;
}


template <>
sb* cfactory::create_obj(sb *obj)
{
  vSB_.push_back(obj);
  std::cout << "Fungerar för sb! " << std::endl;
  return obj;
}



int main()
{
  cfactory factory;
  //factory.create<int>(5);

  //Så vill jag få till någon i den här stilen
  sb *sb_1 = factory.create<sb>(12);
  sb *sb_2 = factory.create<sb>("hej", 42);
  sb *sb_3 = factory.create<sb>("tack för hjälpen!");

  sa *sa_ = factory.create<sa>(/*   BLa bla bla osv m.m.*/);

  factory.out();

  return -1;
};