Makefile拒绝工作

Question

我有一些链接器错误，我不能在我的生活中解决。我只是有一个.h文件和一个不会编译成可执行文件的.cc文件我不会发布除了makefile之外的所有代码：

# Compiler variables
CCFLAGS = -Wall

# Rule to link object code files to create executable file
assignment5.exe: assignment5.cc
        g++ -Wall -g -std=c++11 assignment5.cc assignment5.h  -o assignment5.exe

clean:
        rm assignment5.exe

我在同一目录中有assignment5.h和assignment5.cc，当运行'make'时，我收到此错误：

assignment5.cc:113: undefined reference to `binTree::inorder(void (*)(int))'
assignment5.cc:116: undefined reference to `binTree::preorder(void (*)(int))'
assignment5.cc:119: undefined reference to `binTree::postorder(void (*)(int))'

如果有人可以帮助我，我将永远感激编辑：代码为那些问.h文件：

#ifndef ASSIGNMENT5
#define ASSIGNMENT5
class binTree; class BST;
 class Node {
 public:
    // the value
    int data;

    // the left and right
    Node * left;
    Node * right;

    // the constructor
    Node(int data)
    {
        // set the data
        this->data = data;

        // set left and right to null
        this->right = nullptr;
        this->left = nullptr;
    }
};
class binTree
{
 public:
    binTree();
    virtual void insert( int ); //Inserts a node into the tree
    unsigned height() const; //Returns height of the tree
    unsigned size() const; //Returns size of the tree
    void inorder( void(*)(int) ); //Inorder traversal of tree
    void preorder( void(*)(int) ); //Preorder traversal
    void postorder( void(*)(int) ); //Postorder traversal

protected:
    Node* root; //root of the tree

private:
    void insert( Node*&, int ); //Private version of insert()
    unsigned height( Node* ) const; //Private version of height
    unsigned size( Node* ) const; //Private version of size()
    void inorder( Node*, void(*)(int) ); //Private version of inorder()
    void preorder( Node*, void(*)(int) ); //Private version of preorder()
    void postorder( Node*, void(*)(int) ); //Private version of postorder()

};
#endif

.cc文件：

#include "assignment5.h"
#include <iostream>
#include <iomanip>
#include <algorithm>
#include <vector>
using namespace std;

const int MAX_SIZE = 40;
const int MAX_COUNT = 40;
const int WIDTH = 5;
const int ROW_SIZE = 8;
int mcount = 0;
int rcount = 0;

void display(int d)
{
    if (mcount < MAX_COUNT) {
        cout << setw(WIDTH) << d;
        mcount++;
        rcount++;
        if (rcount == ROW_SIZE) {
            cout << endl;
            rcount = 0;
        }
    }
}

binTree::binTree()
{
    // set the root to null pointer
    root = nullptr;
}

void binTree::insert( int v )         //Inserts a node into the tree
{
    // insert this value into the root
    insert(root,v);
}

unsigned binTree::height() const            //Returns height of the tree
{
    // return the height of this tree
    return height(root);
}
unsigned binTree::size() const            //Returns size of the tree
{
    // return the size
    return size(root);
}
void binTree::inorder( void(*)(int) p )      //Inorder traversal of tree
{
    // use the local inorder
    inorder(root, p);
}
void binTree::preorder( void(*)(int) p )      //Preorder traversal
{
    // use the local preorder
   inorder(root, p);
}
void binTree::postorder( void(*)(int) p )    //Postorder traversal
{
    // use the local inorder
    postorder(root, p);
}

void binTree::insert( Node*& node, int n )        //Private version of insert()
{
    // if this is null, create new node
    if( node == nullptr )
    {
        // create new node
        node = new Node(n);
    }

    // if node is less or more
    if( n < node->data )
    {
        // go left
        insert(node->left,n);
    }
    else if( n > node->data )
    {
        // go right
        insert(node->right, n);
    }
}

unsigned binTree::height( Node* node ) const    //Private version of height
{
    // if this is null, return 0
    if( node == nullptr )
        return 0;

    // left height and right height
    unsigned leftHeight = 0;
    unsigned rightHeight = 0;

    // check if left height
    if( node->left != nullptr )
        leftHeight = height( node->left );

    // right height
    if( node->right != nullptr )
        rightHeight = height( node->right );

    // return max
    if( leftHeight > rightHeight )
        return leftHeight + 1;
    else
        return rightHeight+1;
}
unsigned binTree::size( Node*  node) const     //Private version of size()
{
    // if this is null
    if( node == nullptr )
        return 0;

    // return size
    return 1 + size(node->left) + size(node->right);
}

#define BINTREE_MAIN
#ifdef BINTREE_MAIN
int main() {
    vector<int> v(MAX_SIZE);
    for (int i=1; i<MAX_SIZE; i++)
        v[i] = i;
    random_shuffle( v.begin(), v.end());

    binTree bt;
    vector<int>::iterator it;
    for (it=v.begin(); it!=v.end(); it++)
        bt.insert( *it );

    cout << "Height: " << bt.height() << endl;
    cout << "Size: " << bt.size() << endl;
    cout << "In order traverse (displaying first " << MAX_COUNT << " numbers): " << endl;
    mcount = rcount = 0;
    bt.inorder( display );
    cout << "

Pre order traverse (displaying first " << MAX_COUNT << " numbers): " << endl;
    mcount = rcount = 0;
    bt.preorder( display );
    cout << "

Post order traverse (displaying first " << MAX_COUNT << " numbers): " << endl;
    mcount = rcount = 0;
    bt.postorder( display );

    cout << endl;
    return 0;
}

#endif

Answer 1

另一答案

Answer 2

另一答案