Template Return c++ - c++

Question

I am trying to switch between two class objects based on a global variable DOF. The idea is to change the return type using the template class. But the first line inside main() has a compile-time error template argument deduction/substitution failed. Could you please help me to understand the problem and fix it and is there a better way of doing this? Any suggestions and help are appreciated. Thanks in advance.
#include <iostream>
#include <string>
class MM
{
public:
MM(){}
std::string printName()
{
return "MM";
}
};
class MM2
{
public:
MM2(){}
std::string printName()
{
return "MM2";
}
};
using namespace std;
const unsigned short int DOF = 7;
MM* obj = nullptr;
MM2* obj2 = nullptr;
template<class T>
T getClass()
{
if(DOF==7)
{
if(obj == nullptr)
{
obj = new MM();
}
return obj;
}
else if(DOF == 6)
{
if(obj2 == nullptr)
{
obj2 = new MM2();
}
return obj2;
}
}
int main()
{
getClass()->printName();
//std::cout << "class name " << getClass()->printName() << std::endl;
return 0;
}

Answer 1

That is not how templates work in C++. The type of the template parameter must be known at compile time and cannot change at runtime.
The pattern you are trying to achieve in your example scan easily be done with virtual functions: make MM and MM2 have a common base class and make printName a virtual function. While we are here: don't use manual memory management, i.e. don't use explicit new/delete. Use smart pointers like unique_ptr.
Other options are std::any and std:: variant but I wouldn't recommend them unless you have a very particular use case for them.
For your simple example an option could be to return a function pointer or a std::function. That would work on your example because your classes are stateless, but I suspect your real classes have state or more methods you wish to access in which case you shouldn't try to do this.

Answer 2

If you can use C++17 (and if you can't then that's a shame), you can do this if you switch things round a bit.
Firstly, use a template parameter to determine what getClass does and use if constexpr instead of just plain old if:
template<int N>
auto getClass()
{
if constexpr (N == 7)
{
if(obj == nullptr)
{
obj = new MM();
}
return obj;
}
else if constexpr (N == 6)
{
if(obj2 == nullptr)
{
obj2 = new MM2();
}
return obj2;
}
}
Then invoke this template like this:
std::cout << "class name " << getClass <DOF> ()->printName() << std::endl;
Miscellaneous notes:
All paths through getClass should return a value.
You are leaking memory by calling new and not calling delete. Better options are available.
Edit: Here's a C++11 solution using SFINAE:
template<int N, typename std::enable_if<N == 7, int>::type = 0>
MM *getClass()
{
if(obj == nullptr)
{
obj = new MM();
}
return obj;
}
template<int N, typename std::enable_if<N == 6, int>::type = 0>
MM2 *getClass()
{
if(obj2 == nullptr)
{
obj2 = new MM2();
}
return obj2;
}
And then you can still do:
std::cout << "class name " << getClass <DOF> ()->printName() << std::endl;
Live demo

Answer 3

This is something you might try. As others have said, templates only work at compile time: if you want to dynamically change the types later during runtime, then polymorphism is the way to go. You can use a kind of 'PIMPL' design to effectively 'insert' a base class above the MM and MM2 classes. The base class includes pure virtual functions for all the common functions for MM and MM2 that you need to access (eg printName() in this example).
#include <iostream>
#include <memory>
#include <string>
class MM
{
public:
MM() {}
std::string printName()
{
return "MM";
}
};
class MM2
{
public:
MM2() {}
std::string printName()
{
return "MM2";
}
};
class MMBase
{
public:
virtual std::string printName() = 0;
virtual ~MMBase() {}
};
//Templated wrapper for each MM class type, deriving from abstract MMBase
template<class T>
class MMWrap : public MMBase
{
std::unique_ptr<T> _impl;
public:
MMWrap() : _impl(nullptr)
{
_impl = std::make_unique<T>();
}
//Pass function call to _impl pointer
std::string printName()
{
return _impl->printName();
}
};
class MMFactory
{
public:
enum MMType {TypeMM2=6,TypeMM};
static MMType _type;
static std::unique_ptr<MMBase> getMM()
{
if (_type == TypeMM) return std::unique_ptr<MMBase>(new MMWrap<MM>());
if (_type == TypeMM2) return std::unique_ptr<MMBase>(new MMWrap<MM2>());
return nullptr; //Avoids compiler warning about not all paths return value
}
};
//Initialize static member to which default MM type is required
MMFactory::MMType MMFactory::_type = MMFactory::TypeMM;
int main()
{
std::cout<< MMFactory::getMM()->printName() << std::endl;
MMFactory::_type = MMFactory::TypeMM2;
std::cout << MMFactory::getMM()->printName() << std::endl;
}
I've put in a templated wrapper class, but that may need modification depending what parameters the MM/MM2 constructors need. Also the wrapped pointers are created within the constructor (if they throw then there might be an issue): these could be moved to a lazy evaluation model, making _impl mutable. I don't know how MM/MM2 are used later: if they have functions which take references to other MM types then a bit more work may be needed.