ich habe eine sehr einfache Klasse, die einfach nur die Koordinaten und Größe eines Rechtecks beschreibt, und die Setter und Getter Methoden dazu hat.

class SimpleShape
{
public:
    int GetXPosition();
    int GetYPosition();
    int GetWidth();
    int GetHeight();
    void SetXPosition(int xposition);
    void SetYPosition(int yposition);
    void SetWidth(int width);
    void SetHeight(int height);
    SimpleShape(int sx,int sy);
    ~SimpleShape();
private:
    int itsXPosition;
    int itsYPosition;
    int itsWidth;
    int itsHeight;
};

SimpleShape::SimpleShape(int sx,int sy)
{
    itsXPosition=sx;
    itsYPosition=sy;
    itsWidth=200;
    itsHeight=50;
}

SimpleShape::~SimpleShape()
{
}

int SimpleShape::GetXPosition()
{
    return itsXPosition;
}

int SimpleShape::GetYPosition()
{
    return itsYPosition;
}

int SimpleShape::GetWidth()
{
    return itsWidth;
}

int SimpleShape::GetHeight()
{
    return itsHeight;
}

void SimpleShape::SetXPosition(int xposition)
{
    itsXPosition=xposition;
}

void SimpleShape::SetYPosition(int yposition)
{
    itsYPosition=yposition;
}

void SimpleShape::SetWidth(int width)
{
    itsWidth=width;
}

void SimpleShape::SetHeight(int height)
{
    itsHeight=height;
}

Nach der Message WM_PAINT, hohlt sich das Programm die Werte über die Getter Methoden und zeichnet ein Rechteck.
Soweit so gut.
Bei einem Klick in das Fenster soll sich das Rechteck aber um 5 Pixel nach unten bewegen.
Habe also WM_LBUTTONDOWN mit aufgenommen. Aber das Rechteck bewegt sich kein stück.
Ich hab ja das Gefühl das ich das erste Objekt an der falschen Stelle initialisiere. Aber wenn ich es ausserhalb der Callback Routine erstelle bekomme ich immer Out of Scope fehler.
Das gesammte Programm sieht im Moment so aus:

#if defined(UNICODE) && !defined(_UNICODE)
    #define _UNICODE
#elif defined(_UNICODE) && !defined(UNICODE)
    #define UNICODE
#endif

#include <tchar.h>
#include <windows.h>
#include <simpleshape.h>

/*  Declare Windows procedure  */
LRESULT CALLBACK WindowProcedure (HWND, UINT, WPARAM, LPARAM);

/*  Make the class name into a global variable  */
TCHAR szClassName[ ] = _T("CodeBlocksWindowsApp");

int WINAPI WinMain (HINSTANCE hThisInstance,
                     HINSTANCE hPrevInstance,
                     LPSTR lpszArgument,
                     int nCmdShow)
{
    HWND hwnd;               /* This is the handle for our window */
    MSG messages;            /* Here messages to the application are saved */
    WNDCLASSEX wincl;        /* Data structure for the windowclass */

    /* The Window structure */
    wincl.hInstance = hThisInstance;
    wincl.lpszClassName = szClassName;
    wincl.lpfnWndProc = WindowProcedure;      /* This function is called by windows */
    wincl.style = CS_DBLCLKS;                 /* Catch double-clicks */
    wincl.cbSize = sizeof (WNDCLASSEX);

    /* Use default icon and mouse-pointer */
    wincl.hIcon = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hIconSm = LoadIcon (NULL, IDI_APPLICATION);
    wincl.hCursor = LoadCursor (NULL, IDC_ARROW);
    wincl.lpszMenuName = NULL;                 /* No menu */
    wincl.cbClsExtra = 0;                      /* No extra bytes after the window class */
    wincl.cbWndExtra = 0;                      /* structure or the window instance */
    /* Use Windows's default colour as the background of the window */
    wincl.hbrBackground = (HBRUSH) COLOR_BACKGROUND;

    /* Register the window class, and if it fails quit the program */
    if (!RegisterClassEx (&wincl))
        return 0;

    /* The class is registered, let's create the program*/
    hwnd = CreateWindowEx (
           0,                   /* Extended possibilites for variation */
           szClassName,         /* Classname */
           _T("Code::Blocks Template Windows App"),       /* Title Text */
           WS_OVERLAPPEDWINDOW, /* default window */
           CW_USEDEFAULT,       /* Windows decides the position */
           CW_USEDEFAULT,       /* where the window ends up on the screen */
           544,                 /* The programs width */
           375,                 /* and height in pixels */
           HWND_DESKTOP,        /* The window is a child-window to desktop */
           NULL,                /* No menu */
           hThisInstance,       /* Program Instance handler */
           NULL                 /* No Window Creation data */
           );

    /* Make the window visible on the screen */
    ShowWindow (hwnd, nCmdShow);

    /* Run the message loop. It will run until GetMessage() returns 0 */
    while (GetMessage (&messages, NULL, 0, 0))
    {
        /* Translate virtual-key messages into character messages */
        TranslateMessage(&messages);
        /* Send message to WindowProcedure */
        DispatchMessage(&messages);
    }

    /* The program return-value is 0 - The value that PostQuitMessage() gave */
    return messages.wParam;
}

/*  This function is called by the Windows function DispatchMessage()  */

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

    HDC         hdc;
    PAINTSTRUCT ps;
    SimpleShape FirstShape(50,50);

    switch (message)                  /* handle the messages */
    {
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        case WM_PAINT:
            hdc = BeginPaint(hwnd, &ps);

            Rectangle(hdc,
                      FirstShape.GetXPosition(),
                      FirstShape.GetYPosition(),
                      FirstShape.GetXPosition()+FirstShape.GetWidth(),
                      FirstShape.GetYPosition()+FirstShape.GetHeight());

            EndPaint(hwnd, &ps);
            return 0;
        case WM_LBUTTONDOWN:
            FirstShape.SetYPosition(FirstShape.GetYPosition()+5);
            InvalidateRect(hwnd, NULL, TRUE);
            return 0;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

Mein Objekt wird bei Zeile 86 erstellt, also innerhalb der Callback Routine vor der Message Case Abfrage.

Wäre dankbar wenn jemand etwas Licht auf dieses Thema scheinen könnte.

ich habe eine sehr einfache Klasse,

Schonmal daran gedacht, die Methoden inline zu schreiben? Deine sehr einfache Klasse kommt sehr bloatig daher.

error: 'FirstShape' was not declared in this scope|

Hab gerade gemerkt das es recht gut funktioniert wenn ich das Objekt global mache.
Ich weiß nur nicht ob das schlau ist.
Ich hab schon öffter gelesen das es keine gute Idee ist Variablen global zu machen.
Ist das bei Objekten auch so?

Ich weiß nur nicht ob das schlau ist.
Ist das bei Objekten auch so?

Ja, das ist nicht so schlau. Ähm Variablen sind auch Objekte. Alles was Speicher belegt, ist ein Objekt. Zu Objekten von einfachten Typen wie int sagt man halt meistens Variablen. Zu Objekten von Klassen sagt man meistens Instanz.

Wenn du was bewegen willst, sollte es eine Funktion geben, die dir die aktuelle Position liefert, also get_position(). Und dann als nächstes sollte es eine Funktion set_position geben, in die du die Werte reinsteckst, die get_position() geliefert hat und dabei eben einen Wert addierst. Im Endeffekt also set_position( get_position()+5) );

static SimpleShape FirstShape(50,50);

an (so wird die Variable nur beim ersten Mal initialisiert und bei weiteren Aufrufen der Funktion behält sie ihren Wert).

class Rect
{
private:
	int itsXPosition;
    int itsYPosition;
    int itsWidth;
    int itsHeight;
public:
	Rect() : itsXPosition(50), itsYPosition(50), itsWidth(200), itsHeight(200)
	{
	}

	void draw()
	{
		Rectangle(hdc,
                      itsXPosition,
                      itsYPosition,
                      itsWidth,
                      itsHeight);
        itsXPosition += 5;
        itsYPosition += 5;
	}
};

int main()
{
	Rect r;
	for(;;sleep(200))
		r.draw();
}

Das kompiliert so natürlich nicht, hab ich nur eben runtergetippt. Müsstest du anpassen.