vielen dank im voraus

meinst du das so ?

CMeinDlg* dlg = ja hier hänge ich :p

da musst du dich auch genauer ausdrücken :p
Wo zum Teufel willst du denn dein handle haben?

Du hast einen this Zeiger der auf die Speicheradresse deines Dialogs zeigt.
mit this->m_hWnd hast du dein Handle von deinem Dlg.

Ansonsten, in einer anderen Klasse müsstest du den Zeiger von deinem Dialog übergeben.

*winke*
Hellsgore

habe eine dlg klasse und eine eigene klasse
im dlg befindet STATIC text anzeigen die verändert werden müssen,
allerdings sollen diese in einer methode meiner Eigenen klasse verändert werden....

hoffe das macht mein vorhaben etwas deutlicher....
habe mir gedacht ich mache das so in meiner anderen klasse

CMeinHauptDlg* Dlg = ;

vieleicht ist auch mein ansatz komplett falsch...
bin noch unerfahren was handle handling ^^ angeht :p

passe ma nu gut auf *g*:

Ich zeige dir das jetzt anhand eines Bsp. :

Meine Nebenklasse von CWnd:
.cpp

// MeineKlasse.cpp : implementation file
//

#include "stdafx.h"
#include "ZeigerKlasse.h" //.h vom HauptDlg
#include "MeineKlasse.h"  

// CMeineKlasse

IMPLEMENT_DYNAMIC(CMeineKlasse, CWnd)
//Hier im Konstruktor trägst du den Zeiger ein
CMeineKlasse::CMeineKlasse(CWnd* p_Zeiger)
{
//m_pZeiger ist die Membervariable von deiner zweiten Klasse
//dieser Zeigt später auf dein Dlg
	m_pZeiger = p_Zeiger;
}

CMeineKlasse::~CMeineKlasse()
{
}

BEGIN_MESSAGE_MAP(CMeineKlasse, CWnd)
END_MESSAGE_MAP()

// CMeineKlasse message handlers
//Irgendeine Funktion
void CMeineKlasse::Paul()
{
         //Setzt dann den Text im HauptDlg
	m_pZeiger->SetWindowText("Paul");
}

und nun meine Header

.h

#pragma once

// CMeineKlasse

class CMeineKlasse : public CWnd
{
	DECLARE_DYNAMIC(CMeineKlasse)

public:
         //Hier den Zeiger eintragen
	CMeineKlasse(CWnd* p_Zeiger);
	virtual ~CMeineKlasse();
	void Paul();
         //Memberzeiger der später auf Dlg zeigt
	CWnd* m_pZeiger;
protected:
	DECLARE_MESSAGE_MAP()
};

wenn du das in dem Konstruktor deiner eigenen Klasse drin hast sind wir schonmal ein Stück weiter.

Jetzt noch dein HauptDlg:

.cpp

#include "MeineKlasse.h" //natürlich musste die includen

void CZeigerKlasseDlg::OnBnClickedButton1()
{
	CMeineKlasse *test = new CMeineKlasse(this); //Hier Zeiger übergeben
	test->Paul(); //Funktion aufrufen

}

und so hast du nun einen Zeiger übergeben den du dann in deiner Klasse nutzen kannst. Das hier war jetzt nur EIN Bsp. gibt noch ein paar andere....

Ich denke aber mal damit kann man das recht gut verstehen.

*winke*
Hellsgore

EDIT:

Ich vergaß jetzt kannst du natürlich auch dein Handle benutzen mit m_pZeiger->m_hWnd.
Oder mit m_pZeiger->SetDlgItemText(ID_DEINSTATIC, "Paul hat eine große Nase") deinen Text setzen wie du lustig bist

ich habe ein neues topic geschrieben vvieleicht erläutert das besser mein problem

dein beispiel kopier ich mir aber trotzdem ^^ vielen vielen dank

*wink back*
T1c4L

ich weiss nicht bin ja noch unerfahren aber....mhmm....

bspl:
CMeineKlasse
CHauptDLG

sollen sich die 2 gegenseitig includieren damit ich ein zusammenspiel bekomme?

oder ich verrafffs total

Du befindest dich nun in deiner Nebenklasse. Diese Nebenklasse hat einen Konstruktor.

Nebenklasse .h:

class CMeineKlasse : public CWnd
{
	DECLARE_DYNAMIC(CMeineKlasse)

public:
	CMeineKlasse(CWnd* p_Zeiger); //<--- Konstruktor, in Klammer eintragen CWnd* p_Zeiger
	virtual ~CMeineKlasse();
	void Paul(); //irgendeine Funktion

	CWnd* m_pZeiger; //Hier eine Membervariable als Zeiger von CWnd
protected:
	DECLARE_MESSAGE_MAP()
};

jetzt meine Nebenklasse .cpp

// MeineKlasse.cpp : implementation file
//

#include "stdafx.h"
#include "MeineKlasse.h"

// CMeineKlasse

IMPLEMENT_DYNAMIC(CMeineKlasse, CWnd)
//Hier auch in Klammern eintragen CWnd* p_Zeiger
CMeineKlasse::CMeineKlasse(CWnd* p_Zeiger)
{
         //Hier den übergebenen Zeiger dem MemberZeiger zuweisen
	m_pZeiger = p_Zeiger;
}

CMeineKlasse::~CMeineKlasse()
{
}

BEGIN_MESSAGE_MAP(CMeineKlasse, CWnd)
END_MESSAGE_MAP()

// CMeineKlasse message handlers

void CMeineKlasse::Paul()
{
         //Und hier kannst du schon auf deinen DLG zugreifen 
	m_pZeiger->SetWindowText("Paul");
}

Nun schauen wir uns die Hauptklasse an:

//ganz am Anfang die .h deiner Nebenklasse includieren
//falls noch nicht geschehen
#include "MeineKlasse.h"
//blablabla MessageMap blabla 
//der ganze Kram vor deinem Aufruf deiner Nebenklasse juckt 
//uns jetzt mal nicht

//Dann kommt irgendwann dein Aufruf mit dem du auf deine
//Nebenklasse zugreifst. Diese könnte z.B. so aussehen:

void CDeineHauptDlg::OnBnClickedButton1()
{
//Hier die Nebenklasse mit der Übergabe deines
//Hauptdlg Zeigers
	CMeineKlasse *test = new CMeineKlasse(this); //this = Zeiger von deinem Haupt
	test->Paul(); //Hier rufst du dann eine Funktion auf

}

und das wars eigentlich schon. Ich hoffe jetzt wird dir das klar *g*

*winke*
Hellsgore

respekt für soviel geduld.
Und deshalb hab ich da auch mal eine Bitte an Dich. Könntest Du dir dieses Posing mal anschauen. Ich kann irgendwie keinen Fehler daran finden.
Vieleicht liegt es auch nur an die Form der Befehlsübergabe?
Ach ja, der Link http://www.c-plusplus.net/forum/viewtopic.php?t=66149