Simple const * question

[Jaco Naude]

Hi

I've been struggling with something that should be very simple to
solve... Basically, I get a const Obj* from a function and I need to
send a pointer to this object to a function accepting only a Obj*. I
get compiler errors as shown below:

source\ManagerViewer.cpp: In member function `void
managerViewer::addLoggerWidget(const QWidget*)':
source\ManagerViewer.cpp:26: error: invalid conversion from `const
QWidget*' to `QWidget*'

I understand that the following will result in a pointer which can be
changed, and the compiler stops:
QWidget* widget = const_widget_ptr;

But the function accepting the pointer is not my own and I need to
send a non-const pointer to it.

Is there a way to work around this?
Thanks in advance
Jaco

 

[Andrew Koenig]

I've been struggling with something that should be very simple to
solve... Basically, I get a const Obj* from a function and I need to
send a pointer to this object to a function accepting only a Obj*.

No you don't. Or at least you don't need to ask advice about how to do it.

If you have a const Obj*, that means you have a pointer to an object that
you have promised not to modify.

If you have a function that accepts only an Obj*, it means that the function
reserves the right to modify the object.

So what you are trying to do is to figure out how to break your promise not
to modify the object. The best advice -- and the only advice I can advocate
until you convince me that it is really important to do otherwise -- is
"Don't do it."

 

[.rhavin grobert]

No you don't.  Or at least you don't need to ask advice about how to do it.

If you have a const Obj*, that means you have a pointer to an object that
you have promised not to modify.

If you have a function that accepts only an Obj*, it means that the function
reserves the right to modify the object.

So what you are trying to do is to figure out how to break your promise not
to modify the object.  The best advice -- and the only advice I can advocate
until you convince me that it is really important to do otherwise -- is
"Don't do it."

Guess the following:

int Obj::Read() const;
int Obj::Write(int iWhatever);

int PrettyFunction(int iCommand, Obj* pObject, int iAux)
{
switch(iCommand)
{
case CMD_READ:
return pObject->Read();
case CMD_WRITE:
return pObject->Write(iAux);
default:
DropBombOnWhiteHouse();
}
}

If you have a Obj const* it would still be apropriate to call the
PrettyFunction with the CMD_WRITE by const_cast'ing.

 

[.rhavin grobert]

Guess the following:

int Obj::Read() const;
int Obj::Write(int iWhatever);

int PrettyFunction(int iCommand, Obj* pObject, int iAux)
{
  switch(iCommand)
  {
  case CMD_READ:
    return pObject->Read();
  case CMD_WRITE:
    return pObject->Write(iAux);
  default:
    DropBombOnWhiteHouse();
  }

}

If you have a Obj const* it would still be apropriate to call the
PrettyFunction with the CMD_WRITE by const_cast'ing.

err, i meant "CMD_READ" and forgot a "return" ;-)

 

[Salt_Peter]

Guess the following:

int Obj::Read() const;
int Obj::Write(int iWhatever);

int PrettyFunction(int iCommand, Obj* pObject, int iAux)
{
switch(iCommand)
{
case CMD_READ:
return pObject->Read();
case CMD_WRITE:
return pObject->Write(iAux);
default:
DropBombOnWhiteHouse();
}

}

If you have a Obj const* it would still be apropriate to call the
PrettyFunction with the CMD_WRITE by const_cast'ing.

That you could do it, yes, thats its appropriate, no.
The problem here is you are passing a pointer to a constant and
looking for a way to break a promise.
To drive the point a little further, the parameter Obj* pObject should
really be
Obj* const pObject
where that crucial pointer can't be reseated (or better yet Obj&
r_obj).

If the client of your code sees a constant pointer to a constant (ie:
const Obj* const pObject), the last thing the client will expect is
that the pointee gets modified or reseated. Either would break the
contract and in essence: the interface. At that point your client (who
might very well be yourself in the near future) will then face the
horror of having to read and consult every line of code because the
interface can no longer be trusted.

 

[James Kanze]

I've been struggling with something that should be very simple
to solve... Basically, I get a  const Obj* from a function and
I need to send a pointer to this object to a function
accepting only a Obj*. I get compiler errors as shown below:

source\ManagerViewer.cpp: In member function `void
managerViewer::addLoggerWidget(const QWidget*)':
source\ManagerViewer.cpp:26: error: invalid conversion from `const
QWidget*' to `QWidget*'

I understand that the following will result in a pointer which
can be changed, and the compiler stops:
QWidget* widget = const_widget_ptr;

But the function accepting the pointer is not my own and I
need to send a non-const pointer to it.

Is there a way to work around this?

Others have already pointed out many of the issues, but I'll
jump on one additional point. I don't know what QWidgit is, but
from it's name, it sounds like a windowing component. And
normally, there's never any reason to put const on a pointer to
a windowing component. The design error is likely in the
signature of addLoggerWidget, which should take a QWidgit*, and
not a QWidgit const*.