Thread: Class functions can't use const =/

For a project due tonight ;-p. The project is done, everything works, but I was going back through the code and saw a few of my node class functions don't accept const input when they should be (for good programming, right?). So I added a few consts in, and I'm getting an error that confuzes me (dealing with converting a const to a non-const). I can't see what needs changed for it to work.

Relevant code:

Code:

void setLR(const Node<T> *l, const Node<T> *r) { setLeft(l); setRight(r); }
void setLeft(const Node<T> *l) { left = l; }  //the error is on this line
void setRight(const Node<T> *r) { right = r; }

Error:

Code:

error C2440: '=' : cannot convert from 'const Node<T> *' to 'Node<T> *'
        with
        [
            T=tool
        ]
        and
        [
            T=tool
        ]
        Conversion loses qualifiers

The node class is templated and for the project I'm using, I have a small tool class I use it with. Any ideas what the problem is?

You can't pass const nodes to the function because it attempts to store them internally as non-const. This makes sense when you consider that at a later point, something might actually modify those nodes. Therefore, pass non-const nodes and you'll be fine. Linked list nodes are non-const by nature anyway - if you don't need to modify the list, what's the point? The strength of the linked list is fast insertion and removal.

Originally Posted by CornedBee

...

Right, but shouldn't they be able to accept const nodes? Because the function itself does not change the node passed to it, just *this.

But 'left' is of type 'Node *', and you can't assign a pointer-to-const (like 'l') to a pointer-to-non-const.

Ah, thanks. I guess that makes sense. But how would you do it so that the pointer doesn't change what it's pointing to? That's what I was trying to do (I believe).

If Node is a template, make the template type const. The Node itself can't be const in order to be included in the list.

Ok, I think I just did it:

Code:

void setLeft(Node<T> *const l) { left = l; }

I just did that for all of the above functions, and I'm pretty sure it does that (makes it unable to change where the pointer points too). Put const after the * and it does that, right? (The program still works as normal, and assuming that code gets called on all inserts, it does that).

Originally Posted by neandrake

Ok, I think I just did it:

Code:

void setLeft(Node<T> *const l) { left = l; }

I just did that for all of the above functions, and I'm pretty sure it does that (makes it unable to change where the pointer points too). Put const after the * and it does that, right? (The program still works as normal, and assuming that code gets called on all inserts, it does that).

Yes, it prevents the pointer passed as argument from being changed. Quite useless, if you ask me. It's just a copy. It's like
void func(const int arg);
Fine, so arg can't be changed inside func. However, that is hardly important for the caller because arg is a copy of the passed argument anyway.

Well, would it be possible to pass as a reference also?

A reference to the pointer? Yes, but it wouldn't make sense. A reference to the node? Yes again, but a pointer makes more sense.