change bit size of packed struct in derived class - c++

Question

The existing code:
typedef unsigned int uint;
Class A
{
union xReg
{
uint allX;
struct
{
uint x3 : 9;
uint x2 : 9;
uint x1 : 14;
}__attribute__((__packed__)) __attribute__((aligned(4)));
};
};
My requirement:
Now, I need to derive a class from A, and and in the derived class, the bit sizes of x1, x2 and x3 has to change.
How do i do this ?
Thanks for your help !
EDIT
I have a class (lets say A) with approx. 7-8 unions (each representing HW register), and around 20 (approx.) functions. Most of these functions create instances of these unions, and use the bits (x1, x2, x3 etc in my example).
Now, my requirement is to add code for a new hardware which has 95% of functionality same. The changes include the change in register bit sizes, and some functionality change. So, among 20 functions, atleast 5 functions I need to change to change the implementation. This is the reason for me to select inheritance and override these functions.
The rest 15 functions, only change is the bit size changes. So, I dont want to override these functions, but use the base class ones. But, the bit sizes of the registers (unions) should change. How do I do that?

Answer 1

You cannot change a bit-field length in a derived class in C++.
What you could try, however, is parametrize your class with the bit_field lengths.
template <size_t N1, size_t N2, size_t N3 = 32 - N1 - N2>
struct myStruct
{
uint bitField1 : N1;
uint bitField2 : N2;
uint bitField3 : N3;
};
Now you can instantiate the struct with any N1, N2, N3 you wish, for example:
myStruct<9, 9> s;

Answer 2

With the given design you cannot solve it. The problem is that while you can derive and override methods, data members cannot be overridden, the members that are not overridden in the derived class would access the field in exactly the same way that they are doing, and the result is that you would be using different sizes in different places.
Runtime polymorphism
I haven't think much on the design, but the first simple runtime approach would be refactoring all the existing code so that instead of accessing the fields directly they do so by means of accessors (setters and getters), and that map the arguments to the storage types. You would be able to override those accessors and the functions would not depend on the exact size of each bitfield. On the negative side, having the accessors virtual means that there will be a performance instance, so you might consider
Compile time (or static) polymorphism
You can refactor the class so that it is a template that takes as argument the type of the union. That way, you can instantiate the template with a different union in what would be in your current design an derived class. Addition of new member functions (if you want to use member functions) would not be so simple, and you might end up having to use CRTP or some other approach to create the base of the implementation while allowing you to extend it with specialization.
template <typename R>
class A
{
R xReg;
public:
unsigned int read_x1() const {
return xReg.x1;
}
// rest of implementation
};
union xReg1 {
unsigned int all;
struct {
unsigned int x3 : 9;
unsigned int x2 : 9;
unsigned int x1 : 14;
};
};
union xReg2 {
unsigned int all;
struct {
unsigned int x3 : 8;
unsigned int x2 : 9;
unsigned int x1 : 15;
};
};
int main() {
A< xReg1 > initial;
std::cout << initial.access_x1() << std::endl;
A< xReg2 > second;
std::cout << second.access_x1() << std::endl;
}

Answer 3

Given your additional problem statement, a variant on what Armen suggested might be applicable. It sounds as though you do not need actual inheritance here, just some way to reuse some of the common code.
You might not want member functions at all, for instance.
template<typename reg>
union hardware_register {
unsigned all;
struct {
unsigned i : reg::i;
unsigned j : reg::j;
unsigned k : reg::k;
};
};
template<typename hardware>
void print_fields(const hardware& hw) {
cout << hw.i << " " << hw.j << " " << hw.k << endl;
}
//this method needs special handling depending on what type of hardware you're on
template<typename hardware>
void print_largest_field(const hardware& hw);
struct register_a {
static const unsigned i = 9;
static const unsigned j = 4;
static const unsigned k = 15;
};
struct register_b {
static const unsigned i = 4;
static const unsigned j = 15;
static const unsigned k = 9;
};
template<>
void print_largest_field<register_a>(const register_a& a) {
cout << a.k << endl;
}
template<>
void print_largest_field<register_b>(const register_b& b) {
cout << b.j << endl;
}
int main() {
hardware_register<register_a> a;
hardware_register<register_b> b;
print_fields(a);
print_fields(b);
print_largest_field(a);
print_largest_field(b);
}
Alternatively, you can wrap up all the common functionality into a templated base class. You derive from that base class, and implement whatever special behavior you need.
template<typename HW>
struct base {
void print_fields {
cout << hw.i << hw.j << hw.k << endl;
};
private:
HW hw;
};
struct hw_a : base<register_a> {
void print_largest_field {
cout << hw.k << end;
}
};
struct hw_b : base<register_b> {
void print_largest_field {
cout << hw.j << end;
}
};
You can provide multiple template parameters for your different types of registers, or expand on the underlying trait structure such that it defines more than one register at a time.