自学教程：C++ EmptyClipboard函数代码示例

void CopyToClipboard(HWND hwnd) {  if (!hwnd || !OpenClipboard(hwnd)) return;  LRESULT len = SendDlgItemMessage(hwnd, IDC_LOGWIN, WM_GETTEXTLENGTH, 0, 0);  HGLOBAL mem = GlobalAlloc(GMEM_MOVEABLE, (++len)*sizeof(TCHAR));  if (!mem) { CloseClipboard(); return; }  TCHAR *txt = (TCHAR *)GlobalLock(mem);  if (!txt) { CloseClipboard(); return; }  EmptyClipboard();  txt[0] = 0;  SendDlgItemMessage(hwnd, IDC_LOGWIN, WM_GETTEXT, (WPARAM)(len), (LPARAM)txt);  GlobalUnlock(mem);#ifdef _UNICODE  SetClipboardData(CF_UNICODETEXT, mem);#else  SetClipboardData(CF_TEXT, mem);#endif  CloseClipboard();}

Status sys_clipboard_set(const wchar_t* text){	if(!OpenClipboard(hWndNewOwner))		WARN_RETURN(ERR::FAIL);	WARN_IF_FALSE(EmptyClipboard());	// NB: to enable copy/pasting something other than text, add	// message handlers for WM_RENDERFORMAT and WM_RENDERALLFORMATS.	HGLOBAL hMem;	Status ret = SetClipboardText(text, hMem);	WARN_IF_FALSE(CloseClipboard());	// must happen before GlobalFree	ENSURE(GlobalFree(hMem) == 0);	// (0 indicates success)	return ret;}

//////////////////////////////////////////////////////////////////////////////////////////////////// clipboard//////////////////////////////////////////////////////////////////////////////////////////////////void cGUIEdit::ClipboardCopy(){	int s1 = sel1(), s2 = sel2();	int size = s2-s1;	if(size==0) return; // no selection	if(!OpenClipboard(NULL)) return;	if(EmptyClipboard())	{		HGLOBAL handler = GlobalAlloc(GMEM_MOVEABLE|GMEM_DDESHARE,size+1); assert(handler!=NULL);		void* data = GlobalLock(handler); assert(data!=NULL);		memcpy(data,txt.c_str() + s1,size);		((LPWSTR)data)[size]=0;		GlobalUnlock(handler);		SetClipboardData(CF_UNICODETEXT,handler);	}	CloseClipboard();}

BOOL CClipboard::SetTextW(HWND owner, const wchar_t* str, int len){	if (str && *str && OpenClipboard(owner))	{		EmptyClipboard();		HANDLE hmem = GlobalAlloc(GMEM_MOVEABLE | GMEM_DDESHARE, len + 4);		if (hmem)		{			wchar_t* buf = (wchar_t*)GlobalLock(hmem);			memcpy(buf, str, len + 4);			GlobalUnlock(hmem);			SetClipboardData(CF_UNICODETEXT, hmem);		}		CloseClipboard();		return TRUE;	}	return FALSE;}

void CopyToClipboard(const char* text) ///Copies a string to the clipboard.{    HGLOBAL hText;    char *pText;    hText = GlobalAlloc(GMEM_DDESHARE | GMEM_MOVEABLE, strlen(text)+1);    pText = (char*)GlobalLock(hText);    strcpy(pText, text);    OpenClipboard(0);    EmptyClipboard();    if(!SetClipboardData(CF_OEMTEXT, hText))    {        MessageBeep(MB_ICONERROR);    }    MessageBeep(MB_ICONINFORMATION);    CloseClipboard();}

LRESULT CMainDlg::OnCopyClip(WORD /*wNotifyCode*/, WORD wID, HWND /*hWndCtl*/, BOOL& /*bHandled*/){	OpenClipboard();	EmptyClipboard();	FrqValue atk = GetSetting(gen1AtkEd);	AmpValue pk  = GetSetting(gen1VolEd);	FrqValue dec = GetSetting(gen1DecEd);	AmpValue sus = GetSetting(gen1SusEd);	FrqValue rel = GetSetting(gen1RelEd);	FrqValue mul1 = GetSetting(gen2MulEd);	AmpValue amp1 = GetSetting(gen2NdxEd);	FrqValue atk1 = GetSetting(gen2AtkEd);	AmpValue pk1  = GetSetting(gen2PckEd);	FrqValue dec1 = GetSetting(gen2DecEd);	AmpValue sus1 = GetSetting(gen2SusEd);	FrqValue rel1 = GetSetting(gen2RelEd);	AmpValue end1 = GetSetting(gen2EndEd);	FrqValue mul2 = GetSetting(gen3MulEd);	AmpValue amp2 = GetSetting(gen3NdxEd);	FrqValue atk2 = GetSetting(gen3AtkEd);	AmpValue pk2  = GetSetting(gen3PckEd);	FrqValue dec2 = GetSetting(gen3DecEd);	AmpValue sus2 = GetSetting(gen3SusEd);	FrqValue rel2 = GetSetting(gen3RelEd);	AmpValue end2 = GetSetting(gen3EndEd);	char txt[1024];	sprintf(txt, "{ %4d, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f,/r/n%6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f,/r/n%6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f, %6.3f },/r/n",		algorithm, 0.0, atk, pk, dec, sus, rel, 0.0,		mul1, amp1, atk1, pk1, dec1, sus1, rel1, end1,		mul2, amp2, atk2, pk2, dec2, sus2, rel2, end2);	HANDLE mem = GlobalAlloc(0, strlen(txt)+1);	char *ptxt = (char*)GlobalLock(mem);	strcpy(ptxt, txt);	GlobalUnlock(mem);	SetClipboardData(CF_TEXT, mem);	CloseClipboard();	return 0;}

void CutOrCopyFiles(LPCTSTR lpBuffer,UINT uBufLen,BOOL bCopy){	UINT uDropEffect;	DROPFILES dropFiles;	UINT uGblLen,uDropFilesLen;	HGLOBAL hGblFiles,hGblEffect;	char *szData,*szFileList;	DWORD *dwDropEffect;	uDropEffect=RegisterClipboardFormat(L"Preferred DropEffect");	hGblEffect=GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_DDESHARE,sizeof(DWORD));	dwDropEffect=(DWORD*)GlobalLock(hGblEffect);	if(bCopy)		*dwDropEffect=DROPEFFECT_COPY;	else 		*dwDropEffect=DROPEFFECT_MOVE;	GlobalUnlock(hGblEffect);	uDropFilesLen=sizeof(DROPFILES);	dropFiles.pFiles =uDropFilesLen;	dropFiles.pt.x=0;	dropFiles.pt.y=0;	dropFiles.fNC =FALSE;	dropFiles.fWide =TRUE;	uGblLen=uDropFilesLen+uBufLen*2+20;	hGblFiles= GlobalAlloc(GMEM_ZEROINIT|GMEM_MOVEABLE|GMEM_DDESHARE, uGblLen);	szData=(char*)GlobalLock(hGblFiles);	memset(szData, 0, uGblLen);	memcpy(szData,(LPVOID)(&dropFiles),uDropFilesLen);	szFileList=szData+uDropFilesLen;	memcpy(szFileList, lpBuffer, uBufLen*sizeof(TCHAR));	GlobalUnlock(hGblFiles);	if( OpenClipboard(NULL) )	{		EmptyClipboard();		SetClipboardData( CF_HDROP, hGblFiles );		SetClipboardData(uDropEffect,hGblEffect);		CloseClipboard();	}}   

void CCommunicationTrafficDlg::OnBnClickedCopy(){//--------------------------------------------------------------------------------------------------------------------       CArray <int, int> aryListSel;    int nCount= m_DataList.GetSelCount();    aryListSel.SetSize(nCount);    m_DataList.GetSelItems(nCount, aryListSel.GetData());   //  aryListSel中存的就是选中列的index值，如果需要取内容，加以下语句：        CString str,content;        for (int i= nCount-1; i>= 0; i--)        {            m_DataList.GetText(aryListSel.GetAt(i), (CString&)str);            str+=_T("/n");            content==str;        }//--------------------------------------------------------------------------------------------------------------------         HGLOBAL hClip;     //定义一个HGLOBAL句柄变量用来指向分配的内存块    if (OpenClipboard())    {        EmptyClipboard();                            //将剪贴板内容清空        hClip=GlobalAlloc(GMEM_MOVEABLE,content.GetLength()+1);         //在堆上分配可移动的内存块，程序返回一个内存句柄        char * buff;                                 //定义指向字符型的指针变量        buff=(char*)GlobalLock(hClip);        //对分配的内存块进行加锁，将内存块句柄转化成一个指针,并将相应的引用计数器加1        strcpy(buff,(char*)content.GetBuffer());        //将用户输入的数据复制到指针变量中，实际上就是复制到分配的内存块中        GlobalUnlock(hClip);        //数据写入完毕，进行解锁操作，并将引用计数器数字减1        SetClipboardData(CF_TEXT,hClip);        //将存放有数据的内存块放入剪贴板的资源管理中        CloseClipboard();        //关闭剪贴板，释放剪贴板资源的占用权          }//--------------------------------------------------------------------------------------------------------------------}

void _glfwPlatformSetClipboardString(_GLFWwindow* window, const char* string){    WCHAR* wideString;    HANDLE stringHandle;    size_t wideSize;    wideString = _glfwCreateWideStringFromUTF8(string);    if (!wideString)    {        _glfwInputError(GLFW_PLATFORM_ERROR,                        "Win32: Failed to convert string to UTF-16");        return;    }    wideSize = (wcslen(wideString) + 1) * sizeof(WCHAR);    stringHandle = GlobalAlloc(GMEM_MOVEABLE, wideSize);    if (!stringHandle)    {        free(wideString);        _glfwInputError(GLFW_PLATFORM_ERROR,                        "Win32: Failed to allocate global handle for clipboard");        return;    }    memcpy(GlobalLock(stringHandle), wideString, wideSize);    GlobalUnlock(stringHandle);    if (!OpenClipboard(window->win32.handle))    {        GlobalFree(stringHandle);        free(wideString);        _glfwInputError(GLFW_PLATFORM_ERROR, "Win32: Failed to open clipboard");        return;    }    EmptyClipboard();    SetClipboardData(CF_UNICODETEXT, stringHandle);    CloseClipboard();    free(wideString);}

VOIDCopyTextToClipboard(LPCWSTR lpszText){    if(OpenClipboard(NULL))    {        HGLOBAL ClipBuffer;        WCHAR *Buffer;        EmptyClipboard();        ClipBuffer = GlobalAlloc(GMEM_DDESHARE, (wcslen(lpszText) + 1) * sizeof(TCHAR));        Buffer = (WCHAR*)GlobalLock(ClipBuffer);        wcscpy(Buffer, lpszText);        GlobalUnlock(ClipBuffer);        SetClipboardData(CF_UNICODETEXT, ClipBuffer);        CloseClipboard();    }}

int CBitmap::SetClipboard() {	HANDLE hGMem = GlobalAlloc(GHND, m_bmpInfoHeader.biSize + m_image.buf.size());	BITMAPINFOHEADER *pBih = (BITMAPINFOHEADER *)GlobalLock(hGMem);	*pBih = *(BITMAPINFOHEADER *)&m_bmpInfoHeader;	//pBih->biBitCount = 32;	//pBih->biCompression = BI_RGB;		int width	= m_image.width;	int height	= m_image.height;	int bytesPerPixel = m_bmpInfoHeader.biBitCount / 8;	int bytesPerLine = ( (width + (m_bmpInfoHeader.biBitCount % 32 != 0) ) * bytesPerPixel >> 2) << 2;//	int writeSize = bytesPerLine * height;		printf("Setting... w=%d, h=%d", width, height);	int offset = pBih->biSize + pBih->biClrUsed * (pBih->biBitCount > 24 ? sizeof(RGBQuad) : sizeof(RGBTriple));	u8 *imgData = (u8 *)pBih + offset;	u32 *pBuf = (u32 *)&m_image.buf[0];		switch(m_bmpInfoHeader.biBitCount) {		case 24: {			if(m_bmpInfoHeader.biHeight < 0) // Top to bottom				REP(y, height)	REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];			else // Bottom to top				REV(y, height)	REP(x, width) *(RGBTriple *)&imgData[bytesPerLine*y + 3*x] = *(RGBTriple *)&pBuf[width*y+x];		} break;				case 32: {			if(m_bmpInfoHeader.biHeight < 0) // Top to bottom				REP(y, height)	REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];			else // Bottom to top				REV(y, height)	REP(x, width) *(u32 *)&imgData[(width*y+x)*4] = pBuf[width*y+x];		} break;	}	GlobalUnlock(hGMem);		if( !OpenClipboard(NULL) ) return -1;	EmptyClipboard();	SetClipboardData(CF_DIB, hGMem);	CloseClipboard();		puts("OK");	return 0;}

void CGumpListView::OnPopupCopygumpid(){	int iGumpID = GetSelectedGumpID();	CString strText = GfxXtoA(iGumpID);		if  (!OpenClipboard()) return;		EmptyClipboard();	HGLOBAL hClipboardData;	hClipboardData = GlobalAlloc(GMEM_DDESHARE, strText.GetLength()+1);	char * pchData = (char*)GlobalLock(hClipboardData);	strcpy(pchData, strText);	GlobalUnlock(hClipboardData);	SetClipboardData(CF_TEXT,hClipboardData);	CloseClipboard();}

void Clipboard::set(std::string text){   if ( !OpenClipboard(NULL) )   {      //AfxMessageBox( _T("Cannot open the Clipboard") );      std::cout << "Clipboard.set(): Cannot open the Clipboard" << std::endl;      return;   }   // Remove the current Clipboard contents    if( !EmptyClipboard() )   {      std::cout << "Clipboard.set(): Cannot empty the Clipboard" << std::endl;      return;   }   // Get the currently selected data   //std::cout << "this is causing a crash somewhere: sizeof(text):" << sizeof(text) << " text.length():" << text.length();   HGLOBAL hGlob = GlobalAlloc(GMEM_MOVEABLE, text.size()+1);   //strcpy_s((char*)hGlob, 64, text.c_str());   if (!hGlob)   {      std::cout << "Clipboard.set(): could not allocate hGlob" << std::endl;      CloseClipboard();      return;   }   memcpy(GlobalLock(hGlob),text.c_str(),text.size()+1);   GlobalUnlock(hGlob);   // For the appropriate data formats...    if ( ::SetClipboardData( CF_TEXT, hGlob ) == NULL )   {      std::cout << "Clipboard.set(): Unable to set Clipboard data, error: " << GetLastError() << std::endl;      //CString msg;      //msg.Format(_T("Unable to set Clipboard data, error: %d"), GetLastError());      //AfxMessageBox( msg );      CloseClipboard();      GlobalFree(hGlob);      return;   }   CloseClipboard();   get_instance()->__text = text;}

  void Copy( const char * data, int len )  {    HWND hWnd = GetForegroundWindow();    if (!::OpenClipboard( hWnd ))      return;    EmptyClipboard();    HGLOBAL h = GlobalAlloc(GMEM_MOVEABLE,(len + 1) * sizeof(WCHAR));    WCHAR * pMem = (WCHAR*)GlobalLock(h);    ZeroMemory( pMem, (len + 1) * sizeof(WCHAR) );    CopyMemory( pMem, data, (len + 1) * sizeof(WCHAR) );    GlobalUnlock(h);    SetClipboardData(CF_TEXT,h);    CloseClipboard();  }

static bool win_set_clipboard_text(ALLEGRO_DISPLAY *display, const char *text){   HWND handle = get_window_handle(display);   HANDLE hMem = NULL;   wchar_t *tstr = NULL;   size_t size;   size_t len;   LPTSTR dst;   if (!OpenClipboard(handle)) {      ALLEGRO_DEBUG("Could not open clipboard for handle %p", handle);      return false;   }   /* Convert the text from UTF-8 to Windows Unicode */   tstr = _al_win_utf16(text);   len  = wcslen(tstr);   size = (len+1) * sizeof(wchar_t);   /* Save the data to the clipboard */   hMem = GlobalAlloc(GMEM_MOVEABLE, size);   if (!hMem) {      al_free(tstr);      ALLEGRO_DEBUG("GlobalAlloc failed to allocate memory for the clipboard data");      return false;   }   dst = (LPTSTR)GlobalLock(hMem);   /* Copy the text over. Unlike SDL, do NOT convert newlines, that's for the    * use to decide. */   memmove(dst, tstr, size);   dst[len] = 0;   GlobalUnlock(hMem);   EmptyClipboard();   if (!SetClipboardData(TEXT_FORMAT, hMem)) {      al_free(tstr);      ALLEGRO_DEBUG("Couldn't set clipboard data");      return false;   }   al_free(tstr);   CloseClipboard();   return true;}

	BOOL CopyTextToClipboard(HWND hwnd, const std::wstring &wtext) {		OpenClipboard(hwnd);		EmptyClipboard();		HANDLE hglbCopy = GlobalAlloc(GMEM_MOVEABLE, (wtext.size() + 1) * sizeof(wchar_t));		if (hglbCopy == NULL) {			CloseClipboard();			return FALSE;		}		// Lock the handle and copy the text to the buffer.		wchar_t *lptstrCopy = (wchar_t *)GlobalLock(hglbCopy);		wcscpy(lptstrCopy, wtext.c_str());		lptstrCopy[wtext.size()] = (wchar_t) 0;    // null character		GlobalUnlock(hglbCopy);		SetClipboardData(CF_UNICODETEXT, hglbCopy);		CloseClipboard();		return TRUE;	}

void SetClipboard(const tstring& sBuf){	if (!OpenClipboard(NULL))		return;	EmptyClipboard();	HGLOBAL hClipboard;	hClipboard = GlobalAlloc(GMEM_MOVEABLE, sBuf.length()+1);	char* pszBuffer = (char*)GlobalLock(hClipboard);	strcpy(pszBuffer, LPCSTR(sBuf.c_str()));	GlobalUnlock(hClipboard);	SetClipboardData(CF_TEXT, hClipboard);	CloseClipboard();}

HRESULT cdecl LogFlush(HWND hwnd){    int i;    HGLOBAL hGlobalMemory=NULL;    TCHAR  *lpGlobalMemory=NULL;    OpenClipboard(hwnd);    EmptyClipboard();    hGlobalMemory=GlobalAlloc(GHND, (DWORD) (gLoggerPointer + 1)*sizeof(TCHAR));    lpGlobalMemory=(TCHAR *)GlobalLock(hGlobalMemory);    for(i=0;i<gLoggerPointer;i++)        *lpGlobalMemory++=gLoggerArray[i];    SetClipboardData(CF_TEXT,hGlobalMemory);    CloseClipboard();    return(NOERROR);}

bool Clipboard::Set(const Clipboard* clipboard, HWND fallback_owner) {  auto fallback = false;  if (!OpenClipboard(clipboard->owner())) {    if (!OpenClipboard(fallback_owner))      return false;    fallback = true;  }  if (!EmptyClipboard()) {    CloseClipboard();    return false;  }  for (auto& pair : *clipboard) {    const auto& format_id = pair.first;    if (fallback && format_id == CF_OWNERDISPLAY)      continue;    auto& format = pair.second;    auto handle = GlobalAlloc(GMEM_MOVEABLE, format->size());    if (handle == NULL)      continue;    auto failed = true;    auto memory = GlobalLock(handle);    if (memory != nullptr) {      memcpy(memory, format->Get(), format->size());      GlobalUnlock(memory);      if (SetClipboardData(format_id, handle) != NULL)        failed = false;    }    if (failed)      GlobalFree(handle);  }  CloseClipboard();  return true;}

/// copy text onto the clipboard.// @param text the text// @function set_clipboarddef set_clipboard(Str text) {  HGLOBAL glob;  LPWSTR p;  int bufsize = 3*strlen(text);  if (! OpenClipboard(NULL)) {    return push_error(L);  }  EmptyClipboard();  glob = GlobalAlloc(GMEM_MOVEABLE, bufsize);  p = (LPWSTR)GlobalLock(glob);  wstring_buff(text,p,bufsize);  GlobalUnlock(glob);  if (SetClipboardData(CF_UNICODETEXT,glob) == NULL) {    CloseClipboard();    return push_error(L);  }  CloseClipboard();  return 0;}

PUBLIC voidput_scrap(int type, int srclen, char *src){  scrap_type format;  int dstlen;  char *dst;  format = convert_format(type);  dstlen = convert_data(type, NULL, src, srclen);#if defined(X11_SCRAP)/* * */  dst = (char *)alloca(dstlen);  if ( dst != NULL )    {      convert_data(type, dst, src, srclen);      XChangeProperty(SDL_Display, DefaultRootWindow(SDL_Display),		      XA_CUT_BUFFER0, format, 8, PropModeReplace,		      (unsigned char *) dst, dstlen);      if ( we_lost_clipboard() )        XSetSelectionOwner(SDL_Display, XA_PRIMARY, SDL_Window, CurrentTime);    }#elif defined(WIN_SCRAP)/* * */  if ( OpenClipboard(SDL_Window) )    {      HANDLE hMem;      hMem = GlobalAlloc((GMEM_MOVEABLE|GMEM_DDESHARE), dstlen);      if ( hMem != NULL )        {          dst = (char *)GlobalLock(hMem);          convert_data(type, dst, src, srclen);          GlobalUnlock(hMem);          EmptyClipboard();          SetClipboardData(format, hMem);        }      CloseClipboard();    }#endif /* scrap type */}

void CLogGraph::CopyToClipboard(){	if (!m_bDragSel)return;	if ( !OpenClipboard() )	{		AfxMessageBox( "Cannot open the Clipboard" );		return;	} 	if( !EmptyClipboard() )	{		AfxMessageBox( "Cannot empty the Clipboard" );		return;	}	int size = m_pDataEt - m_pDataSt;	tdata* p = m_pDataSt;	CString strsum = "";	CString str;	for (int i = 0; i<size; i++)	{		str.Format("%s, %d/r/n", tformat("%Y-%m-%d %H:%M:%S", p->time), p->temp/100);		strsum += str;		p++;	}	HGLOBAL hGlobal = GlobalAlloc( GHND | GMEM_SHARE, (strsum.GetLength() + 1) *sizeof(TCHAR) );	PSTR pGlobal = (PSTR)GlobalLock( hGlobal );	lstrcpy( pGlobal, TEXT( strsum ) );	GlobalUnlock( hGlobal ); 	if ( ::SetClipboardData( CF_TEXT, hGlobal  ) == NULL )	{		AfxMessageBox( "Unable to set Clipboard data" );		CloseClipboard();		return;	}	CloseClipboard(); }

// CopyToClipBoard ////////////////////////////////////////////////////////1.00//		
C++ Emsg1函数代码示例
C++ EmptyCString函数代码示例