Muss ich eine CreateWindowEx-Funktion immer bei WM_CREATE hinschreiben?
Will nämlich, dass sich bei einem Buttonklick immer mehr Editboxen erstellen lassen, nach folgendem Beispiel:

case WM_COMMAND:
            if(lParam==(LPARAM)hButtonPlus){
                if(HIWORD(wParam) == BN_CLICKED){
                    n++;
                    sum[n].hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "Edit", sum[n].buffer,
                                             WS_CHILD | WS_VISIBLE, 20+n*50, 30, 30, 30,
                                             hwnd, NULL, 
                                             ((LPCREATESTRUCT) lParam) -> hInstance,
                                             NULL);   
                }            
            }                
            break;

Das Programm stürzt aber jedesmal ab, wenn ich dann auch auf den Button klicke.

Ach ja: sum[] ist ein Array einer Klasse, die den char buffer[255] und die HWND hEdit beinhaltet.

Hab ich da einen Fehler gemacht?

Vielen Danke für jede Hilfe.

Davor hab ich ja auf die selbe Weise sum[0] erstellt und das funktioniert.
Das steht aber unter WM_CREATE.

Und wie kann ich dann die Box ohne LPCREATESTRUCT erstellen?

Ob sum[] groß genug ist oder nicht können wir ja schlecht wissen du zeigst uns ja nicht wie du es definiert hast. Wie dem auch sei wenn es eine feste größe hat solltest du natürlich erstmal überprüfen ob n noch im gültigen bereich liegt bevor du es als index in das array benutzt...

class summand
{
    public:
    int anz;
    char buffer[255];
    int boxwidth;
    int boxhight;
    int ableiten();    
    HWND hEdit;          
};

Ich habs jetzt mit GetModuleHandle(0) versucht und dadurch lassen sich irgendwie nur 2 neue Boxen erstellen, obwohl ich ja eigentlich 10 deklariert habe.

Das Problem besteht weiterhin.
Ich kann nur eine Box hinzufügen, aber warum nicht mehr?
Es kommt kein Fehler, es passiert einfach nichts, wenn ich ein zweites mal auf den Button klicke.

Hat eventuell jemand eine Idee, woran das liegen könnte.

Sum ist ne Variable der Klasse summand

Dann zeig doch bitte auch noch, wo du den Speicher für dein summand-Array reservierst und die einzelnen Instanzen erzeugt werden...

void *ptr;

    ptr=∑
    ptr=malloc(100);

(ich hoffe das ist nicht totaler Schwachsinn).

Von Instanzen hab ich ehrlich gesagt noch nie was gehört.

Aja...

class CSummand
{
protected:
    int m_nCount;
    char m_cBuffer[255];
    int m_nBoxWidth;
    int m_nBoxHight;
    HWND m_hEdit;

public:
    int Ableiten(void);
    bool CreateWindow(...); // Public ist in dem Fall zwar notfalls ok... weils sonnst umständlich ist... aber normal sollte man das net amchen ;)  Also immer schön Funktionen dafür schreiben :)             
};

Hmm mach das am einfachsten mit nem Pointer da gehts leicht...

[edit]So... hier mal wie de es machen kannst [/edit]

CSummand* m_pSum // Das auch!;
UINT m_nSumCount; // Muss im Konstruktor auf 0 gesetzte werden!

Dann kannst de dir ne AddSummand Funktion schreiben... die dann in etwa so aussieht wie diese:

void AddSummand(....)
{
	CSummand* pTmp = NULL;

	if(m_pSum)
	{
		pTmp = new CSummand[m_nSumCount];
		memcpy(pTmp, m_pSum, sizeof(CSummand) * m_nSumCount);
	}

	delete [] m_pSum;
	m_pSum = new CSummand[m_nSumCount + 1];

	if(pTmp)
		memcpy(m_pSum, pTmp, sizeof(CSummand) * m_nSumCount);

	delete [] pTmp;

	// Hier jetzt bsw. m_pSum[m_nSumCount].CreateWindow(...) oder auch einfach m_pSum[m_nSumCount].hEdit = CreateWindow(...) ... kommt halt drauf an wie de deine Klasse jetzt machst...

	++m_nSumCount;
}

Ich hab das jetzt erstmal so umgeschrieben:

class summand
{
    private:
        int anz;
        int boxwidth;
        int boxhight;    

    public:
        char buffer[10][255];
        HWND hEdit;          
        int ableiten(); 
        summand(void); 
        int add_sum(HWND);        
};

summand::summand(void){
    anz=0;
    boxwidth=50;
    boxhight=30;
    buffer[0][0]=NULL;
}

int summand::add_sum(HWND hwnd){

    hEdit = CreateWindowEx (WS_EX_CLIENTEDGE, "Edit", buffer[anz],
                            WS_CHILD | WS_VISIBLE, 20+50*anz, 30, boxwidth, boxhight,
                            hwnd, NULL, 
                            GetModuleHandle(0),
                            NULL);

    anz++; 
    return 0; 
}

Aber wie kann ich jetzt in dieser add_sum-Funktion die Speicherreservierung festlegen?

Also... in der AddSummand funktion die ich gepostet hab... 1. ne temporäre Variable anlege... den inhalt von m_pSum reinkopieren... dann m_pSum um eins vergrößern.... wieder zurück kopieren... tjo... dann noch den neuen entry ausfüllen... das wärs

Du willst doch einen Array von CSummand? Oder willst du innerhalb von CSummand einen Edit Array... ?!

Danke für die Hilfe.

Du musst nur noch nen Destruktor basteln... delete [] m_pEdits usw

Aja.. ist jetzt ja ganz einfach aufzurufen... du musst einfach nen object von summand erzeugen und kannst dann mit AddSum so viele Edits hinzufügen wie de willst

PS: Keine Garantie das es funktioniert... hab das gerade einfach hier in das "Nachrichten schreiben"-Feld getippt... also nicht getestet nix

#define STRICT

#include <windows.h>

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

/*  Make the class name into a global variable  */
char szClassName[ ] = "WindowsApp";

class summand
{
    protected:
        UINT anz;
        int boxwidth;
        int boxhight;    
        HWND hEdit;
        char buffer[255];        
    public:   
        int ableiten(); 
        summand(void); 
        int add_sum(HWND, int);        
};

summand::summand(void){
    boxwidth=50;
    boxhight=30;
    buffer[0]=' ';
}

int summand::add_sum(HWND hwnd, int a){      

    hEdit = CreateWindowEx (WS_EX_CLIENTEDGE, "Edit", buffer,
                            WS_CHILD | WS_VISIBLE, 20+100*a, 30, boxwidth, boxhight,
                            hwnd, NULL, 
                            GetModuleHandle(0),
                            NULL);

    return a; 
}

int WINAPI WinMain (HINSTANCE hThisInstance,
                    HINSTANCE hPrevInstance,
                    LPSTR lpszArgument,
                    int nFunsterStil)

{
//...Hier steht der Standardcode, wie bei jeder Windows-Anwendung.
}

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

LRESULT CALLBACK WindowProcedure (HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
    int n=0,i;
    static HWND hButtonPlus, hButtonMinus;
    summand* sum;
    summand* tmp=NULL;

    switch (message)                  /* handle the messages */
    {
        case WM_CREATE:
            hButtonPlus = CreateWindow ("button", "+", WS_CHILD | WS_VISIBLE,
                                        50, 100, 20, 20, hwnd, NULL, 
                                        ((LPCREATESTRUCT) lParam) ->hInstance,
                                        NULL);
            hButtonMinus = CreateWindow ("button", "-", WS_CHILD | WS_VISIBLE,
                                        70, 100, 20, 20, hwnd, NULL, 
                                        ((LPCREATESTRUCT) lParam) ->hInstance,
                                        NULL);
            /*sum[0].hEdit = CreateWindowEx (WS_EX_CLIENTEDGE, "Edit", sum[0].buffer,
                                           WS_CHILD | WS_VISIBLE, 20, 30, 30, 30,
                                           hwnd, NULL, 
                                           GetModuleHandle(0),
                                           NULL);*/

            break;
        case WM_COMMAND:
            if(lParam==(LPARAM)hButtonPlus){
                if(HIWORD(wParam) == BN_CLICKED){

                    if(sum){
                        tmp = new summand[n];
                        memcpy (tmp, sum, sizeof(summand) * n); 
                    }    
                    delete [] sum;  
                    sum = new summand[n+1];
                    if(tmp)
                        memcpy (sum, tmp, sizeof(summand) * n);
                    delete [] tmp;                 

                    sum[n].add_sum(hwnd, n);
                    n++;
                }            
            }                
            break;
        case WM_DESTROY:
            PostQuitMessage (0);       /* send a WM_QUIT to the message queue */
            break;
        default:                      /* for messages that we don't deal with */
            return DefWindowProc (hwnd, message, wParam, lParam);
    }

    return 0;
}

#define MAX_SUM	32
...
...
	summand sum[MAX_SUM];
...
...
        case WM_COMMAND:
            if(lParam==(LPARAM)hButtonPlus){
                if(HIWORD(wParam) == BN_CLICKED){
					if( n < MAX_SUM )
					{
	                    sum[n].hEdit = CreateWindowEx(WS_EX_CLIENTEDGE, "Edit", sum[n].buffer,
				                                      WS_CHILD | WS_VISIBLE, 20+n*50, 30, 30, 30,
					                                  hwnd, NULL,
							                          ((LPCREATESTRUCT) lParam) -> hInstance,
									                  NULL);
						n++;
					}
                }            
            }                
            break;

int summand::add_sum(HWND hwnd, int a){      

    hEdit = CreateWindowEx (WS_EX_CLIENTEDGE, "Edit", buffer,
                            WS_CHILD | WS_VISIBLE, 20+100*a, 30, boxwidth, boxhight,
                            hwnd, NULL,
                            GetModuleHandle(0),
                            NULL);

    return a;
}

du gibst deinen Button doch gar keine ID... da steht ja NULL
Bin mir nicht ganz sicher ob das der Fehler ist, aber du kannst ja auch mal GetLastError benutzen, um den Fehler genauer zu spezifizieren

Das Problem ist der Index, den ich n genannt habe. Der bleibt immer gleich, obwohl ich den bei jedem Buttonklick hochzählen lasse.

Desswegen erstellt der die neue Editbox immer mit den selben Koordinaten, also sind diese Deckungsgleich und ich kann die dann nicht mehr unterscheiden.

Aber warum zählt der das n nicht hoch?