如何在类中将函数作为参数传递?

Question

我正在尝试通过属于模板化binarySearchTree的inordertraversal类将我的print函数作为参数传递。 每当我在main中定义这些功能时，程序都可以正常工作，但是每当我尝试封装它们时，都会出现错误：

"expected primary-expression before '&' token"

这是有效的代码

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

我的inordertraveral模板化类的声明是

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

如果需要，我可以显示其余代码，但这一切都很好用

一旦我将这些函数移动到我的类中，它看起来像这样 (print和binarySearchTree的声明与上述声明的.cpp相同)

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

错误是在print的括号内做，我已经尝试了很多不同的东西，但对我来说这是正确的声明;因此我不知道为什么它不起作用。

任何建议将不胜感激。

---

编辑：print是一个函数指针，用于打印存储在二叉搜索树中的classdatatype的详细信息。

---

编辑2：最小可重现示例。

数据类型是原样的，与上面的示例中不同。这是我所能做的最基本的东西，我最终得到了另一个我无法解决的错误，但就此示例而言，这无关紧要，应该被忽略。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;
}

类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

类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);
}
}

类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
}

Answer 1

void bst::print(classdatatype& x) // is a member function

和

void print(classdatatype& x);    // is a free function.

因此，用于保存它们的函数指针也将不同。

---

OP 在评论中提到，他/她希望将成员函数print()从类bst传递到binarySearchTree<elemType>类的成员函数inorderTraversal()。在这种情况下，传递成员函数是不够的，除此之外，还应传递将调用print函数的类的实例。

Lambda函数可以派上用场，通过捕获类的实例并传递给binarySearchTree类的inorderTraversal()来简化bst。

这意味着，内部template <class elemType> class binarySearchTree提供：

template<typename Callable>
void inorderTraversal(Callable visit)
{
inorder(root, visit);  // simply pass visit further
// or avoid coping by warapping std::cref(): i.e. inorder(root, std::cref(visit));
}
template<typename Callable>
void inorder(binaryTreeNode<elemType>* p, Callable visit)
{
if (p != NULL)
{
inorder(p->llink, visit);  // or inorder(root, std::cref(visit));
visit(p->info);            // call directly with parameter
inorder(p->rlink, visit);  // or inorder(root, std::cref(visit));
}
}

bst类内部

void printfunctions(windlogtype& x)
{
// lambda captures the instance by copy
const auto printThisLogType = [this](windlogtype & x)->void { this->print(x); };
treeRoot.inorderTraversal(printThisLogType); // pass the callable lambda
}

下面是编译代码：https://godbolt.org/z/jhCnPs

---

PS：另一个错误来自windlogtype类的operator<<，您错过了返回std::ostream的引用。

老实说，您可以通过将windlogtype替换为int并在声明旁边显示成员函数的防御来制作更简单的最小代码。这将使代码易于阅读。