C / C++ / MFC

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();
  ...

int i;                               // You created an integer type called i
double d;                            // You created a double called d
DownloadManager objDownloadManager;  // You created a DownloadManager called objDownloadManager

int* i;                               // You created a pointer to an integer type called i
double* d;                            // You created a pointer to a double type called d
DownloadManager* objDownloadManager;  // You created a pointer to a DownloadManager type called objDownloadManager

Ratul Thakur wrote:

...what does FGAPIENTRY stand for...

// Function pointer assignment should just provide the function (and class) name
FunctionPointer_B = &INHERITANCE_A::Process_INHERITANCE_A;

// call the function through the pointer by
FunctionPointer_B(Text);

class INHERITANCE_B  {

};

class INHERITANCE_C {

};

class INHERITANCE_A : public INHERITANCE_B, public INHERITANCE_C
{
public:

	void Process_INHERITANCE_A(char *Text);
	bool TestFunctionPointer(char*Text);

};

typedef void(INHERITANCE_A::*FunctionPointer_B)(char *);

bool INHERITANCE_A::TestFunctionPointer(char*Text)
{
	FunctionPointer_B somePtr = &INHERITANCE_A::Process_INHERITANCE_A;
	return true;
}

void INHERITANCE_A::Process_INHERITANCE_A(char *Text)
{

}

 void someFunc (char* text){
     // .... some code in here
}

// Here are our two function pointers
void(*FunctionPointer_A)(char *);
void(*FunctionPointer_B)(char *);

// You can set either of them to the function using the & symbol .. item 1 use of function pointers
FunctionPointer_A = &someFunc;
FunctionPointer_B = &someFunc;

// Or you can set one and copy the other which is item 1 then item 2 use of function pointers
FunctionPointer_A = &someFunc;
FunctionPointer_B = FunctionPointer_A ;

FunctionPointer_B = Process_INHERITANCE_A( Text);

FunctionPointer_B = &INHERITANCE_A::Process_INHERITANCE_A;

void(INHERITANCE_A::*FunctionPointer_B)(char *);