Comment comprendre le presse-papiers de la communication inter-processus C++ MFC

Le contenu de cet article explique comment comprendre le presse-papiers de la communication inter-processus C++ MFC. Il a une certaine valeur de référence. Les amis dans le besoin peuvent s'y référer.

Le Presse-papiers Windows est un mécanisme de communication inter-processus relativement simple, et sa surcharge est relativement faible. Son principe de mise en œuvre est très simple. Il s'agit en fait d'une zone mémoire maintenue par le système d'exploitation
Cette zone mémoire n'appartient à aucun processus distinct, mais chaque processus peut accéder à cette zone mémoire lorsqu'un processus y place des données. dans la zone mémoire, et un autre processus peut récupérer les données de la zone mémoire pour réaliser la communication. Le processus de mise en œuvre se compose de deux parties, l'une est l'opération de mémoire partagée et l'autre est l'opération de presse-papiers.
1. Opération du presse-papiers
(1) HWND GetClipboardOwner();
Fonction : Obtenez le handle pointant vers le propriétaire actuel du presse-papiers
Si cette fonction est exécutée avec succès, elle renvoie la fenêtre propriétaire. la poignée du presse-papiers. Sinon, NULL est renvoyé.

(2) BOOL OpenClipboard(HWND hWndNewOwner);
Le premier paramètre hWndNewOwner pointe vers un handle de fenêtre qui lui est associé, ce qui signifie que cette fenêtre ouvre le presse-papiers. Si ce paramètre est défini sur NULL, alors. ouvrez le presse-papiers avec la tâche ou le processus en cours. Si le presse-papiers est ouvert avec succès, la fonction renvoie une valeur non nulle. Si un autre programme a déjà ouvert le presse-papiers, le programme actuel ne peut pas ouvrir le presse-papiers, donc l'ouverture du presse-papiers échoue et la fonction renvoie une valeur 0. En fait, c'est facile à comprendre. Si vous y réfléchissez, le presse-papiers n'a qu'une telle zone mémoire. Votre processus A veut y écrire des données, et votre processus B veut y écrire des données. Alors ne plaisantez pas. La façon de résoudre ce désordre est la suivante : si le processus A écrit des données dans le presse-papiers (ce qui peut être compris comme le processus A ouvrant le presse-papiers), alors le processus B ne peut pas écrire de données dans le presse-papiers puisque le processus B ne peut pas écrire de données dans le presse-papiers. Presse-papiers, Ensuite, je laisserai le processus B échouer à ouvrir le presse-papiers. Ainsi, si un programme a ouvert le presse-papiers, les autres applications ne pourront pas modifier le presse-papiers jusqu'à ce que le programme qui a ouvert le presse-papiers appelle la fonction CloseClipboard,et seulement après avoir appelé la fonction EmptyClipboard, le presse-papiers s'ouvre. La fenêtre actuelle peut avoir un presse-papiers

(3) BOOL CloseClipboard(void);
Si un processus ouvre le presse-papiers, avant que le processus n'appelle la fonction CloseClipboard pour fermer le handle du presse-papiers, les autres processus ne peuvent pas ouvrir le presse-papiers. presse-papiers, nous devrions donc fermer le presse-papiers à chaque fois que nous l'utilisons. Notez que fermer le presse-papiers ici ne signifie pas que le programme qui ouvre actuellement le presse-papiers perd la propriété du presse-papiers. Ce n'est qu'après qu'un autre programme aura appelé la fonction EmptyClipboard que le programme actuel perdra la propriété du presse-papiers. presse-papiers.

(4) HANDLE SetClipboardData(UINT uFormat, HANDLE hMem );
La fonction SetClipboardData est utilisée pour placer des données dans le presse-papiers. Cette fonction place les données dans le presse-papiers au format spécifié. Le premier paramètre uFormat permet de spécifier le format des données à placer dans le presse-papiers, comme CF_BITMAP, CF_TEXT, CF_DIB, etc. (pour les autres formats, veuillez vous référer à MSDN). Le deuxième paramètre hMem est utilisé pour spécifier le handle des données avec le format spécifié. Ce paramètre peut être NULL. Si le paramètre est NULL, cela indique que jusqu'à ce qu'un programme demande les données dans le presse-papiers, le programme (c'est-à-dire qu'il a les données). Processus de propriété du presse-papiers) copiera les données dans le presse-papiers, c'est-à-dire fournira les données dans le format de presse-papiers spécifié. La technologie de soumission retardée mentionnée ci-dessus sera présentée en détail plus tard.

(5) BOOL IsClipboardFormatAvailable( UINT format );
Cette fonction est utilisée pour déterminer si le format des données dans le presse-papiers est le format spécifié par format.

(6) HANDLE GetClipboardData( UINT uFormat );
Cette fonction renvoie un handle vers l'objet presse-papiers qui existe dans le presse-papiers dans le format spécifié selon le format spécifié par uFormat.

2. Allocation de mémoire partagée
(1) HGLOBAL WINAPI GlobalAlloc( UINT uFlags, SIZE_T dwBytes );
Le premier paramètre uFlags est utilisé pour spécifier la méthode d'allocation de mémoire. Sa valeur est affichée dans la liste suivante. Cependant, lors de l'utilisation du presse-papiers, en raison de la nécessité d'effectuer un échange de données dynamique, GHND ou GMEM_MOVEABLE doit être utilisé :
GHND Une combinaison de GMEM_MOVEABLE et GMEM_ZEROINIT.
GMEM_FIXED alloue une mémoire fixe et la valeur de retour est un pointeur.
GMEM_MOVEABLE Alloue un morceau de mémoire amovible.
GMEM_ZEROINIT initialise le contenu de la mémoire à 0
GPTR est la combinaison de GMEM_FIXED et GMEM_ZEROINIT.
Le deuxième paramètre dwBytes permet de préciser le nombre d'octets alloués.

(2) HGLOBAL WINAPI GlobalReAlloc(HGLOBAL hMem, SIZE_T dwBytes, UINT uFlags);
Cette fonction est une fonction de réallocation, c'est-à-dire pour étendre l'espace mémoire sur l'objet de données d'origine hMem.
Le premier paramètre hMem représente le handle de l'objet de données renvoyé par la fonction GlobalAlloc.
Le deuxième paramètre dwBytes spécifie la taille de la mémoire qui doit être réaffectée.
Le troisième paramètre uFlags précise la méthode d'allocation (voir la fonction GlobalAlloc).

(3) SIZE_T WINAPI GlobalSize( HGLOBAL hMem );
Cette fonction est utilisée pour renvoyer la taille du bloc mémoire.
Le premier paramètre hMem représente le handle de l'objet de données renvoyé par la fonction GlobalAlloc.

(4) LPVOID WINAPI GlobalLock( HGLOBAL hMem );
La fonction de cette fonction est de verrouiller l'objet mémoire global puis de renvoyer le pointeur sur le premier octet du bloc mémoire de l'objet.
Le premier paramètre hMem représente le handle de l'objet de données renvoyé par la fonction GlobalAlloc.

(5) BOOL WINAPI GlobalUnlock( HGLOBAL hMem );
Vous pouvez accéder à cette mémoire globale via la fonction GlobalLock ci-dessus
Le verrouillage signifie que vous utilisez déjà ce morceau de mémoire. mémoire, les autres programmes ne peuvent plus utiliser cette mémoire globale, et si vous ne la déverrouillez jamais, ce n'est pas un problème, les autres programmes ne pourront jamais utiliser cette mémoire globale, on l'appelle toujours mémoire globale. Que faites-vous ? Cette fonction est donc utilisée pour déverrouiller l'objet mémoire globale.
Le premier paramètre hMem représente le handle de l'objet de données renvoyé par la fonction GlobalAlloc.

(6) HGLOBAL WINAPI GlobalFree( HGLOBAL hMem );
Cette fonction libère le bloc mémoire global.
Le premier paramètre hMem représente le handle de l'objet de données renvoyé par la fonction GlobalAlloc.

Ce qui suit est un exemple de code. Les lecteurs peuvent également effectuer un certain test en effectuant Ctrl+C (copier les données dans le presse-papiers) ou Ctrl+V (copier les données depuis le presse-papiers) sur leur propre ordinateur :

// Ctrl+C.cpp : 定义控制台应用程序的入口点。//#include "stdafx.h"#include <iostream>  #include <process.h>  #include <windows.h>  using namespace std;int main()
{
    HWND hWnd = GetClipboardOwner();//获取当前剪贴板所属的窗口句柄
    DWORD Len = 32;
    HGLOBAL pClipData;
    pClipData = GlobalAlloc(GHND,Len+1);//分配共享内存

    char* pData;
    pData = (char*)GlobalLock(pClipData);//内存控制句柄加锁，其他进程不能再访问

    for(int i = 0;i < Len;i++)
    {
        pData[i] = &#39;a&#39;+i;                //在全局内存中赋值
    }

   GlobalUnlock(pClipData);//内存控制句柄解锁，其他进程可以访问

   if(!OpenClipboard(hWnd))//打开剪贴板
   {       cout<<"OPen fail!"<<endl;       return 0; 
   }

   EmptyClipboard();//清空剪贴板，这一步才真正拥有剪贴板
   SetClipboardData(CF_TEXT,pClipData);//将共享内存里的数据放入剪贴板
   CloseClipboard();//关闭剪贴板

   cout<<"剪贴完成"<<endl;   return 0;
}

//Ctrl+V.cpp#include "stdafx.h"#include <iostream>  #include <process.h>  #include <windows.h>  using namespace std;int main()
{
    HWND hWnd = GetClipboardOwner();//获取当前剪贴板所属的窗口句柄

    if(!OpenClipboard(hWnd))//打开剪贴板
    {        cout<<"OPen fail!"<<endl;        return 0; 
    }    if(IsClipboardFormatAvailable(CF_TEXT))
    {
         HANDLE hCilpData = GetClipboardData(CF_TEXT);
         DWORD Len = GlobalSize(hCilpData);          char* pData;
          pData = (char*)GlobalLock(hCilpData);//内存控制句柄加锁，其他进程不能再访问
          cout<<"剪贴板内容是："<<pData<<endl;
          GlobalUnlock(hCilpData);//内存控制句柄解锁，其他进程可以访问
    }

   EmptyClipboard();//清空剪贴板，这一步才真正拥有剪贴板

   CloseClipboard();//关闭剪贴板

   cin.get();   return 0;
}

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!