Can C Templates Emulate `template` for Simplified Argument Passing?

Simplified Argument Passing for C Templates

In C templates, arguments are passed explicitly using template parameters. While this provides control and flexibility, it can be cumbersome for certain scenarios, especially when dealing with complex types like pointers-to-member-functions.

The question arises: can we emulate the behavior of template to enable compile-time argument passing with a more simplified syntax?

It turns out that C does not provide direct support for this. The closest alternative is using macros, which introduces verbosity and can be error-prone.

Macro-Based Approach

<code class="cpp">#define AUTO_ARG(x) decltype(x), x

f.bar<AUTO_ARG(5)>();
f.bar<AUTO_ARG(&Baz::bang)>();</code>

Generator-Based Approach

Alternatively, we can leverage a code generator to achieve a similar effect. Here's a possible approach:

<code class="cpp">template <typename T>
struct foo
{
    foo(const T&amp;) {} // do whatever
};

template <typename T>
foo<T> make_foo(const T&amp; x)
{
    return foo<T>(x);
}</code>

This allows for deduction of the template argument:

<code class="cpp">make_foo(5); // equivalent to foo<int>(5)
make_foo(&Baz::bang); // equivalent to foo<decltype(&Baz::bang)>(&Baz::bang)</code>

While this generator approach eliminates the need for explicit template parameters, it introduces an indirection and may not be suitable for all scenarios.

Ultimately, the best approach depends on the specific requirements of the project and the desired level of simplicity, flexibility, and maintainability.

The above is the detailed content of Can C Templates Emulate `template` for Simplified Argument Passing?. For more information, please follow other related articles on the PHP Chinese website!