Templated function with optional compile time arg

I have the following templated functions with an optional port argument, which should be recognized at compile time:

template<typename T>
void inner(T arg1){...}

template<typename T>
void inner(T arg1, int port){...}

I want to call the inner functions from outer functions with minimum repetition:

template<typename T>
void outer(T arg1){
    /* Do some stuff */
    inner(arg1);
}

template<typename T>
void outer(T arg1, int port){
    /* Do same stuff as in void outer(T arg1) */
    inner(arg1, port);
}

In my solution attempt I made use of variadic templates:

template<typename T, typename... Args>
void outer(T arg1, Args... args){
    inner(arg1, args...);
}

It is used like this:

int main(int argc, char **argv)
{
    outer(10);
    outer(10, 20);
    
	return 0;
}

However, I do not like to have a variable amount of parameters but just 0 or 1.
Either you specify the port or not.
How can I do this?

Tried to explore SFINAE, enable_if and such, but I was not able to make sense out of it.

The usual way to avoid repetition is to write a function:

void Do_some_stuff(Some args);

template<typename T>
void outer(T arg1){
    Do_some_stuff( ... );
    inner(arg1);
}

template<typename T>
void outer(T arg1, int port){
    Do_some_stuff( ... );
    inner(arg1, port);
}

There are multiple options to consider. The easiest one is using a variadic template but limiting the number of arguments in the outer function, e.g. using static_assert

#include<iostream>

template<typename T>
void inner(T arg1){std::cout << "one\n";}

template<typename T>
void inner(T arg1, int port){std::cout << "two\n";}

template<typename T, typename... Args>
void outer(T arg1, Args... args){
    static_assert(sizeof...(Args) < 2, "no more than one param");
    inner(arg1, args...);
}


int main()
{
    outer(1,2);
    outer(1);
//    outer(1,2,3); //fails to compile
}

https://godbolt.org/z/ehcej8zrs

Given the type of the second parameter is known, outer can be a single function taking two parameters, one of which is an optional empty by default. I cannot tell if it's acceptable from your API and ABI's standpoint, if it is though, it looks more-less the following way:

#include <iostream>
#include <optional>

template<typename T>
void inner(T arg1){std::cout << "one\n";}

template<typename T>
void inner(T arg1, int port){std::cout << "two\n";}

template<typename T>
void outer(T arg1, std::optional<int> port = {} ){
    if (port) {
        inner(arg1, *port);
    } else {
        inner(arg1);
    }
}


int main()
{
    outer(1,2);
    outer(1);
//    outer(1,2,3); //fails to compile
}

https://godbolt.org/z/6jnnMMGKW

For the sake of the example I have assumed you are using C++17 or newer, if not, std::optional can be replaced by the one from Boost.