InputHandler

Heeiiigou

Hallo liebe Community,

ich stehe gerade vor einem Problem, wo ich nicht weiterkomme.

Der Aufbau meines Programms ist folgender:

.................................main.cpp
........................................|
...............................systemclass.h
...................................../............\
..........................InputClass.h.....FileClass.h

So in der systemclass erstelle ich ein stinknormales Fenster. Ich wollte versuchen, den Messagehandler in die InputClass.h zu verlegen. Jedoch funktioniert dies nicht, und es wird kein Fenster angezeigt und der Code wird Fehlerfrei compiliert. Hier der Code:

So Funktionierts:

void TSystem::Initialize()
{
	m_file = new TFileClass();
	m_input = new TInputClass();
	ApplicationHandle = this;
}

LRESULT CALLBACK TSystem::DispatchInput(HWND hWnd,UINT msg, WPARAM wParam,LPARAM lParam)
{
	return DefWindowProc(hWnd,msg,wParam,lParam);
}

static LRESULT CALLBACK wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return ApplicationHandle->DispatchInput(hWnd, msg, wParam, lParam);
}

Jedoch sobald ich in der Funktion DispatchInput auf das Objekt von InputClass zugreife wird nichts mehr angezeigt jedoch compiliert er es. Ich habe nur als Beispiel eine öffentliche Integer Variable in der InputClass deklariert un weise eine Zahl zu:

LRESULT CALLBACK TSystem::DispatchInput(HWND hWnd,UINT msg, WPARAM wParam,LPARAM lParam)
{
        m_input->i = 5;
	return DefWindowProc(hWnd,msg,wParam,lParam);
}

Wo liegt hierbei der Fehler. Habe auch schon Google zum schwitzen gebracht

Heeiiigou

Hier nochmal das ganze Projekt falls benötigt:

main.cpp:

////////////
//main.cpp//
////////////

////////////
//Includes//
////////////

//////////////
//MyIncludes//
//////////////
#include "system.h"

///////////////////////
//Global Declarations//
///////////////////////
TSystem *sys;

///////////
//WinMain//
///////////
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, PSTR CmdLine, int CmdShow)
{
	sys = new TSystem();
	sys->CreateClass(hInstance);
	sys->CreateWin(hInstance);
	sys->MessageChain();

	delete sys;
	sys = 0;

	return 0;
}

system.h:

////////////
//system.h//
////////////
#ifndef _SYSTEM_H_
#define _SYSTEM_H_

////////////
//Includes//
////////////
#include <Windows.h>

//////////////
//MyIncludes//
//////////////
#include "filetransfer.h"
#include "InputClass.h"

///////////////
//TSystemClass//
///////////////
class TSystem
{
public:
	TSystem();
	TSystem(const TSystem&);
	~TSystem();

	void MessageChain();
	void CreateClass(HINSTANCE);
	void CreateWin(HINSTANCE);
	void Initialize();
	void FreeRAM();
	LRESULT CALLBACK DispatchInput(HWND,UINT,WPARAM,LPARAM);
private:
	WNDCLASS m_wc;
	HWND m_hWnd;
	MSG m_msg;
	TFileClass *m_file;
	TInputClass *m_input;
protected:
};

LRESULT CALLBACK wndProc(HWND, UINT, WPARAM, LPARAM);
static  TSystem* ApplicationHandle;

#endif

System.cpp

////////////
//system.cpp//
////////////
#include "system.h"

TSystem::TSystem()
{
	ZeroMemory(&m_hWnd, sizeof(HWND));
	ZeroMemory(&m_wc, sizeof(WNDCLASS));
	ZeroMemory(&m_msg, sizeof(MSG));
}

TSystem::TSystem(const TSystem& other)
{
}

TSystem::~TSystem()
{

}

void TSystem::Initialize()
{
	m_file = new TFileClass();
	m_input = new TInputClass();
	ApplicationHandle = this;
}

void TSystem::CreateClass(HINSTANCE hInstance)
{
	m_wc.cbClsExtra			= 0;
	m_wc.cbWndExtra			= 0;
	m_wc.hbrBackground		= (HBRUSH)WHITE_BRUSH;
	m_wc.hCursor			= LoadCursor(hInstance,IDC_ARROW);
	m_wc.hIcon				= LoadIcon(hInstance, IDI_APPLICATION);
	m_wc.hInstance			= hInstance;
	m_wc.lpfnWndProc		= wndProc;
	m_wc.lpszClassName		= L"SkalierTool";
	m_wc.lpszMenuName		= NULL;
	m_wc.style				= CS_VREDRAW | CS_HREDRAW;

	RegisterClass(&m_wc);
}

void TSystem::CreateWin(HINSTANCE hInstance)
{
	m_hWnd = CreateWindow(	L"SkalierTool",
							L"SkalierTool",
							WS_OVERLAPPEDWINDOW | WS_POPUP,
							300,300,
							800, 600,
							NULL, NULL,
							hInstance,
							NULL);
	ShowWindow(m_hWnd, SW_NORMAL);
	UpdateWindow(m_hWnd);
}

void TSystem::MessageChain()
{
	while(GetMessage(&m_msg,NULL,0,0))
	{
		TranslateMessage(&m_msg);
		DispatchMessage(&m_msg);
	}
	this->FreeRAM();
}

LRESULT CALLBACK TSystem::DispatchInput(HWND hWnd,UINT msg, WPARAM wParam,LPARAM lParam)
{
        m_input->i = 5;
	return DefWindowProc(hWnd,msg,wParam,lParam);
}

LRESULT CALLBACK wndProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
	return ApplicationHandle->DispatchInput(hWnd, msg, wParam, lParam);
}

void TSystem::FreeRAM()
{
	ZeroMemory(&m_hWnd, sizeof(HWND));
	ZeroMemory(&m_wc, sizeof(WNDCLASS));
	ZeroMemory(&m_msg, sizeof(MSG));
	m_file->FreeRAM();
}

Inputclass.h

//////////////////
//InputClass.h//
//////////////////
#ifndef _INPUTHANDLER_H_
#define _INPUTHANDLER_H_

////////////
//Includes//
////////////
#include <Windows.h>

//////////////
//MyIncludes//
//////////////

//////////////
//TInputClass//
//////////////
class TInputClass
{
public:
	int i;
private:

protected:
};
#endif

Inputclass.cpp

//////////////////
//InputClass.cpp//
//////////////////
#include "InputClass.h"

Heeiiigou

Jetzt hab ich durch ausprobieren noch herausgefunden, dass ich in einem Switch auf das Objekt zugreifen kann und das Programm dann funktioniert. Jetzt stellt sich mir die Frage warum dass so ist?^^

Also, unabhängig von der Winapi hört es sich so an, als ob dein m_input->i Zugriff den Stack durcheinander bringt. Würd mal schauen, ob m_input wirklich auf ein valides Object zeigt. Vorm Einbauen dieses Befehls hat es ja auch funktioniert.

Funktioniert Variable = m_input->i ?
Wenn ja, dann überschreibst du dir irgendwas wegen einem falschen Zeiger.

merano

MC schrieb:

Würd mal schauen, ob m_input wirklich auf ein valides Object zeigt.

In der Klasse TSystem sind zwei Zeiger

TFileClass *m_file; 
TInputClass *m_input;

Diese werden erst nach Aufruf der Methode

void TSystem::Initialize()

gültig.

Das hat den Nachteil, das man vergessen kann sie aufzurufen (was hier
auch genau passiert), oder genauso schlimm man kann sie mehrfach aufrufen
und überschreibt den alten Zeiger.

Auch

static TSystem* ApplicationHandle;

ist nicht so gesund: Jede Instanz der Klasse überschreibt die globale static beim Aufruf
der methode Initialize().

Soll das ein singleton werden ?