template programming - c++

Question

I am new to template programming. I have a question like this
A.process(B)
where A is a template parameter.
Is it fine for me to set B as a template parameter as well? By that I would be able to let different type A objects to process different type of objects B. B normally would not be used polymorphically in run time.
Thanks.

Answer 1

If I understand your requirement, then yes - you can do something like:
template <typename A, typename B>
void fn(A& a, B& b)
{
...other code...
a.process(b);
...other code...
}

Answer 2

Well, since we're all speculating on the meaning of the question, I'll offer what I think is in mind here. In the same way that one can create a template like -
template<typename T, std::size_t size = 50> struct fixed_array {
private:
T a[size];
};
...with "size" being an instance of an existing type, and not the name of a type, I think the questioner wants to know if one can do something like the following -
struct A_type {
... // whatever constitutes this class plus overloaded methods like ...
void process(int B) {
std::cout << "int overload: " << B << std::endl;
}
void process(const char* B) {
std::cout << "string overload: " << B << std::endl;
}
} A; // an actual instance of A_type
template<A_type A, int B> void foo() {
A.process(B); // will call the int overload
}
main() {
foo<A, 3>(); // produces the output "int overload: 3"
}
The answer is "no". At least, not as formulated above. There are restrictions on non-type template parameters that are well-summarized here: template parameters. The type of such a parameter has to conform to LiteralType, which includes references. So by tweaking the function definition as follows -
template<A_type& A, int B> void foo() {
A.process(B); // will call the int overload
}
Now we're good-to-go, and it satisfies the questioner's requirement to produce a template (class or function) in which A and B, both of which are clearly instances and not types, are both parameterized at compile time, such that A.process(B) can be understood and compiled. By C++20, there are a set of rules that allow the original formulation of foo if A_type obeys a number of conventions, but that's all covered in the above link. NOTE: while LiteralType entities can include references, the object of those references must be statically defined, either in the global declaration area or declared with the keyword static. The compiler must know the value at compile time, and it must be impossible to change at run-time. So for example the following -
template<A_type& A, const char* B> void bar() {
A.process(B);
}
this main definition will not compile -
main() {
bar<A, "hello">();
}
but the following will -
const char* h_string = "hello";
template<A_type& A, const char*& B> void bar() { // note the switch to reference
A.process(B);
}
main() {
bar<A, h_string>(); // will produce output "string overload: hello"
}
as will -
main() {
static const char* h_string = "hello";
bar<A, h_string>();
}
For reasons I can't quite work out, even using double in stead of int didn't work in the version of clang I tried this on, so it may not be as flexible a trick as the questioner would like. That being said, there are without doubt many other approaches to solving the questioner's higher level problem.