Mit dynamisch und statisch kann man es schon so sagen, trifft aber bei dir nur auf Objekte zu, einfacher wäre es sich so zu merken: (ok, schlecht ausgedrückt, will sagen, es geht nicht nur bei dynamischen Objekten sondern auch bei Strukturen usw...)
"->" ist ein Zeiger auf etwas.
Wenn also object.struktur->feld1 steht, dann ist in der Klasse keine wirkliche Struktur vorhanden sondern nur ein Pointer "Struktur" der auf eine Struktur zeigt, wir sprechen aber die Variable feld1 an. (Dadurch der Pfeil).
Der Punkt (.) kommt in allen anderen Fällen zum Einsatz, wenn man direkt eine Variable hat und keinen Pointer.
übrigens gibts dann auch noch den this pointer der immer auf das eigene Objekt zeigt. Daher wird man manchmal "this->" finden, wenn man das eigene Objekt ansprechen möchte, anstatt nur die Variablennamen des objekts zu nennen. Auch hier der Pfeil, weil auf Variablen zurückgegriffen werden sollen, die im Speicher durch einen Pointer gezeigt werden. (In diesem Fall pointet er auf unser Objekt)
So sieht dann meine Fensterklasse aus:
Code: Alles auswählen
class ctrl_window
{
private: MSG msg;
WNDCLASS wndclass;
HINSTANCE instance;
HGLRC hrc;
PAINTSTRUCT ps;
SCROLLINFO scrollinfo_VERT; //For Scrollbar Information
SCROLLINFO scrollinfo_HORZ; //For Scrollbar Information
char* classname; //important for tabcontrol
protected: HWND hwnd;
HWND hwnd_toolbar;
HWND parent;
HDC hdc;
HMENU h_menubar;
int pos_x;
int pos_y;
int size_x;
int size_y;
public: int create(HINSTANCE hinstance, MSG p_msg, WNDPROC wndproc, int pos_x, int pos_y, int size_x, int size_y, char* caption, HWND parent, int ex_style, int flags = WS_CAPTION | WS_OVERLAPPED | WS_SYSMENU );
void set_text( char* text ) { SetWindowText(hwnd, text);}
char* get_text( void );
void destroy(bool flag);
void enable( bool status) {EnableWindow(hwnd, status);}
void show( int status ) {ShowWindow(hwnd, status);}
MSG get_msg( void ) {return msg;}
bool get_message(HWND p_hwnd) {GetMessage(&msg,p_hwnd,0,0);}
bool translate_message( void ) {TranslateMessage(&msg);}
LRESULT dispatch_message( void ) {return DispatchMessage(&msg);}
void invalidate_window( int flags = RDW_NOCHILDREN | RDW_INVALIDATE);
//OpenGL
bool create_gl_rc( int size_x, int size_y, int typ);
void resize_gl_rc( int size_x, int size_y, int typ);
void delete_gl_rc( void );
HGLRC get_hrc( void ) {return hrc;}
//Scrollbar
void sb_create(int typ, int min, int max, int pos);
void sb_set_scrollrange(int typ, int min, int max);
void sb_set_pos(int typ, int param);
void sb_update( WPARAM wParam, LPARAM lParam, int direction );
void sb_get_scrollinfo(int typ, SCROLLINFO& scrollstruct);
int sb_get_scrollrange(int typ, bool flag);
int sb_get_pos(int typ);
//Toolbar
bool tb_create( int style );
bool tb_add_button(int command, char* bitmap_filename, int style = TBSTYLE_BUTTON);
bool tb_add_std_button(int command, int std_ID, int style = TBSTYLE_BUTTON);
void tb_delete_button(int command);
void tb_enable_button(int command, bool status);
bool tb_add_separator( void );
int tb_get_button_state( int command );
void tb_set_button_state( int command, int state);
HWND get_hwnd_toolbar() {return hwnd_toolbar;}
void begin_paint( void );
void end_paint( void );
int get_size_x( void );
int get_size_y( void );
void set_size( int size_x, int size_y);
void set_hdc( HDC p_hdc ) {hdc = p_hdc;}
HWND get_hwnd() {return hwnd;}
HINSTANCE get_instance() {return (HINSTANCE) wndclass.hInstance;}
HDC get_hdc( void ) {return hdc;}
char* get_classname( void ) {return classname;}
PAINTSTRUCT get_paintstruct ( void ) {return ps;}
};
(Die Fensterklasse ist in ständiger änderung oder überarbeitung und kein Endprodukt)
Wie man sieht, werden auch Dinge wie das Fensterhandle intern weggespeichert. Das kann man mit Methoden wie window.get_hwnd() bekommen. Außerdem kann man mit einfachen Methoden einen OpenGL-Rendercontext erzeugen. Ebenso kann man so Toolbars und Scrollleisten hinzufügen.
Von dieser Klasse werden alle meine Buttons abgeleitet, auch wenn es meist nicht sinnvoll wäre, ich weiß...
ömm, aber so ne frage:
wiso machst du das "schwierig", wenns auch "einfach" geht?
ich würde jetzt keine fenster mittels der api create window öffnen, aber warum machst du das?
hat das einen vorteil?
Der Vorteil ist, dass es objektorientiert ist und demnach leichter zu handhaben. Wo Purebasic sowas schreibt:
Code: Alles auswählen
SelectElement(liste(), element)
schreibe ich:
liste.select_element(element);
Es besteht also schon im Befehl die direkte Verknüpfung zum Objekt, zur Liste in diesem Fall. Nicht ein Befehl wo man die Liste einsetzt, sondern jede Liste hat diesen Befehl den man in Verbindung mit ihr nur aufrufen muss.
Anderes Beispiel:
Man hat ein Fenster "mainwindow" und möchte dazu Scrollleisten erstellen: Bei mir so möglich:
Code: Alles auswählen
mainwindow.sb_create(SB_HORZ, 0, 100, 0);
mainwindow.sb_create(SB_VERT, 0, 100, 0);
Damit werden dem Mainwindow-Fenster 2 Scrollleisten hinzugefügt welche von 0 - 100 bei Position 0 starten. (Siehe wieder die direkte Verknüpfung des Fensters schon im Namen vor dem Punkt).
Ein weiterer Punkt, warum ich das so mache ist, dass es nicht anders geht.^^ C++ bietet keine Befehle für GUI-Anwendungen, man muss sich seine Fenster selbst basteln, etwa aus der WinAPI. Daher habe ich die wichtigsten Funktionen zum Erstellen von Fenstern in Klassen gelegt und kann so nun einfach darauf zugreifen.
