Function template has already been defined?

Question

In the attached code, I can't get beyond the error function template has already been defined for every function in my class file.

I have been all through it and can't figure out where the functions are already defined anywhere. Note that this code was assembled while going through the chapters of a book, just trying to create functional code to start off with.

BagInterface.h:

/** @file BagInterface.h */
#ifndef BAG_INTERFACE_
#define BAG_INTERFACE_

#include <vector>

using std::vector;

template<class ItemType>
class BagInterface
{
public:
    /** Gets the current number of entries in this bag.
    @return  The integer number of entries currently in the bag. */
    virtual int getCurrentSize() const = 0;

    /** See whether this bag is empty.
    @return  True if the bag is empty, or false if not. */
    virtual bool isEmpty() const = 0;

    /** Adds a new entry to this bag.
    @post  If successful, newEntry is stored in the bag and
    the count of items in the bag has increased by 1.
    @param newEntry  The object to be addedd as a new entry.
    @return  True if addition was successful, or false if not. */
    virtual bool add(const ItemType& newEntry) = 0;

    /** Removes one occurrence of a given entry from this bag.
    if possible.
    @post  If successful, anEntry has been removed from the bag
    and the count of items in the bag has decreased by 1.
    @param anEntry  The entry to be removed.
    @return  True if removal was successful, or false if not. */
    virtual bool remove(const ItemType& anEntry) = 0;

    /** Removes all entries from this bag.
    @post  Bag contains no items, and the count of the items is 0. */
    virtual void clear() = 0;

    /** Counts the number of times a given entry appears in this bag.
    @param anEntry  The entry to be counted.
    @return  The number of times anEntry appears in the bag. */
    virtual int getFrequencyOf(const ItemType& anEntry) const = 0;

    /** Tests whether this bag contains a given entry.
    @param anEntry  The entry top locate.
    @return  True if bag contains anEntry, or False otherwise. */
    virtual bool contains(const ItemType& anEntry) const = 0;

    /** Empties and then fills a given vector with all entries that
    are in this bag.
    @return A vector containing copies of all the entries in this bag. */
    virtual vector<ItemType> toVector() const = 0;

    /** Destroys this bag and frees its assigned memory. */
    virtual ~BagInterface() { }
}; // end BagInterface
#endif

ArrayBag.h:

/** @file ArrayBag.h */
#ifndef ARRAY_BAG_
#define ARRAY_BAG_

#include "BagInterface.h"

template<class ItemType>
class ArrayBag : public BagInterface<ItemType>
{
private:
    static const int DEFAULT_CAPACITY = 6;
    ItemType items[DEFAULT_CAPACITY];
    int itemCount;
    int maxItems;
    int getIndexOf(const ItemType& target, int searchIndex) const;
    int countFrequency(const ItemType& target, int searchIndex) const;

public:
    ArrayBag();
    int getCurrentSize() const;
    bool isEmpty() const;
    bool add(const ItemType& newEntry);
    bool remove(const ItemType& anEntry);
    void clear();
    bool contains(const ItemType& anEntry) const;
    int getFrequencyOf(const ItemType& anEntry) const;
    vector<ItemType> toVector() const;
};

#include "ArrayBag.cpp"
#endif

ArrayBag.cpp:

#include "ArrayBag.h"


template<class ItemType>
ArrayBag<ItemType>::ArrayBag() : itemCount(0), maxItems(DEFAULT_CAPACITY)
{

}

template<class ItemType>
int ArrayBag<ItemType>::getIndexOf(const ItemType& target, int searchIndex) const
{
    int result = -1;

    if (searchIndex < itemCount)
    {
        if (items[searchIndex] == target)
        {
            result = searchIndex;
        }
        else
        {
            result = getIndexOf(target, searchIndex + 1);
        }
    }
    return result;
}

template<class ItemType>
bool ArrayBag<ItemType>::add(const ItemType& newEntry)
{
    bool hasRoomToAdd = (itemCount < maxItems);
    if (hasRoomToAdd)
    {
        items[itemCount] = newEntry;
        itemCount++;
    }
    return hasRoomToAdd;
}

template<class ItemType>
vector<ItemType> ArrayBag<ItemType>::toVector() const
{
    vector<ItemType> bagContents;
    for (int i = 0; i < itemCount; i++)
        bagContents.push_back(items[i]);
    return bagContents;
}

template<class ItemType>
int ArrayBag<ItemType>::getCurrentSize() const
{
    return itemCount;
}

template<class ItemType>
bool ArrayBag<ItemType>::isEmpty() const
{
    return itemCount == 0;
}

template<class ItemType>
bool ArrayBag<ItemType>::remove(const ItemType& anEntry)
{
    int locatedIndex = getIndexOf(anEntry, 0);
    bool canRemoveItem = !isEmpty() && (locatedIndex > 1);
    if (canRemoveItem)
    {
        itemCount--;
        items[locatedIndex] = items[itemCount];
    }
    return canRemoveItem;
}

template<class ItemType>
void ArrayBag<ItemType>::clear()
{
    itemCount = 0;
}

template<class ItemType>
int ArrayBag<ItemType>::getFrequencyOf(const ItemType& anEntry) const
{
    return countFrequency(anEntry, 0);
}

template<class ItemType>
int ArrayBag<ItemType>::countFrequency(const ItemType& target, int searchIndex) const
{
    int frequency = 0;
    if (searchIndex < itemCount)
    {
        if (items[searchIndex] == target)
        {
            frequency = 1 + countFrequency(target, searchIndex + 1);
        }
        else
        {
            frequency = countFrequency(target, searchIndex + 1);
        }
    }
    return frequency;
}

template<class ItemType>
bool ArrayBag<ItemType>::contains(const ItemType& anEntry) const
{
    bool found = false;
    int curIndex = 0;
    while (!found && (curIndex < itemCount))
    {
        if (anEntry == items[curIndex])
            found = true;
        else
            curIndex++;
    }
    return found;
}

Bag.cpp:

#include <iostream>
#include <string>
#include "ArrayBag.h"

using std::cout;
using std::endl;

void displayBag(ArrayBag<std::string>& bag)
{
    cout << "The bag contains " << bag.getCurrentSize() << " items:" << endl;
    vector<std::string> bagItems = bag.toVector();

    int numberOfEntries = (int)bagItems.size();
    for (int i = 0; i < numberOfEntries; i++)
    {
        cout << bagItems[i] << " ";
    }
    cout << endl << endl;
}

void bagTester(ArrayBag<std::string>& bag)
{
    cout << "isEmpty: returns " << bag.isEmpty() << "; should be 1 (true)" << endl;
    displayBag(bag);

    std::string items[] = { "one","two", "three", "four", "five", "one" };
    cout << "Add 6 items to the bag: " << endl;
    for (int i = 0; i < 6; i++)
    {
        bag.add(items[i]);
    }

    displayBag(bag);
    cout << "isEmpty: returns " << bag.isEmpty() << "; should be 0 (false)" << endl;
    cout << "getCurrentSize: returns " << bag.getCurrentSize() << "; should be 6" << endl;
    cout << "Try to add another entry:  add(\"extra\") returns " << bag.add("extra") << endl;
}

int main()
{
    ArrayBag<std::string> bag;
    cout << "Testing the Array-Based Bag:" << endl;
    cout << "The initial bag is empty." << endl;
    bagTester(bag);
    cout << "All done!" << endl;
    std::cin.get();

    return 0;
}

Answer 1

I've reproduced your problem and understand what's going on. The unusual construct with include ArrayBag.cpp works fine, as long as you don't compile it, and just use it "as a header". But it's content must appear only once in each translation unit. That's why we have include guards: Any file you #include should have include guards, and ArrayBag.cpp dosn't. Here's how it goes:

1. You compile Arraybag.cpp, which

2. includes the declarations in ArrayBag.h Fine, but

3. ArrayBag.h then includes Arraybag.cpp, which does not have its own include guard

4. The definitions are parsed, and after the end of Arraybag.cpp, parsing continues back at the end of ArrayBag.h .

5. We are now done with the first line of the compilation of ArrayBag.cpp, but we are still parsing it: and we go through the rest of ArrayBag.cpp again.

You can still compile ArrayBag.cpp, for the sake of it:

ArrayBag.cpp

// would just be
#include "ArrayBagDefinitions.h"

And ArrayBagDefinitions.h would be your old ArrayBag.cpp file, but with include guards. Your code then compiles fine with vs2017.

Answer 2

Can you please show the makefile, environment, compiler ? I've compiled it whitout problems, I'm using qt creator IDE under windows(mingw32), and the makefile is created automaticly by qmake, so, I supouse that your problem may be in the makefile, I know that it is a comment, but due to my reputation I am not able to make comments, so, after you show the makefile I will can help you.

please avoid mark as negative this answer, I am tryining of help, and increase my reputation. if it answer is not contructive please, let me know and I will remove it.

the output of for code is :

output

Answer 3

In your book, did they mention not to compile ArrayBag.cpp?

In C++, the compiler generates code when a template class is instantiated. Our trusty friend can't do this without a definition. For this reason, the definition needs to be available at compile time (there's more reasons why). For readability, you'll often see people separate the declaration of a template class from the definition.

As the book has shown you, we can take advantage of #include to supply the definition to the compiler while still separating the two.

The caveat here is that you cannot compile the files you used to separate the definition. Depending on whether ArrayBag.cpp is compiled before ArrayBag.h is included somewhere else, the compiler will have a hizzy fit when he finds out that you already tried to define ArrayBag.

Alternatively, you can add an include guard in ArrayBag.cpp, which will prevent the compiler from attempting define ArrayBag again during compilation of ArrayBag.cpp, but I don't advise this. It will add unnecessary time during compilation. After all, we're abusing the simplicity of #include here to mitigate a pain point in the requirements of the compiler.

---

If you're using Visual Studio, you can treat a .cpp file as a header file by right clicking on the file in the solution explorer > Properties > General > Excluded From Build: Yes