不确定如何创建MakeFIle

Question

I am having problems with creating a makefile for a project containing 3 c++ files.

While in the directory containing the files (tree.h, helperMethods.h, and main.cpp), I first use the command emacs makefile.make . Then, in emacs, I write the makefile as:

all: tree.h helperMethods.h main.cpp
[tab]g++ -std=c++0x -o project3 tree.h helperMethods.h main.cpp

I have verified manually that the command g++ -std=c++0x -o project3 tree.h helperMethods.h main.cpp does indeed compile the three files and make an executable that works at it should.

After this, I save the makefile, exit out of emacs, and attempt to run it.

First I used make but this returned:

make: *** No targets specified and no makefile found.  Stop.

Then I tried using make -f makefile.make but this didn't work either and returned:

make: Nothing to be done for `all'.

At this point, I'm unsure as to why the makefile wasn't constructed properly. I don't have very much experience with makefiles; I'm pretty sure that I have the commands in the body of the makefile correct but I didn't set it up properly when I wrote it.

If it is at all relevant, here are the 3 files:

tree.h:

#ifndef tree_h
#define tree_h
#include <vector>

using namespace std;

template<class T>
class tree
{
public:
    tree<T> * parent;
    T element;
    vector<tree<T> > nodes;
    tree(const T& theElement)
    {
        element = theElement;
        nodes = vector<tree<T> >();
    }
    tree()
    {
        nodes = vector<tree<T> >();
    }
};

#endif

helperMethods.h

#ifndef helperMethods_h
#define helperMethods_h

#include "tree.h"

#include <tuple>
#include <string>
#include <iostream>
#include <vector>

using namespace std;

string printName(tuple<string, string, string> myTuple){
    string ret = "";
    if(std::get<0>(myTuple).length() > 0)
        ret += get<0>(myTuple) + " ";
    if(std::get<1>(myTuple).length() > 0 || std::get<2>(myTuple).length() > 0)
        ret += "(";
    if(std::get<1>(myTuple).length() > 0)
        ret += get<1>(myTuple);
    if(std::get<1>(myTuple).length() > 0 && std::get<2>(myTuple).length() > 0)
        ret += ", ";
    if(std::get<2>(myTuple).length() > 0)
        ret += get<2>(myTuple);
    if(std::get<1>(myTuple).length() > 0 || std::get<2>(myTuple).length() > 0)
        ret += ")";
    return ret;
}

bool tupleContain(tuple<string, string, string> myTuple, string myString){
    return (std::get<0>(myTuple).compare(myString) == 0) || (std::get<1>(myTuple).compare(myString) == 0);
}

void findElement(tree<tuple<string, string, string> > myTree, string myString, bool* found, vector<int> *ret)
{
    if(tupleContain(myTree.element, myString))
        *found = true;
    if(! * found)
    {
        for(int counter = 0; counter < (int)myTree.nodes.size(); counter ++)
        {
            if(!* found)
            {
                (*ret).push_back(counter);
                findElement(myTree.nodes.at(counter), myString, found, ret);
                if(!* found)
                    (*ret).pop_back();
            }
        }
    }
}

void getLineage(tree<tuple<string, string, string> > myTree, string myString){
    bool dummyForFound = false;
    bool * found = & dummyForFound;
    vector<int> lineage = vector<int>();
    vector<int> * pointer = & lineage;
    findElement(myTree, myString, found, &lineage);
    if(lineage.size() == 0)
    {
        cout << "Species not present" << endl;
        return;
    }
    vector<string> printString = vector<string>(lineage.size() + 1);
    tree<tuple<string, string, string> > * currentNodePointer = & myTree;
    for(int counter = 0; counter <= (int) lineage.size(); counter ++)
    {
        string currentLine = "";
        for(int counter2 = 0; counter2 < 2*((int) lineage.size() - counter); counter2 ++)
            currentLine += ">";
        if(counter != lineage.size())
            currentLine += " ";
        tree<tuple<string, string, string> > currentNode = * currentNodePointer;
        currentLine += printName(currentNode.element);
        if(counter < (int) lineage.size())
        {
            int foo = lineage.at(counter);
            tree<tuple<string, string, string> > currentNodeDummy = currentNode.nodes.at(foo);
            *currentNodePointer = currentNodeDummy;
        }
        printString.at(counter) = currentLine;
    }
    for(int counter = 0; counter < (int) printString.size(); counter ++)
        cout << printString.at(printString.size() - counter - 1) << endl;
    cout << endl;
}

void getCommonLineage(tree<tuple<string, string, string> > myTree , string name1, string name2)
{
    bool dummyForFound = false;
    bool * found = & dummyForFound;
    vector<int> lineage1 = vector<int>();
    vector<int> * pointer1 = & lineage1;
    vector<int> lineage2 = vector<int>();
    vector<int> * pointer2 = & lineage2;
    findElement(myTree, name1, found, pointer1);
    * found = false;
    findElement(myTree, name2, found, pointer2);
    if(lineage2.size() == 0 || lineage1.size() == 0)
    {
        cout << "At least one species not present." << endl;
        return;
    }
    bool stillSame = lineage1.at(0) == lineage2.at(0);
    cout << "Level[0] Common Ancestor: ROOT (ROOT, ROOT)" << endl;
    tree<tuple<string, string, string>> * lastSharedNode = & myTree;
    int finalCounter = 0;
    for(int counter = 0; counter < (int) min(lineage1.size(), lineage2.size()) && stillSame; counter ++)
    {
        tree<tuple<string, string, string> > dummyNode = * lastSharedNode;
        tree<tuple<string, string, string> > currentNode = dummyNode.nodes.at(lineage1.at(counter));
        *lastSharedNode = currentNode;
        if(counter < (int) min(lineage1.size(), lineage2.size()) - 1 && lineage1.at(counter + 1) != lineage2.at(counter + 1))
            stillSame = false;
        tuple<string, string, string> currentElement = currentNode.element;
        cout << "Level[" << counter + 1 << "] Commont Ancestor: " << printName(currentElement) << endl;
        finalCounter ++;
    }
    cout << endl;
    cout << "Ancestry unique to " << name1 << endl;
    tree<tuple<string, string, string> > savedNode = *lastSharedNode;
    tree<tuple<string, string, string> > * currentUnsharedNode = lastSharedNode;
    for(int counter = finalCounter; counter < (int) lineage1.size(); counter ++)
    {
        tree<tuple<string, string, string> > dummyNode = * currentUnsharedNode;
        tree<tuple<string, string, string> > currentNode = dummyNode.nodes.at(lineage1.at(counter));
        tuple<string, string, string> currentElement = currentNode.element;
        *currentUnsharedNode = currentNode;
        cout << "Level[" << counter + 1 << "] ";
        if(counter == lineage1.size() - 1)
            cout << "Species of interest: ";
        cout << printName(currentElement) << endl;
    }
    cout << endl;
    currentUnsharedNode = &savedNode;
    cout << "Ancestry unique to " << name2 << endl;
    for(int counter = finalCounter; counter < (int) lineage2.size(); counter ++)
    {
        tree<tuple<string, string, string> > dummyNode = * currentUnsharedNode;
        tree<tuple<string, string, string> > currentNode = dummyNode.nodes.at(lineage2.at(counter));
        tuple<string, string, string> currentElement = currentNode.element;
        *currentUnsharedNode = currentNode;
        cout << "Level[" << counter + 1 << "] ";
        if(counter == lineage2.size() - 1)
            cout << "Species of interest: ";
        cout << printName(currentElement) << endl;
    }
    cout << endl;
}
#endif

main.cpp

#include "rapidxml.h"
#include "tree.h"
#include "helperMethods.h"

#include <string>
#include <string.h>
#include <stdio.h>
#include <iostream>
#include <vector>
#include <queue>
#include <tuple>

using namespace rapidxml;

int main(int argc, const char * arv[]){
    tuple<string, string, string> human ("Human", "Homo sapiens", "Species");
    tuple<string, string, string> apes ("Apes", "", "");
    tuple<string, string, string> dogs ("Dogs", "", "");
    tuple<string, string, string> root ("Root", "", "");
    tuple<string, string, string> bears ("Bears", "", "");
    tuple<string, string, string> cat ("Cat", "", "");
    tuple<string, string, string> horse ("Horse", "", "");
    tree<tuple<string, string, string> > myTree = tree<tuple<string, string, string>>(root);
    tree<tuple<string, string, string> > b = tree<tuple<string, string, string>>(dogs);
    tree<tuple<string, string, string> > c = tree<tuple<string, string, string>>(apes);
    tree<tuple<string, string, string> > d = tree<tuple<string, string, string>>(bears);
    tree<tuple<string, string, string> > e = tree<tuple<string, string, string>>(horse);
    tree<tuple<string, string, string> > f = tree<tuple<string, string, string>>(human);
    tree<tuple<string, string, string> > h = tree<tuple<string, string, string>>(cat);
    d.nodes.push_back(f);
    e.nodes.push_back(h);
    b.nodes.push_back(d);
    b.nodes.push_back(e);
    myTree.nodes.push_back(b);
    myTree.nodes.push_back(c);
    cout << printName(myTree.nodes.at(0).element);

    cout << "Welcome to my Tree of Life program!" << endl << endl;

    int choice = 1;
    while(choice == 1 || choice == 2) {
        cout << "Please choose from the following options:" << endl;
        cout << "   1.Get the lineage of a species" << endl;
        cout << "   2.Get the commmon lineage of two species" << endl;
        cout << "   3.Exit program" << endl << endl;
        cin >> choice;
        cout << endl;
        if(choice == 1)
        {
            cout << "Please enter the name of the species of interest:" << endl;
            string name;
            cin >> name;
            cout << endl;
            getLineage(myTree, name);
        }
        if(choice == 2)
        {
            string name1, name2;
            cout << "Please enter the name of the first species: " << endl;
            cin >> name1;
            cout << "Please enter the name of the second species: " << endl;
            cin >> name2;
            getCommonLineage(myTree, name1, name2);
        }
    }
    return 0;
}

Answer 1

Makefiles are usually called Makefile (although makefile works, too) without any extension. If you use an extension ( not recommended ), you have to tell make the name of the makefile. That's tedious and unnecessary.

Second, you don't need to put header files in the compile command line, and you shouldn't do so. You use #include lines in your file to specify the header files. So your compile command might look like this:

g++ -std=c++0x -o project3 main.cpp

Now, in that command:

• main.cpp is the source

• project3 is the target (ie, the file which will be created.)

Also:

• tree.h and helperMethods.h are needed for the compile to work; the compilation depends on this files. (You know that, but they don't show up in the command-line so its not obvious.) Furthermore, if they change, you have to recompile your file.

A makefile explains how to make a target from its sources , and also lists the dependencies of the target . (Technically, make doesn't distinguish between sources and dependencies ; it considers both of them prerequisites . But it's convenient to recognize the difference.)

So for the above command, the entire make recipe might look like this:

project3: main.cpp tree.h helperMethods.h 
        g++ -std=c++0x -o project3 main.cpp

Normally, we don't use filenames like main.cpp ; rather, we'd call the main file for project3 project3.cpp , just as the target (output) file is project3 . In fact, if you did that, and you didn't have any other dependencies (header files), you could type:

make project3

without a makefile at all , and make would come up with the command:

g++ -o project3 project3.cpp

In this case, that command would be wrong because it doesn't specify the correct C++ standard. But it often works, and it's a good reason to name your targets and sources with the same basename.

One more thing: your file tree.h is a header-only library, which is fine. But helperMethods.h is only pretending to be a header file. It's really a complete implementation. You should fix that.

Also, it's really a bad idea to put using namespace std in a header file. Header files should explicitly use the std:: namespace prefix on everything which needs it. It's generally not recommended to use using namespace std anywhere, but it's particularly bad in header files because it silently pollutes the default namespace of any file which includes the header. This can lead to very obscure bugs, or compilation errors.

Answer 2

School project, eh? project3 seems an awful arbitrary name for something you're working on yourself.

You don't need to include .h files in your makefile processing because, strictly speaking, they never need to be compiled independently. Your makefile would need a rule for building main.o out of main.cpp, and then a rule for building an executable out of main.o. The header files should be added as dependencies of main.o, so that if either of them change, make will know to rebuild from there.

Basically, it will need to look something like this:

# http://stackoverflow.com/questions/15458126/unsure-how-to-create-a-makefile
all: project3

clean:
    -rm main.o project3

project3: main.o
    g++ -std=c++0x -o project3 main.o

main.o: main.cpp tree.h helperMethods.h
    g++ -std=c++0x -c main.cpp

Someone else may produce a dramatically different, but equally valid, makefile for this purpose. There's a degree of freedom to the process.

What you have here is a rule to build the whole thing (keeping in mind that if no target is provided, the first one in the makefile is automatically chosen), rules to clean up any intermediate files, a rule to build the executable from the object files, and a rule to build the object file from the source files. This approach doesn't scale very well; it would be unpleasant to manage by hand all of the dependencies for larger, more complex makefiles, but in this very simple case it's fine.