How to pass instance of template to another instance of another template? - c++

Question

I have two class templates that must be templates (C++). I just simplified their code to show the essence of the problem. How to pass an object (obj1) from one template (MyClass1) to another object (obj2) from second template (MyClass2)? I tried through the template parameter and the constructor, but I still have compilation errors. How to do it correctly? What is important, I don't know template parameters, therefore solution has be universal, not for specified parameters. Object should be passed by pointer or reference, I don't need its copy.
template<int a, int b>
class MyClass1 {
public:
MyClass1() {
// Do something...
}
int foo(int x) {
return a * x + b;
}
};
template<double m, double n>
class MyClass2 {
public:
MyClass2() {
// Do something
}
double bar(int x) {
// Do something with x using object of MyClass1 and then with m...
}
double zet(int x) {
// Do something with x using object of MyClass1 and then with n...
}
};
int main() {
MyClass1<4, 3> obj1;
MyClass2<3.14, 2.56> obj2; // <-- How to pass obj1 here???
// Maybe that way?: MyClass2<3.14, 2.56, obj1> obj2;
// Or that way?: MyClass2<3.14, 2.56> obj2(obj1);
obj1.foo(12);
obj2.bar(1.234);
obj2.zet(5.678);
}
I'm not sure if this is relevant to this problem, but I'm writing C++ code for AVR in Atmel Studio 7 with standard settings.

Answer 1

Your code does not compile with C++11 because of this:
A non-type template parameter must have a structural type, which is
one of the following types (optionally cv-qualified, the qualifiers
are ignored):
lvalue reference type (to object or to function);
an integral type;
a
pointer type (to object or to function);
a pointer to member type (to
member object or to member function);
an enumeration type;
std::nullptr_t; (since C++11)
a floating-point type; (since C++20)
Regarding your core problem, you can do the something like this:
template<int m, int n, typename Obj1Type>
class MyClass2 {
Obj1Type obj1_;
public:
MyClass2() {
// Do something
}
MyClass2(Obj1Type const& obj1) {
obj1_ = obj1;
}
// ...
};
And then in main:
int main() {
MyClass1<4, 3> obj1;
MyClass2<3, 2, MyClass1<4, 3>> obj2(obj1);
obj1.foo(12);
obj2.bar(1);
obj2.zet(5);
}
Check it out live
UPDATE
You could also make use of inheritance and create a simple base class for this purpose:
class BaseMyClass1 {};
template<int a, int b>
class MyClass1 : public BaseMyClass1 {
// ...
};
template<int m, int n>
class MyClass2 {
BaseMyClass1 obj1_;
public:
MyClass2() {
// Do something
}
template <typename Obj1Type>
MyClass2(Obj1Type const& obj1) {
obj1_ = obj1;
}
// ...
};
And then in main:
int main() {
MyClass1<4, 3> obj1;
MyClass2<3, 2> obj2(obj1);
obj1.foo(12);
obj2.bar(1);
obj2.zet(5);
}
This saves you declaring a template in template parameter list. However, this might not be the perfect solution for you because it introduces object slicing.
Check it out live

Answer 2

Template class accepts another template class as template parameter. So you can pass typename T for Myclass2.
Example program:
You can try something like this:
#include <iostream>
using namespace std;
template<typename T1>
class Myclass1
{
public:
Myclass1(T1 x):m1_x(x)
{
cout << "Myclass1 C'tor" << m1_x << endl;
}
T1 m1_x;
T1 get_x()
{
return m1_x;
}
};
template < typename T1 >
class Myclass2
{
public:
Myclass2(T1 x): m_x(x)
{
cout << "My class 2 C'tor with value" << m_x.get_x() << endl;
}
public:
T1 m_x;
};
int main()
{
Myclass1 <int > obj1(5000);
Myclass2< Myclass1 <int> > obj2 ( obj1 );
return 0;
}