wieder einmal wrappen...("read" fehler ohne kompiliermeldungen)

[*omg*]

ganz schlecht gekapselt

[MichaM.]

MFK schrieb:

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.

[sinnlos]

Mit new und delete würde es vielleicht laufen, aber es gibt trotzdem keinen Sinn dieses Objekt auf dem Heap anzulegen.

[Blackhawk]

MFK schrieb:

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...

[ja!]

Du hast *nichts* verstanden.

[Blackhawk]

alles klar :p

dann weiß ich ja bescheid
flamer

[MFK]

Blackhawk schrieb:

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?

[ja!]

ich bin kein flamer. aber du bist ein progger.

[Blackhawk]

naja win zeigt auf Window ^^

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.

[MFK]

Blackhawk schrieb:

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.

[Blackhawk]

win zeigt in die pampa.. sozusagen
ich werd mich mal intensiver mit den grundlagen befassen...
also denke ich, dass es nicht ging, weil win ja in die pampa gezeigt hat und deshalb die funktionen nicht gefunden wurden. ich hätte mit new erstellen sollen.
ist das jetz richtig so??

@flamer: tschuldigung, bist kein flamer

[miller_m]

jetzt bleibt nur noch die frage warum du dein win objekt auf den heap legst?
auf dem stack wäre es besser aufgehoben.

[Blackhawk]

ich bin doch aufm Stack (Window win)??

[miller_m]

Blackhawk schrieb:

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

[MichaM.]

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

[miller_m]

MichaM. schrieb:

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

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

[MichaM.]

miller_m schrieb:

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.

[miller_m]

MichaM. schrieb:

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.

[Blackhawk]

am normalen code vom wrapper hat sich nichts geändert, nur beim aufruf. eben mit dem heap->stack. aber bitte..

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

[MichaM.]

Blackhawk schrieb:

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.