Having a template refer to a member from a jointly-inherited class - c++

Question

It's obvious that the following code won't compile, because it gives an "undeclared identifier" error at the line 'n = n_init'. Nevertheless, to a human reader the intent is probably clear enough: I want to declare a template for a class which will never be instantiated by itself, but only by multiple inheritance alongside another class which is guaranteed to contain at minimum a member 'n' of type int and a member 'p' of type T*, but which (being a C struct obtained from elsewhere) I'm not at liberty to derive from another template containing these fields:
// In a C header file from elsewhere:
// ----------------------------------
typedef struct {
float *p;
int n;
} float_array_C;
// In my C++ header file:
// ----------------------
template<typename T> class MyArray
{
public:
MyArray(int n_init)
{
n = n_init;
contents.resize(n);
p = contents.data();
}
virtual void mustExist() = 0;
private:
std::vector<T> contents;
};
class float_array : public float_array_C, public MyArray<float>
{
public:
float_array(int n) : float_array_C(), MyArray(n)
{}
virtual void mustExist() {}
};
...
float_array testArray(10);
I've also tried this approach, with equally little success:
typedef struct {
float *p;
int n;
} float_array_C;
template<typename T1, typename T2> class MyArray
{
public:
MyArray(int n_init)
{
&T2::n = n_init;
contents.resize(n);
&T2::p = contents.data();
}
private:
std::vector<T1> contents;
};
typedef MyArray<float, float_array_C> floatArray;
...
float_array testArray(10);
Can this, or anything remotely similar to it, in fact be done?

Answer 1

In order for this to work, the template class must derive from the type containing n and then you can access it as T::n where T is the template parameter.
(You can't access the inherited member using just n because that's not a dependent name and so the compiler will try to resolve it when the template itself is compiled, not later when it is instantiated, and no n exists within MyArray or at the global scope. Using T::n causes it to be a dependent name -- depending on T -- and so resolution of the name is deferred until the template is instantiated.)
typedef struct {
float *p;
int n;
} float_array_C;
template <typename T>
class MyArray : public T
{
public:
MyArray(int n_init) {
T::n = n_init;
}
};
Note that you will run into problems with code like this:
class Foo : public float_array_C, public MyArray<float_array_C> { /* ... */ };
In this case both Foo and MyArray<float_array_C> contain a separate instance of float_array_C. You can use virtual inheritance for float_array_C if this is a problem:
template <typename T>
class MyArray : virtual public T { /* ... */ };
class Foo :
virtual public float_array_C,
public MyArray<float_array_C>
{ /* ... */ };

Answer 2

Another approach which only needs one template argument:
typedef struct {
float *p;
int n;
} float_array_C;
template<typename T> class MyArray : public T
{
public:
MyArray(int n_init)
{
T::n = n_init;
contents.resize(T::n);
T::p = contents.data();
}
private:
std::vector<std::remove_pointer_t<decltype(T::p)>> contents;
};
typedef MyArray<float_array_C> floatArray;