ich hab mal angefangen die funktionen zur erstellung eines winapi fensters zu kapseln. ich weiß hier aber hint und vorn nicht, was ich dafür wohin packen muss
ich hab einfach mal angefangen. (die FAQ und Suche hab ich schon durchsucht, half mir aber net) hier mein code:
(winapi.cpp, habe den code zum testen nur in eine datei gemacht.)

#include <windows.h>

LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam);

class Window
{
	private:
		HWND hWnd;
	  PAINTSTRUCT ps;
		HDC hdc;
		MSG msg;
	public:
		LPCSTR szAppName;
		Window();
	  ~Window();
		void Initialize(HINSTANCE hInstance,int iCmdShow);
	  int Loop();
};

Window::Window()
{
	szAppName="Winapitest";
}

Window::~Window()
{
}

void Window::Initialize(HINSTANCE hInstance,int iCmdShow)
{
	Window *win;
	WNDCLASS wc;

  wc.style=CS_HREDRAW|CS_VREDRAW;
  wc.lpfnWndProc=WndProc;
  wc.cbClsExtra=0;
  wc.cbWndExtra=0;
  wc.hInstance=hInstance;
  wc.hCursor=LoadCursor(NULL,IDC_ARROW);
  wc.hIcon=0;
  wc.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH);
  wc.lpszClassName=szAppName;
  wc.lpszMenuName=0;

  RegisterClass(&wc);  // Fensterklasse Registrieren

	hWnd=CreateWindow(szAppName,  // Fenstername
                    "Wrapper",
                    WS_OVERLAPPEDWINDOW,
                    CW_USEDEFAULT,          /* X-Position auf dem Monitor */
                    CW_USEDEFAULT,          /* Y-Position auf dem Monitor */
                    800,          /* Fensterbreite              */
                    550,          /* Fensterhoehe               */
                    NULL,
                    NULL,
                    hInstance,
                    NULL);

  ShowWindow(hWnd,iCmdShow);
  UpdateWindow(hWnd);
	win->Loop();
}

int Window::Loop()
{
	while(GetMessage(&msg,NULL,0,0))
	{
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return msg.wParam;
}

LRESULT CALLBACK WndProc(HWND hWnd,UINT msg,WPARAM wParam,LPARAM lParam)
{
	switch(msg)
	{
		case WM_CREATE:
			MessageBox(hWnd,"test","test",MB_OK+MB_ICONINFORMATION);
			break;
	  case WM_CLOSE:
			break;
		case WM_PAINT:
			break;
	}

	return DefWindowProc(hWnd,msg,wParam,lParam);
}

test.cpp:

#include <windows.h>
#include "winapi.cpp"

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR szCmdLine,int iCmdShow)
{
	Window *win;

	win->Initialize(hInstance,iCmdShow);
	return win->Loop();
}

kompilier aufruf: g++ -s test.cpp -mwindows -o test.exe
..
kompiler bringt keine fehler und bei programmstart gibts einen fehler in anweisung "read" (addresen: 0x00401368 verweist auf 0x00000063)

hoffe ihr könnt mir helfen

Window *win;
win->Initialize(hInstance,iCmdShow);

Vielleicht solltest du einen Gang zurückschalten, und dich mit den Grundlagen von C bzw. C++ befassen, zumindest bis du diese Frage beantworten kannst:

Worauf zeigt win?

P.S.: Klassen hast du auch noch nicht richtig verstanden. Weißt du, was this ist?

Worauf zeigt win?

Auf: 0x00000063

kennst du new, aber dazu auch delete?

Ich glaub ich werd in Kürze mal ein Mini-Tutorial mit Beispiel schreiben für sowas.

Blackhawk schrieb:

Window *win;
win->Initialize(hInstance,iCmdShow);

P.S.: Klassen hast du auch noch nicht richtig verstanden. Weißt du, was this ist?

nein, ich weiß nich was this ist.....
omg ich bin doch nicht blöd

und die grundlagen kann ich auch

@MichaM.: ja, kenn ich, aber wie soll ich denn deleten wenn ich damit returne (scheiß frage aber find die antwort einfach nicht)

und flame brauch ich auch nicht. kannst mir erstmal deinen code zeigen...

@sinnlos: der sinn ist, dass ich nicht jedesmal den winapi kack schreiben muss...

dann weiß ich ja bescheid
flamer

nein, ich weiß nich was this ist.....
...
und die grundlagen kann ich auch

Das widerspricht sich. Aber wenn du die Grundlagen verstanden hast, kannst du die Frage ja beantworten: Wohin zeigt dein Zeiger win?

und außerdem war ich wirklich dumm.. warum ein zeiger wenn auch Window win geht..
geht jetzt übrigens.
nochmal danke an alle flamer ;P und an MFK und MichaM.

naja win zeigt auf Window ^^

Du hast keine Ahnung. Das ist kein "Flame", sondern schlicht und einfach die Wahrheit. Ich rate dir, dich mit Grundlagen zu befassen.

und außerdem war ich wirklich dumm.. warum ein zeiger wenn auch Window win geht..
geht jetzt übrigens.

Nicht, dass du erklären könntest, wieso es jetzt geht, und wieso es vorher nicht ging.

nochmal danke an alle flamer ;P und an MFK und MichaM.

Gern geschehen. Weitere Hilfe hast du von mir jedenfalls nicht zu erwarten. Dafür ist mir meine Zeit zu schade.

@flamer: tschuldigung, bist kein flamer

ich bin doch aufm Stack (Window win)??

so ja. aber in deinem obrigen bsp wolltest du einen pointer verwenden (der noch nicht allokiert worden war) und wenn du ihn erstellt hättest wäre das auf dem heap gewesen. deswegen die frage

Ich würde zu gern den jetzigen Code sehen, du auch miller_m?

jep.
wann reg'st du dich? bzw. warum nicht?

wann reg'st du dich? bzw. warum nicht?

Ich bin auch reg. (MiC++ha), aber ich habe Hausverbot
Quatsch, ich arbeite gerade an ein bestimmtes Projekt wo es um Cookies, Sessions, Sicherheit etc. geht. Ich müßte mich praktisch für jedes Posting einloggen, das wäre lästig.

ich arbeite gerade an ein bestimmtes Projekt wo es um Cookies, Sessions, Sicherheit etc. geht. Ich müßte mich praktisch für jedes Posting einloggen, das wäre lästig.

stimmt wär mir auch zuwider.

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

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,LPSTR szCmdLine,int iCmdShow)
{
	Window win;

	win.szAppTitle="Ein Test :P";
	win.Initialize(hInstance,iCmdShow);
	return win.Loop();
}

wenn man das so wie es ist mit -mwindows und wrapper.cpp mitlinkt dann gehts.
(ich hab jetzt die klasse & deklaration getrennt, wie sichs gehört^^)
wolltet ihr den wrapper haben?

hier mal die .h

#include <windows.h>

class Window
{
  private:
	HWND hWnd;
	PAINTSTRUCT ps;
	HDC hdc;
	MSG msg;
  public:
	LPCSTR szAppName;
	LPCSTR szAppTitle;
	Window();
	~Window();
	void Initialize(HINSTANCE hInstance,int iCmdShow);
	int Loop();
};

wolltet ihr den wrapper haben?

Willst du den haben:
(Ich sagte ja ich mach mal ein Tut.)

/******************************************************************/
/**                                                              **/
/**             WinAPI - Windows/Controls Wrapper Vorlage        **/
/**             File: wrapper.h                                  **/
/**             Designed für Blackhawk                           **/
/**                                                              **/
/******************************************************************/

#ifndef WRAPPER_H
#define WRAPPER_H

#include <windows.h>

/******************************************************************/
/**         Alle Klassen etc. steht ein kleines 'w' vor.         **/
/******************************************************************/

/*:::::: Als erstes machen wir unsere Basis Klasse dem Compiler bekannt */
class wBasisControl;

/*:::::: Wir brauchen paar Konstanten um zu sehen welcher Controltype gefragt ist */
const int wMasterWindow    = 1;
const int wOwnerWindow     = 2;
const int wChildWindow     = 3;
const int wStandardControl = 4;

/*:::::: Nun werden wir einige Typen definieren um Funktionszeiger zu speichern für die Events */
typedef void (*wMouseEvent)(wBasisControl*, int, int, WPARAM);     /* void(Object,X,Y,Key_Flags) */
typedef void (*wKeyEvent)  (wBasisControl*, int, LPARAM);          /* void(Object,Virtual_Key,Key_Data) */
typedef void (*wEvent)     (wBasisControl*);                       /* void(Object) für Events ohne Parameter */
typedef void (*wProcEvent) (wBasisControl*, UINT, LPARAM, WPARAM); /* für sonstige Events mit Parameter */

/*:::::: DIE STATIC GLOBALE WndProc für alle Klassen, hier declardiert */
static LRESULT CALLBACK wBasisWndProc (HWND, UINT, WPARAM, LPARAM);

/*:::::: Um einen besseren Überblick zu erhalten, stecken wir die Getter und Setter Funktionen in Klassen */
/*:::::: Die Getter Klasse "->Get->Funktion" */
class wGetter {
	private:
		wBasisControl* obj;        /* hier einen Zeiger für die Controlklasse */
	public:
		wGetter(wBasisControl*);
		~wGetter() {}
		LPCSTR     Caption();
		int 	   Width();
		int 	   Height();
		int 	   Top();
		int        Left();
		long 	   Style();
		long 	   StyleEx();
		/* weitere könnt ihr dann ergänzen, bzw. in abgeleiteten Klassen ergänzen für diverse Controls */
};
/*:::::: Nun folgt der entsp. Setter, auch diesen dann Ergänzen */
class wSetter {
	private:
		wBasisControl* obj;     /* wieder der Zeiger zur Controlklasse */
	public:
		wSetter(wBasisControl*);
		~wSetter() {}
		void       Caption(LPCSTR);
		void	   Width(int);
		void	   Height(int);
		void	   Top(int);
		void	   Left(int);
		void	   Style(long);
		void	   StyleEx(long);
};

/*:::::: Jetzt gehts rund, es folgt die BasisKlasse: */
class wBasisControl {
	protected:
		int 	   ClassType;
		HWND   	   Handle;
		HWND	   Parent;
		HINSTANCE  HInstance;
		long	   UserData;
		WNDPROC    DefaultWndProc;
		/* Hier wird sicher noch was folgen, wenn ihr es erweitert */
	public:
		wBasisControl();
		wGetter*     Get;
		wSetter*     Set;
		HWND 	     GET_Handle();
		HWND	     GET_Parent();
		HINSTANCE    GET_Instance();
		long	     GET_UserData();
		void	     SET_UserData(long);
		int          GET_ClassType();
		WNDPROC      GET_DefaultWndProc();
		virtual      ~wBasisControl();
		wMouseEvent  OnMouseMove;
		wMouseEvent  OnMouseDown;
		wMouseEvent  OnMouseUp;
		wMouseEvent  OnDoubleClick;
		wKeyEvent    OnKeyDown;
		wKeyEvent    OnKeyUp;
		wProcEvent   OnMessage;
		wEvent	     OnCreate;
		/* Nah, hier werdet ihr sicherlich noch einiges rein pusten, aber dann auch Basisproc erweitern */
};

/*:::::: Soooo, nun kommt unser erstes Control, das Window ;-) */
class wWindow : public wBasisControl {
	private:
		bool   isWindow;
		/* somethink */
	public:
		HWND   FastWindowCreate(HINSTANCE, HWND, int, int, LPCSTR, int); /* Hinst.,ParentHandle, width, height, titel,classtype */
		~wWindow();
		/* Hier könnt ihr euch dann austoben */
};

class wButton : public wBasisControl {
	private:
		bool   isButton;
	public:
		HWND   InitButton(HWND, int, int, int, int, LPCSTR); /* Handle,left,top,width,height,Caption */
		~wButton();
}; 

/****************************************************************************/
/** So, nun könnt ihr euch austoben und fleisig Controls in Klassen packen **/
/****************************************************************************/

#endif

Bin mit dem Tut. aber noch nicht fertig, muß ja auch noch was anderes machen
die cpp datei dazu ist aber fertig und funktionstüchtig, muß nur noch alles Überarbeitet werden.

häkchen an automatisch einloggen ?!

Was meinst du damit?

Ist das ein "Tutorial" dafür wie man schlechte Wrapper schreibt?

Ja, genau, gut eraten (erkannt ehr weniger)