C / C++ / MFC

void RollCharacter (char* MyStr, unsigned short Pos) {
	while (MyStr[Pos] <= 'z') {								
		printf("Permutation string = %s\r\n",  MyStr);	// Print the entry
		MyStr[Pos]++;									// Increment character
	}
}

//To test it
char TestStr[10] = { 0 };		   // Clear an array of character space
TestStr[0] = 'c';                  // Start start character . .. I choose "c"
RollCharacter(TestStr, 0);         // Roll that single character which is column zero

static char CodeSet[6] = { 'a', 'b', 'c', 'A', 'B', 'C'};

void CovertCountToCode(char* Buf,  unsigned short BufSize, unsigned long Count) {
	if ((Buf) && (BufSize)) {										// Sanity check on buffer and size
		BOOL notComplete = TRUE;									// Not completed conversion starts true
		unsigned short column = BufSize - 2;						// We start right column for this
		memset(Buf, 0x20, BufSize);									// Clear buffer to spaces
		Buf[BufSize - 1] = '\0';									// Terminate string
		do {
			unsigned short digit = Count % _countof(CodeSet);		// Modulo to set size to get "digit"
			Buf[column] = CodeSet[digit];							// Transfer the character at set position
			column--;												// Move a column left
			if (Count >= _countof(CodeSet)) {						// If we will need to loop again
				Count /= _countof(CodeSet);							// Divid by set size
				Count--;											// Subtract one  
			} else notComplete = FALSE;								// Loop is now complete
		} while ((notComplete) && (column > 0));					// Loop until complete or out of buffer room
	}
}

void CountInCode(unsigned short MaxCount) {
	char Buf[10];													// Buffer for our display text to build
	unsigned short i;
	for (i = 0; i < MaxCount; i++) {								// For each count
		CovertCountToCode(Buf, _countof(Buf), i);					// Convert count to display text
		printf("Code string = %s\r\n", Buf);						// Print the display text
	}
}

// Code to display first 50 counts .. which will be  ... a to abb
CountInCode(50);

int* r;
r = (int *) malloc ((n+ 1) * sizeof(int));

free(r);

// You will need the forward declares
class USDB;
class HCD;

class USBD {
public:
	void ConnectHCD (HCD* hcd);   // Connect a HCD pointer into a USBD
    void SomeFunction (void);    // Some test function

	HCD* ConnectedHCD; // Pointer to connected buddy class it will be NULL after construction
};

class HCD {
public:
	void ConnectUSBD (USBD* usbd); // Connect a USBD into a HCD

	USBD* ConnectedUSBD; // Pointer to connected buddy class it will be NULL after construction
};

/* Simply hold given HCD pointer .. allows connectedHCD to be private if you want */
void USBD::ConnectHCD (HCD* hcd) {
	ConnectedHCD = hcd;
}

/* Our test function */
void USBD::SomeFunction (void){ 
}

/* Simply hold given USBD pointer ... allows connectedUSBD to be private if you want */
void HCD::ConnectUSBD (USBD* usbd) {
	ConnectedUSBD = usbd;
}

// SO LETS USE IT IN YOUR CODE

/* First we create our class objects */ 
USBD usbd;    // Create a usbd
HCD hcd;      // Create a hcd

/* Then we connect them */
usbd.ConnectHCD(&hcd);  // Connect the created hcd as a pointer into usbd
hcd.ConnectUSBD(&usbd); // Connect the created usbd as a pointer into hcd

// Done you may now freely use the each class inside the other using the pointer
// Dead simple and get around all the mess you are doing .. so lets do one
hcd.ConnectedUSBD->SomeFunction();  // Just call it via the the pointer

void USBD:: SomeFuncThatNeedsHCD (HCD* hcd){
    hcd->SomeHCDFunction();
}

static void SomeStaticCodeWhoAccessHCD (HCD* hcd){
    hcd->SomeHCDFunction();
}

PSOMECLASS* TheClassObject = NULL;

static void InterruptComesInHere (void){
   if (TheClassObject) {                 // Make sure class/object has been set otherwise interrupt just returns
       TheClassObject->CallSomeMethod(); // Send interrupt into class/object if set
   }
}

class IDE_USBD;
class IDE_HCD;

class IDE_USBD {
	// ... this classes data and at least prototypes to functions

public:
	// lets do a prototype
	int Hello(void);
};


class IDE_HCD {
	// ... this classes data and at least prototypes to functions
};

// Class IDE_ILI9341 can now use the above two classes as the compiler can size them
class IDE_ILI9341
{
public:
	IDE_HCD hcd;
	IDE_USBD usbd;
};


// we can put the code for IDE_USBD prototype down here
int IDE_USBD::Hello(void) {

}

class IDE_USBD;
class IDE_HCD;

class IDE_ILI9341
{
public:
	IDE_HCD* hcd;
	IDE_USBD* usbd;
};

class IDE_USB {
};

class IDE_HCD {
};

 hcd = new IDE_HCD ( /* .. parameters it takes ..*/ );
usbd = new IDE_USB ( /* .. parameters it takes ..*/ );

class IDE_USBD;
class IDE_HCD;

class IDE_ILI9341
{
public:
  IDE_HCD hcd;
  IDE_USBD usbd();
  ...