C / C++ / MFC

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

STARTUPINFO si = { sizeof(si) };
PROCESS_INFORMATION pi;
BOOL bOk = CreateProcess(
		_T("C:\\Windows\\system32\\notepad.exe"),
		NULL,
		NULL,
		NULL,
		FALSE,
		0,
		NULL,
		NULL,
		&si,
		&pi
		);
if (bOk)
{
	CloseHandle(pi.hThread); // We don't need so don't leak it!
	WaitForSingleObject(pi.hProcess, INFINITE);
	CloseHandle(pi.hProcess); // We're finished with it.

	MessageBox(NULL, _T("Finished"), _T("Create and wait"), MB_OK);
}

ed welch wrote:

yet other programs use it without any problems.