How to pass functions as parameters within a class?

I am trying to pass my print function as a paramater through my inordertraversal class which belongs to a templated binarySearchTree. whenever I define these functions within main the program works fine but whenever i try to encapsulate them I get a error:

"expected primary-expression before '&' token"

This is the code that works

void print(classdatatype& x); 
int main()
{
    binarySearchTree<classdatatype> tree;
    tree.inorderTraversal(print);
    return 0;
}

void print(classdatatype& x)   {  cout << x << " ";      } 

The declaration of my inordertraveral templated class is

template <class elemType>
void binarySearchTree<elemType>::inorderTraversal(void (*visit)(elemType& item))

I can show the rest of the code if needed but this all works just fine

Once I move these functions into my class it looks like this (the declarations for print and the binarySearchTree are in the .cpp same as they are declared above)

void bst::printfunctions(classdatatype& x)
{
    tree.inorderTraversal(print(classdatatype & x)); //error here
}

void bst::print(classdatatype& x) 
{ 
    cout << x << " "; 
} 

The error is to do within the brackets of print, I have tried many different things but to me this is the correct declaration; therefore I don't know why it's not working.

Any advice would be greatly appreciated.

---

EDIT: print is a function pointer to print the details of classdatatype which is stored inside a binary search tree.

---

EDIT2: minimal reproducible example.

Data types are as they are and not like in the above example. This is as basic as I could make this and I ended up getting another error which I couldn't resolve but for the purpose of this example it doesn't matter and should be ignored. main() is included but is minimal and may not serve its purpose but the problem doesn't lie here anyway.

main()

#include <iostream>
#include "windlogtype.h"
using namespace std;

int main()
{
    windlogtype wind;

    ifstream infile("data.txt");
    //for purose of this data is one integer value
    infile >> wind;

    //do something
    //main purpose is to get input
    return 0;
}

class windlogtype

#include "windlogtype.h"
windlogtype::windlogtype() { }    
windlogtype::windlogtype(int i)     {   num = i; }    
int windlogtype::Getnumber() const  {   return num; }    
void windlogtype::Setnumber(int i)  {   num = i; }    
ostream operator<<(ostream& os, const windlogtype& w)
{
    os << w.Getnumber() << '\n';
    return os;
}

#ifndef WINDLOGTYPE_H
#define WINDLOGTYPE_H

#include <iostream>
using namespace std;

class windlogtype
{
public:
    windlogtype();
    windlogtype(int i);
    int Getnumber() const;
    void Setnumber(int i);
private:
    int num;
};
ostream operator<<(ostream& os, const windlogtype& w);

#endif // WINDLOGTYPE_H

class binarySearchTree

#include <iostream>
#include <assert.h>
using namespace std;

template <class elemType> struct binaryTreeNode
{
    elemType info;
    binaryTreeNode<elemType>* llink;
    binaryTreeNode<elemType>* rlink;
};

template <class elemType> class binarySearchTree
{
public:
    const binarySearchTree<elemType>& operator=(const binarySearchTree<elemType>&);
    void inorderTraversal(void (*visit) (elemType&));
    binarySearchTree();
    ~binarySearchTree();
    binaryTreeNode<elemType>* root;
private:
    void inorder(binaryTreeNode<elemType>* p, void (*visit) (elemType&));
};

template <class elemType> binarySearchTree<elemType>::binarySearchTree() {
    root = NULL;
}    
template <class elemType> void binarySearchTree<elemType>::inorderTraversal(void (*visit) (elemType& item))
{
    inorder(root, *visit);
}    
template <class elemType> void binarySearchTree<elemType>::inorder(binaryTreeNode<elemType>* p, void (*visit) (elemType& item))
{
    if (p != NULL)
    {
        inorder(p->llink, *visit);
        (*visit)(p->info);
        inorder(p->rlink, *visit);
    }
}

class bst

#ifndef BST_H
#define BST_H
#include "binarySearchTree.h"
#include "windlogtype.h"
using namespace std;

class bst
{
public:
    bst();
    void InsertTree(windlogtype& newwind);
    void printfunctions(windlogtype& x);
    binarySearchTree<windlogtype>& GetTree();
    void print(windlogtype& x);
private:
    binarySearchTree<windlogtype> treeRoot;
};    
#endif // BST_H

#include "bst.h"

bst::bst(){/*ctor*/ }    
binarySearchTree<windlogtype>& bst::GetTree() {     return treeRoot;  }
void bst::print(windlogtype& x)               {     cout << x << " ";  }
void bst::printfunctions(windlogtype& x)
{
    treeRoot.inorderTraversal(print(windlogtype & x)); // error lies here
}