LeetCode Reverse Nodes in k-Group
Don't use the macro NULL.  Use the specific keyword nullptr now.
Your struct can be more simply written using immediate inline initializers.
struct ListNode {
    int val = 0;
    ListNode* next = nullptr;
    ListNode() = default;
    ListNode(int x) : val{x} {}
    ListNode(int x, ListNode* next) : val{x}, next{next} {}
};
 

Also note that the * goes with the type in C++, not with the name being declared.
Regarding
void reverse(ListNode** subHead, ListNode** subTail)
It appears that the names subHead and subTail are never modified by the code, so this would be easier if you passed references to the pointers, rather than having an extra explicit dereference operation when you use it.
ListNode* itHead = *subHead;
//...
while (itHead != end) {
    //...
    itHead = next;
}

This is just a for loop that's spread out for no reason.  The value of next you want is lost during the body of the loop, so I can see why you don't put that inside a for construct.  But you can put the declaration of subHead there... put the parts you can into a for loop, even if it's not all three of them.
Re:
if (*subHead==NULL) return;
Don't make explicit comparisons against null.  Use the truth predicates that are part of the (possibly smart!) pointer.
Combining this with the tip of using references (...ListNode*&amp; subHead,) you get simply:  if (!subHead)  return;.
Re:
std::swap(*subHead, *subTail);
This works because you know that these are raw pointers.  But generally you write code like this as a template, or at least you code mostly as if you are writing a template, to ease future maintenance.  If the type of something changes, the code should at best still work; second but still OK is cause a compile-time error that you must fix; but bad is to silently fail.  Consider what would happen if these were not raw pointers but iterators of some type, including something supplied by your program or another library (not in std).
You need to use the so-called &quot;std two-step&quot; to use swap and a few others.  Or, if using C++20 you can use std::ranges::swap instead.  Always use swap etc. properly without relying on knowledge that the overload you want is indeed found in std.