Hier die entsprechenden Stellen des Quelltextes:

Das Erstellen des Fensters:

bool CEngine::InitWindow(HWND hParentWnd)
{
	WNDCLASSEX	wndStruct;	// Struktur der Fenster-Eigenschaften

	// Eigenschaften des Fensters festlegen
	wndStruct.hInstance		= m_hInstance;				// Die erstellende Instanz (Prozess)
	wndStruct.lpszClassName = "Test";		// Name des Fensters
	wndStruct.lpfnWndProc	= WinEvents;				// Callback Routine für Ereignisse
	wndStruct.style			= CS_HREDRAW | CS_VREDRAW;			// Fensterart 
	wndStruct.cbSize		= sizeof(WNDCLASSEX);				// Größe in Bytes    
	wndStruct.hIcon			= LoadIcon(NULL, IDI_APPLICATION);	// Standard-Icon nutzen
	wndStruct.hIconSm		= LoadIcon(NULL, IDI_APPLICATION);	// kleines Icon = Standard
	wndStruct.hCursor		= LoadCursor(NULL, IDC_ARROW);		// normaler Mauszeiger
	wndStruct.lpszMenuName	= NULL;								// kein Menü vorhanden
	wndStruct.cbClsExtra	= 0;								// keinerlei Extras
	wndStruct.cbWndExtra	= 0;
    wndStruct.hbrBackground = (HBRUSH)COLOR_BACKGROUND;	// Hintergrundfarbe = Standard

	// Versuche die Fenster-Klasse anzumelden, ansonsten Fehler zurückgeben
	if (!RegisterClassEx(&wndStruct))
	{
		ERRORMSG("Fenster-Klasse konnte nicht registriert werden!","InitWindow();");
		return false;
	}

	// das Hauptfenster wird erzeugt
	m_hWnd = CreateWindowEx(0, "Test", "Test", WS_OVERLAPPEDWINDOW,
							200, 100, m_Config.GetScreenWidth(), m_Config.GetScreenHeight(), 
							hParentWnd, NULL, m_hInstance, NULL);

	ShowWindow(m_hWnd, SW_SHOW);

	return true;
}	// ~CEngine::InitWindow();

Die Callback Routine:

LRESULT CALLBACK WinEvents(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uiMsg)				// nach Nachrichtentyp unterscheiden
	{
		case WM_KEYDOWN:
		{
			switch(wParam)
			{
				case VK_ESCAPE:
				{					
					DestroyWindow(hWnd);
					break;
				}
			}

		}

	}	// ~switch(uiMsg);

	// wurde kein passender Nachrichtentyp gefunden, Nachricht an Windows weiterleiten
	return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}

Die Definition der Klasse:

class __declspec(dllexport) CEngine
{
public:
			// Der Konstruktor
			CEngine(HINSTANCE hInst, HWND hParentWnd, CParameters params, CNoiseData nData);
			~CEngine(void);		// Der Destruktor	

	void		MainLoop(void);		// Die Hauptschleife der 3D-Anwendung
	inline bool	IsRunning(void)	{ return m_bRunning; }	// Prüft ob die Anwendung noch läuft

protected:
	bool	InitWindow(HWND hParentWnd);	// legt das Fenster der Anwendung an	
	bool	InitD3D(void);		// Initialisiert Direct 3D
	bool	InitScene(void);	// Initialisiert die Szenerie nach TaskSwitch oder Init
	void	ShutDown(void);		// Räumt die Anwendung auf
	bool	Render(void);		// Render das aktuelle Bild

private:
	bool		m_bRunning;		// Gibt an, ob die Anwendung noch läuft

	// Objekte zur Fensterverwaltung
	HINSTANCE	m_hInstance;	// Handle der startenden Instanz
	MSG			m_msgEvent;		// Nachrichten Objekt des Hauptfensters
	HWND		m_hWnd;			// das Fenster Handle	

	// Objekte für Direct 3D
	D3DXMATRIX				m_matProjection;		// Die Projektionsmatrix
	LPDIRECT3D9				m_pD3DObject;			// Das Direct-3D Objekt (Zeiger)
	LPDIRECT3DDEVICE9		m_pD3DDevice;			// Das Direct-3D Geräte-Device (Zeiger)
	D3DPRESENT_PARAMETERS	m_PresentParameters;	// Struktur mit D3D Eigenschaften

};	// ~class CEngine;

// Callback Routine für Windows-Nachrichten
LRESULT CALLBACK WinEvents(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);

Wenn ich nun einfach den Funktionsprototypen in die Klasse verschiebe und als Klassenmethode ansehe, dazu den Namen der Funktion von WinEvents in CEngine::WinEvents ändere und compile kommt folgendes:

error C3867: "CEngine::WinEvents": Dem Funktionsaufruf fehlt die Argumentliste. Verwenden Sie "&CEngine::WinEvents", um einen Zeiger auf den Member zu erstellen.

Wenn ich dann "wndStruct.lpfnWndProc = WinEvents;" durch "wndStruct.lpfnWndProc = &CEngine::WinEvents;" ersetze, so kommt ein neuer Fehler:

error C2440: '=': 'LRESULT (__stdcall CEngine::* )(HWND,UINT,WPARAM,LPARAM)' kann nicht in 'WNDPROC' konvertiert werden

Kann mir da jemand erzählen wie ich das zum laufen bekomme?

http://www.c-plusplus.net/forum/viewtopic-var-t-is-174421.html

#ifndef _CMAINWND_H_
#define _CMAINWND_H_

#include <windows.h>
#include "CWndUnknown.h"

class CMainWnd : public CWndUnknown
{
public:
	CMainWnd();
	~CMainWnd();

private:

	// message processing function:
	virtual LRESULT ProcessWindowMessage(HWND, UINT, WPARAM, LPARAM);
};

#endif

Wichtig ist dabei, dass du die Klasse CWndUnknown davon ableitest und du deine Callback-Funktion so deklarierst.

Die Klasse CWndUnknown sieht so aus:
Header-Datei:

#ifndef _CWNDUNKNOWN_H_
#define _CWNDUNKNOWN_H_

#include <windows.h>

class CWndUnknown
{
public:
	static bool Init(HINSTANCE);

	void* GetUnknownClassPtr();

	static TCHAR* GetUnknownClassName();
	static WNDPROC GetStartWndProc();

protected:
	static LRESULT CALLBACK StartWindowProc(HWND, UINT, WPARAM, LPARAM);

	virtual LRESULT ProcessWindowMessage(HWND, UINT, WPARAM, LPARAM);

};

#endif

C++ - Datei:

#include <windows.h>
#include "CWndUnknown.h"

bool CWndUnknown::Init(HINSTANCE hInst)
{
	WNDCLASSEX wc;
	wc.cbSize		= sizeof(WNDCLASSEX);
    wc.cbClsExtra	= 0;
    wc.cbWndExtra	= 0;
    wc.hbrBackground= (HBRUSH)GetStockObject(BLACK_BRUSH);
    wc.hCursor		= LoadCursor(0, IDC_ARROW);
    wc.hIcon		= 0;
    wc.hIconSm		= 0;
    wc.hInstance	= hInst;
    wc.lpfnWndProc	= GetStartWndProc();
    wc.lpszClassName= GetUnknownClassName();
    wc.lpszMenuName	= 0;
    wc.style		= 0;
    if(!RegisterClassEx(&wc))
        return false;

	return true;
}

LRESULT CALLBACK CWndUnknown::StartWindowProc(HWND hwnd, UINT message,
								WPARAM wParam, LPARAM lParam)
{
	if(message == WM_CREATE)
	{
		SetWindowLongPtr(hwnd, GWLP_USERDATA,
			(LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams));
	}

	CWndUnknown *pUnknown;
	if(pUnknown = (CWndUnknown*)GetWindowLongPtr(hwnd, GWLP_USERDATA))
		return pUnknown->ProcessWindowMessage(hwnd, message, wParam, lParam);
	return DefWindowProc(hwnd, message, wParam, lParam);
}

LRESULT CWndUnknown::ProcessWindowMessage(HWND hwnd, UINT message,
								WPARAM wParam, LPARAM lParam)
{
	return 0;
}

void* CWndUnknown::GetUnknownClassPtr()
{
	return this;
}

WNDPROC CWndUnknown::GetStartWndProc()
{
	return (WNDPROC)&StartWindowProc;
}

TCHAR* CWndUnknown::GetUnknownClassName()
{
	return "DeinKlassenname";
}

Du musst lediglich, bevor du das Fesnter erstellst, die Fensterklasse registrieren mittels CWndUnknown::Init(hInstance);
Sonst brauchst du dich um nichts zu kümmern. CWndUnknown tut nämlich den Pointer auf sich selbst im Userdate-Bereich eines Fensters speichern und bei einer Message diesen auslesen und an ProcessWindowMessage() weiterleiten. Da diese Funktion aber mit virtual deklariert ist, wird dafür die ProcessWindowMessage-Funktion aus CMainWnd benutzt.

[edit]selbstverständlich kannst du auch die Fensterklasse wie gewohnt zum Programmstart deklarieren und die Ini-Anweisung raushauen ... wichtig ist, dass eben die CALLBACK-Funktion bei WNDCLASSEX.lpfnWndProc auf CWndUnknown::GetStartWndProc() gesetzt wird.

MfG

Wollte das was du als Edit geschrieben hast versuchen und die Init weglassen und meine "alte dafür nehmen. Welche der ganzen Methoden von CUnknownWnd brauch ich eigentlich, bzw was machen die genau?

Das Erstellen des Fensters:

bool CEngine::InitWindow(HWND hParentWnd)
{
	WNDCLASSEX	wndStruct;	// Struktur der Fenster-Eigenschaften

	// Eigenschaften des Fensters festlegen
	wndStruct.hInstance		= m_hInstance;				// Die erstellende Instanz (Prozess)
	wndStruct.lpszClassName = "Klassenname";		// Das ist nicht der Name (Titel) sondern der Klassenname!!!
	wndStruct.lpfnWndProc	= GetStartWndProc()			// Callback Routine für Ereignisse !!!
	wndStruct.style			= CS_HREDRAW | CS_VREDRAW;			// Fensterart 
	wndStruct.cbSize		= sizeof(WNDCLASSEX);				// Größe in Bytes    
	wndStruct.hIcon			= LoadIcon(NULL, IDI_APPLICATION);	// Standard-Icon nutzen
	wndStruct.hIconSm		= LoadIcon(NULL, IDI_APPLICATION);	// kleines Icon = Standard
	wndStruct.hCursor		= LoadCursor(NULL, IDC_ARROW);		// normaler Mauszeiger
	wndStruct.lpszMenuName	= NULL;								// kein Menü vorhanden
	wndStruct.cbClsExtra	= 0;								// keinerlei Extras
	wndStruct.cbWndExtra	= 0;
    wndStruct.hbrBackground = (HBRUSH)COLOR_BACKGROUND;	// Hintergrundfarbe = Standard

	// Versuche die Fenster-Klasse anzumelden, ansonsten Fehler zurückgeben
	if (!RegisterClassEx(&wndStruct))
	{
		ERRORMSG("Fenster-Klasse konnte nicht registriert werden!","InitWindow();");
		return false;
	}

	// das Hauptfenster wird erzeugt
	m_hWnd = CreateWindowEx(0, "Test", "Test", WS_OVERLAPPEDWINDOW,
							200, 100, m_Config.GetScreenWidth(), m_Config.GetScreenHeight(), 
							hParentWnd, NULL, m_hInstance, GetUnknownClassPtr()); // !!!!

	ShowWindow(m_hWnd, SW_SHOW);

	return true;
}	// ~CEngine::InitWindow();

Diese musst du so umbenennen:
Die Callback Routine:

LRESULT CEngine::ProcessWindowMessage(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uiMsg)				// nach Nachrichtentyp unterscheiden
	{
		case WM_KEYDOWN:
		{
			switch(wParam)
			{
				case VK_ESCAPE:
				{					
					DestroyWindow(hWnd);
					break;
				}
			}

		}

	}	// ~switch(uiMsg);

	// wurde kein passender Nachrichtentyp gefunden, Nachricht an Windows weiterleiten
	return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}

Die Definition der Klasse:
#include "CWndUnknown.h"

class __declspec(dllexport) CEngine : public CWndUnknown // !!!
{
public:
			// Der Konstruktor
			CEngine(HINSTANCE hInst, HWND hParentWnd, CParameters params, CNoiseData nData);
			~CEngine(void);		// Der Destruktor	

	void		MainLoop(void);		// Die Hauptschleife der 3D-Anwendung
	inline bool	IsRunning(void)	{ return m_bRunning; }	// Prüft ob die Anwendung noch läuft

protected:
	bool	InitWindow(HWND hParentWnd);	// legt das Fenster der Anwendung an	
	bool	InitD3D(void);		// Initialisiert Direct 3D
	bool	InitScene(void);	// Initialisiert die Szenerie nach TaskSwitch oder Init
	void	ShutDown(void);		// Räumt die Anwendung auf
	bool	Render(void);		// Render das aktuelle Bild

private:
	bool		m_bRunning;		// Gibt an, ob die Anwendung noch läuft

	// Objekte zur Fensterverwaltung
	HINSTANCE	m_hInstance;	// Handle der startenden Instanz
	MSG			m_msgEvent;		// Nachrichten Objekt des Hauptfensters
	HWND		m_hWnd;			// das Fenster Handle	

	// Objekte für Direct 3D
	D3DXMATRIX				m_matProjection;		// Die Projektionsmatrix
	LPDIRECT3D9				m_pD3DObject;			// Das Direct-3D Objekt (Zeiger)
	LPDIRECT3DDEVICE9		m_pD3DDevice;			// Das Direct-3D Geräte-Device (Zeiger)
	D3DPRESENT_PARAMETERS	m_PresentParameters;	// Struktur mit D3D Eigenschaften
// Callback Routine für Windows-Nachrichten
virtual LRESULT ProcessWindowMessage(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam); // !!!!!

};	// ~class CEngine;

'ProcWndMsg': Ist kein Element von 'CWndEvents'

Wenn ich diese Methode mit als Mitglied von der Unknown Klasse mache geht es, allerdings kann ich dann nicht von dieser auf die Variablen von CEngine zugreifen.

Das Grundproblem liegt darin, das die abgeleitete Fensterklasse die Methode der Basisklasse nicht kennt. (bzw andersrum)

Ich hab die Namen der Methoden einfach etwas geändert. Bei dir hieß sie ProcessWindowMessage()

omg - und wie soll ich mit dieser information was anfangen können???
versetz dich doch in meine situation - glaubst du mit deiner aussage kann ich dir irgendwie helfen, wenn du irgendwelche namen irgendwo änderst und es dann nicht mehr funktioniert?
Specke dienen Code aufs WESENTLICHE ab und poste ihn hier nochmal

Toll jetzt editierst du - es gibt auch ein Vorschau-Button .
Wenn du ProcessWindowMessage() in CEngine änderst musst du das natürlich auch in CWndUnkonwn ändern, hatte ich oben geschrieben: "in deiner klasse musst du CWndUnknown ableiten ( : CWndUnknown), die Callback-funktion als virtual deklarieren und ProcessWindowMessage benennen". Aber wenn du dich nicht daran halten willst, dann kann ich dir auch nicht helfen, verarschen lassen tun wir uns hier nicht.

Natürlich hab ich die Namen an allen entsprechenden Stellen geändert. Nur weil ich andere Methoden-und Klassennamen benutze muss es ja nicht falsch sein. Was bei dir CWndUnknown ist, ist bei mir CWndEvents. Der Rest sind eigentlich nur Abkürzungen. Ich zeig einfach mal die Auszüge wie es jetz bei mir aussieht.

Die Klasse CEngine

class __declspec(dllexport) CEngine : public CWndEvents
{
public:
			// Der Konstruktor
			CEngine(HINSTANCE hInst, HWND hParentWnd, CParameters params, CNoiseData nData);
			~CEngine(void);		// Der Destruktor	

	void		MainLoop(void);		// Die Hauptschleife der 3D-Anwendung
	inline bool	IsRunning(void)	{ return m_bRunning; }	// Prüft ob die Anwendung noch läuft

protected:
	bool	InitWindow(HWND hParentWnd);	// legt das Fenster der Anwendung an	
	bool	InitD3D(void);		// Initialisiert Direct 3D
	bool	InitScene(void);	// Initialisiert die Szenerie nach TaskSwitch oder Init
	void	ShutDown(void);		// Räumt die Anwendung auf
	bool	Render(void);		// Render das aktuelle Bild

private:
	bool		m_bRunning;		// Gibt an, ob die Anwendung noch läuft

	// Objekte zur Fensterverwaltung
	HINSTANCE	m_hInstance;	// Handle der startenden Instanz
	MSG			m_msgEvent;		// Nachrichten Objekt des Hauptfensters
	HWND		m_hWnd;			// das Fenster Handle	

	// Objekte für Direct 3D
	D3DXMATRIX				m_matProjection;		// Die Projektionsmatrix
	LPDIRECT3D9				m_pD3DObject;			// Das Direct-3D Objekt (Zeiger)
	LPDIRECT3DDEVICE9		m_pD3DDevice;			// Das Direct-3D Geräte-Device (Zeiger)
	D3DPRESENT_PARAMETERS	m_PresentParameters;	// Struktur mit D3D Eigenschaften

	// Methode zum Auswerten und Weiterleiten der Nachrichten
	virtual LRESULT ProcWndMsg(HWND, UINT, WPARAM, LPARAM);

};	// ~class CEngine;

CEngine::InitWindow

bool CEngine::InitWindow(HWND hParentWnd)
{
	WNDCLASSEX	wndStruct;	// Struktur der Fenster-Eigenschaften

	// Eigenschaften des Fensters festlegen
	wndStruct.hInstance		= m_hInstance;				// Die erstellende Instanz (Prozess)
	wndStruct.lpszClassName = "Test";		// Name der Fensterklasse
	wndStruct.lpfnWndProc	= GetStartWndProc();		// Callback Routine für Ereignisse
	wndStruct.style			= CS_HREDRAW | CS_VREDRAW;			// Fensterart 
	wndStruct.cbSize		= sizeof(WNDCLASSEX);				// Größe in Bytes    
	wndStruct.hIcon			= LoadIcon(NULL, IDI_APPLICATION);	// Standard-Icon nutzen
	wndStruct.hIconSm		= LoadIcon(NULL, IDI_APPLICATION);	// kleines Icon = Standard
	wndStruct.hCursor		= LoadCursor(NULL, IDC_ARROW);		// normaler Mauszeiger
	wndStruct.lpszMenuName	= NULL;								// kein Menü vorhanden
	wndStruct.cbClsExtra	= 0;								// keinerlei Extras
	wndStruct.cbWndExtra	= 0;
    wndStruct.hbrBackground = (HBRUSH)COLOR_BACKGROUND;	// Hintergrundfarbe = Standard

	// Versuche die Fenster-Klasse anzumelden, ansonsten Fehler zurückgeben
	if (!RegisterClassEx(&wndStruct))
	{
		ERRORMSG("Fenster-Klasse konnte nicht registriert werden!","InitWindow();");
		return false;
	}

	// das Hauptfenster wird erzeugt
	m_hWnd = CreateWindowEx(0, "Test", "Test", WS_OVERLAPPEDWINDOW,
							200, 100, m_Config.GetScreenWidth(), m_Config.GetScreenHeight(), 
							hParentWnd, NULL, m_hInstance, GetEventClassPtr());

	ShowWindow(m_hWnd, SW_SHOW);

	return true;
}	// ~CEngine::InitWindow();

CEngine::ProcWndMsg

LRESULT CEngine::ProcWndMsg(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam) 
{ 
    switch(uiMsg)				// nach Nachrichtentyp unterscheiden
	{
		case WM_KEYDOWN:
		{
			switch(wParam)
			{
				case VK_ESCAPE:
				{					
					m_bRunning = false;
					break;
				}
			}

		}

	}	// ~switch(uiMsg);

	// wurde kein passender Nachrichtentyp gefunden, Nachricht an Windows weiterleiten	
	return DefWindowProc(hWnd, uiMsg, wParam, lParam);

}	// ~CWndEvents::ProcWndMsg();

wndevents.h

#include <windows.h> 

class CWndEvents
{ 
public: 

    // Gibt einen Zeiger auf das Objekt zurück
	inline	void* CWndEvents::GetEventClassPtr() { return this; }

	// Gibt den Ereignis-auslösenden Prozess zurück
	inline	WNDPROC GetStartWndProc() { return (WNDPROC)&StartWndProc; }

protected: 
	// Die eigentliche Callback-Routine
    static	LRESULT CALLBACK StartWndProc(HWND, UINT, WPARAM, LPARAM);     

};

wndevents.cpp

#include <windows.h> 
#include "wndevents.h" 

LRESULT CALLBACK CWndEvents::StartWndProc(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam) 
{ 
	// Wird das Fenster angelegt, Pointer auf das Fenster merken
	if(uiMsg == WM_CREATE) 
	{ 
		SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)(((LPCREATESTRUCT)lParam)->lpCreateParams)); 
	} 

	// Pointer abfragen und Ergebnis weiterleiten
	CWndEvents *pWnd; 
	if(pWnd = (CWndEvents*)GetWindowLongPtr(hWnd, GWLP_USERDATA)) 
		return pWnd->ProcWndMsg(hWnd, uiMsg, wParam, lParam); 

	// Falls keine spezielle Behandlung, an Windows-Standard weiterleiten
	return DefWindowProc(hWnd, uiMsg, wParam, lParam); 

}	// ~CALLBACK CWndEvents::StartWndProc();

Ich habe bereits deine Variante ausprobiert und sie funktionierte (was ich auch bereits weiter oben beschrieben hatte). Nur wollte ich halt eine Variante wo ich direkt von CEngine auf die Routine zugreifen kann und nicht von der abgeleiteten Klasse. Aus diesem Grund habe ich diese auch nach CEngine verlegt, sonst wäre sie ja doppelt deklariert.

Entschuldige mal, du musst ja nicht gleich beleiddigend werden.

Gleich?

Der Code ist bereits stark abgespeckt.

lange nicht auf WESENTLICHE

In andern Sektionen dieses Forums hiess es eher das man mal etwas mehr zeigen soll um Zusammenhänge sehen zu können.

am besten du postest noch dein ganzes Projekt mit resource files, compiler-spezifische header files etc um die Zusammenhänge zu zeigen .

Ich habe bereits deine Variante ausprobiert und sie funktionierte (was ich auch bereits weiter oben beschrieben hatte).

wo?

Nur wollte ich halt eine Variante wo ich direkt von CEngine auf die Routine zugreifen kann und nicht von der abgeleiteten Klasse. Aus diesem Grund habe ich diese auch nach CEngine verlegt, sonst wäre sie ja doppelt deklariert.

wie ich bereits sagte: lerne erst die basics und komm dann wieder. Informier dich am besten auch über das Wort "virtual". Dann wirst du sehen dass du schwachfug postest.

kokunze schrieb:

also hab das versucht, allerdings meldet er jetzt immer:

'ProcWndMsg': Ist kein Element von 'CWndEvents'

Wenn ich diese Methode mit als Mitglied von der Unknown Klasse mache geht es, allerdings kann ich dann nicht von dieser auf die Variablen von CEngine zugreifen.

ich wollte lediglich ein wenig Hilfe wie ich das ganze so umschreiben kann, das ich von CEngine darauf zugreifen kann. Was du jetzt hier für Hasstiraden loslässt ist mir schleierhaft. Ich dachte das ist ein Forum zum gegenseitigen Helfen und nicht im sich zuzuflamen.

LRESULT CEngine::ProcessWindowMessage(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
    switch(uiMsg)                // nach Nachrichtentyp unterscheiden
    {
        case WM_KEYDOWN:
        {
            switch(wParam)
            {
                case VK_ESCAPE:
                {                   
                    DestroyWindow(hWnd);
                    break;
                }
            }

        }

    }    // ~switch(uiMsg);

    // wurde kein passender Nachrichtentyp gefunden, Nachricht an Windows weiterleiten
    return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}

kannst du mir jetzt mal bitte erklären warum du nicht von CEngine auf .... was auch immer zugreifen kannst?????

"Wenn ich diese Methode mit als Mitglied von der Unknown Klasse mache geht es, allerdings ..."

Ich hab es inzwischen hinbekommen durch überschreiben der Methode in der abgeleiteten Klasse. Problem ist allerdings das ich nun das Hauptprogramm nicht mehr kompilieren kann, weil besagtes ja in einer Klasse einer DLL war. Muss das nun also erstmal irgendwie umschreiben das der Starter weiß, das er die abgeleitete Klasse zum initialisieren aufrufen muss. Aber das ist ein anderer Schuh...

mit "hier" war gemeint das ich da bereits geschrieben hab, das es in besagter Variante läuft.

"Wenn ich diese Methode mit als Mitglied von der Unknown Klasse mache geht es, allerdings ..."

warum lässt du das allerdings weg?
"Wenn ich diese Methode mit als Mitglied von der Unknown Klasse mache geht es, allerdings kann ich dann nicht von dieser auf die Variablen von CEngine zugreifen."
Genau das ist schlicht und einfach falsch, weshalb man daraus nicht ableiten kann das es geht. Vielmehr suggerierst du damit dass man es compilen kann (das heißt noch lange nicht dass es klappt), was du damit bekräftigst, dass du zuvor den compiler error aufführst, wenn du das nicht so machst.
Nochmal: du kannst, wenn du es machst so wie ich es sage, auf Membervariablen und Memberfunktionen deiner Klasse zugreifen. Und wenn du das gegenteilige behauptest, scheint es doch nicht zu gehen, oder?

Ich hab es inzwischen hinbekommen durch überschreiben der Methode in der abgeleiteten Klasse.

was hast du nun im vergleich zu meinem code geändert? der funktioniert würdest du nicht alles ändern wollen ohne zu wissen was du da tust.

Problem ist allerdings das ich nun das Hauptprogramm nicht mehr kompilieren kann, weil besagtes ja in einer Klasse einer DLL war. Muss das nun also erstmal irgendwie umschreiben das der Starter weiß, das er die abgeleitete Klasse zum initialisieren aufrufen muss. Aber das ist ein anderer Schuh...

für mich redest du wirres zeugs.

Alles beim alten wie ganz am Anfang der hreaderstellung und dann einfach die Methode static deklarieren und schon gibts keine Probleme mehr.

Alles beim alten wie ganz am Anfang der hreaderstellung und dann einfach die Methode static deklarieren und schon gibts keine Probleme mehr.

Aber wie greifst Du dann auf die Membervariablen zu ? Das geht doch innerhalb einer statischen Methode nicht ?!?

Allerdings bekomm ich nun immer nen Linkerfehler:

error LNK2001: Nicht aufgelöstes externes Symbol ""private: static bool CEngine::m_bRunning" (?m_bRunning@CEngine@@0_NA)

Die Klasse:

class __declspec(dllexport) CEngine
{
public:
...

private:

	// Callback Routine für Windows-Nachrichten
	static LRESULT CALLBACK WinEvents(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam);

	static bool		m_bRunning;		// Gibt an, ob die Anwendung noch läuft

...

};	// ~class CEngine;

Die Methode:

LRESULT CALLBACK CEngine::WinEvents(HWND hWnd, UINT uiMsg, WPARAM wParam, LPARAM lParam)
{
	switch(uiMsg)				// nach Nachrichtentyp unterscheiden
	{

 ...

		case WM_DESTROY:
		{
			m_bRunning = false;
			break;
		}

	}	// ~switch(uiMsg);

	// wurde kein passender Nachrichtentyp gefunden, Nachricht an Windows weiterleiten	
	return DefWindowProc(hWnd, uiMsg, wParam, lParam);
}