In fm_matrix.h:

class fm_vector;

class fm_matrix
{
	public: float data[16];

		fm_matrix();
		fm_matrix(float newdata[]);
		static fm_matrix RotMat_Deg (float degrees, fm_vector* axis);
		static fm_matrix TransMat (fm_vector* units);
		static fm_matrix ScaleMat (float factor);
		static fm_matrix IdentMat ();
		float operator[](int index);
		float* at (int index);
		fm_matrix transpose();
		fm_matrix operator* (float rhs);
		fm_vector operator* (fm_vector* rhs);
		fm_matrix operator* (fm_matrix* rhs);
		void operator= (fm_matrix* rhs);
		float* getdata();
		void display();
};

class fm_vector 
{
	public: float data[4];
		fm_vector();
		fm_vector(bool InitMe);
		fm_vector (float newdata[4]);
		fm_vector (float x, float y, float z, float n);
		float operator[](int index);
		float* at(int index);
		fm_vector operator* (float rhs);
		float operator* (fm_vector* rhs);
		void operator= (fm_vector* rhs);
		fm_vector operator* (fm_matrix* rhs);
		fm_vector operator/ (float rhs);
		fm_vector operator+ (fm_vector* rhs);
		void display();
		fm_vector normalise();
};




In file fm_matrix.cpp

#include "fm_matrix.h"
//#include "fm_vector.h"
#include <iostream>
#include <cmath> 	//M_PI kort 'n define vir windows - #if defined(_USE_MATH_DEFINES) && !defined(_MATH_DEFINES_DEFINED) 
			// #define _MATH_DEFINES_DEFINED

fm_matrix::fm_matrix()
{
	//std::cout << "creating new matrix" << std::endl;
	/*data = FM_Identity_Mat;*/
	for (int i=0; i<16; i++)
		data[i] = 0;
	for (int i=0; i<16; i=i+5)
		data[i] = 1;
	//data = { 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1 };
}

fm_matrix::fm_matrix(float newdata[16])
{
//	data = newdata;
	for (int i=0; i<16; i++)
		data[i] = newdata[i];
}

fm_matrix fm_matrix::RotMat_Deg (float degrees, fm_vector* axis)
{
	const float Cosine = std::cos(degrees * M_PI / 180);
	const float Sine = std::sin(degrees * M_PI / 180);
	*(axis) = axis->normalise();
	fm_matrix result;
	*(result.at(0)) = *(axis->at(0)) * *(axis->at(0)) * (1-Cosine) + Cosine;
	*(result.at(1)) = *(axis->at(0)) * *(axis->at(1)) * (1-Cosine) + *(axis->at(2)) * Sine;
	*(result.at(2)) = *(axis->at(0)) * *(axis->at(2)) * (1-Cosine) - *(axis->at(1)) * Sine;
	*(result.at(3)) = 0;
	*(result.at(4)) = *(axis->at(1)) * *(axis->at(0)) * (1-Cosine) - *(axis->at(2)) * Sine;
	*(result.at(5)) = *(axis->at(1)) * *(axis->at(1)) * (1-Cosine) + Cosine;
	*(result.at(6)) = *(axis->at(1)) * *(axis->at(2)) * (1-Cosine) + *(axis->at(0)) * Sine;
	*(result.at(7)) = 0;
	*(result.at(8)) = *(axis->at(2)) * *(axis->at(0)) * (1-Cosine) + *(axis->at(1)) * Sine;
	*(result.at(9)) = *(axis->at(2)) * *(axis->at(1)) * (1-Cosine) - *(axis->at(0)) * Sine;
	*(result.at(10)) = *(axis->at(2)) * *(axis->at(2)) * (1-Cosine) + Cosine;
	*(result.at(11)) = 0;
	*(result.at(12)) = 0;
	*(result.at(13)) = 0;
	*(result.at(14)) = 0;
	*(result.at(15)) = 1;

	return result;
}

fm_matrix fm_matrix::IdentMat()
{
	fm_matrix mat1;
	return mat1;
}

fm_matrix fm_matrix::TransMat (fm_vector* units)
{
	fm_matrix tmp;
	for (int i=0; i<3; i++)
		*(tmp.at(i+12)) = *(units->at(i));
	return tmp;
}

fm_matrix fm_matrix::ScaleMat (float factor)
{
	fm_matrix tmp;
	for (int i=0; i<15; i=i+5)
		*(tmp.at(i)) = factor;
	return tmp;
}

float* fm_matrix::at(int index)
{
	if ((index  < 0) || (index > 15))
		return NULL;
	return &data[index];
}

fm_matrix fm_matrix::transpose()
{
	fm_matrix tmp;
	for (int i=0; i<4; i++)
		for (int j=0; j<4; j++)
			*(tmp.at(i*4+j)) = data[j*4+i];
	return tmp;
}

fm_matrix fm_matrix::operator* (float rhs)
{
	fm_matrix tmp;
	for (int i=0; i<16; i++)
		*(tmp.at(i)) = data[i] * rhs;
	return tmp;
}

fm_vector fm_matrix::operator* (fm_vector* rhs)
{
	fm_vector tmp(false);
	for (int i=0; i<4; i++)
	{
		float sum=0;
		for (int j=0; j<4; j++)
			sum += *(rhs->at(j)) * data[i*4+j];
		*(tmp.at(i)) = sum;
	}
	return tmp;
}

fm_matrix fm_matrix::operator* (fm_matrix* rhs)
{
	fm_matrix tmp;
	for (int i=0; i<4; i++)
		for (int j=0; j<4; j++)
		{
			float sum=0;
			for (int k=0; k<4; k++)
				sum += *(rhs->at(i+k*4)) * data[j*4+k];
			*(tmp.at(j*4+i)) = sum;
		}
	return tmp;
}

void fm_matrix::operator= (fm_matrix* rhs)
{
	//fm_matrix tmp;
	for (int i=0; i<16; i++)
		//*(tmp.at(i)) = *(rhs->at(i));
		data[i] = *(rhs->at(i));
	//return tmp;
}

float* fm_matrix::getdata()
{
	return &data[0];
}

void fm_matrix::display()
{
	//std::cout.precision(4);
	for (int i=0; i<4; i++)
	{
		for (int j=0; j<4; j++)
			std::cout << data[j*4+i] << " ";
		std::cout << std::endl;
	}
}

fm_vector::fm_vector()
{
	fm_vector (true);
}

fm_vector::fm_vector(bool InitMe)
{
	//std::cout << "creating new vector" << std::endl;
	if (InitMe)
		for (int i=0; i<4; i++)
			data[i]=0;
}

fm_vector::fm_vector(float newdata[4])
{
	//data = newdata;
	for (int i=0; i<4; i++)
		data[i] = newdata[i];
}

fm_vector::fm_vector (float x, float y, float z, float n)
{
	data[0] = x;
	data[1] = y;
	data[2] = z;
	data[3] = n;
}

float* fm_vector::at(int index)
{
	if ((index < 0) || (index > 3))
		return NULL;
	return &data[index];
}

fm_vector fm_vector::operator* (float rhs)
{
	fm_vector tmp;
	for (int i=0; i<4; i++)
		*(tmp.at(i)) = data[i]*rhs;
	return tmp;
}

float fm_vector::operator* (fm_vector* rhs)
{
	float sum = 0;
	for (int i=0; i<4; i++)
		sum += *(rhs->at(i)) * data[i];
	return sum;
}

fm_vector fm_vector::operator* (fm_matrix* rhs)
{
	fm_vector tmp;
	for (int i=0; i<4; i++)
	{
		float sum=0;
		for (int j=0; j<4; j++)
			sum += *(rhs->at(j*4 + i)) * data[j];
		*(tmp.at(i)) = sum;
	}
	return tmp;
}

void fm_vector::operator= (fm_vector* rhs)
{
	for (int i=0; i<4; i++)
		data[i] = *(rhs->at(i));
}

fm_vector fm_vector::operator/ (float rhs)
{
	fm_vector tmp(data[0]/rhs, data[1]/rhs, data[2]/rhs, data[3]/rhs);
	return tmp;	
}

fm_vector fm_vector::operator+ (fm_vector* rhs)
{
	fm_vector tmp (false);
	for (int i=0; i<4; i++)
		*(tmp.at(i)) = data[i] + *(rhs->at(i));
	return tmp;
}

void fm_vector::display()
{
	for (int i=0; i<4; i++)
		std::cout << data[i] << " ";
	std::cout << std::endl;
}

fm_vector fm_vector::normalise()
{
	float length = sqrtf(data[0]*data[0] + data[1]*data[1] + data[2]*data[2] + data[3]*data[3]);
	fm_vector result;
	for (int i=0; i<4; i++)
		*(result.at(i)) = data[i] / length;
	return result;
}