Class template with both pointer type and regular type
c++, pointers, templates
Solution
See this: C++ template specialization, calling methods on types that could be pointers or references unambiguously
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?
Problem
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, use `Node<Foo *>` will be more convenient. But it could also be that the node will hold primitive time, say `int`. Then use `Node<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` should `cout << *v` when it is and `cout << 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.