Introduction à STRICT et Biscuits message

Traductions disponibles Traductions disponibles
Numéro d'article: 83456 - Voir les produits auxquels s'applique cet article
Agrandir tout | Réduire tout

Sommaire

Résumé

Les fichiers en-tête WINDOWS.H et WINDOWSX.H dans version 3.1 du Microsoft Windows Software Development Kit (SDK) fournissent nouvelles fonctionnalités pour faciliter le développement applications pour l'environnement Windows plus rapide et plus facile. Ces fonctionnalités permettent au compilateur C de rechercher les nombreuses erreurs de programmation courantes lors de la compilation.

Cet article fournit une présentation et exemples des nouvelles fonctionnalités, ainsi que d'un mappage route à d'autres ressources dans le Kit de développement qui expliquent les.

Plus d'informations

Les fichiers d'en-tête WINDOWS.H et WINDOWSX.H fournissent les fonctionnalités suivantes :

  • Nouveaux types de données et leurs définitions associées
  • Une variable de préprocesseur STRICT, qui applique la vérification par le compilateur de type possible strictest
  • Macros pour simplifier plusieurs opérations courantes dans la programmation Windows
  • Macros de contrôle pour simplifier la communication avec les contrôles Windows
  • Message Biscuits (qui sont une méthode pratique, portable et type sécurisé pour gérer les messages) et leurs paramètres associés et renvoyer des valeurs dans l'environnement Windows
Nouveaux types et la vérification de type STRICTE sont implémentés dans le fichier WINDOWS.H ; les macros, macros contrôle, et Biscuits message sont implémentées dans WINDOWSX.H. Le programme d'installation de Kit de développement logiciel (SDK) Windows chacun de ces fichiers copie dans le répertoire include (par défaut, C:\WINDEV\INCLUDE).

Le kit de développement fournit également les ressources suivantes :

  • WINDOWS.TXT, qui décrit les nouveaux types et STRICTES fonctionnalités fournies par WINDOWS.H.
  • WINDOWSX.TXT, qui explique les macros, contrôler les macros et message Biscuits fournis par WINDOWSX.H.
  • MAKEAPP exemple d'application, qui utilise toutes les nouvelles fonctionnalités de WINDOWS.H et WINDOWSX.H. MAKEAPP pouvez créer des modèles d'application qui utilisent toutes les nouvelles fonctionnalités.
  • MAKEAPP.TXT, qui explique comment utiliser MAKEAPP comme un générateur de modèle d'application.
Tout nouveau code développé pour Windows utilisez les nouveaux types de données et définir la variable de préprocesseur STRICTE. Cette opération permet la vérification de type puissant et permet au compilateur C rechercher le nombre de problèmes lors de la compilation.

À l'aide les macros, macros de contrôle et message Biscuits vous aide à en cours de recherche d'erreurs et augmente la portabilité du code ; toutefois, l'utilisation de ces fonctionnalités une question de goût. Certains développeurs tels que les et les trouver utiles, d'autres ne le font pas.

La méthode la plus simple pour vous familiariser avec les nouvelles fonctionnalités consiste à examiner le WINDOWS.H et fichiers d'en-tête, les fichiers de texte WINDOWS.TXT et WINDOWSX.TXT associés et la MAKEAPP WINDOWSX.H exemple d'application. Chacune de ces nouvelles fonctionnalités est implémentée dans un des fichiers d'en-tête (généralement d'une macro relativement simple) et est expliqué dans un des fichiers texte.

Chacune de ces nouvelles fonctionnalités est conçu pour traiter les trois objectifs :

  • Rendre le code source d'une application plus facile à lire
  • Activer le compilateur C pour intercepter les erreurs de programmation
  • Facilité de portage de 32 bits Windows
En règle générale, les nouvelles fonctionnalités peuvent servir appropriés dans une application. Partie le code pouvez utiliser les méthodes traditionnelles et tout autre code peut utiliser différentes combinaisons de nouvelles fonctionnalités de. La seule exception à cela est le préprocesseur STRICT variable-si STRICT est définie dans n'importe quel module source, l'entier module doit être « STRICT conforme » avant de compiler avec succès.

Chacune de ces nouvelles fonctionnalités est compatible avec Windows 3.0. Vous pouvez utiliser les nouvelles fonctionnalités dans une application qui s'exécuteront dans la version 3.0 et vous pouvez modifier existant code pour utiliser les nouvelles fonctionnalités.

Le reste de cet article fournit une introduction à chacune des nouvelles fonctionnalités.

Nouveaux types de données, définitions des types et les macros d'assistance

Les nouveaux types de données sont implémentés dans WINDOWS.H et décrit dans WINDOWS.TXT. WPARAM, LPARAM et UINT sont des exemples de nouveaux types de données. HINSTANCE, HMODULE et HTASK sont des exemples de nouveaux types poignée. Utilisant les types de données nouvelle peut faciliter code source lire et simplifier les porter à Windows 32 bits.

Variable Preprocessor STRICT

La variable de préprocesseur STRICTE est implémentée dans WINDOWS.H et décrit dans WINDOWSX.TXT. Lorsqu'une application définit STRICT, le compilateur C applique niveau le plus élevé possible de la vérification des types, qui permet au compilateur de rechercher les erreurs autant que possible. Il est beaucoup plus productif pour rechercher des erreurs lors de la compilation que pour recherchez plus tard avec un débogueur.

Si une application peut utiliser les nouveaux types de données indiqués ci-dessus sans définir STRICT, il ne devez utiliser les nouveaux types Si STRICT est défini.

Pour activer la vérification de type STRICTE, une application doit définir la variable d'environnement STRICT avant notamment WINDOWS.H, comme suit :
   #define STRICT
   #include windows.h
				
STRICT de la variable d'environnement et les nouveaux types de données sont compatibles avec Windows 3.0, C++, niveau d'avertissement du compilateur Microsoft C le plus élevé (spécifié par le commutateur option S4) et ANSI c.

Exemple d'utilisation STRICT

La fonction ReleaseDC est prototypée comme suit :
   int WINAPI ReleaseDC(HWND, HDC);
				
dans une application, un programmeur peut par inadvertance passer les deux paramètres à la fonction ReleaseDC, comme suit :
   ReleaseDC(hDC, hWnd);
				
généralement, le compilateur n'intercepter pas cette erreur types de données le HDC et le HWND étant définies à UINT variables. Toutefois, si STRICT est activée, les types de données HDC et HWND sont définies comme totalement différents types, qui permet au compilateur intercepter l'erreur lors de la compilation. (Pour plus d'informations sur la manière dont les types de données HWND et HDC sont définis, consultez la macro DECLARE_HANDLE WINDOWS.H.)

Le fichier WINDOWS.TXT contient des instructions étape par étape pour écrire du code STRICT-compatible avec Windows. WINDOWS.TXT répertorie également les erreurs de compilateur courantes générées tandis que la compilation d'une application avec STRICT définis et les méthodes pour résoudre ces erreurs.

Conversion de code existant en STRICT

WINDOWS.TXT décrit comment convertir code Windows existant pour être compatibles avec STRICT. Toutefois, cette conversion nécessite une quantité bon de travail. Si le code existant est stable et modifiés pas très souvent, les efforts pour convertir le code ne peuvent pas être utile.

Macros

Les macros sont implémentés dans WINDOWSX.H. Chacun d'eux est répertorié et décrit dans WINDOWSX.TXT.

Les macros peuvent être utilisés pour simplifier programmation opérations de Windows courants. Les macros sont conçues pour faciliter la lecture et d'écriture de code. Il peuvent éliminer la quantité saisie et empêcher les erreurs de conversion de type. Les macros sont compatibles avec Windows 32 bits.

Par exemple, la méthode traditionnelle pour sous-classer une fenêtre implique de code tel que le suivant :
   lpfnOldWndProc = SetWindowLong(hwnd, GWL_WNDPROC,
                                  (LPARAM)(WNDPROC)lpfnNewWndProc);
				
le code suivant qui utilise une nouvelle macro accomplit la même tâche :
   lpfnOldWndProc = SubclassWindow(hwnd, lpfnNewWndProc);
				
incluent d'autres macros : GlobalAllocPtr, DeletePen, SelectBitmap et GetWindowID.

Macros de message de contrôle

Les macros de message de contrôle sont implémentés dans WINDOWSX.H. Chacun d'eux est répertorié et décrit dans WINDOWSX.TXT.

Les macros de message de contrôle simplifient le traitement des contrôles de Windows (modifier les contrôles, les zones de liste et ainsi de suite). Les macros de message de contrôle rend le code potentiellement plus lisible, plus petite et gère tous les casting de type requis. Lorsque utilisée conjointement avec la variable préprocesseur STRICTE, les fonctions de message de contrôle empêcher type erreurs et passage de paramètres incorrect.

Sont des exemples de macros de message de contrôle : Static_Enable, Button_GetCheck, Edit_GetLineCount et ScrollBar_SetRange.

Chaque macro de message de contrôle correspondant à une existante contrôle message ou la fenêtre Gestionnaire de fonction. Par exemple, Button_GetCheck peut être utilisé en place du message BM_GETCHECK et Button_SetText peut être utilisé à la place de SetWindowText à plusieurs reprises.

Un contrôle message-exemple de macro

L'exemple suivant illustre la puissance des macros de message de contrôle.

Le code suivant utilise des appels SendMessage traditionnels pour extraire toutes les lignes de texte d'un contrôle de modification :
   void PrintLines(HWND hwndEdit)
   {
      int line;
      int lineLast = (int)SendMessage(hwndEdit, EM_GETLINECOUNT,
                                      0, 0L);

      for (line = 0; line < lineLast; line)
      {
         int cch;
         char ach[80];

         *((LPINT)ach) = sizeof(ach);
         cch = (int)SendMessage(hwndEdit, EM_GETLINE,
                                line, (LONG)(LPSTR)ach);

         printf(ach); // or whatever ...
      }
   }
				
les utilise de code suivant contrôle macros de message pour effectuer la même tâche, récupération toutes les lignes de texte à partir d'un contrôle de modification :
   void PrintLines(HWND hwndEdit)
   {
      int line;
      int lineLast = Edit_GetLineCount(hwndEdit);

      for (line = 0; line < lineLast; line++)
      {
         int cch;
         char ach[80];

         cch = Edit_GetLine(hwndEdit, line, ach, sizeof(ach));

         printf(ach); // or whatever ...
      }
   }
				

Message Biscuits

Les Biscuits de message sont implémentés dans WINDOWSX.H. Les Biscuits de message sont décrits dans WINDOWSX.TXT, qui explique également certains en détail comment les utiliser. WINDOWSX.TXT ne répertorie pas tous les messages Biscuits ; la liste est disponible dans WINDOWSX.H.

Les deux plus grands avantages Biscuits message sont :

  • Type de données sécurité, car les Biscuits message effectuer beaucoup de conversion de type
  • Simplification de portage de 32 bits Windows
Une application peut utiliser Biscuits message qu'elle définit STRICT ou non. En outre, une application peut utiliser message Biscuits pour traiter des messages et code traditionnel pour traiter d'autres.

L'aide de biscuits message radicalement modifie l'apparence d'une procédure de fenêtre (voir l'exemple ci-dessous). Ce changement d'apparence est ou non un effet secondaire souhaitable dépend les codage tastes du développeur application.

En règle générale, une procédure de fenêtre traitera de messages, avec le code de la procédure pour traiter chaque message. Cela conduit souvent au code source pour une procédure de fenêtre continuer sur de nombreuses pages. Lorsqu'une application utilise message Biscuits, presque n'importe quelle procédure de fenêtre peut être répertorié très manière concise. L'essentiel du code est transférée vers message-Gestion des fonctions qui appellent les Biscuits message.

Un exemple de Cracker message simple

L'exemple de code suivant montre à l'aide les Biscuits message HANDLE_WM_ * dans une procédure de fenêtre :
   LRESULT _export CALLBACK Template_WndProc(HWND hwnd, WORD msg,
                                             WPARAM wParam,
                                             LPARAM lParam)
   {
      switch (msg)
      {
      case WM_MOUSEMOVE:
         return HANDLE_WM_MOUSEMOVE(hwnd, wParam, lParam,
                                    Template_OnMouseMove);

      case WM_LBUTTONDOWN:
         return HANDLE_WM_LBUTTONDOWN(hwnd, wParam, lParam,
                                      Template_OnLButtonDown);

      case WM_LBUTTONUP:
         return HANDLE_WM_LBUTTONDUP(hwnd, wParam, lParam,
                                     Template_OnLButtonUp);

      case WM_CTLCOLOR:
         return HANDLE_WM_CTLCOLOR(hwnd, wParam, lParam,
                                   Template_OnCtlColor);

      default:
         return Template_DefProc(hwnd, msg, wParam, lParam);
      }
   }
				
l'application doit également contenir les fonctions de gestion des messages suivantes qui sont appelées par les Biscuits message :
   void Template_OnMouseMove(HWND hwnd, int x, int y, UINT keyFlags)
   {
      // code to handle WM_MOUSEMOVE...
   }

   void Template_OnLButtonDown(HWND hwnd, BOOL fDoubleClick, int x,
                               int y, UINT keyFlags)
   {
      // code to handle WM_LBUTTONDOWN...
   }

   void Template_OnLButtonUp(HWND hwnd, int x, int y, UINT keyFlags)
   {
      // code to handle WM_LBUTTONUP
   }

   HBRUSH Template_OnCtlColor(HWND hwnd, HDC hdc, HWND hwndChild,
                              int type)
   {
      // code to handle WM_CTLCOLOR
   }
				
si le code de procédure de fenêtre ci-dessus est compact, la macro HANDLE_MSG simplifie encore davantage le code. Par exemple :
   LRESULT _export CALLBACK Template_WndProc(HWND hwnd, WORD msg,
                                             WPARAM wParam,
                                             LPARAM lParam)
   {
       switch (msg)
       {
       HANDLE_MSG(hwnd, WM_MOUSEMOVE, Template_OnMouseMove);
       HANDLE_MSG(hwnd, WM_LBUTTONDOWN, Template_OnLButtonDown);
       HANDLE_MSG(hwnd, WM_LBUTTONDBLCLK, Template_OnLButtonDown);
       HANDLE_MSG(hwnd, WM_LBUTTONUP, Template_OnLButtonUp);

       default:
           return Template_DefProc(hwnd, msg, wParam, lParam);
       }
   }
				

Notions fondamentales Cracker message

Si une procédure de fenêtre utilise un cracker message pour traiter un message particulier, il doit également implémenter une fonction pour traiter ce message. Cette fonction doit avoir une « signature » (la commande et types de paramètres et type de retour de la fonction) spécifique. La signature correcte pour chaque fonction est répertoriée dans WINDOWSX.H à côté de la cracker message correspondant.

Par exemple, si la procédure de fenêtre dans l'exemple ci-dessus utilise la cracker message HANDLE_WM_MOUSEMOVE, il doit également implémenter la fonction Template_OnMouseMove, qui appelle la cracker message.

Une fois que l'application implémente Template_OnMouseMove, le cracker message traite le message comme suit :

  1. Fractionne wParam et lParam en composants
  2. Type diffuse les parties correctement
  3. Transmet les valeurs comme paramètres à la fonction fourni par l'application (dans ce cas, la fonction Template_OnMouseMove)
  4. Renvoie une valeur appropriée à partir de traitement du message
Pour plus d'informations sur les rouages internes de biscuits les message, voir la section « Comment message Biscuits fonctionner » dans WINDOWSX.TXT.

Message Biscuits ont plusieurs utilisations

Le fichier de texte WINDOWSX.TXT explique et illustre comment utiliser message Biscuits dans plusieurs situations de programmation autre application, notamment les suivantes :

  • La transmission de messages DefWindowProc, CallWindowProc et ainsi de suite.
  • Messages de fenêtre privée et enregistré.
  • Windows avec des données d'instance.
  • Procédures de boîte de dialogue.
  • Fenêtre sous-classement.
  • Un autre type créer boîte de dialogue boîte procédures, permet à une procédure de boîte de dialogue renvoyer un type de données LRESULT. Cette méthode permet à une application contourner la limitation traditionnelle que procédures de boîte de dialogue doivent renvoyer un type de données Boolean.

Propriétés

Numéro d'article: 83456 - Dernière mise à jour: samedi 6 novembre 1999 - Version: 1.0
Les informations contenues dans cet article s'appliquent au(x) produit(s) suivant(s):
  • Microsoft Windows Software Development Kit 3.1
Mots-clés : 
kbmt kb16bitonly KB83456 KbMtfr
Traduction automatique
IMPORTANT : Cet article est issu du système de traduction automatique mis au point par Microsoft (http://support.microsoft.com/gp/mtdetails). Un certain nombre d?articles obtenus par traduction automatique sont en effet mis à votre disposition en complément des articles traduits en langue française par des traducteurs professionnels. Cela vous permet d?avoir accès, dans votre propre langue, à l?ensemble des articles de la base de connaissances rédigés originellement en langue anglaise. Les articles traduits automatiquement ne sont pas toujours parfaits et peuvent comporter des erreurs de vocabulaire, de syntaxe ou de grammaire (probablement semblables aux erreurs que ferait une personne étrangère s?exprimant dans votre langue !). Néanmoins, mis à part ces imperfections, ces articles devraient suffire à vous orienter et à vous aider à résoudre votre problème. Microsoft s?efforce aussi continuellement de faire évoluer son système de traduction automatique.
La version anglaise de cet article est la suivante: 83456
L'INFORMATION CONTENUE DANS CE DOCUMENT EST FOURNIE PAR MICROSOFT SANS GARANTIE D'AUCUNE SORTE, EXPLICITE OU IMPLICITE. L'UTILISATEUR ASSUME LE RISQUE DE L'UTILISATION DU CONTENU DE CE DOCUMENT. CE DOCUMENT NE PEUT ETRE REVENDU OU CEDE EN ECHANGE D'UN QUELCONQUE PROFIT.
Exclusion de responsabilité concernant les contenus obsolètes dans la Base de connaissances
Cet article concerne des produits pour lesquels Microsoft n'offre plus de support. Il est par conséquent fourni « en l'état » et ne sera plus mis à jour.

Envoyer des commentaires

 

Contact us for more help

Contact us for more help
Connect with Answer Desk for expert help.
Get more support from smallbusiness.support.microsoft.com