Member Function Templates

Building on our previous lesson on function templates, we now expand our knowledge to templates for member functions.

As we might expect, these templates can be instantiated to create functions within the scope of a class or a struct. In this lesson, we’ll cover:

• The syntax for defining member function templates
• How to instantiate and call member function templates
• Using member function templates in class templates
• How to separate declarations from definitions
• Important considerations when using header and implementation files

Creating Member Function Templates

The syntax for member function templates is identical to those of regular function templates. We provide a list of template parameters, followed by the body of our template.

Below, we define Attack as a member function template within the Player class:

1#include <iostream>
2
Monster Class|Show
3class Monster {/*...*/};
8
9class Player {
10 public:
11  template <typename T>
12  void Attack(T Target) {
13    std::cout << "\nAttacking " << Target.Name;
14  }
15
16  std::string Name;
17};
18
19int main() {
20  Player PlayerOne{"Anna"};
21  Player PlayerTwo{"Roderick"};
22  PlayerOne.Attack<Player>(PlayerTwo);
23
24  Monster Goblin{"Bonker"};
25  PlayerOne.Attack<Monster>(Goblin);
26}

1Attacking Roderick
2Attacking Bonker

Naturally, the functions generated by a member function template have all the same capabilities of a member function. For example, they can access the this pointer, call other member functions, and access member variables in the context of the current object:

1#include <iostream>
2
Monster Class|Show
3class Monster {/*...*/};
8
9class Player {
10 public:
11  template <typename T>
12  void Attack(T Target) {
13    std::cout << Name << " is attacking "
14      << Target.Name << '\n';
15  }
16
17  std::string Name;
18};
19
Main Function|Show
20int main() {/*...*/}

1Anna is attacking Roderick
2Anna is attacking Bonker

When the compiler can deduce which function needs to be instantiated from the template based on our function arguments, we can remove the template arguments:

1#include <iostream>
2
Monster Class|Show
3class Monster {/*...*/};
8
Player Class|Show
9class Player {/*...*/};
20
21int main() {
22  Player PlayerOne{"Anna"};
23  Player PlayerTwo{"Roderick"};
24  PlayerOne.Attack<Player>(PlayerTwo);
25  PlayerOne.Attack(PlayerTwo);
26
27  Monster Goblin{"Bonker"};
28  PlayerOne.Attack<Monster>(Goblin);
29  PlayerOne.Attack(Goblin);
30}

1Anna is attacking Roderick
2Anna is attacking Bonker

Member Templates in Template Classes

Sometimes, we’ll be creating member function templates within a class that itself will be an instance of a template:

1template <typename ClassParameter>
2class SomeClassTemplate {
3  template <typename FunctionParameter>
4  void SomeFunctionTemplate() {
5    // ...
6  }
7};

In this scenario, our member function template will also have access to the class template arguments.

We’ve updated our previous example to make Player a class template, rather than an individual class. It accepts a template argument specifying the preferred combat style of the class it creates:

1#include <iostream>
2
3enum class Style { Melee, Magic };
4
Monster Class|Show
5class Monster {/*...*/};
10
11template <Style CombatStyle>
12class Player {
13 public:
14  template <typename T>
15  void Attack(T Target) {
16    std::cout << Name << " is attacking "
17      << Target.Name;
18
19    if (CombatStyle == Style::Melee) {
20      std::cout << " with a sword\n";
21    } else {
22      std::cout << " with magic\n";
23    }
24  }
25
26  std::string Name;
27};
28
29int main() {
30  Player<Style::Magic> PlayerOne{"Anna"};
31  Monster Goblin{"Bonker"};
32  PlayerOne.Attack(Goblin);
33
34  Player<Style::Melee> PlayerTwo{"Roderick"};
35  PlayerTwo.Attack(PlayerOne);
36}

1Anna is attacking Bonker with magic
2Roderick is attacking Anna with a sword

The previous example used template argument deduction to allow us to simply write Attack(Goblin) instead of Attack<Monster>(Goblin). We can specify the template arguments if preferred and, in some scenarios, we will need to.

However, now that Player is a class template, we can no longer use it in scenarios where a type is expected.

When we have a template, and we need a type, we have to provide the template arguments that will generate that type, such as Player<Style::Magic>:

1#include <iostream>
2
3enum class Style { Melee, Magic };
4
Monster Class|Show
5class Monster {/*...*/};
10
Player Class|Show
11class Player {/*...*/};
29
30int main() {
31  Player<Style::Magic> PlayerOne{"Anna"};
32  Monster Goblin{"Bonker"};
33  PlayerOne.Attack<Monster>(Goblin);  
34
35  Player<Style::Melee> PlayerTwo{"Roderick"};
36  PlayerTwo.Attack<Player<Style::Magic>>(
37    PlayerOne);
38}

1Anna is attacking Bonker with magic
2Roderick is attacking Anna with a sword

Remember: we can introduce type aliases as needed to make our code easier to understand:

1#include <iostream>
2
3enum class Style { Melee, Magic };
4
Monster Class|Show
5class Monster {/*...*/};
10
Player Class|Show
11class Player {/*...*/};
28
29int main() {
30  using MeleePlayer = Player<Style::Melee>;
31  using MagicPlayer = Player<Style::Magic>;
32
33  MagicPlayer PlayerOne{"Anna"};
34  Monster Goblin{"Bonker"};
35  PlayerOne.Attack<Monster>(Goblin);
36
37  MeleePlayer PlayerTwo{"Roderick"};
38  PlayerTwo.Attack<MagicPlayer>(PlayerOne);
39}

1Anna is attacking Bonker with magic
2Roderick is attacking Anna with a sword

Defining Member Templates Separately

If we want to separate the declaration of a member function template from its implementation, our code could look something like this:

1#include <iostream>
2
3class Player {
4 public:
5  template <typename T>
6  void Attack(T Target);
7
8  std::string Name;
9};
10
11template <typename T>
12void Player::Attack(T Target) {
13  std::cout << "\nAttacking " << Target.Name;
14}

Where the template function is part of a template class, our implementation would have two sets of template arguments - one for the class, and one for the function.

Additionally, we need to fully qualify what class we’re providing an implementation for, by including the template arguments. With these two considerations combined, our code would look something like this:

1#include <iostream>
2enum class Style { Melee, Magic };
3
Player Class Declaration|Show
4class Player {/*...*/};
13
14template <Style CombatStyle>
15template <typename T>
16void Player<CombatStyle>::Attack(T Target) {
17  std::cout << Name << " is attacking " << Target.Name;
18
19  if (CombatStyle == Style::Melee) {
20    std::cout << " with a sword\n";
21  } else {
22    std::cout << " with magic\n";
23  }
24}

In the previous examples, we assume the declaration and definition are within the same file. If we want to split them across different files - such as a header file an and implementation file - there are some additional problems to overcome.

We introduced these problems, and options for working around them, earlier in the chapter:

Templates and Header Files

Learn how to separate class templates into declarations and definitions while avoiding common linker errors

Summary

In this lesson, we learned about member function templates in C++. The key takeaways are:

• Member function templates allow us to create generic functions within classes and structs
• The syntax is similar to regular function templates, with the template parameters defined before the function
• Member function templates can access the class's member variables and functions
• When the class is also a template, the member function template has access to the class template parameters
• Defining member function templates separately requires fully qualifying the class name with its template arguments
• Additional considerations are needed when using member function templates across header and implementation files

Next Lesson

Template Specialization

A practical guide to template specialization in C++ covering full and partial specialization, and the scenarios where they’re useful

ContinueView Course