Undefined reference to operator << in inherited class - c++

Question

I'm trying to overload the << and >> operators for a polygon class and a derived triangle class. The problem is that my compiler is returning the following error:
error: undefined reference to `operator<<(std::ostream&, triangle const&)'
I am fairly certain that I did define the above operator however. I have the following line in my triangle.h file:
std::ostream & operator << (std::ostream & os, triangle const&);
This problem occurs specifically for the triangle class. When I remove the line trying to output a triangle, my program works correctly. There is no problem outputting a polygon. What is causing this problem and how do I fix it? Is it a problem with my include hierarchy?
I think the relevant files are main.cpp, triangle.h, and triangle.cpp but I included a full copy of my code below in case the error is caused by something else. Thank you for your help and patience.
main.cpp
#include <iostream>
#include "triangle.h"
using namespace std;
int main()
{
triangle t (vertex (0, 0), vertex (5, 0), vertex (0, 5));
triangle l (t);
cout << l[0] << endl;
cout << "L: " << l << endl; //not working
polygon p;
p.add (vertex (0,0));
cout << "P: " << p << endl; //working
return 0;
}
triangle.h
#include "polygon.h"
#include <iostream>
class triangle : public polygon
{
public:
triangle(vertex = vertex(), vertex = vertex(), vertex = vertex());
triangle(const triangle &);
double area() const;
vertex operator[](size_t i) const;
private:
size_t size() const;
void add(vertex iv);
std::vector<vertex> v;
};
std::ostream & operator << (std::ostream & os, triangle const&);
std::istream & operator >> (std::istream & is, triangle & t);
triangle.cpp
#include "triangle.h"
#include <math.h>
#include <cassert>
triangle::triangle(vertex ta, vertex tb, vertex tc)
{
v.push_back(ta);
v.push_back(tb);
v.push_back(tc);
}
triangle::triangle(const triangle & t)
{
v=t.v;
}
double triangle::area() const
{
double a=sqrt((v[0].x-v[1].x)*(v[0].x-v[1].x)+(v[0].y-v[1].y)*(v[0].y-v[1].y));
double b=sqrt((v[1].x-v[2].x)*(v[1].x-v[2].x)+(v[1].y-v[2].y)*(v[1].y-v[2].y));
double c=sqrt((v[2].x-v[0].x)*(v[2].x-v[0].x)+(v[2].y-v[0].y)*(v[2].y-v[0].y));
double s=((a+b+c)/2);
return sqrt(s*(s-a)*(s-b)*(s-c));
}
vertex triangle::operator[] (std::size_t i) const
{
assert (i<3);
return v[i];
}
inline std::ostream & operator << (std::ostream & os, triangle const & t)
{
std::cout << "test" << std::endl;
return os << t[0];
}
std::istream & operator >> (std::istream & is, triangle & t)
{
vertex vx;
for (size_t i = 0; i < 3; ++i)
{
is >> vx.x >> vx.y;
//t.v.push_back(vx);
}
return is;
}
polygon.h
#include <iostream>
#include <vector>
#include "vertex.h"
class polygon
{
public:
// pre:
// post: empty polygon created
polygon();
// pre:
// post: polygon created and initialized to given polygon source
polygon(const polygon & source);
// pre:
// post: return number of vertices in this polygon
std::size_t size() const;
// pre: 0 <= i < size()
// post: return vertex i in this polygon
vertex operator[](size_t i) const;
// pre:
// post: vertex is added to this polygon
void add(const vertex & v);
private:
std::vector<vertex> v;
};
std::ostream & operator << (std::ostream & os, const polygon & p);
std::istream & operator >> (std::istream & is, polygon & p);
polygon.cpp
#include <cassert>
#include "polygon.h"
polygon::polygon()
{
v = std::vector<vertex> ();
}
polygon::polygon(const polygon & p)
{
v = p.v;
}
std::size_t polygon::size() const
{
return v.size();
}
vertex polygon::operator[] (std::size_t i) const
{
assert(i < size());
return v[i];
}
void polygon::add(const vertex & vx)
{
v.push_back(vx);
}
std::ostream & operator << (std::ostream & os, const polygon & p)
{
for (std::size_t i = 0; i < p.size(); ++i)
os << p[i] << " ";
return os;
}
std::istream & operator >> (std::istream & is, polygon & p)
{
std::size_t n;
vertex vx;
is >> n;
for (size_t i = 0; i < n; ++i)
{
is >> vx.x >> vx.y;
p.add(vx);
}
return is;
}
vertex.h
#include <iostream>
struct vertex
{
double x, y;
vertex(double ix = 0.0, double iy = 0.0)
{
x = ix;
y = iy;
}
};
std::ostream & operator << (std::ostream & os, const vertex & v);
vertex.cpp
#include "vertex.h"
std::ostream & operator << (std::ostream & os, const vertex & v)
{
os << "(" << v.x << ", " << v.y << ")";
return os;
}

Answer 1

Here's your problem:
// triangle.cpp
inline std::ostream & operator << (std::ostream & os, triangle const & t)
^^^^^^
Inline functions must be defined in all translation units that use them, and this is only defined in one. Either remove inline, or move the definition into the header to make it available anywhere its used.