Question

I wrote myself a StringHelper in cpp to convert. But it won’t compile if I put the sourceode in an external cpp-file (included in the Codeblocks-projectfile) or I don’t understand the errors:

HPP:

#ifndef _INPUT_STRINGHELPER_HPP
    #define _INPUT_STRINGHELPER_HPP

    #include <string>
    #include <sstream>
    #include <deque>

    namespace FiveDimension
    {
        void SplitStream(std::stringstream& s, char c, std::deque<std::string>& ret);
        void SplitString(std::string s, char c, std::deque<std::string>& ret);
        template<typename T> T StringToAll(std::string val);
        template<typename T> bool TryStringToAll(std::string val, T &ret);
        template<typename T> std::string AllToString(T val);
    }

#endif

CPP:

#include "StringHelper.hpp"

void FiveDimension::SplitStream(std::stringstream& s, char c, std::deque<std::string>& ret)
{
    std::string line;

    while(std::getline(s, line, c))
        ret.push_back(line);
}
void FiveDimension::SplitString(std::string s, char c, std::deque<std::string>& ret)
{
    std::string line;
    std::stringstream ss(s);

    while(std::getline(ss, line, c))
        ret.push_back(line);
}
template<typename T> T FiveDimension::StringToAll(std::string val)
{
    std::stringstream s(val);
    T ret;
    s >> ret;
    return ret;
}
template<typename T> bool FiveDimension::TryStringToAll(std::string val, T &ret)
{
    std::stringstream s(val);
    return (s >> ret);
}
template<typename T> std::string FiveDimension::AllToString(T val)
{
    std::stringstream s;
    s << val;
    return s.str();
}

I also tried for example:

template<typename T> std::string FiveDimension::AllToString<T>(T val)
{
    std::stringstream s;
    s << val;
    return s.str();
}

but this doesn’t even compile this file and make me feel I don’t know anything about templates so I came here.
I read the answer by Aaron on this topic: "Undefined reference to" template class constructor . After that I understood a lot more. But how can I predefine a function ?

Answer 1

I’ll do a brief of the answer, that is in the topic, you’ve mentioned:
There are two ways out of this problem:

1. Use inlines (I know, that you don’t want to, but it’s more general and correct way).
2. Use definitions of the types you’ll be using in the .cpp file.

For template classes you should use the following code:

template class your_class_name < typename_to_use >;

Where typename_to_use is something like int, std::string or else.
For template functions you should use the following code:

template return_type your_function_name<typename_to_use>(...parameters);

For template member functions you should use the following code:

template return_type your_class_name::your_function_name<typename_to_use>(...parameters);

or

template return_type your_class_name<class_typename_to_use>::your_function_name<function_typename_to_use>(...parameters);

The last case is describing the situation when the template class uses a template function.