C++ implementation in header issues - c++

Question

I'm working on a fairly large project (3D graphics engine) and I've run into some trouble while restructuring the code a bit. I want to have all of my classes implemented in single files (only have .hpp rather than having both a .cpp and .hpp file for each class). I don't have a specific reason for doing it this way other than just wanting to, but I'm hoping to avoid discussions over what C++ best practices are.
When I do it this way I get a series of multiple definition errors that look like this:
/tmp/ccztDQam.o: In function `Point3DH::normalize()':
Renderer.cpp:(.text+0x736): multiple definition of `Point3DH::normalize()'
/tmp/ccawpiuU.o:main.cpp:(.text+0x1a6de): first defined here
/tmp/ccztDQam.o: In function `Point3DH::dot(Point3DH, Point3DH)':
Renderer.cpp:(.text+0x79e): multiple definition of `Point3DH::dot(Point3DH, Point3DH)'
/tmp/ccawpiuU.o:main.cpp:(.text+0x1a746): first defined here
/tmp/ccztDQam.o: In function `Point3DH::cross(Point3DH, Point3DH)':
Renderer.cpp:(.text+0x7d6): multiple definition of `Point3DH::cross(Point3DH, Point3DH)'
/tmp/ccawpiuU.o:main.cpp:(.text+0x1a77e): first defined here
...
The issue comes when the classes start including each other and code is repeated multiple times. It seems that header guards are not sufficient as explained in this answer. I'm wondering if there is any way to get around this or an alternate way to achieve the goal.
The project is organized into modules (folders) such as geometry or polygon which contain relevant classes so include paths go to the parent directory and then into the correct module and class
For reference, here is what one of the files looks like (./graphics/Raster.hpp):
#ifndef GRAPHICS_RASTER
#define GRAPHICS_RASTER
#include "../graphics/Colour.hpp"
#include <vector>
class Raster {
private:
std::vector<Colour> image;
std::vector<double> zBuffer;
int width;
int height;
public:
Raster(int, int, Colour);
void setPixel(int, int, double, Colour);
int getWidth();
int getHeight();
};
#endif
#ifndef GRAPHICS_RASTER_IMPLEMENTATION
#define GRAPHICS_RASTER_IMPLEMENTATION
#include "../graphics/Colour.hpp"
#include <vector>
#include <limits>
Raster::Raster(int width, int height, Colour clear) :
image(std::vector<Colour>(width*height, clear)),
zBuffer(std::vector<double>(width*height, -std::numeric_limits<double>::max())),
width(width),
height(height)
{}
void Raster::setPixel(int x, int y, double z, Colour c) {
if(x < 0 || x >= width || y < 0 || y >= height) return;
if(z <= zBuffer[(height - y - 1)*width + x]) return;
image[(height - y - 1)*width + x] = c;
zBuffer[(height - y - 1)*width + x] = z;
}
int Raster::getWidth() {return width;}
int Raster::getHeight() {return height;}
#endif

Answer 1

If you for some reason want to implement everything in header files, you have to make all your functions inline. Functions defined in class definitions are implicitly inline. Functions defined out-of-class have to be declared with inline keyword explicitly.
That's what you have to do with every definition that you have in the "implementation" section of your header - add explicit inline keyword to every function definition. E.g.
inline void Raster::setPixel(int x, int y, double z, Colour c) {
if(x < 0 || x >= width || y < 0 || y >= height) return;
if(z <= zBuffer[(height - y - 1)*width + x]) return;
image[(height - y - 1)*width + x] = c;
zBuffer[(height - y - 1)*width + x] = z;
}
and so on.
Of course, you can also move all your member function definitions into class definition (which will make them inline), but that will preclude such distinctly separated two-section header structure as you have now. I don't know how important it is to you.

Answer 2

Every time your header is included in a cpp file, you create a new copy of the implementation.
You need to make sure that the implementation is only used in one cpp file - or inline every method.

Answer 3

This guide have good ideas on doing that:
https://github.com/nothings/stb/blob/master/docs/stb_howto.txt
examples:
https://github.com/nothings/stb
Basically:
1-make a #define UNIQUE_NAME_IMP and #define UNIQUE_NAME_HEADER to make implementation and declaration visible on different files by using:
your implementation:
#ifdef _DECL_
type declaration
function prototype
#endif
#ifdef _IMPL_
code
#endif
and in another file that will use it:
#define _DECL_
#include <my_header.h>
code...
...
//use this only once to avoid
//duplicate symbol like you mentioned in your post.
#define _IMPL_
#include <my_header.h>
2-avoid memory allocation, make your functions use the memory you pass on with your structures.
3-avoid external dependencies. Each dependency will make you use flags or create requirements to comply before using your header...
4-use "static". This makes the implementation private to the source file that creates it.