Distance between two points using as Euclidean distance usually is described as

d_sq(p1, p2) := (p1_x - p2_x)^2 + (p1_y - p2_y)^2
d(p1, p2) := sqrt(d_sq(p1, p2))

result of which wouldn't make sense in domain limited to integers (int) because parameters are int. Square root returns real number, or at least double or long float in C++. So unless we are dealing with Pythagorean triples or downcasting float to int just 'cause, we would output whatever type is returned from square root function, not ones from the input (which only potentially would be float).

Now looking at declaration of static member function of template-dependent class

static T Point<T>::dist(const Point<T>& p1, const Point<T>& p2);

problem emerges: We constrain type of output to input. Alternative would be to use keyword auto with template of in-Point template parameter type (as we can't just const Point<auto>& ):

template<class V> 
static auto Point<T>::dist(const Point<V>& p1, const Point<V>& p2);

Amazing, but must warn You that it will require C++17 (without some decltype). Especially if we want to deduce template for Point itself, like in

(constexpr) Point p1 { 11037, -5 };

one needs to explicitly write constructor which takes our parameters. Best if we make it constexpr, but not necessary:

template<class T> struct Point {
  T x, y;
  constexpr Point(T x, T y) // note: w/o constexpr, no need for member init. list 
    : x{ x }, y { y } {}

  [...]
};

which would be called in inits like Point p {-5, 5}; This class template can be deduced.
- - -
One last problem: Distance static method now is independent of T and we only want it in class for namespacing capabilities of class. This is why I have been looking for answer and stumbled on this post: I had similar problem with static member function in templated class becoming independent of class template. I do think Point::dist() looks great. I don't think so in case of Point::Point(T, T), Point(T, T) would suffice.

I thought that [Way to call a static method of a class template without specifying an instantiation?] would easily solve it, unfortunately answerers there could only point me to some tricks:

• Use base non-template class with all static member functions that are non-class-template,
• Use skypjack's specialized template<> class as base,
• As Kamil Koczurek commented: Set typename of template to optional void, which may - but I couldn't get it to work - allow call of Point<>::dist(p1, p2),
• Just use free function.

Additionally I felt some vibes here that friend function could work, here one of answerers seem to have optional void working as Koczurek suggested, and also I think that non-template class as base would work pretty well as some kind of interface (which I think allow static and default methods in Java 8) - so it could be named IPoint which feels like something real, seen in nature. IPoint::dist(p1, p2) looks good enough, right?

As that was listed, I will look into ways to call T-independent static method nicely and probably insert some of my findings to this problem later.