Calling nested static members in c++

I am creating a program that calls a nested template function. It works fine if the nested template function is a class member (i.e. by adding this->template). But how to make it work in the static case (i.e. the ???)

The code example is a bit complex, but the most important lines are the difference between the this->template test_recursive_sub<TH>(gs...);and the static version ??? test_recursive_sub<TH>(gs...);in calling a nested template function in the same class. What has to replace the ???

#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

struct TestObject1 {
	using Type = int;
};

struct TestObject2 {
	using Type = int;
};

struct TestObject3 {
	using Type = int;
};

struct MyStruct {
	template<typename TH>
	void printno() {
		typename TH::Type num = 100;
		std::cout << num << std::endl;
	}

	template<typename TH>
	void static st_printno() {
		typename TH::Type num = 100;
		std::cout << num << std::endl;
	}

	template<typename TH, typename ... TG>
	void test_recursive_sub(TG &... gs) {
		printno<TH>();
	}

	template<typename TH, typename ... TG>
	void test_recursive(TG &... gs) {
		this->template test_recursive_sub<TH>(gs...);
	}

	template<typename TH, typename ... TGs>
	static void recursive_sub(TGs &... gs) {
		MyStruct::st_printno<TH>();
	}

	template<typename TH, typename ... TGs>
	static void static_recursive(TGs &... gs) {
		??? test_recursive_sub<TH>(gs...);
	}
};

int static_template_nesting() {

	TestObject1 to1;
	TestObject2 to2;

	MyStruct ro1;

	ro1.test_recursive<TestObject2>(to1, to1, to2);
	ro1.test_recursive<TestObject3>(to2);
	MyStruct::static_recursive<TestObject2>(to1, to1, to2);
	MyStruct::static_recursive<TestObject3>(to2);

	return 0;
}

The way you right it, there is no recursion (no function calling itself).
Besides, a static function can only call a static function (non static should be called by an object).
The template arguments were not declared neither used properly.
First declare a generic version of the function that will take a first argument (head) and the other ones (tails). You seemed to be on this track already.
If the number of arguments in tails is non zero then you can recurse: process head then forward tails to the same function without specifying template arguments: the function will deduce them by itself.
If the number of arguments in tails is zero, you call a special implementation.
Before C++17, you will write a function for each case and use SFINAE to leave only one overload well-formed. You can do that by adding an std::enable_if_t, in the template parameters, that will be invalid for the single argument case.
Since C++17 it's easier, simply write a single function with an if constexpr, as you would write a classical recursion.
Here is the fix:

#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

// will use std::enable_if until C++14
#include <type_traits>

struct TestObject1 {
    using Type = int;
};

struct TestObject2 {
    using Type = int;
};

struct TestObject3 {
    using Type = int;
};

struct MyStruct {
    template <typename TH>
    void printno() {
        typename TH::Type num = 100;
        std::cout << num << std::endl;
    }

    template <typename TH>
    void static st_printno() {
        typename TH::Type num = 100;
        std::cout << num << std::endl;
    }

    template <typename TH, typename... TG>
    void test_recursive_sub(TG &...gs) {
        printno<TH>();
    }

    template <typename TH, typename... TG>
    void test_recursive(TG &...gs) {
        this->template test_recursive_sub<TH>(gs...);
    }

    template <typename TH, typename... TGs>
    static void recursive_sub(TGs &...gs) {
        MyStruct::st_printno<TH>();
    }

    // C++14 version
    // overload for multiple argument only
    // SFINAE will eliminate it if there is only one argument
    template <typename TH, typename... TGs,
              std::enable_if_t<(sizeof...(TGs) > 0), bool> = true>
    static void static_recursive(TH &head, TGs &...tail) {
        std::cout << "process an arg then " << sizeof...(TGs) << " args"
                  << std::endl;
        static_recursive(tail...);
    }
    template <typename TH>
    // overload for single argument only
    static void static_recursive(TH &head) {
        std::cout << "process single element" << std::endl;
    }
    // C++17 version
    // template <typename TH, typename... TGs>
    // static void static_recursive(TH &head, TGs &...tail) {
    //     if constexpr (sizeof...(TGs) > 0) {
    //         std::cout << "process an arg then " << sizeof...(TGs) << " args"
    //                   << std::endl;
    //         static_recursive(tail...);
    //     } else {
    //         std::cout << "process single element" << std::endl;
    //     }
    // }
};

int main() {
    TestObject1 to1;
    TestObject2 to2;

    MyStruct ro1;

    ro1.test_recursive<TestObject2>(to1, to1, to2);
    ro1.test_recursive<TestObject3>(to2);
    // no need to give template arguments, they are deduced
    MyStruct::static_recursive(to1, to1, to2);
    MyStruct::static_recursive(to2);

    return 0;
}

Live