Does C++ support abstract array lengths - c++

Question

If I have a base class A I would like to be able to write code in Athat uses an array whose size is determined by its children
I want to be able to have an array of pointers to A, but I don't want to have a separate member function created for each length
The best I could come up with is as follows:
class A
{
char type;
int * values;
int calc(int pos); // implementation is not relevant to question
public:
A (int * arr) : values(arr) {}
int foo(int pos)
{
int index=calc(pos);
return values[index];
}
};
template <size_t X>
class B : public A
{
int vals[X];
public:
B() : A(vals) {}
};
template<>
class B<0>; // don't want 0 allowed
This allows A to access an array where the child determines the size, and it is contiguous memory
But, it wastes the space of the values pointer and obfuscates information the compiler could use for optimization since as implemented it doesn't have to be contiguous memory that the child passes on construction, but I would like to require continuous memory.
Ideally I would like to use the offset directly in A
In C this works as int values[] but there is no C++ equivalent

Answer 1

Yes you can, using templates:
template<std::size_t size>
struct A {
A(std::array<int, size> _values) : values{_values} {}
private:
std::array<int, size> values;
};
struct B : A<4> {
using A<4>::A;
};
Then, you can use your class like this:
B myB{5, 6, 3, 2};
std::array allocates memory on the stack, or in the struct directly, just like a fixed array. You can test this by comparing sizes.
If you need a common base class, you can do this:
struct C {
virtual ~C() {}
virtual int* data();
virtual std::size_t size();
};
And then overriting theses in A:
template<std::size_t size>
struct A : C {
A(std::array<int, size> _values) : values{_values} {}
int* data() override {
return values.data();
}
std::size_t size() override {
return size;
}
private:
std::array<int, size> values;
};

Answer 2

The classic way to implement this is using inheritance and virtual members:
class A {
virtual int& value_at(size_t pos);
// other interesting methods
};
// subclass of A that uses std::vector for storage
class B: public A {
std::vector<int> storage;
int& value_at(size_t pos) {
return storage[pos];
}
};
// subclass of A that uses a fixed-size array for storage
template<int N>
class C: public A {
int storage[N];
int& value_at(size_t pos) {
return storage[pos];
}
};
B b; // ...initialize b...
C<10> c; // ...initialize c...
A *a1 = &b;
A *a2 = &c;
// call a1->value_at(), a2->value_at() to access arrays
// transparently, regardless of storage (along with other
// public methods of A).
This approach will require A::value_at to dispatch via a virtual table or equivalent mechanism. If it is known at compile-time which storage strategy will be used, you can make A a template class:
template<typename T>
class A: public T {
// other interesting methods, that use value_at() from T
};
class vec_storage {
std::vector<int> storage;
public:
int& value_at(size_t pos) {
return storage[pos];
}
};
// subclass of A that uses a fixed-size array for storage
template<int N>
class array_storage {
int storage[N];
public:
int& value_at(size_t pos) {
return storage[pos];
}
};
A<vec_storage> b;
A<array_storage<10>> c;
In this example, b and c will perform without the additional indirection at run-time, but at the cost that there is no generic base class, so a function expecting some A & cannot be passed a reference to either b or c.

Answer 3

For just the basic ability to change the size of the object's array, you're probably looking for templates, as Fred Larson pointed out. It's actually quite simple...
template <const int arraySize>
class MyClass
{
private:
int vals[arraySize];
}
At this point, you don't even need any derived classes. You're good to go, and can work with any size on the fly.
Bear in mind, however, that MyClass is not a valid type in this scenario. Because this is a template, you must specify the size.
MyClass wrong; //This will throw an error. MyClass is not a type.
MyClass<64> right; //This is a proper use of the type.
If you need the additional ability to store those objects of different sizes, you can combine this with inheritance fairly easily using a virtual [but not abstract] base class.
(Please ignore the crufty design, as I haven't bothered to define my constructors/destructors in this example.)
class BaseClass
{
public:
BaseClass(){}
virtual int access(int i)
{
return 0;
}
virtual ~BaseClass(){}
};
template <const int arraySize>
class MyClass : public BaseClass
{
public:
MyClass(){}
int access(int i)
{
return vals[i];
}
~MyClass(){}
private:
int vals[arraySize];
};
WARNING: It is critical that the base NOT be abstract if you want to be able to store your derived classes in a vector. See this question.
In this example, of course, you may want to create wrapper functions for accessing the array.