Invalid conversion from class pointer to int

Question

I am unable to figure out what the problem is in the code below

class Node
{
    private:
        int index, value;

    public:
        Node(int index=0, int value=0):index(index),value(value){}

        int getIndex()
        {
            return index;
        }

        int getValue()
        {
            return value;
        }
};


int main()
{
    Node n = new Node(10,10);
    return 0;
}

I get

invalid conversion from Node* to int

`Node n = new Node(10,10);` --> `Node* n = new Node(10,10);` — ks1322, Sep 26 '18 at 14:44
Add an `explicit` to the constructor to avoid the implicit conversion from `int`. — molbdnilo, Sep 26 '18 at 14:55
...and if that `index` really is to be an index, consider making it `unsigned` to avoid all those warnings coming up e.g. when comparing it to some other size / index value (which _are_ usually `unsigned`). — DevSolar, Sep 26 '18 at 14:57

François Andrieux · Accepted Answer · 2018-09-26T15:24:59.970

new returns a pointer. You can't assign a pointer to n, it's a Node. The quick fix would be to change the offending line to Node * n = new Node(10,10); or auto n = new Node(10,10);.

However using new is no longer the recommended solution for the dynamic creation of objects in modern c++. Prefer auto n = std::make_unique<Node>(10, 10); instead which makes n a smart pointer. By using smart pointers, you relieve yourself from having to manually track ownership and from having to remember to delete your object exactly once. You also make your code much more robust in case of unexpected exceptions. You'll need to #include <memory>. See std::make_unique and std::make_shared :

#include <memory>

int main()
{
    auto n = std::make_unique<Node>(10,10);
    return 0;
}

Though in this case, it doesn't seem like dynamic allocation is required. Simply using Node n{10, 10}; would be sufficient.

score 2 · Answer 2 · answered Sep 26 '18 at 14:52

If you want it on the stack

Node n(10, 10);

The object will be made on the stack. It goes out of scope at the end of the function, or even before it (for instance if it was declared in a loop).

If you want it on the heap

Node *n = new Node(10, 10);

The object is allocated on the heap, and a pointer to it is on the stack. It behaves more you'd expect it with Java's "references". The object will not be deleted when the pointer goes out of scope. Instead, delete has to be called at some point or else the memory will be leaked (unlike with Java's "references", which are garbage collected).

Better yet, use a smart pointer and never call `new` and `delete`. Also always useful to look here: https://stackoverflow.com/q/388242/485343 — rustyx, Sep 26 '18 at 14:53

NikNye · Answer 3 · 2018-09-26T15:09:27.083

1

When using the new argument you need to use a pointer. The line

Node n = new Node(10,10);

Should be

Node* n = new Node(10,10);

The error message is because the value returned from new is a numeric location in memory and the closest datatype the compiler knows to represent this is an int.

edited Sep 26 '18 at 15:09

answered Sep 26 '18 at 14:47

NikNye

119
6

A location in memory doesn't look like an int. – rustyx Sep 26 '18 at 14:51
1

OT: looks like the compiler is trying to create a Node from int using its constructor. Unless you really want `Node n = 5;` to succeed, make the constructor `explicit` – Sep 26 '18 at 14:51

Invalid conversion from class pointer to int

3 Answers3

If you want it on the stack

If you want it on the heap