c++: Use template default arugment and check if it is set explicitly - c++

Question

Edit: thanks for the prompt replies. I found my notation about T is confusing.
T is not a template argument but actual type hard coded in the switch clause, according to case.
I have the following template function that takes two template arguments, while the latter is optional:
template <typename F, typename RT = int>
pipe(Input input, F operation)
{
// the Input is a container with its value stored in unknown type T
// and I do the following switch to call different version of
// operation (a template function as well) according to T
switch (input.type())
{
case 0: RT output = (RT) operation<char>(input);break;
case 1: RT output = (RT) operation<int>(input);break;
...
}
return output;
}
What I would like to achieve is to allow determine RT according to the parsed data type T when RT is not explicitly set, i.e.:
when call with pipe<F>(input, operation), the return type would be the same as the data type of input;
when call with pipe<F, RT>(input, operation), the return type would be set to RT regardless what input data type is.
I can achieve this for now by doing overloading, which involves copy paste the nearly the same chunk of code with a little modification
Therefore I am asking if there is a way to avoid this by having a special "dummy" type as the default RT:
template <typename F, typename RT = dummy>
and have some switch in the function pipe like this:
if (RT == dummy)
// use T determined from switch as RT
else
// use the specified RT
Any suggestions?

Answer 1

You should reverse your ordering. If you make the "dummy" template 2nd, to provide it explicitly, you will also have to provide the first type - and then you won't be able to take advantage of template deduction.
Instead, provide two overloads of pipe. One in which RT is explicitly provided:
template <typename RT, typename F>
void pipe(Input input, F operation) {
switch (input.type())
{
case 0: RT output = (RT) operation<char>(input);break;
case 1: RT output = (RT) operation<int>(input);break;
...
}
return output;
}
And one in which it's determined from Input and calls the other one:
template <typename F>
void pipe(Input input, F operation)
{
pipe<typename Input::value_type>(input, operation);
// ^^^^^^^^^^^^^^^^^^^^^^^^^^
// or whatever metafunction
}
No dummy or need to avoid deduction necessary.

Answer 2

One thing that could actually help you, even if it doesn't answer your question directly is to use the internal typedefs of your container.
All the STL containers have a value_type alias which identify the element which are actually contained within.
Then you can call:
(RT) operation<input::value_type>(input)