Pointers to Members

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
9class Party {
10 public:
11  void for_each(auto Func) {  
12    Func(PlayerOne);          
13    Func(PlayerTwo);          
14    Func(PlayerThree);        
15  }                           
16
17 private:
18  Player PlayerOne{"Roderick"};
19  Player PlayerTwo{"Anna"};
20  Player PlayerThree{"Steve"};
21};

1#include <iostream>
2
Player Class|Show
3class Player {/*...*/};
8
Party Class|Show
9class Party {/*...*/};
23
24void LogName(Player& P) {       
25  std::cout << P.Name << '\n';  
26}  
27
28int main() {
29  Party MyParty;
30  MyParty.for_each(LogName);  
31}

1#include <iostream>
2
3class Player {
4 public:
5  void LogName() {
6    std::cout << Name << '\n';
7  }
8  
9  std::string Name;
10};
11
Party Class|Show
12class Party {/*...*/};
26
27int main() {
28  Party MyParty;
29  
30  // We want to use the `Player::LogName()` function
31  MyParty.for_each(/* ??? */);
32}

1#include <iostream>
2
3class Character {
4 public:
5  int GetHealth() { return Health; }
6  int Health;
7};
8
9int main() {
10  Character P1{50};
11  Character P2{100};
12
13  // Calling GetHealth() in the context of P1
14  std::cout << P1.GetHealth() << '\n';
15
16  // Calling GetHealth() in the context of P2
17  std::cout << P2.GetHealth();
18}

1class Character {
2public:
3  int GetHealth() {
4    // Equivalent to this->Health
5    return Health;
6  }
7  
8  bool isAlive() {
9    // Equivalent to this->GetHealth()
10    return GetHealth() <= 0;
11  }
12  
13  int Health;
14};

1#include <iostream>
2
3class Character {
4 public:
5  // Static member function
6  static float GetArmor() { return Armor; }
7
8  // Static data member declaration
9  static float Armor;
10
11  // Non-static data member
12  int Health{100};
13};
14
15// Static data member definition
16float Character::Armor = 0.2;

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/};
18
19int main() {
20  // Creating an object is unnecessary - we can
21  // directly access static members from the
22  // class using the :: operator
23  std::cout << Character::Armor << '\n';
24  std::cout << Character::GetArmor();
25}

1struct ExampleType{
2  static int Add(int x, int y) {
3    return x + y;
4  }
5  
6  static int Value;
7};
8
9int ExampleType::Value = 42;
10
11int Add(int x, int y) {
12  return x + y;
13}
14
15int main() {
16  int LocalVariable{50};
17
18  int* PointerA{&LocalVariable};
19  int* PointerB{&ExampleType::Value};
20
21  int (*PointerC)(int x, int y){
22    Add
23  };
24
25  int (*PointerD)(int x, int y){
26    &ExampleType::Add
27  };
28}

1#include <string>
2
Character Class|Show
3class Character {/*...*/};
16
17int main() {
18  // Returns a std::string and accepts no args
19  std::string (Character::*Getter)(){
20    &Character::GetName};
21
22  // Returns void and accepts std::string arg
23  void (Character::*Setter)(const std::string&){
24    &Character::SetName};
25}

1#include <string>
2
Character Class|Show
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20
21  using SetNamePtrType =
22    void (Character::*)(const std::string&);
23
24  GetNamePtrType Getter{&Character::GetName};
25  SetNamePtrType Setter{&Character::SetName};
26}

1#include <string>
2
Character Class|Show
3class Character {/*...*/};
16
17int main() {
18  // Call GetName() in the context of PlayerOne
19  Character PlayerOne;
20  PlayerOne.GetName();
21
22  // Call GetName() in the context of PlayerTwo
23  Character PlayerTwo;
24  PlayerTwo.GetName();
25
26  // Call SetName() in the context of PlayerTwo
27  Character* Ptr{&PlayerTwo};
28  Ptr->SetName("Anna");
29}

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/};
16
17int main() {
18  using GetNamePtrType =
19    std::string (Character::*)();
20
21  GetNamePtrType GetName{&Character::GetName};
22  Character PlayerOne{"Anna"};
23
24  std::cout << (PlayerOne.*GetName)();
25}

1#include <iostream>
2
Character Class|Show
3class Character {/*...*/};
16
17int main() {
18  using SetNamePtrType =
19    void (Character::*)(const std::string&);
20
21  SetNamePtrType SetName{&Character::SetName};
22  Character PlayerOne{"Anna"};
23
24  (PlayerOne.*SetName)("Roderick");
25
26  std::cout << PlayerOne.GetName();
27}

1int Add(int x, int y) {
2  return x + y;
3}
4
5int main() {
6  Add(1, 2);
7  
8  // Equivalently:
9  std::invoke(Add, 1, 2);
10}

1#include <iostream>
2
3class Player {
4public:
5  std::string GetName() { return Name; }
6  std::string Name;
7};
8
9void Log(auto Getter, Player& Object) {
10  // Incompatible with member function pointers
11  std::cout << Getter(Object) << '\n';
12
13  // Incompatible with functors, lambdas, etc
14  std::cout << (Object.*Getter)() << '\n';
15}
16
17int main() {
18  Player PlayerOne{"Anna"};
19  Log(&Player::GetName, PlayerOne);
20  Log(
21    [](Player& P){ return P.Name; },
22    PlayerOne
23  );
24}

1#include <iostream>
2
3class Player {
4 public:
5  std::string GetName() { return Name; }
6  std::string Name;
7};
8
9int main() {
10  Player PlayerOne{"Anna"};
11  auto Ptr{&Player::GetName};
12
13  std::cout << std::invoke(Ptr, PlayerOne) << '\n';
14  std::cout << std::invoke(Ptr, &PlayerOne);
15}

1#include <iostream>
2
3class Player {
4 public:
5  void SetName(std::string NewName, bool Log) {
6    Name = NewName;
7    if (Log) {
8      std::cout << "Name is now " << Name;
9    }
10  }
11
12  std::string Name;
13};
14
15int main() {
16  Player PlayerOne;
17  auto Ptr{&Player::SetName};
18
19  std::invoke(Ptr, PlayerOne, "Anna", true);
20}

1#include <iostream>
2
3class Player {
4public:
5  std::string GetName() { return Name; }
6
7  std::string Name;
8};
9
10void Log(auto Getter, Player& Object) {
11  std::cout << std::invoke(Getter, Object) << '\n';
12}
13
14int main() {
15  Player PlayerOne{"Anna"};
16  Log(&Player::GetName, PlayerOne);
17  Log(
18    [](Player& P){ return P.Name; },
19    PlayerOne
20  );
21}

1#include <functional>
2#include <iostream>
3
4class Player {
5public:
6  std::string GetName() { return Name; }
7
8  std::string Name;
9};
10
11int main() {
12  Player PlayerOne{"Anna"};
13
14  auto GetName{std::mem_fn(&Player::GetName)};
15
16  std::cout << GetName(PlayerOne);
17}

1#include <functional>
2#include <iostream>
3
4class Player {
5public:
6  std::string GetName() { return Name; }
7 void SetName(const std::string& NewName) {
8    Name = NewName;
9  }
10
11  std::string Name;
12};
13
14int main() {
15  Player PlayerOne;
16
17  auto SetName{std::mem_fn(&Player::SetName)};
18  SetName(PlayerOne, "Anna");
19
20  std::cout << PlayerOne.GetName();
21}

1#include <functional>
2#include <iostream>
3
4class Player {
5 public:
6  std::string GetName() { return Name; }
7
8  std::string Name;
9};
10
11void Log(auto Getter, Player& Object) {
12  // Not compatible with member pointers
13  std::cout << Getter(Object) << '\n';  
14}
15
16int main() {
17  Player PlayerOne{"Anna"};
18
19  // Intermediate lambda for compatibility:
20  Log([](const Player& P){
21    return P.Name;
22  }, PlayerOne);
23
24  // Alternative using std::mem_fn():
25  Log(std::mem_fn(&Player::GetName), PlayerOne);
26}

1#include <iostream>
2
3class Player {
4  void PrivateMethod() {
5    std::cout << "Invoking Private Method";
6  }
7};
8
9int main() {
10  auto Ptr{&Player::PrivateMethod};
11}

1class Player {
2 public:
3  static auto GetPtr() {
4    return &Player::PrivateMethod;
5  }
6
7 private:
8  void PrivateMethod() {
9    std::cout << "Invoking Private Method";
10  }
11};

1#include <iostream>
2
3class Player {
4 public:
5  static auto GetPtr() {
6    return &Player::PrivateMethod;
7  }
8
9 private:
10  void PrivateMethod() {
11    std::cout << "Invoking Private Method";
12  }
13};
14
15int main() {
16  auto Ptr{Player::GetPtr()};
17
18  Player PlayerOne;
19  std::invoke(Ptr, &PlayerOne);
20}

1#include <iostream>
2
3class Character {
4 public:
5  void Attack() {
6    std::cout << "Using Character Attack";
7  }
8};
9
10class Dragon : public Character {
11 public:
12  void Attack() {
13    std::cout << "Using Dragon Attack";
14  }
15};
16
17void Combat(auto Function, Character& Attacker) {
18  std::invoke(Function, Attacker);
19}
20
21int main() {
22  Dragon Monster;
23  Combat(&Character::Attack, Monster);
24}

1#include <iostream>
2
3class Character {
4 public:
5  virtual void Attack() {
6    std::cout << "Using Character Attack";
7  }
8};
9
10class Dragon : public Character {
11 public:
12  void Attack() override {
13    std::cout << "Using Dragon Attack";
14  }
15};
16
17// Unchanged
18void Combat(auto Function, Character& Attacker) {
19  std::invoke(Function, Attacker);
20}
21
22// Unchanged
23int main() {
24  Dragon Monster;
25  Combat(&Character::Attack, Monster);
26}

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  void SetName(const std::string& NewName) {
10    Name = NewName;
11  }
12
13  std::string Name;
14};
15
16int main() {
17  using SetNamePtrType =
18    void (Character::*)(const std::string&);
19
20  Character PlayerOne;
21
22  // Creating a const pointer
23  const SetNamePtrType SetName{
24    &Character::SetName};
25
26  // This is fine
27  (PlayerOne.*SetName)("Anna");  
28
29  // This is not
30  SetName = nullptr;  
31}

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  std::string Name;
10};
11
12int main() {
13  using GetNamePtrType =
14    std::string (Character::*)() const;
15
16  GetNamePtrType Func{&Character::GetName};
17}

1#include <iostream>
2
3class Character {
4 public:
5  std::string GetName() const {
6    return Name;
7  }
8
9  void SetName(const std::string& NewName) {
10    Name = NewName;
11  }
12
13  std::string Name;
14};
15
16int main() {
17  using GetNamePtrType =
18    std::string (Character::*)() const;
19
20  const GetNamePtrType GetName{&Character::GetName};
21
22  SetName = nullptr;
23}

1#include <iostream>
2
3class Player {
4 public:
5  std::string Name;
6};
7
8void Log(auto Getter, Player& Object) {
9  std::cout << std::invoke(Getter, Object) << '\n';
10}
11
12int main() {
13  Player PlayerOne{"Anna"};
14
15  // We can use a lambda:
16  Log([](Player& P){
17    return P.Name;
18  }, PlayerOne);
19
20  // Or a simple pointer-to-member:
21  Log(&Player::Name, PlayerOne);
22}

1#include <iostream>
2#include <functional>
3
4class Player {
5 public:
6  int Score;
7};
8
9int main() {
10  Player John(50);
11  int Player::*Ptr{&Player::Score};
12
13  std::cout << "Using std::invoke: "
14    << std::invoke(Ptr, &John) << '\n';
15
16  auto GetPlayerScore{std::mem_fn(Ptr)};
17  std::cout << "Using std::mem_fn: "
18    << GetPlayerScore(&John) << '\n';
19
20  auto GetJohnScore{std::bind_front(Ptr, &John)};
21  std::cout << "Using std::bind_front: "
22    << GetJohnScore();
23}

1#include <iostream>
2
3class Player {
4 public:
5  static int Health;
6};
7
8int Player::Health{100};
9
10int main() {
11  int* PlayerHealth{&Player::Health};
12  std::cout << *PlayerHealth;
13}