C / C++ / MFC

CPallini shoulda wrote:

About 3 characters.

dtaylor01 wrote:

if (score >= 85);
else if (score >= 75);
else if (score >= 65);
else if (score >= 55);

dtaylor01 wrote:

End if

if (score > 85)
{
    grade = 'A';
}
else if (score >= 75)
{

auralius wrote:

before i run the thread i did put it into a newobj, so meaning that every newobj has its own member

CPROXY *newobj = (CPROXY *)param;

Mark Salsbery
Microsoft MVP - Visual C++

auralius wrote:

eaning that for every thread will be handled by new CPROXY newobj pointer.

auralius wrote:

there is a main function that will call int ServerThreadRunner()

auralius wrote:

What came to my mind is: there is no need for synchronization unless i put the queue as a static variable. am i right?

Mark Salsbery
Microsoft MVP - Visual C++

class CPROXY
{
public:
			
	CPROXY(void);
	~CPROXY(void);

	int Run(int nPort);

	static DWORD WINAPI MotherThread(LPVOID param);
	static DWORD WINAPI DaughterThread(LPVOID param);
	int MotherThreadWorker();
	int DaughterThreadWorker();

	int GetAddressAndPort(char * cStr, char *cAddress, int * nPort);


private:

	ACE_SOCK_Acceptor	client_acceptor;
	ACE_SOCK_Connector	server_connector;

	CRITICAL_SECTION	guard;
	HANDLE			wait;

	bool				isMotherThreadRunning;
	bool				isDaughterThreadRunning;

	static std::list<ACE_SOCK_Stream> queue;
};

CPROXY::CPROXY(void)
{
	InitializeCriticalSection(&guard);
	wait = CreateEvent(NULL, FALSE, FALSE, NULL);
}

CPROXY::~CPROXY(void)
{
}

std::list<ACE_SOCK_Stream> CPROXY::queue; 

int CPROXY::Run(int nPort)
{
	DWORD thid;
	HANDLE hMotherThread = CreateThread(NULL, 0, MotherThread, this, 0, &thid);
	if (!hMotherThread)
		return -1;

	ACE_SOCK_Stream client_stream;
	ACE_INET_Addr addr;
	addr.set(nPort, addr.get_ip_address());

	int e = client_acceptor.open(addr);
	if (e == INVALID_SOCKET)
		return -1;

	while(true)
	{
		int e = client_acceptor.accept(client_stream);
		if (e == INVALID_SOCKET)
			continue;

		//Store in a buffer.
		EnterCriticalSection(&guard);
		queue.push_back(client_stream);
		LeaveCriticalSection(&guard);
	}
	
	return 0;
}

DWORD WINAPI CPROXY::MotherThread(LPVOID param)
{
	CPROXY *newobj = (CPROXY *)param;

	newobj->MotherThreadWorker();

	return 0;
}

int CPROXY::MotherThreadWorker()
{
	isMotherThreadRunning = true;

	while (isMotherThreadRunning)
	{
		EnterCriticalSection(&guard);
		bool isEmpty = queue.empty();
		LeaveCriticalSection(&guard);

		if (!isEmpty){
			DWORD thid;
			HANDLE hDaughterThread = CreateThread(NULL, 0, DaughterThread, this, 0, &thid);
			if (!hDaughterThread)
				continue;

			printf("\nWAITING!\n");
			WaitForSingleObject(wait, INFINITE);
			printf("\nFINISHED!\n");
		}
	}
	return 0;
}

DWORD WINAPI CPROXY::DaughterThread(LPVOID param)
{
	CPROXY *newobj = (CPROXY *)param;

	newobj->DaughterThreadWorker();
        :
        :
	return 0;
}

int CPROXY::DaughterThreadWorker()
{
	char buf[BUFSIZE];
	char cServerAddress[256];
	int  nServerPort;

	EnterCriticalSection(&guard);
	ACE_SOCK_Stream client_stream = queue.front();
	queue.pop_front();
	LeaveCriticalSection(&guard);

	SetEvent(wait);
        :
        :
        :
	return 0;
}

auralius wrote:

Does it still need synchronization?

Mark Salsbery
Microsoft MVP - Visual C++

Quecumber256 wrote:

class Planets
{
public:
double Mercury;
double Mercury();

Quecumber256 wrote:

double Planets::Mercury
double Planets::Mercury()
{
return wgh * 0.4155;
}

Quecumber256 wrote:

system("pause");

#include <iostream>
using namespace std;

class Planet
{
private:
  double _dFactor;

public:
  Planet(double dFactor = 1.0) : _dFactor(dFactor) {} 

  double localWeight(double dWeightOnEarth)
  {
    return dWeightOnEarth * _dFactor;
  }
};
void main()
{
  Planet planetEarth, planetMercury(.38);
  double dYourWeight = 235.6;

  cout << "If your weight on Earth is " << planetEarth.localWeight(dYourWeight) << endl;
  cout << "then weight on Mercury is " << planetMercury.localWeight(dYourWeight) << endl;
}