熊熊学习乐园

A place for growing

0%

Chapter11-Function-Overloading-and-Function-Templates

发表于 更新于 分类于 ，

Functions can be overloaded so long as each overloaded function can be differentiated by the compiler. If an overloaded function can not be differentiated, a compile error will result.

Introduction to function overloading

Function overloading allows us to create multiple functions with the same name, so long as each identically named function has different parameter types (or the functions can be otherwise differentiated).

Function overload differentiation

How overloaded functions are differentiated

Function property Used for differentiation Notes
Number of parameters Yes
Type of parameters Yes Excludes typedefs, type aliases, and const qualifier on value parameters. Includes ellipses.
Return type No
  • Ellipses: 
    1
    2
    void func(int, ...);
    void func(double, ...); // may not differentiatiable

Overloading based on number of parameters

1
2
3
4
5
6
7
8
9
int add(int x, int y)
{
    return x + y;
}

int add(int x, int y, int z)
{
    return x + y + z;
}

Overloading based on type of parameters

1
2
3
4
int add(int x, int y); // integer version
double add(double x, double y); // floating point version
double add(int x, double y); // mixed version
double add(double x, int y); // mixed version

Because type aliases (or typedefs) are not distinct types, overloaded functions using type aliases are not distinct from overloads using the aliased type.

For parameters passed by value, the const qualifier is also not considered (But for parameters passed by pointer, const qualifier can be differentiated). Therefore, the following functions are not considered to be differentiated:

1
2
void print(int);
void print(const int); // not differentiated from print(int)

The return type of a function is not considered for differentiation

A function’s return type is not considered when differentiating overloaded functions.

1
2
int getRandomValue();
double getRandomValue();

Type signature

A function’s type signature (generally called a signature) is defined as the parts of the function header that are used for differentiation of the function.

Function overload resolution and ambiguous matches

The process of matching function calls to a specific overloaded function is called overload resolution.

Resolving overloaded function calls

Three possible outcomes:

  • No matching functions were found. The compiler moves to the next step in the sequence.
  • A single matching function was found. This function is considered to be the best match. The matching process is now complete, and subsequent steps are not executed.
  • More than one matching function was found. The compiler will issue an ambiguous match compile error. We’ll discuss this case further in a bit.

If the compiler reaches the end of the entire sequence without finding a match, it will generate a compile error that no matching overloaded function could be found for the function call.

The argument matching sequence

  • Step 1 : The compiler tries to find an exact match
    • First, the compiler will see if there is an overloaded function where the type of the arguments in the function call exactly matches the type of the parameters in the overloaded functions.
    • Second, the compiler will apply a number of trivial conversions to the arguments in the function call. The trivial conversions are a set of specific conversion rules that will modify types (without modifying the value) for purposes of finding a match. These include:
      • lvalue to rvalue conversions
      • qualification conversions (e.g. non-const to const)
      • non-reference to reference conversions
  • Step 2: If no exact match is found, the compiler tries to find a match by applying numeric promotion to the argument(s).
  • Step 3: If no match is found via numeric promotion, the compiler tries to find a match by applying numeric conversions
  • Step 4: If no match is found via numeric conversion, the compiler tries to find a match through any user-defined conversions.
  • Step 5: If no match is found via user-defined conversion, the compiler will look for a matching function that uses ellipsis.
  • Step 6: If no matches have been found by this point, the compiler gives up and will issue a compile error about not being able to find a matching function.

Ambiguous matches

An ambiguous match occurs when the compiler finds two or more functions that can be made to match in the same step. When this occurs, the compiler will stop matching and issue a compile error stating that it has found an ambiguous function call.

Resolving ambiguous matches

  1. Often, the best way is simply to define a new overloaded function that takes parameters of exactly the type you are trying to call the function with. Then C++ will be able to find an exact match for the function call.
  2. Alternatively, explicitly cast the ambiguous argument(s) to match the type of the function you want to call. For example, to have foo(0) match foo(unsigned int) in the above example, you would do this: examp： 
    1
    2
    int x{ 0 };
    foo(static_cast<unsigned int>(x)); // will call foo(unsigned int)
  3. If your argument is a literal, you can use the literal suffix to ensure your literal is interpreted as the correct type: 
    1
    foo(0u); // will call foo(unsigned int) since 'u' suffix is unsigned int, so this is now an exact match

Matching for functions with multiple arguments

If there are multiple arguments, the compiler applies the matching rules to each argument in turn. The function chosen must provide a better match than all the other candidate functions for at least one parameter, and no worse for all of the other parameters.

Deleting functions

Deleting a function using the = delete specifier

In cases where we have a function that we explicitly do not want to be callable, we can define that function as deleted by using the = delete specifier. If the compiler matches a function call to a deleted function, compilation will be halted with a compile error.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>

void printInt(int x)
{
    std::cout << x << '\n';
}

void printInt(char) = delete; // calls to this function will halt compilation
void printInt(bool) = delete; // calls to this function will halt compilation

int main()
{
    printInt(97);   // okay

    printInt('a');  // compile error: function deleted
    printInt(true); // compile error: function deleted

    printInt(5.0);  // compile error: ambiguous match

    return 0;
}

= delete means “I forbid this”, not “this doesn’t exist”.

Deleted function participate in all stages of function overload resolution (not just in the exact match stage). If a deleted function is selected, then a compilation error results.

Deleting all non-matching overloads

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>

// This function will take precedence for arguments of type int
void printInt(int x)
{
    std::cout << x << '\n';
}

// This function template will take precedence for arguments of other types
// Since this function template is deleted, calls to it will halt compilation
template <typename T>
void printInt(T x) = delete;

int main()
{
    printInt(97);   // okay
    printInt('a');  // compile error
    printInt(true); // compile error

    return 0;
}

Default arguments

Default arguments can not be redeclared, and must be declared before use

Once declared, a default argument can not be redeclared in the same translation unit. That means for a function with a forward declaration and a function definition, the default argument can be declared in either the forward declaration or the function definition, but not both.

1
2
3
4
5
6
7
8
9
#include <iostream>

void print(int x, int y=4); // forward declaration

void print(int x, int y=4) // compile error: redefinition of default argument
{
    std::cout << "x: " << x << '\n';
    std::cout << "y: " << y << '\n';
}

The default argument must also be declared in the translation unit before it can be used:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
#include <iostream>

void print(int x, int y); // forward declaration, no default argument

int main()
{
    print(3); // compile error: default argument for y hasn't been defined yet

    return 0;
}

void print(int x, int y=4)
{
    std::cout << "x: " << x << '\n';
    std::cout << "y: " << y << '\n';
}

The best practice is to declare the default argument in the forward declaration and not in the function definition, as the forward declaration is more likely to be seen by other files and included before use (particularly if it’s in a header file).

Default arguments and function overloading

Functions with default arguments may be overloaded. For example, the following is allowed:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
#include <iostream>
#include <string_view>

void print(std::string_view s)
{
    std::cout << s << '\n';
}

void print(char c = ' ')
{
    std::cout << c << '\n';
}

int main()
{
    print("Hello, world"); // resolves to print(std::string_view)
    print('a');            // resolves to print(char)
    print();               // resolves to print(char)

    return 0;
}

Now consider this case:

1
2
3
void print(int x);                  // signature print(int)
void print(int x, int y = 10);      // signature print(int, int)
void print(int x, double y = 20.5); // signature print(int, double)

Default values are not part of a function’s signature, so these function declarations are differentiated overloads.

Default arguments can lead to ambiguous matches

1
2
3
4
5
6
7
8
9
10
11
12
13
14
void foo(int x = 0)
{
}

void foo(double d = 0.0)
{
}

int main()
{
    foo(); // ambiguous function call

    return 0;
}

Default arguments don’t work for functions called through function pointers

Introduction to C++ templates

Instead of manually creating a bunch of mostly-identical functions or classes (one for each set of different types), we instead create a single template. Just like a normal definition, a template describes what a function or class looks like. Unlike a normal definition (where all types must be specified), in a template we can use one or more placeholder types. A placeholder type represents some type that is not known at the time the template is written, but that will be provided later.

Function templates

When we create our function template, we use placeholder types (also called type template parameters, or informally template types) for any parameter types, return types, or types used in the function body that we want to be specified later.

C++ supports 3 different kinds of template parameters: - Type template parameters (where the template parameter represents a type). - Non-type template parameters (where the template parameter represents a constexpr value). - Template template parameters (where the template parameter represents a template).

Creating a templated max function

1
2
3
4
5
template <typename T> // this is the template parameter declaration(type template parameter declaration)
T max(T x, T y) // this is the function template definition for max<T>
{
    return (x < y) ? y : x;
}

There is no difference between the typename and class keywords in this context. You will often see people use the class keyword since it was introduced into the language earlier.

Using a function template

Function templates are not actually functions -- their code isn’t compiled or executed directly. Instead, function templates have one job: to generate functions (that are compiled and executed).

Syntax: 

1
max<actual_type>(arg1, arg2); // actual_type is some actual type, like int or double

The process of creating functions (with specific types) from function templates (with template types) is called function template instantiation (or instantiation for short). When a function is instantiated due to a function call, it’s called implicit instantiation. A function that is instantiated from a template is technically called a specialization, but in common language is often called a function instance. The template from which a specialization is produced is called a primary template. Function instances are normal functions in all regards.

Template argument deduction

In cases where the type of the arguments match the actual type we want, we do not need to specify the actual type -- instead, we can use template argument deduction to have the compiler deduce the actual type that should be used from the argument types in the function call.

1
std::cout << max<int>(1, 2) << '\n'; // specifying we want to call max<int>

We can use this instead. 

1
2
std::cout << max<>(1, 2) << '\n';
std::cout << max(1, 2) << '\n';

The difference between the two cases has to do with how the compiler resolves the function call from a set of overloaded functions. In the top case (with the empty angled brackets), the compiler will only consider max<int> template function overloads when determining which overloaded function to call. In the bottom case (with no angled brackets), the compiler will consider both max<int> template function overloads and max non-template function overloads. When the bottom case results in both a template function and a non-template function that are equally viable, the non-template function will be preferred.

The normal function call syntax will prefer a non-template function over an equally viable function instantiated from a template.

That last point may be non-obvious. A function template has an implementation that works for multiple types -- but as a result, it must be generic.

Favor the normal function call syntax when making calls to a function instantiated from a function template (unless you need the function template version to be preferred over a matching non-template function).

Function templates with non-template parameters

It’s possible to create function templates that have both template parameters and non-template parameters. The type template parameters can be matched to any type, and the non-template parameters work like the parameters of normal functions.

We can tell the compiler that instantiation of function templates with certain arguments should be disallowed. This is done by using function template specialization, which allow us to overload a function template for a specific set of template arguments, along with = delete, which tells the compiler that any use of the function should emit a compilation error.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
#include <iostream>
#include <string>

template <typename T>
T addOne(T x)
{
    return x + 1;
}

// Use function template specialization to tell the compiler that addOne(const char*) should emit a compilation error
// const char* will match a string literal
template <>
const char* addOne(const char* x) = delete;

int main()
{
    std::cout << addOne("Hello, world!") << '\n'; // compile error

    return 0;
}

Function templates and default arguments for non-template parameters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
#include <iostream>

template <typename T>
void print(T val, int times=1)
{
    while (times--)
    {
        std::cout << val;
    }
}

int main()
{
    print(5);      // print 5 1 time
    print('a', 3); // print 'a' 3 times

    return 0;
}

Beware function templates with modifiable static local variables

When a static local variable is used in a function template, each function instantiated from that template will have a separate version of the static local variable.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
#include <iostream>

// Here's a function template with a static local variable that is modified
template <typename T>
void printIDAndValue(T value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

int main()
{
    printIDAndValue(12);
    printIDAndValue(13);

    printIDAndValue(14.5);

    return 0;
}

It actually works like: 

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
#include <iostream>

template <typename T>
void printIDAndValue(T value);

template <>
void printIDAndValue<int>(int value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

template <>
void printIDAndValue<double>(double value)
{
    static int id{ 0 };
    std::cout << ++id << ") " << value << '\n';
}

int main()
{
    printIDAndValue(12);   // calls printIDAndValue<int>()
    printIDAndValue(13);   // calls printIDAndValue<int>()

    printIDAndValue(14.5); // calls printIDAndValue<double>()

    return 0;
}

Note that printIDAndValue<int> and printIDAndValue<double> each have their own independent static local variable named id, not one that is shared between them.

# Function templates with multiple template types

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(2, 3.5) << '\n';  // compile error

    return 0;
}

Use static_cast to convert the arguments to matching types

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(static_cast<double>(2), 3.5) << '\n'; // convert our int to a double so we can call max(double, double)

    return 0;
}

Provide an explicit type template argument

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
#include <iostream>

template <typename T>
T max(T x, T y)
{
    return (x < y) ? y : x;
}

int main()
{
    // we've explicitly specified type double, so the compiler won't use template argument deduction
    std::cout << max<double>(2, 3.5) << '\n';

    return 0;
}

Function templates with multiple template type parameters

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

template <typename T, typename U> // We're using two template type parameters named T and U
T max(T x, U y) // x can resolve to type T, and y can resolve to type U
{
    return (x < y) ? y : x; // uh oh, we have a narrowing conversion problem here
}

int main()
{
    std::cout << max(2, 3.5) << '\n'; // resolves to max<int, double>

    return 0;
}

With "treat warnings as errors" turned off, it will give 3 as the result because T is translated as int.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

template <typename T, typename U>
auto max(T x, U y)
{
    return (x < y) ? y : x;
}

int main()
{
    std::cout << max(2, 3.5) << '\n';

    return 0;
}

Just note that a function with an auto return type needs to be fully defined before it can be used (a forward declaration won’t suffice), since the compiler has to inspect the function implementation to determine the return type.

Abbreviated function templates C++20

1
2
3
4
auto max(auto x, auto y)
{
    return (x < y) ? y : x;
}

equals to: 

1
2
3
4
5
template <typename T, typename U>
auto max(T x, U y)
{
    return (x < y) ? y : x;
}

Function templates may be overloaded

# Non-type template parameters

Non-type template parameters

A non-type template parameter is a template parameter with a fixed type that serves as a placeholder for a constexpr value passed in as a template argument.

A non-type template parameter can be any of the following types:

  • An integral type
  • An enumeration type
  • std::nullptr_t
  • A floating point type (since C++20)
  • A pointer or reference to an object
  • A pointer or reference to a function
  • A pointer or reference to a member function
  • A literal class type (since C++20)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
#include <iostream>

template <int N> // declare a non-type template parameter of type int named N
void print()
{
    std::cout << N << '\n'; // use value of N here
}

int main()
{
    print<5>(); // 5 is our non-type template argument

    return 0;
}

# Using function templates in multiple files

main.cpp: 

1
2
3
4
5
6
7
8
9
10
11
12
#include <iostream>

template <typename T>
T addOne(T x); // function template forward declaration

int main()
{
    std::cout << addOne(1) << '\n';
    std::cout << addOne(2.3) << '\n';

    return 0;
}
add.cpp: 
1
2
3
4
5
template <typename T>
T addOne(T x) // function template definition
{
    return x + 1;
}
Will get a linker error.

The most conventional way to address this issue is to put all your template code in a header (.h) file instead of a source (.cpp) file:

add.h 

1
2
3
4
5
6
7
8
9
10
#ifndef ADD_H
#define ADD_H

template <typename T>
T addOne(T x) // function template definition
{
    return x + 1;
}

#endif

main.cpp 

1
2
3
4
5
6
7
8
9
10
#include "add.h" // import the function template definition
#include <iostream>

int main()
{
    std::cout << addOne(1) << '\n';
    std::cout << addOne(2.3) << '\n';

    return 0;
}

Template definitions are exempt from the part of the one-definition rule that requires only one definition per program, so it is not a problem to have the same template definition #included into multiple source files. And functions implicitly instantiated from function templates are implicitly inline, so they can be defined in multiple files, so long as each definition is identical.

The templates themselves are not inline, as the concept of inline only applies to variables and functions.

Templates that are needed in multiple files should be defined in a header file, and then #included wherever needed. This allows the compiler to see the full template definition and instantiate the template when needed.