C / C++ / MFC

Quote:

but it uses system generated default constructors, without parameters of course

Quote:

My goal is to create an instance of the top class with parameters passed to the hierarchy lower chain classes.
Do I make sense?

class A
{
public : 

    A( int p ) : a( p )
    {
    }

protected:
    int a;
};

class B
{
public:

    B( int q ) : b( q )
    {
    }

protected:
    int b;
};

class C : public A, B
{
public : 

    C( int x, int y, int z ) : A( x ), B( y), c( z )
    {
        a = x; // also possible
    }

private:

    int c;
};

int _tmain(int argc, _TCHAR* argv[])
{
    C test( 1, 2, 3 );

	return 0;
}

class TestClass {
public:
	TestClass(const string& InitText) { text = InitText; };
	string text;
};

Vaclav_Sal wrote:

something like class A : ( class A parameter list ), public B : ( class b parameter list)...Is that possible ?

Vaclav_Sal wrote:

BTW I cannot figure out the real syntax / usage of the basic syntax class A : ? For example class A : text{};

Vaclav_Sal wrote:

I am getting tired of folks with " my grandma can beat up yours " attitude.

typedef struct MyStateStruct_t {
    int a;
} MYSTATE;        // typedef the structure to a name

typedef enum {
    MY_SELECTOR_0 = 0,
    MY_SELECTOR_1 = 1
} MyEnum_e;

const MYSTATE myStates[2];   // use structure name

enum MyEnum_e selector = MY_SELECTOR_0;  // Set selector to 0
int result1 = myStates[selector].a;       // result1 is myStates[0].a

selector = MY_SELECTOR_1;  // Set selector to 1
int result2 = myStates[selector].a;       // result2 is myStates[1].a

// Define a structure to pass to thread
typedef struct _MYWATCHERDATA {
	HWND AppWindow;             // Application window to post message to
	UINT MsgId;			        // Your private message ID will be WM_APP + some number
	WPARAM CmdId;               // Command ID .. perhaps you have multiple of these watchers
	char* FolderToWatch;        // The string nominating the folder to watch
	HANDLE dwChangeHandles[2];  // These will be thread wait handles (1 for it, 1 for me to force exit)
	BOOL threadExitComplete;	// Thread exit completed
} WATCHERDATA;

// This is the thread routine
// Pass an initialized structure in on LPARAM Of CreateThread
DWORD WINAPI NotifyMeOfFolderChangeThread(LPVOID lpParam)    // thread procedure
{
	BOOL exitSignal = FALSE;                                 // Preset exit signal to false
	WATCHERDATA* watchData = (WATCHERDATA*)lpParam;	         // Typecast the lParam to your structure you pass in

	// Watch Handle[0] belongs to this thread 
	watchData->dwChangeHandles[0] =
		FindFirstChangeNotification(watchData->FolderToWatch, // folder path passed in
			FALSE,										      // no subfolders
			FILE_NOTIFY_CHANGE_FILE_NAME);				      // watch for renaming, creating, or deleting a file
	
	if (INVALID_HANDLE_VALUE == watchData->dwChangeHandles[0])// Error something is dorked probably folder doesn't exist
	{
		DWORD dwError = ::GetLastError();
		// handle error
		return dwError;
	}

	while (exitSignal == FALSE) {
		// Okay we wait on the notification signal or exernal exit signal
		DWORD dwWaitStatus = WaitForMultipleObjects(2, 
			watchData->dwChangeHandles, FALSE, INFINITE);
		
		switch (dwWaitStatus) {
			// Wait exit was from directory change
			case WAIT_OBJECT_0:
				// Post off message back to application window.
				PostMessage(watchData->AppWindow, watchData->MsgId,
					watchData->CmdId, (LPARAM)watchData->FolderToWatch);
				FindNextChangeNotification(watchData->dwChangeHandles[0]);
				break;
			// External thread signal forcing thread to break out and exit
			case WAIT_OBJECT_0 + 1:
				exitSignal = TRUE;           // Yep time to exit
				break;
		}
	}
	watchData->threadExitComplete = TRUE; // Thread has finished with watchData .. tell app that
	return 0;
}

// Initialize a WATCHERDATA structure
char* watchDirectory = "c:\\temp\\";                                // Some directory to watch
WATCHERDATA* myWatch = (WATCHERDATA*) malloc(sizeof(WATCHERDATA)); // Allocate memory
myWatch->AppWindow = myAppHandle;                                  // Application window handle
myWatch->MsgId = WM_APP  + 100;									   // Some private application message ID 
myWatch->CmdId = 1;										           // Some private id we might have multiple watches
int len = strlen(watchDirectory) + 1;                               // size of string
myWatch->FolderToWatch = (char*) malloc(len);					   // Allocate string space 
strcpy_s(myWatch->FolderToWatch, len, watchDirectory);			   // Copy string to allocated memory        
myWatch->dwChangeHandles[0] = 0;								   // Clear thread handle one .. thread itself uses that
myWatch->dwChangeHandles[1] = CreateEvent(0, FALSE, FALSE, "EXIT");// Set thread handle two for us to force exit
myWatch->threadExitComplete = FALSE;	                           // Thread will set this on complete
																   
// Use thread
HANDLE workerThread = CreateThread(NULL, 0, NotifyMeOfFolderChangeThread, myWatch, 0, NULL);

// Change thread priority
SetThreadPriority(workerThread, THREAD_PRIORITY_LOWEST);

// This will do a simple 10 sec wait .. simulating doing something
Sleep(10000);

// Ok manually terminate the thread
SetEvent(myWatch->dwChangeHandles[1]);

// Wait for thread to signal it has finished with myWatch
while (myWatch->threadExitComplete == FALSE) {};

// Okay you are free to cleanup myWatch
free(myWatch->FolderToWatch);
free(myWatch);