Can't get template classes to work well with the linker - c++

Question

I'm currently teaching myself C++, and I'm struggling to get my implementation of a basic template class to compile. I wrote a IntMatrix class that implements a matrix with integer elements, and I'm now trying to extend the class. Code is below. When I try to compile it, I get the error:
g++ -o hw3 -std=c++11 -Wall -Wextra -ansi -pedantic -Wshadow -Weffc++ -Wstrict-overflow=5 -Wno-unused-parameter -Wno-write-strings hw3.cpp
Undefined symbols for architecture x86_64:
"Matrix<int>::~Matrix()", referenced from:
_main in hw3-c5e16c.o
ld: symbol(s) not found for architecture x86_64
clang: error: linker command failed with exit code 1 (use -v to see invocation)
I would be extremely grateful for any assistance. Code:
// main.cpp
#include "matrix.ch"
#include <iostream>
int main() {
Matrix<int> adj(3, 3);
std::cout << adj;
return 0;
}
The matrix header file:
// matrix.h
#ifndef MATRIX_H
#define MATRIX_H
#include <iostream>
#include <iomanip>
using namespace std;
template <typename T>
class Matrix {
public:
//Default constructor.
Matrix( );
//Constructor builds r x c matrix with all zeros.
Matrix(int r, int c);
//Class destructor.
~Matrix( );
//Copy constructor.
Matrix(const Matrix<T>& right);
void print( );
//Assignment operator.
Matrix<T>& operator= (const Matrix<T>& right);
//Element access operator: M(i,j) is element in row i, column j.
int& operator() (int i, int j);
int operator() (int i, int j) const;
//Define matrix addition: A+B.
//Assumes dimension(A)=dimension(B).
friend Matrix<T> operator+ (const Matrix<T>& left, const Matrix<T>& right);
//Define matrix multiplication: A*B.
//Assumes (#cols of A) = (#rows of B).
friend Matrix<T> operator* (const Matrix<T>& left, const Matrix<T>& right);
//Define matrix powers: A^N = A*A*A...A (N times).
//Assumes matrix A is square: #rows = #cols.
friend Matrix<T> operator^<>(const Matrix<T>& left, int power);
//Define matrix input and output.
friend ostream& operator<< (ostream& out, const Matrix<T>& right);
friend istream& operator>> (istream& in, Matrix<T>& right);
private:
int rows; //Number of rows in matrix.
int cols; //Number of columns in matrix.
T* elements; //Matrix elements as an array, read in raster order.
};
template <typename T>
Matrix<T>::Matrix() {
rows = 0;
cols = 0;
elements = NULL;
}
template <typename T>
Matrix<T>::Matrix (int r, int c) {
rows = r;
cols = c;
elements = new T[r*c];
}
template <typename T>
Matrix<T>::~Matrix () {
delete[] elements;
}
template <typename T>
void Matrix<T>::print() {
for (int i = 0; i < rows * cols; i++) {
cout <<setw(10) << elements[i];
if ((i+1) % cols == 0) {
cout << "\n"; // End of row
}
return;
}
}
template <typename T>
int& Matrix<T>::operator() (int i, int j) {
return elements[i * cols + j];
}
template <typename T>
int Matrix<T>::operator() (int i, int j) const{
return elements[i * cols + j];
}
template <typename T>
ostream& operator<< (ostream& out, const Matrix<T>& right) {
for (int i = 0; i < right.rows*right.cols; i++) {
out << setw(10) << right.elements[i];
if ((i+1) % right.cols == 0) {
out << "\n";
}
}
return out;
}
template <typename T>
Matrix<T> operator* (const Matrix<T>& left, const Matrix<T>& right) {
Matrix<T> A (left.rows, right.cols);
for (int i = 0; i < left.rows; i++) {
for (int j = 0; j < right.cols; j++) {
A(i, j) = 0;
for (int k = 0; k < left.cols; k++) {
A(i, j) += left(i, k) * right (k, j);
}
}
}
return A;
}
template <typename T>
Matrix<T>& Matrix<T>::operator= (const Matrix<T>& right) {
if (this != &right) {
rows = right.rows;
cols = right.cols;
delete[] elements; // Note that we clear the array before reassigning it.
elements = new T[rows * cols];
for (int i = 0; i < rows * cols; i++) {
elements[i] = right.elements[i];
}
}
return *this;
}