CareerCup

Create class-B as base of class-A with public access. So all the things happening in base class(B) can be visible to derive class(A).

Define the class B as base and class A as derived, while deriving the base use public inheritance. public inheritance is "Is A" relation so everything of B is also part of A.
if you changed anything in B then it automatically will get reflected in A.

Sounds like a typical "observer pattern" scenario. B has to be "observable" and A has to be an "observer" of B's properties.

I would implement an Abstract class which will contain those changes made to B.
Then, both A and B extend this abstract class.

This requires some more information like- do u only need to reflect only those two variables? Can class A can change the variables too? etc.
So far as suggested by Ranjith use of observer pattern seems fair.

using callbacks. Defining a function pointer in class B and initialize its value in B's constructor to some member function of class A. Then each time, when B is changed, call this function pointer, A will notice the change.

what do you mean by "whatever we do change in Class B"? Relation between the instances or classes? you mean static variables?
I am sorry if this annoys you, I am new here.

For me, the question is not quite clear, but this is "an" answer to it (what exactly is "whatever that happens to...")

class A {
	void	ReceiveMessage(Message m)
	{
		/* Do Something with it! */
	};
};

class B {
	A* a_instance; // An instance of A
	// Link to an instance of A
	B(A* x) {
		a_instance = x;
	};
	/* DO SOMETHING */
	void DoSomething()
	{
		// something
		Message m;
		// m <- whatever you want to tell A.
		UpdateA(m);
           };
	void	UpdateA(Message m) {
		a_instance->ReceiveMessage(m);
	};
};

A a;
B b(&a);
B.DoSomthing();