C++ Incorrect output

[sparki]

Is anyone able to tell me what is wrong with my "virtual Factory& getFactory() const" function in class RenderedPoint? I am just not getting the correct output. I am quite stressed out over this. Thanks.

Output:
0x10040f020 0xffffcb60 - failed RenderingInformation test.

#include <fstream>
#include <vector>
#include <cmath>
#include <Windows.h>
#include <cstdint>

float frand()
{
	return 10.0f * float(rand()) / float(RAND_MAX);
}

int main()
{
	srand(unsigned(time(0)));
	const int COUNT = 100;
	int count = 0;
	int max_count = 0;
	Factory factory(500, 500, Object::VectorType(1, 1));

	bool okay = true;
	for (int i = 0; okay && i < COUNT; ++i)
	{
		const Object::PointType center(frand(), frand());
		const float depth = frand();
		const unsigned int color = rand() % (1 << 24);
		Object* obj = factory.createPoint(center, color, depth);
		Object* clone = obj->clone();
		Factory::RenderingInformation* ri =
			dynamic_cast<Factory::RenderingInformation*>(clone);
		okay = (
			(ri != 0) &&
			(ri->getColor() == color) &&
			(&(ri->getFactory()) == &factory)
		);
		std::cout<<ri->getColor()<<" "<<color<<std::endl;
		std::cout<<&(ri->getFactory())<<" "<<&factory;
		
		delete clone;
		delete obj;
	}
	if (okay)
	{
		++count;
	}
	else
	{
		std::cout << "  - failed RenderingInformation test." << std::endl;
	}
	
	++max_count;
 
	int result = static_cast<int>(
		100.0f * static_cast<float>(count) / static_cast<float>(max_count) + 0.5f
	);
	std::cout << "Tests passed: " << result << "%" << std::endl;
	return result;
}

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;
};

namespace
{
	const unsigned char BYTES_PER_PIXEL = 3;
}	

class RenderedPoint : public Point, public IRenderingInformation
{
public:
	void render() const override;
	
	virtual Factory& getFactory() const //Have issue
	{
 		 
		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:
	int color;
 
	static Factory _myFactory;
	
 };
 
Factory RenderedPoint::_myFactory(500,500,Object::VectorType(1,1));

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());
}

[Peter87]

I'm not sure I understand the problem correctly. Do you expect factory in main() to have the same address as _myFactory in the Factory class? Well, that is impossible because they are obviously different objects.

[sparki]

Hi Peter87, do you have any idea why it failed the renderinginformation test though? I can't figure out why..

[keskiverto]

What "rendering test"?