C / C++ / MFC

std::list< std::basic_string< TCHAR > > myList;
//...

PostMessage(hWnd, wParam, (LPARAM) &myList);

//...

std::list< std::basic_string< TCHAR > > * pList = (std::list< std::basic_string< TCHAR> > *) ppsp->lParam;

HRESULT CCSheetExt::AddPages (LPFNADDPROPSHEETPAGE lpfnAddPageProc, LPARAM lParam )

psp.lParam      = (LPARAM) &myList;

BOOL OnInitDialog ( HWND hwnd, LPARAM lParam )

string_list*  pszFile = (string_list*) ppsp->lParam;

std::list<std::basic_string<TCHAR> > m_lsFiles;

HRESULT CCSheetExt::Initialize (LPCITEMIDLIST pidlFolder, LPDATAOBJECT pDataObj, HKEY hProgID )
{
TCHAR     szFile [MAX_PATH];
UINT      uNumFiles;
HDROP     hdrop;
FORMATETC etc = { CF_HDROP, NULL, DVASPECT_CONTENT, -1, TYMED_HGLOBAL };
STGMEDIUM stg;

    // Read the list of items from the data object.  They're stored in HDROP
    // form, so just get the HDROP handle and then use the drag 'n' drop APIs
    // on it.
    if ( FAILED( pDataObj->GetData ( &etc, &stg )))
        return E_INVALIDARG;

    // Get an HDROP handle.
    hdrop = (HDROP) GlobalLock ( stg.hGlobal );

    if ( NULL == hdrop )
        {
        ReleaseStgMedium ( &stg );
        return E_INVALIDARG;
        }

    // Determine how many files are involved in this operation.
    uNumFiles = DragQueryFile ( hdrop, 0xFFFFFFFF, NULL, 0 );
    for ( UINT uFile = 0; uFile < uNumFiles; uFile++ )
        {
        // Get the next filename.
        if ( 0 == DragQueryFile ( hdrop, uFile, szFile, MAX_PATH ))
            continue;

        // Add the filename to our list of files to act on.
        m_lsFiles.push_back ( szFile );
        }   // end for

    // Release resources.
    GlobalUnlock ( stg.hGlobal );
    ReleaseStgMedium ( &stg );

    // If we found any files we can work with, return S_OK.  Otherwise,
    // return E_FAIL so we don't get called again for this right-click
    // operation.
    return ( m_lsFiles.size() > 0 ) ? S_OK : E_FAIL;
}

HRESULT CCSheetExt::AddPages (LPFNADDPROPSHEETPAGE lpfnAddPageProc, LPARAM lParam )
{
PROPSHEETPAGE  psp;
HPROPSHEETPAGE hPage;
TCHAR          szPageTitle [MAX_PATH];
string_list::const_iterator it, itEnd;
          
		LoadString (hModuleInstance,IDS_PROJNAME,szPageTitle,sizeof(szPageTitle));
		szPageTitle[24] = '\0';

        psp.dwSize      = sizeof(PROPSHEETPAGE);
        psp.dwFlags     = PSP_USEREFPARENT | PSP_USETITLE | PSP_DEFAULT |
                            PSP_USECALLBACK;
        psp.hInstance   = hModuleInstance;
        psp.pszTemplate = MAKEINTRESOURCE(IDD_PROPPAGE);
	psp.pszIcon     = 0; 
        psp.pszTitle    = szPageTitle;
        psp.pfnDlgProc  = PropPageDlgProc;
        psp.lParam      = (LPARAM) &m_lsFiles;
        psp.pfnCallback = PropPageCallbackProc;
        psp.pcRefParent = (UINT*) &_Module.m_nLockCnt;

        hPage = CreatePropertySheetPage ( &psp );

        if ( NULL != hPage )
            {
            // Call the shell's callback function, so it adds the page to
            // the property sheet.
            if ( !lpfnAddPageProc ( hPage, lParam ))
                {
                DestroyPropertySheetPage ( hPage );
                }
            }

    return S_OK;
}

BOOL OnInitDialog ( HWND hwnd, LPARAM lParam )
{        
PROPSHEETPAGE*  ppsp = (PROPSHEETPAGE*) lParam;
string_list*  pszFile = (string_list*) ppsp->lParam;
HANDLE          hFind;
WIN32_FIND_DATA rFind;

	string_list::const_iterator it;

	it = pszFile->begin();
	CCOMString File=it->c_str();
	MessageBox (0, File, "Tests", 0);

}

void CChildDlg::OnHScroll(whatever)
{
    CParentDlg *pParent = (CParentDlg *)GetParent();
    pParent->UpdateZoomInfo(some info about the zoom);
}

class school
{
public:
  vector<student*> students; // remove the pointer for the vector.

school()
{
  // nothing is really needed in the constructor.
}
}

int main()
{
  student* pStudent = new student; // the vector contains pointers to students; so you need to allocate on the heap.
  school aSchool; // allocated on the stack.
  aSchool.students.push_back( pStudent );

  //...
  
  // don't forget to delete all the allocated student pointers (I'll leave that as an exercise)
  return 0;
}

neodeaths wrote:

students.push_back(&s);

class school {
public:
   vector<student*>* students;
   school()
   {
      students = new vector<student*>:
   }
   ~school()
   {
      delete students;
   }
};

#include <windows.h>
#include <stdio.h>
#include <assert.h>
#include <queue>

template <typename T>
class BlockingQueue
{
public:
	BlockingQueue()
	{
		InitializeCriticalSection(&m_Lock);
		m_hBecameNonEmptyEvent = CreateEventW(NULL, TRUE, FALSE, NULL);
	}

	~BlockingQueue()
	{
		assert(m_Queue.empty());
		DeleteCriticalSection(&m_Lock);
		CloseHandle(m_hBecameNonEmptyEvent);
	}

	// Works well with many producer threads.
	void Put(const T& item)
	{
		EnterCriticalSection(&m_Lock);
		if (m_Queue.empty())
			SetEvent(m_hBecameNonEmptyEvent);
		m_Queue.push(item);
		LeaveCriticalSection(&m_Lock);
	}

	// You should call this with only one consumer thread.
	void Get(T& item)
	{
		EnterCriticalSection(&m_Lock);
		if (m_Queue.empty())
		{
			ResetEvent(m_hBecameNonEmptyEvent);
			LeaveCriticalSection(&m_Lock);
			WaitForSingleObject(m_hBecameNonEmptyEvent, INFINITE);
			EnterCriticalSection(&m_Lock);
		}

		item = m_Queue.front();
		m_Queue.pop();
		LeaveCriticalSection(&m_Lock);
	}

private:
	BlockingQueue(const BlockingQueue&);
	BlockingQueue& operator=(const BlockingQueue&);

private:
	CRITICAL_SECTION m_Lock;
	HANDLE m_hBecameNonEmptyEvent;
	std::queue<T> m_Queue;
};

BlockingQueue<int> q;

DWORD __stdcall ThreadProc(void* param)
{
	printf("thread started\n");
	for (;;)
	{
		int i;
		q.Get(i);
		printf("processing %d\n", i);
		if (i == 0)
			break;
	}
	printf("thread is out of the loop, returning from threadproc...\n");
	return 0;
}


int main(int argc, char* argv[])
{
	printf("Creating thread...\n");
	DWORD thread_id;
	HANDLE hThread = ::CreateThread(NULL, 0, ThreadProc, NULL, 0, &thread_id);
	if (!hThread)
	{
		fprintf(stderr, "CreateThread error!\n");
		return 1;
	}

	for (;;)
	{
		char buf[0x100];
		if (!gets(buf))
			break;
		int i;
		if (1 == sscanf(buf, "%d", &i))
		{
			q.Put(i);
			if (i == 0)
				break;
		}
		else
		{
			printf("Not an integer: %s\n", buf);
		}
	}

	printf("Waiting for the thread to finish...\n");
	WaitForSingleObject(hThread, INFINITE);
	printf("Wait finished.\n");
	CloseHandle(hThread);
	return 0;
}

bkelly13 wrote:

This application will be sending

bkelly13 wrote:

This application will be sending between three and nine messages per millisecond