Passing functions as parameters in C++

Question

I am struggling to pass a function as a parameter to a single function that will do each function differently. GCC is saying order is not a function and expression preceding parentheses of apparent call must have (pointer-to-) function type. Any help would be appreciated on how to find a resolution.

#include <iostream>
#include <string>

using namespace std;

class Tree
{
    public:

        const string INORDER_STRING = "Inorder   : ";
        const string PREORDER_STRING = "Preorder  : ";
        const string POSTORDER_STRING = "Postorder : ";
        
        struct Node
        {
            int value;
            struct Node *leftChild, *rightChild;
        };

        Node* newNode(int value)
        {
            Node* tmp = new Node;
            tmp->value = value;
            tmp->leftChild = tmp->rightChild = NULL;
            return tmp;
        }

        Node* root;
        string ORDER_STRING;

        Tree() 
        {
            root = NULL;
            ORDER_STRING = "";
        }

        void goodTreeConstructor() 
        {
            root = newNode(1);
            Node* rL = root->leftChild = newNode(2);
            Node* rR = root->rightChild = newNode(3);
            Node* rLL = rL->leftChild = newNode(4);
            Node* rLR = rL->rightChild = newNode(5);
            Node* rRL = rR->leftChild = newNode(6);
            Node* rRR = rR->rightChild = newNode(7);
            Node* rRRR = rRR->rightChild = newNode(8);
        }

        void badTreeConstructor() 
        {
            root = newNode(1);
            Node* rL = root->leftChild = newNode(2);
            Node* rR = root->rightChild = newNode(3);
            Node* rLL = rL->leftChild = newNode(4);
            Node* rLR = rL->rightChild = newNode(5);
            Node* rRL = rR->leftChild = newNode(6);
            Node* rRR = rR->rightChild = newNode(7);
            Node* rRRR = rRR->rightChild = newNode(8);
        }

        void printNode(int value) { cout << value << ""; }

        void inorder(Node* node) 
        {
            if (node == NULL) { return; }
            inorder(node->leftChild);
            printNode(node->value);
            inorder(node->rightChild);
        }

        void preorder(Node* node) 
        {
            if (node == NULL ) { return; }
            printNode(node->value);
            preorder(node->leftChild);
            preorder(node->rightChild);
        }
        
        void postorder(Node* node)
        {
            if (node == NULL) { return; }
            postorder(node->leftChild);
            postorder(node->rightChild);
            printNode(node->value);
        }

        void printOrder(void (Tree::*order)(Node *))
        {
            cout << ORDER_STRING; order(root); cout << "\n";
        }

        void printInorder() 
        {
            ORDER_STRING = INORDER_STRING;
            printOrder(&Tree::inorder);
        }

        void printPreorder()
        {
            ORDER_STRING = PREORDER_STRING;
            printOrder(&Tree::preorder);
        }
        
        void printPostorder() 
        {
            ORDER_STRING = POSTORDER_STRING;
            printOrder(&Tree::postorder);
        }
};

int main() 
{
    Tree goodTree = Tree();

    goodTree.goodTreeConstructor();
    goodTree.printInorder();
    goodTree.printPreorder();
    goodTree.printPostorder();
    
}

Answer 1

You cannot call a member function using a member function pointer with the syntax order(root).

One correct syntax to call it would be:

(this->*order)(root)

Alternatively, with C++17 you can also use std::invoke:

std::invoke(order, this, root);