C++: template function instantiation does not work with string as return value. Why?
 

Hi,

I'm new with templates in C++, but there is something that's really bugging me:

I can make references of a template function from one .cpp file in a .h file and use that function in another .cpp file if I instantiate the template with the appropriate types. But when the return type is std::string, linker errors occur.

EXAMPLE CODE:

main.cpp
template.cpp
EDIT: I changed the char* instantiation to char const*, with the same result (johnsfine spotted this).

template.h
'g++ *.cpp' returns:
The linker only complains about the template function that returns a string, not about the others (if you leave the function with the string entirely out of it, the whole thing links ond works).

Is there a (practicable) solution for this or do I just have to move templates that won't work like that into header files?

Well, I am no C++ expert, but I see 'main.cpp' includes 'template.h', and I do not see that 'template.h' includes 'template.cpp'. Nor 'main.cpp' includes 'template.cpp'.

So, if my observation is correct, why do you have 'template.cpp' in the first place ?

The last code block shows the output of g++ *.cpp. This means that 'template.cpp' is included in compiling the executable. For functions in 'template.cpp' to be called from 'main.cpp', 'template.h' contains references.

This is the usual way to split up code in more than one .cpp file, .h files [=headers] are interfaces between the .cpp files. Here it even works with the template funtions (which are indeed usually just dumped into header files), just the function that returns a string doesn't work that way.

As I stated in my first post, everything works as long as I don't use a template function that returns a string. I'm afraid your reply misses the point (if you have further ideas, you are still invited to post them here).

One thing I can think of is, the string type seems to be a template itself (the other types aren't), which complicates things. But then I can't find out what the problem is. Maybe that one really is too complicated for me, but I'd rather want to know than to guess.

The failure to find test<std::string>() is easy to understand.

The definition of test is in a separate compilation unit, so you needed to explicitly instantiate every instance of that which you might use. That is what your code is doing with:
So it isn't that std::string is the only type failing to work, but that the above three are the only types that work.

Similarly the failure to find the instantiation of str() needed for str("test"): The compiler has deduced char const* and you simply made the error of providing char* instead.

Edit: The momentary brain lapse below was in my original response. But then I realized I had const&T where you have T, which is why the compiler can't misunderstand "test" for you but did for me:

Similarly I understand the failure to find the instantiation of str() needed for str("test"). But I don't understand why that almost worked and could be fixed easily.

In many places in my own code I have written the equivalent of
template <class T> std::string str(T);
str("test")
and been frustrated that the compiler instantiated something like str<const char[5]> when I really really wanted str<char const*>

So I assumed (without knowing where to check in the C++ standard) that template deduction on "test" produces const char[5] instead of char const*. That has made a lot of my code harder to get right.

But your error messages show a much better behavior by the compiler. It has deduced char const* and you simply made the error of providing char* instead.

As the compiler is telling you, you don't haven't instantiated what you need, and the compiler can't do it itself because it can't see the implementations of those templates. Each cpp is a processed by itself, nothing from any other cpp is considered ("Translation Unit").

Just save yourself a lot of trouble and put the implementations into the header file, or include from the header file a "template implementation" file.

Probably. I am trying to find answers to the following questions:

1. Which of the three files: main.cpp, template.cpp, template.h take part in compilation ?
2. If all three of them, how exactly template.cpp becomes known to the compiler ?

main.cpp and template.cpp are each compiled, but separately (even though those separate compiles might be invoked by a single g++ command.

So the information in template.h is known to the compiler during each compile (because it is #included in each). But the information in template.cpp is not know while compiling main.cpp and is usable by main.cpp only through linking (which in g++ is able to connect to already instantiated instances of a template from other compilation units, but is not able to instantiate new instances).

main.cpp includes template.h, which is an interface to the functions in template.cpp. The compiler knows about template.cpp because I tell it on the command-line ("g++ *.cpp" < this means all .cpp files in that directory are included in the compilation process). If you are curious about how to implement this (standard) kind of code splitting yourself, this link goes to an elaborate explanation. Splitting up your code is in fact basic C++ knowledge, so I can only recommend that link (or easier explanations on how to do it).

I changed it into const char* too, with the same result I'm afraid. Maybe something interesting will come up here :) (otherwise, I'll just put those templates into header files)

Did you read my explanation of both bugs in your code? Did you try both corrections?

I don't believe you would get the same result. Even fixing just one of the two bugs should have changed the error messages.

Repost your code with your understanding of those two corrections and with the error messages if any from recompiling.

I'm sorry, I thought changing "char*" into "char const*" in the instantiation was the only thing you ment. Changing it did have the same result, even though "char const*" is the correct type.

So what was the other bug? I read your posts, but I don't see anything besides the "char const*" issue.

AFAIK C++ files are compiled separately, i.e. declarations from one file are not known in another. That's why, I think, files with template code need to be physically included into the files which instantiate the template code.

The "instantiation" turns templates into full-fledged functions, which can be referred to in headers. They only work as those that you instantiate in the .cpp file, though.

Here is a working version (without string as return parameter), so you get the idea:

main.cpp
template.cpp
template.h
This is a combination of templates and code splitting, which I also want to implement with template functions that return a string, but I ran into the mentioned trouble...

Compile this with the command "g++ main.cpp template.cpp" or just "g++ *.cpp".

Any ideas appreciated

I gtg soon, will check on later responses when I'm back at my PC again ;)

your template should be in the header file.

template.cpp should be template.hpp.
template.cpp is not needed.

then it compiles.

Good morning,

I know that much. That would be common practice. I'm just wondering why the instantiation method does work with simple types and does not work with the string type (note that I also posted a fully working example).

Or rather, I would like to know if it's possible to instantiate template functions that return a string and use them from different .cpp files (or object files or translation units, you get the idea). Again, this does work in the second example I posted, but not when the return type is string.

I just had another look. The "char*" issue did raise up another linker error, I just didn't look at it closely.

I also spotted another mistake: the "test" function was not instantiated with the string type. After I added that instantiation, everything worked. johnsfine already explained that in his first post, and I only understood that now. Sorry for that.

So everything was just a few mistakes on my part. Thank you for your contributions.

The following code works completely, I'm just posting it for convenience:

main.cpp
template.cpp
template.h

Just for information. You don't need to do it that way. With templates (in gcc) you can include the code in the header file and then the compiler will work out which templated functions will be required. So the following will give the same results:

template.h
main.cpp
Note the main is unchanged I have just included it for completeness.

I think you're missing the point. Of course you can include the function definitions in the header file and not have to deal with this problem. But you might have good reasons to want to keep just function declarations in the header file and function definitions in a .cpp file.

TITiAN clearly wanted to do that and knew the basics of how to do that and merely made a couple minor errors in the details. But then started thinking there was something more fundamental wrong with the mechanism, rather than spotting the couple details that were wrong.

One thing that confused me for most of the time was that g++ calls the string type this:
When you think of that whole expression just as "string", it all becomes clear.

Right now I'm having issues with a template function that accepts "T const&" as an argument, but before I start another thread, I'll tear out my own hair ;)

Take yet another look at my main post of this thread. Notice what I said about the compiler's unfortunate behavior when it matches quoted text to a template argument of the form T const&

I hate links to long documents posted alone as apparent answers in complicated threads.

Whose question do you think you're answering? What part of that question do you think you're answering? What part of that long document do you think provides that answer?

The OP in this thread was never confused about the basic questions of why it is easier to have the definition in header rather than cpp files, nor the more advanced question of what you need to do when you really want the definition in a cpp anyway. The OP was only messing up some details within that and already solved even those details.

The link you posted seems to only cover the basics of that, which the OP didn't need and which others in this thread should already understand from what was already in this thread.

The OP (and maybe me as well) are now confused about some of the strange consequences of using T const& as the parameter type in a templated function. Is there something I missed in that document you linked that helps with that question?

well excuse me for not meeting your criteria.

I thought it may help the OP.
It is also a useful resource for C++ problems.

I thought it was fairly relevent myself,
the FAQ says:
which is what the OP was attempting.
if you read the FAQ it refers to the next two which give solutions to the problem.
OP:
next FAQ:
one after that....

obviously I am an idiot.

give me an example, maybe I can get an answer to you.

I'm not sure I have an example where I don't know the answer. Maybe TITiAN will post one.

I have complicated examples, some of which simplify to the example below and others I'm not sure. When I started being confused by this topic 8 years ago, I would not have understood the behavior of the complicated examples that do simplify to the one below. Once it is that simplified as shown below, the behavior is much easier to understand. But I expect many experienced C++ programmers would be surprised at the output of even this simple program:

Why is a double the same size in test1 as in test2, while "text" is 5 bytes in test1 and 4 in test2.

In more complicated cases, I used to make the simple assumption that "test" was a char const* which is 4 bytes (in x86) so that a reference to "text" would be a reference to a char const* which would be a reference to a type that is 4 bytes, just a 1.3 is a double, which is 8 bytes while a reference to 1.3 is a reference to a type that is 8 bytes.

In other words, I thought passing by reference gives you a reference to the type that would have been passed if the same parameter had been passed by value. But that is not generally true.

When writing a very general template that must be prepared to deal with many kinds of input, some of which really ought to be passed by const&, it may be tricky to deal with this extra difference between passing by value and passing by const& (that it is a const& to some other type than would have been passed by value).

You'll get the same difference without templates, it's because one is measuring the size of the literal, the other measuring the size of the pointer:
gives the following output:

I know one is measuring the literal and one is measuring the pointer. That wasn't the tricky part. The tricky part was why. Look at how the two templates are declared and called. It is initially confusing that they behave differently.

I still don't understand why I can't use "const char* const&" as an argument:
main.cpp
template.cpp
template.h
`g++ *.cpp' returns:
As johnsfine mentioned before, g++ wants me to use this template instantiation for the purpose:
Obviously, it would be ridiculous to make instantiations for all possible sizes.

BTW this works:

I figured something out: If I change this line from main.cpp
into this:
it works.

So I guess the compiler can automatically convert char[5] into const char*, but not when it has to deduce that char[5] is const char* as in const char* const&.

Dear Diary,
Today was a lucky day: I found a solution for the problem the use of the "T const&" template type has.

The working version looks like this:
main.cpp
template.cpp
template.h
That's a practicable solution that even works with the const& statement, I suppose.

The function
splits up the automatic conversions (char[5]->char const* and char const*->char const* const&).

I wonder if there has been some confusion about how references work?

As I understand it the reference is established in the declaration and not in the calling of a function. So if you pass a reference of an object to a function that is not expecting a reference then a copy is made. Whereas if in the declaration the function says that it expects a reference then a reference will be used.

The following example first looks at it from a function perspective and then a templated function.

template.h
template.cpp
main.cpp
output
The two functions test() and rtest() are just normal functions. When test() is called a copy is made. Whenever rtest() is called regardless of whether the object or reference to the object is called no copy is done. The function ttest() is just the rtest() function converted to a template function.

My recommendation would be to have the concepts clear by writing a non-templated function if the creation of the templated version is becoming problematic