C++ How can I predefine a constructor parameter when specializing a template for a "new" type

Question

I have a template class that takes a name in its constructor. The name is supposed to be the name of the actual type, so that it can be put into a human-readable list or something.

Anyways I am currently defining the types like this:

typedef templateClass<someType> someTypeClass;

However, in order for the name to be also "someTypeClass" I would need the user to always specify that name correctly. Rather I want some way to force the constructor parameter to always be "someTypeClass" (FOR THAT SPECIFIC TYPE SPECIALISATION).

The purpose of the name parameter is to have a way of knowing the name of a template specialisation. Here a example

template<class t>
class TemplateClass{
private:
    std::string name;
    t data;
public:
    TemplateClass(const char* name);
    /*Irrelevant*/
};
typedef TemplateClass<int> intType; //name should be "intType" but how can I force the name to be "intType" for this case? I dont want the user to have to type "intType" for every instance he wants to make
typedef TemplateClass<char> charType; //name should be "charType"

Is this achieveable in some viable way or is there a better way to go about this?

If the constructor parameter is always `"someTypeClass"`, what is the point of even having that parameter? It provides no information and adds a way to do it wrong. — nwp, Jan 16 '18 at 10:55

super · Accepted Answer · 2018-01-16T16:19:33.140

You can make the name static, and initialize it yourself.

template<class t>
class TemplateClass{
private:
    static const std::string name;
    t data;
public:
    TemplateClass();
    /*Irrelevant*/
}

typedef TemplateClass<int> intType;
template <>
const std::string TemplateClass<int>::name = "intType";

typedef TemplateClass<char> charType;
template <>
const std::string TemplateClass<char>::name = "charType";

Note that with this approach you you probably want to put std::string TemplateClass<int>::name; in your header and the initialization in your .cpp

Clarifying my note with and example

TemplateClass.hpp

#include <string>

template<class t>
class TemplateClass{
private:
    static const std::string name;
    t data;
public:
    TemplateClass();
    /*Irrelevant*/
}

typedef TemplateClass<int> intType;
template <>
const std::string TemplateClass<int>::name;

typedef TemplateClass<char> charType;
template <>
const std::string TemplateClass<char>::name;

TemplateClass.cpp

#include "TemplateClass.hpp"

template <>
const std::string TemplateClass<int>::name = "intType";

template <>
const std::string TemplateClass<char>::name = "charType";

Here we are declaring the specialization variable in the .hpp but ony initializing it in the .cpp. Otherwise it will be initialized in every compilation unit that you include it in, and will get multiple definition errors.

Additional note

If you are using C++17 you can use the new inline variable and do

template <>
inline const std::string TemplateClass<int>::name = "intType";

with no need to add anything in the .cpp file.

You can simplify it to `const std::string intType::name = "intType";` — Caleth, Jan 16 '18 at 12:05
@super I tried implementing it using a macro. However I am getting a "multiple definition of Component::name" error. Here is the macro: "#define DEFINE_COMPONENT(type,typename) typedef Component typename; template<> const std::string typename::name = "typename" " It works neither with Component::name nor with typename::name — MoustacheSpy, Jan 16 '18 at 14:19
@MoustacheSpy Updated my answer to give an exmaple of the bottom note. — super, Jan 16 '18 at 15:43
@super thanks. That makes sense. So basically there isnt a way to do this with macros? — MoustacheSpy, Jan 16 '18 at 16:53
@MoustacheSpy If you mean doing it all with 1 macro, that requires `inline` variable. Seems you can just leave out the declaration in the .hpp and only declare it in the .cpp file but if that is fully "by the book" I don't know but atleast it [compiles and works](https://wandbox.org/permlink/hD52X7wJmD4brCGe). You still need to have the `typedef` in the .hpp and the initializing in the .cpp though. AFAIK there is no way around that. — super, Jan 16 '18 at 17:59

score 0 · Answer 2 · answered Jan 16 '18 at 11:31

What you look for requires reflection and currently c++ has very limited options in this regard.

There is RTTI and typeinfo that's basically it when it comes to current standard. Whether or not it is useful enough I'll leave up to you. Here is the example how can you bind textual info about the type to the class:

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

using namespace std;

template <typename T>
struct A {
    const char* name = typeid(T).name();
};

int main() {
    A<int> a_int;
    A<double> a_double;
    A<string> a_string;
    cout << a_int.name << "\n";
    cout << a_double.name << "\n";
    cout << a_string.name << "\n";
    return 0;
}

So there are two at least three immediate drawbacks, the link explain them a bit:

It doesn't work for every type. type_info::name
The field is not static, though one might expect it to be. It is evaluated at run time. This coincides with 1. constexpr-and-rtti
The names are mangled. Unmangling the result of std::type_info::name

I don't think you can do much better at this point of time. Some reflection proposals are said to be evaluated but it's a rather distant future IMHO.

score 0 · Answer 3 · answered Jan 16 '18 at 14:39

Declaring the data member name as static as this answer suggests and assuming a compiler with C++11 support (to be able to use template alias):

#include <string>

template<class t>
class TemplateClass{
private:
    static const std::string name;
    t data;
public:
    TemplateClass();
    /*Irrelevant*/
};

#define DEFINE_COMPONENT(type, typename) \
template<> \
const std::string TemplateClass<type>::name = #typename; \
using typename = TemplateClass<type>

DEFINE_COMPONENT(int, intType);
DEFINE_COMPONENT(char, charType);

The preprocessor macro DEFINE_COMPONENT does the job of both creating the corresponding template alias with the name passed as the second argument and initializing the string member name for corresponding specialization.

C++ How can I predefine a constructor parameter when specializing a template for a "new" type

3 Answers3