class MyD
	: public ArrayCtrl 
	//works with Label (it has no own Add() overloads, 
	//does not work with ArrayCtrl, it has own Add() overloads
{
public:
	typedef MyD CLASSNAME;
	virtual ~MyD() {}
};

GUI_APP_MAIN
{
	Label l;
	MyD md;
	
	//option 1: << desired >>
	
	void (MyD::* mfp)(Ctrl &) = NULL; 
	mfp = (void (MyD::*)(Ctrl &)) &MyD::Add; 
	//only works if ArrayCtrl:: class has a using Ctrl::Add
	//otherwise
	//error C2440: 'type cast' : cannot convert 
	//from 'overloaded-function' 
	//to 'void (__thiscall Upp::Ctrl::* )(Upp::Ctrl &)' 
	//None of the functions with this name in scope match the target type

	(md.*mfp)(l);
	
	//option 2: doenst work anyway, because binding to Ctrl::Add is clear.
	void (Ctrl::* mfp2)(Ctrl &) = NULL;
	mfp2 = (void (Ctrl::*)(Ctrl &)) &Ctrl::Add; //(void (Ctrl::*)(Ctrl &)) 
	(md.*mfp2)(l); //does *not* call overriden Add(Ctrl&), but the one from Ctrl::
	
	ttest().Run();
}

	mfp = (void (MyD::*)(Ctrl &)) &MyD::Add; 

using Ctrl::Add;

class MyArrayCtrl
	: public ArrayCtrl
{
public:
	typedef MyArrayCtrl CLASSNAME;
	virtual ~MyArrayCtrl() {}
	using Ctrl::Add;
};

class MyD
	: public ArrayCtrl 
{
public:
	typedef MyD CLASSNAME;
	virtual ~MyD() {}
	
	void    Add(Ctrl& ctrl) { Ctrl::Add(ctrl); Update(); }	
};

void (MyD::* mfp)(Ctrl &) = &MyD::Add; 
(md.*mfp)(l);

void (Ctrl::* mfp2)(Ctrl &) = &Ctrl::Add;
(md.*mfp2)(l);

void (MyD::* mfp)(Ctrl &) = &Ctrl::Add; 

mfp = (void (MyD::*)(Ctrl &)) &MyD::Add;

struct Base {
	int result;
	virtual void Add(Ctrl &) { result = 1; }
};

struct Mid : public Base{
	virtual void Add(Ctrl &) { result = 2; }
	void Add(int)			{ result = 4; }
};

struct Top : public Mid{
	void Nothing()  { result = 0; }
};


GUI_APP_MAIN
{
	Label l;
	Top md;
	
	//option 1: << desired >>
	void (Top::* mfp)(Ctrl &) = &Top::Add;
	(md.*mfp)(l);
}

struct Base {
	int result;
	virtual void Add(Ctrl &) { result = 1; }
};

struct Midd : public Base{
	//virtual void Add(Ctrl &) { result = 2; } //EITHER this, virtual or not, no metter
	using Base::Add; //OR this, saves compilation preserving complete Add overloads pool for compiler
	void Add(int)			{ result = 4; }
	void Nothing()   { result = 10; }
};

GUI_APP_MAIN
{
	Label l;
	Midd md;
	
	//option 1: << desired >>
	void (Midd::* mfp)(Ctrl &) = &Midd::Add; //problems even if Mid, not only Top
	(md.*mfp)(l);
}

struct Base1 {
	int result;
	virtual void Add(Ctrl &) { result = 1; }
	virtual void Add(int)			{ result = 2; }
	virtual void Add()			{ result = 3; }
};

struct Midd : public Base1{
	//virtual void Add(Ctrl &) { result = 2; } //EITHER this, virtual or not, no metter
public:
	virtual void Add(int)			{ result = 4; }
	void Nothing()   { result = 10; }
private:
	using Base1::Add; //OR this, saves compilation preserving complete Add overloads pool for compiler
};

GUI_APP_MAIN
{

	Label l1;
	Midd md1;
	
	//option 1: << desired >>
	void (Midd::* mfp1)(Ctrl &) = &Midd::Add; //problems even if Mid, not only Top
	(md1.*mfp1)(l1);
	Exclamation(Format("%d", md1.result));
	
	void (Midd::* mfp12)(int) = &Midd::Add; //problems even if Mid, not only Top
	(md1.*mfp12)(3);
	Exclamation(Format("%d", md1.result));
	
	void (Midd::* mfp13)() = &Midd::Add; //problems even if Mid, not only Top
	(md1.*mfp13)();
	Exclamation(Format("%d", md1.result));
}

1
4
3