C / C++ / MFC

void CChatView::OnChatroomAddtoautojoin()<br />
{<br />
CString strOut;<br />
			strOut.Format(IDS_AUTOJOIN_ADD, GetDocument()->m_strRoom);<br />
			WriteSystemMsg(FALSE, strOut, g_sSettings.GetRGBOK());<br />
	CClipboard::SetText((LPSTR)(LPCSTR)GetDocument()->m_strRoom);<br />
<br />
	OpenClipboard();<br />
	m_strAdd = CClipboard::GetText();<br />
    CloseClipboard();<br />
<br />
	ManageAutojoins dlg;<br />
	dlg.DoModal();<br />
}

<br />
#ifndef __CCLIPBOARD_H<br />
#define __CCLIPBOARD_H<br />
<br />
class CClipboard<br />
{<br />
public:<br />
	static CString GetText(HWND hWnd = NULL);<br />
	static BOOL GetText (LPSTR lpszBuffer,<br />
						 int nBufSize,<br />
						 HWND hWnd = NULL);<br />
	<br />
	static BOOL GetTextLength (unsigned long *pnSize,<br />
							   HWND hWnd = NULL);<br />
	<br />
	static BOOL SetText (LPSTR lpszBuffer,<br />
						 HWND hWND = NULL);<br />
};<br />
<br />
#endif

#include "stdafx.h"<br />
#include "Clipboard.h"<br />
<br />
////////////////////////////////////////////////////////////////////<br />
// GetText<br />
// - Retrieves text from the clipboard<br />
////////////////////////////////////////////////////////////////////<br />
//<br />
// Parameters:<br />
//	lpszBuffer - pointer to a string where the text is to be put<br />
//	nBufSize   - allocated length of lpszBuffer<br />
//	hWnd       - window handle to be used by clipboard<br />
//<br />
// Return Values:<br />
//	TRUE       - Text was successfully copied from clipboard<br />
//	FALSE      - No text on the clipboard<br />
//<br />
////////////////////////////////////////////////////////////////////<br />
<br />
BOOL CClipboard::GetText (LPSTR lpszBuffer, int nBufSize, HWND hWnd)<br />
{<br />
	HGLOBAL hGlobal;		// Global memory handle<br />
	LPSTR lpszData;			// Pointer to clipboard data<br />
	unsigned long nSize;	// Size of clipboard data<br />
<br />
	// First, open the clipboard. OpenClipboard() takes one<br />
	// parameter, the handle of the window that will temporarily<br />
	// be it's owner. If NULL is passed, the current process<br />
	// is assumed.<br />
	OpenClipboard(hWnd);<br />
<br />
	// Request a pointer to the text on the clipboard.<br />
	hGlobal = GetClipboardData(CF_TEXT);<br />
<br />
	// If there was no text on the clipboard, we have<br />
	// been returned a NULL handle.	<br />
	if (hGlobal == NULL) return FALSE;<br />
<br />
	// Now we have a global memory handle to the text<br />
	// stored on the clipboard. We have to lock this global<br />
	// handle so that we have access to it.<br />
	lpszData = (LPSTR)GlobalLock(hGlobal);<br />
	// Now get the size of the text on the clipboard.<br />
	nSize = GlobalSize(hGlobal);<br />
<br />
	// Make sure the text on the clipboard is not longer<br />
	// that the buffer that was allocated for it. If it was<br />
	// snip the text on the clipboard so that it fits.<br />
	if(nSize >= (UINT)nBufSize) nSize = nBufSize - 1;<br />
<br />
	// Now, copy the text into the return buffer. At the<br />
	// end, we need to add a NULL string terminator.<br />
	for (UINT i = 0; i < nSize; ++i)<br />
		*(lpszBuffer + i) = *(lpszData + i);<br />
	*(lpszBuffer + i) = 0;<br />
<br />
	// Now, simply unlock the global memory pointer<br />
	// and close the clipboard.<br />
	GlobalUnlock(hGlobal);<br />
	CloseClipboard();<br />
<br />
	return TRUE;<br />
}<br />
<br />
////////////////////////////////////////////////////////////////////<br />
// GetTextLength<br />
// - Retrieves length of text on the clipboard<br />
////////////////////////////////////////////////////////////////////<br />
//<br />
// Parameters:<br />
//	pnSize     - pointer to unsigned long that will receive<br />
//               the length of the text on the clipboard.<br />
//               NOTE: Does not include NULL terminator.<br />
//	hWnd       - window handle to be used by clipboard<br />
//<br />
// Return Values:<br />
//	TRUE       - Text length was successfully returned.<br />
//	FALSE      - No text on the clipboard<br />
//<br />
////////////////////////////////////////////////////////////////////<br />
<br />
BOOL CClipboard::GetTextLength (unsigned long *pnSize, HWND hWnd)<br />
{<br />
	HGLOBAL hGlobal;		// Global memory handle<br />
	unsigned long nSize;	// Size of clipboard data<br />
	LPSTR lpszData;			// Pointer to clipboard data<br />
<br />
	// First, open the clipboard. OpenClipboard() takes one<br />
	// parameter, the handle of the window that will temporarily<br />
	// be it's owner. If NULL is passed, the current process<br />
	// is assumed.<br />
	OpenClipboard(hWnd);<br />
<br />
	// Request a pointer to the text on the clipboard.<br />
	hGlobal = GetClipboardData(CF_TEXT);<br />
<br />
	// If there was no text on the clipboard, we have<br />
	// been returned a NULL handle.	<br />
	if (hGlobal == NULL) return FALSE;<br />
<br />
	// Now we have a global memory handle to the text<br />
	// stored on the clipboard. We have to lock this global<br />
	// handle so that we have access to it.<br />
	lpszData = (LPSTR)GlobalLock(hGlobal);<br />
	// Now get the size of the text on the clipboard.<br />
	nSize = GlobalSize(hGlobal);<br />
<br />
	// Now, simply unlock the global memory pointer<br />
	// and close the clipboard.<br />
	GlobalUnlock(hGlobal);<br />
	CloseClipboard();<br />
<br />
	// Finally, save the length of the string we found<br />
	// into the pnSize pointer and return.<br />
	*pnSize = nSize;<br />
	return TRUE;<br />
}<br />
<br />
////////////////////////////////////////////////////////////////////<br />
// SetText<br />
// - Places text on the clipboard<br />
////////////////////////////////////////////////////////////////////<br />
//<br />
// Parameters:<br />
//	lpszBuffer - pointer to a string where the text is to be put<br />
//	hWnd       - window handle to be used by clipboard<br />
//<br />
// Return Values:<br />
//	TRUE       - Text was successfully copied from clipboard<br />
//	FALSE      - No text on the clipboard<br />
//<br />
////////////////////////////////////////////////////////////////////<br />
<br />
int CClipboard::SetText (LPSTR lpszBuffer, HWND hWnd)<br />
{<br />
	HGLOBAL hGlobal;		// Global memory handle<br />
	LPSTR lpszData;			// Pointer to clipboard data<br />
	unsigned long nSize;	// Size of clipboard data<br />
<br />
	// First, open the clipboard. OpenClipboard() takes one<br />
	// parameter, the handle of the window that will temporarily<br />
	// be it's owner. If NULL is passed, the current process<br />
	// is assumed. After opening, empty the clipboard so we<br />
	// can put our text on it.<br />
	OpenClipboard(hWnd);<br />
	EmptyClipboard();<br />
<br />
	// Get the size of the string in the buffer that was<br />
	// passed into the function, so we know how much global<br />
	// memory to allocate for the string.<br />
	nSize = lstrlen(lpszBuffer);<br />
<br />
	// Allocate the memory for the string.<br />
	hGlobal = GlobalAlloc(GMEM_ZEROINIT, nSize+1);<br />
	<br />
	// If we got any error during the memory allocation,<br />
	// we have been returned a NULL handle.<br />
	if (hGlobal == NULL) return FALSE;<br />
<br />
	// Now we have a global memory handle to the text<br />
	// stored on the clipboard. We have to lock this global<br />
	// handle so that we have access to it.<br />
	lpszData = (LPSTR)GlobalLock(hGlobal);<br />
<br />
	// Now, copy the text from the buffer into the allocated<br />
	// global memory pointer.<br />
	for (UINT i = 0; i < nSize + 1; ++i)<br />
		*(lpszData + i) = *(lpszBuffer + i);<br />
<br />
	// Now, simply unlock the global memory pointer,<br />
	// set the clipboard data type and pointer,<br />
	// and close the clipboard.<br />
	GlobalUnlock(hGlobal);<br />
	SetClipboardData(CF_TEXT, hGlobal);<br />
	CloseClipboard();<br />
<br />
	return TRUE;<br />
}<br />
<br />
<br />
CString CClipboard::GetText(HWND hWnd)<br />
{<br />
<br />
	CString strReturn;<br />
	ULONG nLen = 0;<br />
	char *buffer = 0;<br />
<br />
	if(GetTextLength(&nLen, hWnd)){<br />
<br />
		buffer = new char[nLen];<br />
		GetText(buffer, nLen, hWnd);<br />
		strReturn = buffer;<br />
		delete buffer;<br />
		buffer = 0;<br />
	}<br />
	return strReturn;<br />
}<br />

1. You don't need to call OpenClipboard() and CloseClipboard() - they are called in the CClipboard functions.
   
2. The DDX_Text() statement will only be executed when DoDataExchange() is called. You have to do more than just set the value in m_strAdd - you have to force DoDataExchange() to be called. You can do this by calling UpdateData(FALSE);.

//---------------------------------------------------------------------------
#pragma hdrstop
//---------------------------------------------------------------------------
#pragma argsused
#include <iostream.h>
//---------------------------------------------------------------------------
class Tkontaktai {                                                // Bazin・klas・
    char vardas[20];
    char tel[12];
public:
    Tkontaktai( ) {vardas[0] = tel[0] = '\0';}
    void saugok(char *v, char *t) {strcpy(vardas, v); strcpy(tel, t);}
    virtual void rodyk( ) {cout << vardas << ", " << tel;}  // Virtualus metodas
    char *s_vardas( ) {return vardas;}
    char *s_tel( ) {return tel;}
};
 
//-------------------------------------------------------
 
template <class T>
class Tnode {
    Tnode *kitas;                                                               // Ry?io dalis
public:
        T duomenys;                                                  // Duomen? laukas
        Tnode (T re, Tnode * rod = NULL):duomenys(re), kitas (rod){ };  // Konstruktorius
        Tnode * Paimti ();                                                // Prijungto elemento pa?alinimas
        void Prijungti  (Tnode *y){                 // Prijungimo metodas
                kitas= y;                         
        }
        Tnode *Papildyti (Tnode *y){          // Papildymo metodas
        y->kitas = this;                            // Aktyvaus objekto rodykl?
        return y;                              // Junginio adresas
        }
        Tnode * Rkitas () {return kitas; }      // Kreipinys ? ry?io dal?
};
 
//-------------------------------------------------------
template <class T>
class Tstack {
   Tnode<T> *head;                                                // Eil?s prad?ia (galva)
public:            // Metod? prototipai
        Tstack () {head= NULL; }                                   // Tu??io steko konstruktorius
    ~Tstack<T>();
        T Pop ();                                                                 // Pradinio elemento skaitymas
        void Push (T y);
        int Empty();
    ostream& operator<< (Tkontaktai* );
};
//-------------------------------------------------------
template <class T>
void Tstack<T>::Push(T y){
        Tnode<T> * temp= new Tnode<T> (y,head);  // Naujas elementas prad?ioje
//    head=head->Papildyti(temp);
        head= temp;                         // Naujas prad?ios adresas
}
//-------------------------------------------------------
template<class T>
T Tstack<T>::Pop(){                         // Elemento pa?alinimo metodas
    Tnode<T> *temp= head;                               // ?alinamo elemento adresas
            T re=head->duomenys;                                                // ?alinamo elemento duomenys
    head = head->Rkitas();                              // Elemento pa?alinimas
    delete temp;                                                                        // Atminties i?laisvinimas
    return re;                    // Reik?m?s gr??inimas
}
//-------------------------------------------------------
template <class T>                                                // Destruktoriaus realizavimas 
Tstack<T>::~Tstack<T>() {
        Tnode<T> *temp;
        while (head){
        temp = head;
        head = head->Rkitas();
        delete temp;
        }
}
//-------------------------------------------------------
template <class T>
int Tstack<T>::Empty(){
        if(head)
                return 0;
        else
                return 1;
}
//-------------------------------------------------------
template<class T>
ostream& Tstack<T>::operator<< (Tkontaktai* duom){
    ostream& outstr;
    outstr << duom->s_vardas() << " " << duom->s_tel() << endl;
    return ostr;
}
//-------------------------------------------------------
 
main(){
    Tstack<Tkontaktai> x;
    Tkontaktai k;
    char vardas[20];                                // Tu??ios eil?s suk?rimas
    char tel[12];
 
    for (int i = 0; i<3; i++){              // Skai?i? eil?s formavimas
         cout << "vardas: ";
         cin >> vardas;
         cout << "telefonas: ";
         cin >> tel;
         k.saugok(vardas, tel);
         x.Push(k);
    }
 
        cout<< "Eileje buvo sie skaiciai:"<< endl;
        while (!(x.Empty()))
        cout << x.Pop() << endl;
    system("pause");
}
//-------------------------------------------------------

class Tkontaktai {                                                // Bazin?klas?
    char vardas[20];
    char tel[12];
public:
	//...
    char *s_vardas( ) {return vardas;}
    char *s_tel( ) {return tel;}
};
//--------
template<class T>
ostream& Tstack::operator<< (Tkontaktai* duom){
    ostream& outstr;
    outstr << duom->s_vardas() << " " << duom->s_tel() << endl;
    return ostr;
}
//--------
template<class T>
Tstack::Pop(){                         // Elemento pa?alinimo metodas
    Tnode *temp= head;                               // ?alinamo elemento adresas
            T re=head->duomenys;                                                // ?alinamo elemento duomenys
    head = head->Rkitas();                              // Elemento pa?alinimas
    delete temp;                                                                        // Atminties i?laisvinimas
    return re;                    // Reik?m?s gr??inimas
}
//--------
main(){
//...
cout << x.Pop() << endl;

}

Dj_Lordas wrote:

templateostream& Tstack::operator<< (Tkontaktai* duom){ ostream& outstr; outstr << duom->s_vardas() << " " << duom->s_tel() << endl; return ostr;}

class Tkontaktai
{
public:
    friend ostream& operator<<( ostream&, const Tkontaktai& );
};
ostream& operator<<( ostream &os, const Tkontaktai &duom )
{
    return os << duom.vardas << " " << duom.tel << endl;
}