C++: Templated function return value

Question

considering following code:

#include <iostream>
using namespace std;

template <typename T>

T foo(T a, T b) {
    if (a<b) {
        return b;
    }
    return a;
}

int main() {
    cout <<foo<int>(3,4) <<endl;
    cout <<foo(1,2) <<endl;
    cout <<foo("hello","goodbuy") <<endl; //>>>>>this line <<<<<<
    cout <<foo<float>(3,4) <<endl;    
}

it prints out: 4 2 hello 4 but when i changed the marked line with this: cout <('hello','goodbuy') <

warning: character constant too long for its type
     cout <<foo<int>('hello','goodbuy') <<endl; 
                     ^
warning: character constant too long for its type
     cout <<foo<int>('hello','goodbuy') <<endl; 
                         ^

and prints out : 4 2 1701604463 4 why does it print out that big number? some help or guidance please thank you

Answer 1

Main problem:

'hello'

is a character literal that denotes an integer, if it is at all accepted (how many characters you can use depends on the compiler). At one time it was used to generate magic numbers that e.g. denoted file types. For example, in old DOS a file that started with the characters MZ was an executable, and the Windows command interpreter, although not Windows Explorer, still recognizes that silly magic:

[H:\dev\test\0119]
> echo MZ >blah.txt

[H:\dev\test\0119]
> blah.txt
This version of H:\dev\test\0119\blah.txt is not compatible with the version of Windows you're running. Check your computer's system informa
tion and then contact the software publisher.

[H:\dev\test\0119]
> _

In old C code that number would perhaps be denoted by an integer constant like 'ZM'.

---

Now, starting with your definition …

template< typename T >
T foo(T a, T b) {
    if (a<b) {
        return b;
    }
    return a;
}

Let me first rewrite it to a form I’m more comfortable with:

template< class Type >
auto foo( Type const a, Type const b)
    -> Type
{ return (a<b? b : a); }

I do this rewrite up front so that that aspect can be ignored in the following.

Regardless of form it has a problem when the actual arguments are of different types, e.g. in the call foo( 3, 4.5 ). Then argument type deduction will fail, so that the type must be specified explicitly, foo<double>( 3, 4.5 ). How to avoid that?

For numeric types you can deal with that like this:

template< class Type1, class Type2 >
auto foo( Type1 const a, Type2 const b )
    -> decltype( a + b )
{ return (a<b? b : a); }

Now you want to call it with string literals as arguments. They will be deduced as type char const*, and then the a + b expression will not compile. For you can't add pointers.

For that matter, the a<b expression would yield an probably unintended result, just comparing the pointer values instead of a lexicographic compare of the strings.

One solution is then to provide an overload of the function:

auto foo( char const* const a, char const* const b)
    -> char const*
{ return (strcmp( a, b ) < 0? b : a); }

Then you can call it like foo( "bravo", "alpha" ).

---

Disclaimer: all C++ code untouched by compilers’ hands.

Answer 2

As commented by @Brian, use " for strings. Otherwise you get a multicharacter literal (link1) (link2).

int main() {
    cout << foo("hello","goodbuy") <<endl;
}

This code compiles, but it has a problem! "hello" and "goodbuy" are arrays of characters, that are converted to a pointer to the first letter when passing as a parameter. So in the template functions you will compare two pointers, which is definitely not what you want (because the return value of this comparison is undefined). One solution is to convert the character arrays into an std::string.

#include <string>

int main() {
    cout << foo<string>("hello", "goodbuy") <<endl;
}