Template in Template Funktion aufrufen, aber mit partieller Typvorgabe

[kali-hi]

Hallo (C++ 23 ...), ich möchte zwei Template Funktionen in einer Test Funktion gegenüberstellen. Der Test Funktion soll nur gesagt werden (via Argument... oder Parametrisierung), welche Template Funktion sie testen soll. Dabei soll die Test Funktion selber festlegen können, wie sie die zu testende Template Funktion parametrisieren will (hier soll nur mit <int>s getestet werden).

#include <cstdint>
#include <cmath>
#include <chrono>
#include <iostream>
#include <vector>
#include <set>
#include <algorithm>
#include <numeric>
#include <random>

using namespace std;

template < typename E >
void select_n_elements_a(const vector < E > & in, vector < E > & out,
                         const uint32_t n) {
	static auto gen = default_random_engine {
		random_device {}()
	};
	vector < uint32_t > indexes(in.size());
	iota(begin(indexes), end(indexes), 0);
	shuffle(indexes.begin(), indexes.end(), gen);
	sort(indexes.begin(), indexes.begin() + n);
	for (auto it = indexes.begin(); it != indexes.begin() + n; it++) {
		out.push_back(in [ * it]);
	}
}

template < typename E >
void select_n_elements_b(const vector < E > & in, vector < E > & out,
                         const uint32_t n) {
	static auto gen = default_random_engine {
		random_device {}()
	};
	ranges::sample(in, back_inserter(out), n, gen);
}

// test until the first match
template < typename F >
void test1(F select_n_elements,
           const uint32_t n,
           const uint32_t type) {
	vector < int > in(n);
	iota(begin(in), end(in), 0);
	for (int i = 0; i < in.size();) {
		vector < int > out = {};
		select_n_elements(in, out, type == 0 ? 1 : n - 1);

		if (type == 0 && out[0] == i || type == 1 && find(out.begin(), out.end(), i) == out.end()) {
			i++;
		}
	}
}

int main() {
	const uint32_t n = 100;
	auto start = chrono::system_clock::now();
	test1(select_n_elements_a < int >, n, 0);
	auto end = chrono::system_clock::now();
	chrono::duration < double > elapsed = end - start;
	cout << "select_n_elements_a 1. n=" << n << ":  " << elapsed.count() << endl;

	start = chrono::system_clock::now();
	test1(select_n_elements_a < int >, n, 1);
	end = chrono::system_clock::now();
	elapsed = end - start;
	cout << "select_n_elements_a 2. n=" << n << ":  " << elapsed.count() << endl;

	start = chrono::system_clock::now();
	test1(select_n_elements_b < int >, n, 0);
	end = chrono::system_clock::now();
	elapsed = end - start;
	cout << "select_n_elements_b 1. n=" << n << ":  " << elapsed.count() << endl;

	start = chrono::system_clock::now();
	test1(select_n_elements_b < int >, n, 1);
	end = chrono::system_clock::now();
	elapsed = end - start;
	cout << "select_n_elements_b 2. n=" << n << ":  " << elapsed.count() << endl;
}

Das Problem tritt hier in Zeile 57, 63, 69 und 75 auf. Dort muss ich bei select_n_elements_a bzw. select_n_elements_b jedes Mal int bei der Initialisierung/Referenz angeben - und das ist nicht gewollt.

Wie würde man das richtig machen? Ich glaube, ich habe schon alle SO Fragen dazu gelesen, aber noch auf keinem grünen Zweig... Könnte es sein, dass man beim Aufruf das template Keyword zusätzlich verwenden muss?

(Bitte nicht zu sehr auf using namespace und endl; herumreiten ...)