C++ compilation error(Underfined ref)

[sparki]

Hi, I am trying to get my member function "virtual Factory& getFactory() const" in class RenderedPoint to work but it doesn't. I am receiving an undefined reference below. Can anyone point out to me the mistake that I am making? Thanks!

Compilation output:
/tmp/ccronZVA.o:factory.cpp:(.rdata$.refptr._ZN13RenderedPoint10_myFactoryE[.refptr._ZN13RenderedPoint10_myFactoryE]+0x0): undefined reference to `RenderedPoint::_myFactory'
collect2: error: ld returned 1 exit status

Header file:
#include <Windows.h>
#include <cstdint>

class Factory final
{
private:
	Factory() = delete;
	Factory(const Factory&) = delete;
	Factory(Factory&&) = delete;
	Factory& operator=(const Factory&) = delete;
	Factory& operator=(Factory&&) = delete;
 
public:
	typedef Object::VectorType VectorType;
	typedef Object::PointType PointType;
	typedef IRenderingInformation RenderingInformation;
	typedef uint8_t Byte;

	Factory(unsigned int width, unsigned int height, const VectorType& extents);
	~Factory();

	Object* createPoint(const PointType& center,
		unsigned color, float depth = 1);

	void writeToBitmap(const char* name);

	static char* readFromBitmap(unsigned int& width, unsigned int& height,
		const char* name);

	static unsigned getColor(Byte r, Byte g, Byte b);

	POINT toDevice(const VectorType& v) const;
	HDC getContext() const;

private:
	HBITMAP _bitmap;
	HDC _context;
	unsigned int _width;
	unsigned int _height;
	void* _bitmapData;
	float _xFactor;
	float _yFactor;
};

Main file:
namespace
{
	const unsigned char BYTES_PER_PIXEL = 3;
}

class RenderedPoint : public Point, public IRenderingInformation
{
public:
	void render() const override;
	
	virtual Factory& getFactory() const
	{
		// static Factory _myFactory;
		return _myFactory;
		
	}	
	virtual unsigned int getColor() const 
	{
		return color;
	}
	RenderedPoint(const PointType& center, unsigned c,
	float d) : Point(center,d),color(c) {}
	
	RenderedPoint* clone() const { return new RenderedPoint(*this); }
private:
	static Factory _myFactory;
	int color;
 };

Factory::Factory(
	unsigned int width,
	unsigned int height,
	const VectorType& extents
) :
	_width{width},
	_height{height},
	_xFactor{static_cast<float>(width) / extents.x()},
	_yFactor{static_cast<float>(height) / extents.y()}
{
	_context = CreateCompatibleDC(0);
	BITMAPINFO bitmapInfo;
	ZeroMemory(&bitmapInfo, sizeof(bitmapInfo));
	bitmapInfo.bmiHeader.biSize = sizeof(bitmapInfo);
	bitmapInfo.bmiHeader.biWidth = width;
	bitmapInfo.bmiHeader.biHeight = height;
	bitmapInfo.bmiHeader.biPlanes = 1;
	bitmapInfo.bmiHeader.biBitCount = 24;
	bitmapInfo.bmiHeader.biCompression = BI_RGB;
	_bitmap = CreateDIBSection(_context, &bitmapInfo, DIB_RGB_COLORS,
		&_bitmapData, 0, 0
	);
	SelectObject(_context, _bitmap);
}

Factory::~Factory()
{
	HGDIOBJ old = SelectObject(_context, GetStockObject(NULL_BRUSH));
	DeleteObject(old);
	DeleteDC(_context);
	DeleteObject(_bitmap);
}

HDC Factory::getContext() const
{
	return _context;
}

unsigned Factory::getColor(Byte r, Byte g, Byte b)
{
	return RGB(r, g, b);
}

void Factory::writeToBitmap(const char* name)
{
	const unsigned int rowData = BYTES_PER_PIXEL * _width;
	const unsigned int rowPadding = (rowData % 4 != 0)
		? (4 - rowData % 4)
		: 0;
	const unsigned int stride = rowData + rowPadding;
	std::fstream out{name, std::ios_base::binary | std::ios_base::out};
	if (out)
	{
		BITMAPFILEHEADER bmfh;
		BITMAPINFOHEADER bmih;

		ZeroMemory(&bmfh, sizeof(bmfh));
		bmfh.bfType = 'B' + ('M' << 8);
		bmfh.bfSize = static_cast<unsigned int>(
			sizeof(bmfh) +
			sizeof(bmih) +
			stride * _height
		);
		bmfh.bfOffBits = sizeof(bmfh) + sizeof(bmih);
		out.write(reinterpret_cast<char*>(&bmfh), sizeof(bmfh));

		ZeroMemory(&bmih, sizeof(bmih));
		bmih.biSize = sizeof(bmih);
		bmih.biWidth = _width;
		bmih.biHeight = _height;
		bmih.biPlanes = 1;
		bmih.biBitCount = 8 * BYTES_PER_PIXEL;
		bmih.biCompression = BI_RGB;
		out.write(reinterpret_cast<char*>(&bmih), sizeof(bmih));

		for (unsigned int h = 0; h < _height; ++h)
		{
			out.write(
				reinterpret_cast<char*>(_bitmapData) + h * stride,
				rowData
			);
			if (stride > rowData)
			{
				out.write("000", stride - rowData);
			}
		}
	}
}

char* Factory::readFromBitmap(unsigned int& width, unsigned int& height,
	const char* name
)
{
	std::fstream in{name, std::ios_base::in | std::ios_base::binary};
	if (in)
	{
		char header[54];
		in.read(header, 54);
		width = *reinterpret_cast<unsigned int*>(header + 18);
		const int signedHeight = *reinterpret_cast<int*>(header + 22);
		height = static_cast<unsigned int>(std::abs(signedHeight));
		const unsigned int size = *reinterpret_cast<unsigned int*>(header + 34);
		const unsigned int stride = size / height;
		const unsigned int rowData = BYTES_PER_PIXEL * width;
		char* const data = new char[rowData * height];
		for (unsigned int i = 0; i < height; ++i)
		{
			in.read(data + rowData * i, rowData);
			if (stride > rowData)
			{
				char buffer[4];
				in.read(buffer, stride - rowData);
			}
		}
		return data;
	}
	else
	{
		return nullptr;
	}
}

Object* Factory::createPoint(const PointType& center, unsigned color,
	float depth
)
{
	return new RenderedPoint(center, color, depth);
}

POINT Factory::toDevice(const VectorType& v) const
{
	return POINT{
		static_cast<int>(_xFactor * v.x() + 0.5f),
		static_cast<int>(static_cast<float>(_height) - _yFactor * v.y() + 0.5f)
	};
}

void RenderedPoint::render() const
{
	POINT p = getFactory().toDevice(center());
	SetPixel(getFactory().getContext(), p.x, p.y, getColor());
}

[Niccolo]

You've declared a static Factory member, _myFactory.

Before I get to why that's a problem, I want to point out that it is a mistake to use leading underscores in your classes. That's reserved "for the implementation" - that's not your implementation, but that of the compiler's.

No application code should use leading underscores, at all, in C++ or C.

That said, while you declared the member, it is not defined. It doesn't actually exist.

You must define in elsewhere in a CPP file to give it "existence". Something like

Factor Factory::_myFactory(...);

The elipses are the parameters required for the constructor, which would have to be constants available at compile time.

The static definition is otherwise similar to the definition of a global variable.

[MikeyBoy]

it is a mistake to use leading underscores in your classes. That's reserved "for the implementation" - that's not your implementation, but that of the compiler's.

No application code should use leading underscores, at all, in C++ or C.

This is inaccurate. The names that are reserved for the C++ implementation are:

- identifiers beginning with an underscore followed immediately by an uppercase letter
- identifiers containing adjacent underscores (or "double underscore")
- identifiers beginning with an underscore in the global namespace

The OP's underscore prefix for data members violates none of these rules, and is fine. While it's not the most popular convention for indicating data members, it's one I've seen in several places before.

[Niccolo]

Experience shows that no one ever bothers to check that list.

Once they start the habit of using the underscore, they use it everywhere in ways that violate these rules.

Without consequence from the compiler, they never realize it's wrong.

The only working policy I've seen in decades of consulting is to refuse all use of the leading underscore. That, everyone can remember.

This list, they never will.

[MikeyBoy]

Experience shows that no one ever bothers to check that list.

Your experience does not match my experience.

In any case, it's one thing to advise people not to do it (which I don't have a problem with, and would certainly agree with as a stylistic preference ;) ), but it's quite another to misleadingly express it as a rule of the language.

Especially not in the Beginners forum, where readers are less likely to have the knowledge and experience to know what the real rules are.