Class template with both pointer type and regular type
The same technique should work here, allowing you to deal with the val
as a reference (or a pointer) uniformly in both cases.
CRTP may help reduce code duplication, allowing for common code for two specializations without any overhead, as well.
Note that ownership semantics get tricky when you sometimes use a pointer and sometimes an instance -- what is the lifetime of val
if sometimes it is a pointer of an argument, and other times it is a copy of the argument, and how to you enforce it?
Oxdeadbeef
Updated on July 09, 2022Comments
-
Oxdeadbeef almost 2 years
I define a Node class with template for its value type
template<class T> class Node { T val; public: Node (T & v) : val (v) {} ... void print() { cout << v << endl; } }
Most times, the node value of interest will be an object class, say
class Foo
. In that case, useNode<Foo *>
will be more convenient. But it could also be that the node will hold primitive time, sayint
. Then useNode<int>
will suffice.The problem is, some of the function may need to behave differently based on whether
T
is a pointer type or not. For example,print
shouldcout << *v
when it is andcout << v
otherwise.What I've tried is to define both:
template<class T> class Node { T val; public: Node (T & v) : val (v) {} ... void print() { cout << v << endl; } } template<class T> class Node<T*> { T* val; public: Node (T* v) : val (v) {} ... void print() { cout << *v << endl; } }
It now can choose the appropriate definition based on whether it's
Node<int> or Node<int *>
But the problem become, the two definitions will share many code. I'm wondering whether there's better way to achieve this.