je pensais a une hash table parceque la principale opération qu´il aura a faire sur son ensemble sera de trouver une fenetre ce qui se fera en O(1) avec une hash table bien dimensionné.
Mais etant donné le nombre de fenetre qu´il risque d´afficher, je ne penses pas que le O(n) de la map va vraiment changer quelque chose. Et en plus ca permet de lister les éléments... comme d´habitude, j´ai bien peur que cela dépende de son problème...

A vrai dire je compte retrouver la fenetre conrespondante grace aux pointeur :

Maclasse *ptr = (Maclass) wParam;
ptr->hwindow....

celui ci se trouvant dans LRESULT CALLBACK.

Que pense tu de cette technique ?

je penses que ce n´est possible que pour les evenements user-defined. et que de plus c´est dangereux en terme de sécurité, n´importe qui peut t´envoyer une message foireux et te faire planter...

Oui ce sont bien des evenement UserDefined.
Au fait pourquoi le code si dessous ne marche pas ?
J´ ai fait un message perso comme vous me l´ avez dit mais il n´ y a aucun texte a l´ecran.

case WM_WRITETEXT:
WindowsClass *window;
window = (reinterpret_cast <WindowsClass*>(wParam));
GetClientRect(window->hWindow, &window->WriteRec);
window->hdc = BeginPaint (window->hWindow, &window->Ps);
TextOut(window->hdc, 20, 10,window->Texte,sizeof(window->Texte)-1);
EndPaint(window->hWindow, &window->Ps);
break;

On a le droit d´écrire sur une zone valide de l´écran ?
je ne suis pas sur
consulte MSDN

On a le droit d´écrire sur une zone valide de l´écran justement. Mais là ce n´est pas le cas car BeginPaint renvoie un hdc qui n´est valable que pour les zone de la fenêtre qui ont besoin d´être redessinée.

Utilise plutot :
window->hdc=GetDC(window->hWindow);
pour obtenir un DC valable pour toute ta fenêtre.

puis n´oublie pas de faire :
ReleaseDC(window->hWindow);
quant tu n´en a plus besoin.

ok tout marche bien.Merci de votre aide !

et quel était le problème ?

Il n´ y avait pas qu´ un probleme :
D´ abord le passage d´ argument avec le message WM_PAINT puis la creation d´ une fenetre dans un thread.

bon jvou avez dis que tout marchait.J´ ai pas mentit.Mais mon esprit du perfectionisme ma poussé a faire un objet constant,pour que ma classe soit reelement utilisable :en effet il faut un bojet comme "cout "(au hasard) qui
puisse etre utilisé dans tout mes programme.
Pour cela je case la fonction WinApi WinMain dans le fichier cpp de ma classe j´y initialise un objet constant et je lance le fonction main de la.Du coup l´ utilisateur n´ a a s´ occuper que de son programme qui commence donc a la fonction main.
Donc tout cela marche , la fenetre aparait, tiens bien une seconde puis disparait comme elle est arivée.etrange.
N ´hesitez pas a me demandez des bout de codes

Second Probleme:

J´ ai surchargé l´ operateur << de cette facon:

/**********************Partie .h**************/
WindowsClass operator << (char*);
WindowsClass operator << (char*);

/**********************Partie.cpp*************/
WindowsClass WindowsClass::operator << (char *texte)
{
/*Je commence par copier le texte
strcpy(Texte,texte);*/

/*Puis j´ envoie un message au thread de gestion des message*/

::SendMessage(hWindow,WM_WRITETEXT,(WPARAM)this,0)
;

return *this; //je return l´ objet

}

WindowsClass WindowsClass::operator << (int truc)
{
if(truc==6)//si on utilise la commande endl

{TextPosY+=20;//saut une ligne
}
else{//sinon on ecrit le numero
char num[50];
itoa(truc,num,50);
strcpy(Texte,num);

::SendMessage(hWindow,WM_WRITETEXT,(WPARAM)this,0)
;
}
return *this; //on return l´ objet
}
/* la presentation est magnifique mais ...*/

Normalement avec sa ne devraije pas pouvoir ecrir :
Window << "Hum des frites << endl << "Les frites c ´est bon << endl;
??
et bien le compilo m´ ecrit :
void value not ignored as it ought to be.

Merci d´ avance,

Un n00b,

Attendez ya pire.

J´initialise mon objet constant grace a une focntion :

::Window.WindowsClassC(hinstance,"ClassName","Une fenêtre pétrolière",nCmdShow,"White",1024,768);

et il se passait ce que je vous citais dans le message juste au dessus.

puis j´ enleve les ::
je compile EREUR. ok je les remet et la je compile et y me remet la meme erreur.

Etrange surtout qui me metait aucune ereur avant.

Voici les erreurs

passing `const WindowsClass´ as `this´ argument of `void WindowsClass::WindowsClassC(HINSTANCE__*, char*, char*, int, char*, int, int)´ discards qualifiers

et
multiple definition of `Window´ en parlant de la ligne cité au dessus.

C´est du copié collé ?

pour l´erreur :
void value not ignored as it ought to be.
il me semble qu´il manque plein de guillemets sur la ligne :
Window << "Hum des frites << endl << "Les frites c ´est bon << endl;

Pour le reste c´est plus dur. Que renvoie ta fonction WindowClassC ?

J´ai l´impression que nombre de tes fonctions renvoi un WindowsClass (les operator<< par exemple) c´est catastrophique. Car lorsque tu lui passe *this, il va créer un nouvel objet WindowsClass et l´initilisé. Et je ne sais pas ce que tu fait dans ton constructeur, mais je crais la boucle infinie ou le truc du genre (et de toute manière, tu ne veux pas d´autre objet). Il faut donc renvoiller des WindowsClass& c´est à dire des référence sur des WindowsClass. Dans ta fonction tu l´utilise pareil (return *this; à la fin) mais toute la différence se situe dans le fait que le compilo lui nevas pas créer de nouvel objet.

pour ta dernière erreur, il faudrait le code de la fonction WindowClassC.

P.S. n´utilise pas :: sauf quand il y a un conflit de nom.

non ce n´ est pas du copié colé les "" sont bien la.

Voila pour un objet constant doisje declaré mes methodes comme constantes ?

Y me reste qu´ une erreur :

invalid initialization of non-const reference of type ´WindowsClass&´ from a temporary of type ´WindowsClass&(*)()´

une fois encore, si on voyait ton code ça serait plus facile.

Mais là j´ai l´impression que tu renvoie un objet local à la fin d´une fonction, et il n´aime pas trop car l´objet sera détruit à la sortie de la fonction donc la référence ne sera plus valide.

En fait il fallait faire

WindowsClass & WindowsClass::operator << (...)

Bon de ce coté la tout marche.

Jme demandais juste un truc.
Comment peut on faire pour recuperer des messages comme un mouvement de souris ou autres pendant que la fenetre est caché ?

Merci d´ avance,

il faut utiliser un hook. La fonction s´appelle SetHookEx je crois, mais ce n´est pas très propre, et pas conforme à ce qu´un programme devrait faire.

Parce que tu peut utiliser quelquechose comme CaptureInput (ce n´est pas ça, mais ça doit pas être loin), pour récupérer les message de la souris, mais alors les autres fenêtres ne les recevront pas, et si ta fenêtre est caché, ça veut dire que plus rien ne répondra pour l´utilisateur.
Mais es-tu sûr d´avoir besoin de ces message ? ça me semble bizarre (mais pas impossible) qu´une fenêtre caché est besoin des événements.

Tu peu me dire comment faire un hook ? Sa me gene pas que les autres fenetres ne recoivent pas de messages je peux leur les envoyé.

avec le hook tu n´as pas besoin, elles recoivent quand même le message.

Pour savoir comment faire, lis la doc de la msdn sur SetWindowsHookEx (c´est le vrai nom).

Le désagrément c´est que seule une fonction se trouvant dans une DLL peut servir pour installer un hook, donc c´est un peu plus dur à déployer.

Ha je connais rien en dll mais je vais quand meme tenté.

Vous sauriez pas quand meme ou on parle des Captureinput ?

++

Ps : pourquoi dis tu que ce n´ est pas propre ?