How come a C++ template returns a hexadecimal value?

Question

I have a simple C++ class that uses generic templates to store and retrieve generic variables. Storing them is no issue but returning the generic variable returns a hexadecimal value.

Could someone tell me why it's doing that?

node.h

#pragma once
#include <iostream>

template <typename T>
class Node {
    private:
        T data;
        Node *next_node;

    public:
        Node(T data) {
            this->data = data;
            std::cout << "Node with data - " << this->data << " - has been created." << std::endl;
        }
        
        T get_data() {
            return this->data;
        }
        
        void set_next_node(Node next) {
            this->next_node = next;
        }

        Node get_next_node() {
            return this->next_node;
        }
};

main.cpp

#include <iostream>
#include "node.h"

int main() {

    Node node = new Node("Hello World");

    std::cout << "Node data: " << node.get_data() << std::endl;

    return 0;
}

output

gabriel@desktop:/media/gabriel/main/repositories/CPP Sandbox/nodes$ g++ main.cpp -o main
gabriel@desktop:/media/gabriel/main/repositories/CPP Sandbox/nodes$ ./main
Node with data - Hello World - has been created.
Node with data - 0x55ec552d3eb0 - has been created.
Node data: 0x55ec552d3eb0

The code you show, and the output you show, do not match. Your code won't even compile Please provide a [mre] — ChrisMM, Feb 22 '23 at 17:12
what do you think that `T` is ? and very much related to that, why do you use `new`? — 463035818_is_not_an_ai, Feb 22 '23 at 17:12
@ChrisMM What do you mean the output doesn't match? I've updated the question. — Gabriel Gavrilov, Feb 22 '23 at 17:13
you mangaged to get `Node x = new Node` to compile, +1 for that. It is an interesting case of maximum confusion caused by pointless use of `new`. — 463035818_is_not_an_ai, Feb 22 '23 at 17:14
The text in it is different from the output. Thus, they cannot be connected. — ChrisMM, Feb 22 '23 at 17:14
@ChrisMM it does compile, there are two different instantations of `Node` — 463035818_is_not_an_ai, Feb 22 '23 at 17:15
@463035818_is_not_a_number, you're right. Should have read more carefully. Though, output still doesn't match with code. — ChrisMM, Feb 22 '23 at 17:15
@463035818_is_not_a_number You're right. Removing the new fixed it. When should I use ``new`` when initiating a class? (I'm still learning C++ so please bare with me). — Gabriel Gavrilov, Feb 22 '23 at 17:16
The OP's first line of code in their `main` is effectively doing this: `Node node{ new Node("Hello World") };`. Thus creating *two* nodes with the named one having it's template type as `Node*`. — Adrian Mole, Feb 22 '23 at 17:16
Mmm... I never considered class template argument deduction could have this specific gotcha. C++ and its emerging properties gets "better" every day. — StoryTeller - Unslander Monica, Feb 22 '23 at 17:18
I don't think the duplciate is appropriate. There is much more going on in this code. And the address is not from printing an array. Vote to reopen — 463035818_is_not_an_ai, Feb 22 '23 at 17:18
What do you think the value of `T` is for `node`? `std::string`? `const char[12]`? What you actually have is a `Node*>`. — Nathan Pierson, Feb 22 '23 at 17:19
Wow, this line `Node x = new Node` is ultra confusing, I think it deserves an actual answer. — pptaszni, Feb 22 '23 at 17:21
"This line" is the result of someone who knows C# or Java attempting to learn C++ and assuming that C++ works the same way. It doesn't. — Sam Varshavchik, Feb 22 '23 at 17:29
the funny thing is that its possible to write another constructor and a deduction guide that makes `Node x = new Node` do the "right thing". Finally it is possible to write this in C++. Whoohooo. I don't think thats what they had in mind when introducing ctad :D — 463035818_is_not_an_ai, Feb 22 '23 at 17:34
"when should I use new" - never. (You will now when you have to, but never is a good approximation) — 463035818_is_not_an_ai, Feb 22 '23 at 18:11

Adrian Mole · Answer 1 · 2023-02-22T17:55:03.883

The problem you are facing is that you are using new to create a node but then trying to assign the pointer returned to a non-pointer Node variable.

This line is the problem:

Node node = new Node("Hello World");

What this does is to first construct an unnamed Node object with a template type of const char *; then, by using the pointer to that new object to initialize your node variable, you are constructing a second Node object, with the deduced template type being Node*. The cout lines showing hexadecimal values are correctly displaying the address value stored in that second, named Node variable.

You can get round this in several ways. The easiest is to not use the new operator:

Node node{ "Hello World" }; // Construct object directly

Another way would be to continue using the new call but then make your node a pointer:

int main() 
{
    Node<const char*>* node = new Node("Hello World"); // Or auto node = new Node("Hello World");
    std::cout << "Node data: " << node->get_data() << std::endl; // Now we need "->" instead of the "."
    delete node;
    return 0;
}

The first line of code in your main function is, effectively, doing this:

Node node{ new Node("Hello World") };

Thus creating two nodes with the named one having it's template type as Node<const char*>*. Or, to put it another way, your first line is equivalent to the following, with explicit template types:

Node< Node<const char*>* > node = new Node<const char*>("Hello World");

Also note that the = operator here is not an assignment but an initialization; this is why the constructor is called.

score 7 · Accepted Answer · edited Feb 26 '23 at 14:18

Without CTAD (class template argument deduction) the line in main reads like this:

Node<Node<const char*>*> node = new Node<const char*>("Hello World");

I am not sure what you actually wanted, but I am certain that it isn't this.

The address that is printed is value of the Node<const char*>* member of the Node<Node<const char*>*>.

Be warned, what follows is bad taste. It is a joke. If you do not get the joke, forget that you have seen the code. Don't do this at home. Or at work. Or really anywhere. Not. In c++. Please. Ok, lets do it.

I removed some cruft from OPs code and also the string literal to avoid possible confusion about conversions or array to pointer decay. Now, this will produce the expected output of 42:

#include <iostream>

template <typename T>
struct Node {
    T data;
    Node(T data) : data(data) {}
    Node(Node<T>* other) : data(other->data) { delete other; }
};

int main() {
    Node node = new Node(42);
    std::cout << "Node data: " << node.data << std::endl;
}

How come a C++ template returns a hexadecimal value?

2 Answers2