Const reference problem

[rag84dec]

Hi
I have a class A
Defind like this

class A
{public:
const ClassB &bInstance;
void function();
}
 

Class ClassB is defined like this

class ClassB
{
public:
void publish();
}
 

If i want to use the bInstance....How can i use....
i tried like this....

void A::function()
{
    bInstance.publish();
}
 
 

I gave me an error "cannot convert cont class to class &"

Soooo I changed the code like this...

void A::function()
{
   ClassB *temp=(ClassB*)&bInstance;
    temp->publish();
}
 
 
 

And it worked...But i want to know the exact reason....please someone help....

[Banfa]

class A
{public:
const ClassB &bInstance;
void function();
}
 

class ClassB
{
public:
void publish();
}
 

You have declared the member of type B (bInstance) in A as a constant reference. That means that A can not change the data referenced.

However in class B the function publish is declared normally, that means that it may change some of the member data of B so when you declare

void A::function()
{
    bInstance.publish();
}
 

You are using a constant reference to try and call a function that may change the instance of B, that is not allowed.

All the casts you did to make it work are a very bad idea, you have basically hacked your way round the the C++ type checking which, when left alone, greatly increase the robustness of your program.

You should do 1 of 2 things either

1. Change the declaration of B

class ClassB
{
public:
   void publish() const;
}
 

Adding the const keyword indicates that the function publish does not change any members of B.

2. Change the declaration of A

class A
{
public:
    ClassB &bInstance;
    void function();
}
 

Removing the const keyword indicates that A can use the reference to change the instence of B referenced.

[weaknessforcats]

void A::function()
{
ClassB *temp=(ClassB*)&bInstance;
temp->publish();
}

Do not cast. bInstance is a const reference. To use it, your function must be const:

void A::function() const
{
  bInstance.publish();
}
 

That will re-assure the compiler that A::function() is not going to change member data.

Casting in C++ usually means a) you are calling a relic C funciton that has void* arguments or some such, or b) your C++ design is weak.

That cast requires the compiler to create a non-const copy of bInstance. That requires a ClassB copy constructor call plus potentially copy constructor call for other members of ClassB plus potentially copy constructor calls for memebers of ClassB that are also class objects, etc... into the sunset.