help!!!!!!! undefined reference to

[ricciopasticcio]

i'm trying to compile and run my code but it gives me the error undefined reference to `main_savitch_15::graph<int>::add_vertex(int const&)'.... i can't seem to fix it.

it's my first time posting on here. i am using Clion

  #ifndef GRAPH_PROJECT_GRAPH_H
#define GRAPH_PROJECT_GRAPH_H
#include <cstdlib>  // Provides size_t
#include <set>      // Provides set
#include <cstddef>

namespace main_savitch_15
{
    template <class Item>
    class graph
    {
    public:
        // MEMBER CONSTANTS
        static const std::size_t MAXIMUM = 20;
        // CONSTRUCTOR
        graph( ) { many_vertices = 0; }
        // MODIFICATION MEMBER FUNCTIONS
        void add_vertex(const Item& label);
        void add_edge(std::size_t source, std::size_t target);
        void remove_edge(std::size_t source, std::size_t target);
        Item& operator [ ] (std::size_t vertex);
        // CONSTANT MEMBER FUNCTIONS
        std::size_t size( ) const { return many_vertices; }
        bool is_edge(std::size_t source, std::size_t target) const;
        std::set<std::size_t> neighbors(std::size_t vertex) const;
        Item operator[ ] (std::size_t vertex) const;
    private:
        bool edges[MAXIMUM][MAXIMUM];
        Item labels[MAXIMUM];
        std::size_t many_vertices;
    };
}

//#include "graph.template" // Include the implementation.
#endif 

  #include <cassert>    // Provides assert
#include <cstdlib>    // Provides size_t
#include <set>        // Provides set
#include "graph.h"

namespace main_savitch_15
{
    template <class Item>
    const std::size_t graph<Item>::MAXIMUM;

    template <class Item>
    void graph<Item>::add_edge(std::size_t source, std::size_t target)
    // Library facilities used: cassert, cstdlib
    {
        assert(source < size( ));
        assert(target < size( ));
        edges[source][target] = true;
    }

    template <class Item>
    void graph<Item>::add_vertex(const Item& label)
    // Library facilities used: cassert, cstdlib
    {
        std::size_t new_vertex_number;
        std::size_t other_number;

        assert(size( ) < MAXIMUM);
        new_vertex_number = many_vertices;
        many_vertices++;
        for (other_number = 0; other_number < many_vertices; ++other_number)
        {
            edges[other_number][new_vertex_number] = false;
            edges[new_vertex_number][other_number] = false;
        }
        labels[new_vertex_number] = label;
    }

    template <class Item>
    bool graph<Item>::is_edge(std::size_t source, std::size_t target) const
    // Library facilities used: cassert, cstdlib
    {
        assert(source < size( ));
        assert(target < size( ));
        return edges[source][target];
    }

    template <class Item>
    Item& graph<Item>::operator[ ] (std::size_t vertex)
    // Library facilities used: cassert, cstdlib
    {
        assert(vertex < size( ));
        return labels[vertex];     // Returns a reference to the label
    }

    template <class Item>
    Item graph<Item>::operator[ ] (std::size_t vertex) const
    // Library facilities used: cassert, cstdlib
    {
        assert(vertex < size( ));
        return labels[vertex];     // Returns only a copy of the label
    }

    template <class Item>
    std::set<std::size_t> graph<Item>::neighbors(std::size_t vertex) const
    // Library facilities used: cassert, cstdlib, set
    {
        std::set<std::size_t> answer;
        std::size_t i;

        assert(vertex < size( ));

        for (i = 0; i < size( ); ++i)
        {
            if (edges[vertex][i])
                answer.insert(i);
        }
        return answer;
    }

    template <class Item>
    void graph<Item>::remove_edge(std::size_t source, std::size_t target)
    // Library facilities used: cassert, cstdlib
    {
        assert(source < size( ));
        assert(target < size( ));
        edges[source][target] = false;
    }
}

#include <iostream>
#include "graph.h"

using namespace main_savitch_15;

int main() {

    int num1 = 3;
    graph<int > first;
    first.add_vertex(num1);
    first.add_vertex(2);
    first.add_edge(1,0);


    return 0;
}

[goldenchicken]

Your add_vertex function takes a const Item&.
In your main function you are passing in an integer an a double

[ricciopasticcio]

oh forgot to change that thanks.. but it doesn't work when i pass all int either

[Enoizat]

Hi, ricciopasticcio.
The long, boring but utterly useful guide to the solution of your problem is here:
http://stackoverflow.com/questions/8752837/undefined-reference-to-template-class-constructor

In short, move graph.cpp into graph.h.
Here an example based on your code:
graph.h:

#ifndef GRAPH_PROJECT_GRAPH_H
#define GRAPH_PROJECT_GRAPH_H


#include <cassert>    // Provides assert
#include <cstddef>
#include <cstdlib>  // Provides size_t
#include <set>      // Provides set

namespace main_savitch_15
{
template <typename Item>
class graph
{
public:
    // MEMBER CONSTANTS
    static const std::size_t MAXIMUM = 20;
    // CONSTRUCTOR
    graph( ) { many_vertices = 0; }

    // MODIFICATION MEMBER FUNCTIONS
    void add_vertex(const Item& label)
    {
        // Library facilities used: cassert, cstdlib
        std::size_t new_vertex_number;
        std::size_t other_number;

        assert(size( ) < MAXIMUM);
        new_vertex_number = many_vertices;
        many_vertices++;
        for (other_number = 0; other_number < many_vertices;
             ++other_number)
        {
            edges[other_number][new_vertex_number] = false;
            edges[new_vertex_number][other_number] = false;
        }
        labels[new_vertex_number] = label;
    }

    void add_edge(std::size_t source, std::size_t target)
    // Library facilities used: cassert, cstdlib
    {
        assert(source < size( ));
        assert(target < size( ));
        edges[source][target] = true;
    }

    void remove_edge(std::size_t source, std::size_t target)
    {
        // Library facilities used: cassert, cstdlib
        assert(source < size( ));
        assert(target < size( ));
        edges[source][target] = false;
    }

    Item& operator [ ] (std::size_t vertex)
    {
        // Library facilities used: cassert, cstdlib
        assert(vertex < size( ));
        return labels[vertex];     // Returns a reference to the label
    }

    // CONSTANT MEMBER FUNCTIONS
    std::size_t size( ) const { return many_vertices; }
    bool is_edge(std::size_t source, std::size_t target) const
    {
        // Library facilities used: cassert, cstdlib
        assert(source < size( ));
        assert(target < size( ));
        return edges[source][target];
    }

    std::set<std::size_t> neighbors(std::size_t vertex) const
    {
        // Library facilities used: cassert, cstdlib, set
        std::set<std::size_t> answer;
        std::size_t i;

        assert(vertex < size( ));

        for (i = 0; i < size( ); ++i)
        {
            if (edges[vertex][i])
                answer.insert(i);
        }
        return answer;
    }

    Item operator[ ] (std::size_t vertex) const
    {
        assert(vertex < size( ));
        return labels[vertex];     // Returns only a copy of the label
    }

private:
    bool edges[MAXIMUM][MAXIMUM];
    Item labels[MAXIMUM];
    std::size_t many_vertices;
};

template <typename Item>
const std::size_t graph<Item>::MAXIMUM;
}

#endif // GRAPH_PROJECT_GRAPH_H