I joined DG in 1979, and I didn't do much work on the Novas (though DG/L still supported Novas), mostly I worked on the Eclipse, MV/Eclipse, and finally finishing the 88000 port of GCC for the AViiON. So perhaps the later generations of Novas had the byte addressing.
I'm not as up on C++ as I am/was in C. Since I've been doing backend work since about 1988, it is somebody else's problem to do the parsing, and build the internal RTL for the code. If you have this:
Code:
struct foo { int a[200]; };
void bar (struct foo a) { ... }
In C, it would pass a copy of the structure. On some machines, it would copy the structure to the stack and pass a pointer. In other machines, it would pass all 200 integers on the stack. Because a local copy is made, no changes to the value will be passed back to the caller.
In C++, if you use '&', it passes a pointer to the object and any changes to the object will be mirrored in the original variable.
Code:
// C style semantics
struct foo { int a[200]; } s;
void bar (struct foo *p}
{
p->a[0] = 1;
}
// C++ semantics
void bar2 (struct foo &p)
{
p.a[1] = 2;
}
void call (void) {
bar (&s);
bar2 (s);
}
// after call, s[0] == 1, and s[1] == 2.
Note in the C syntax, you have to manually do the de-reference, while using the & in the declaration means the compiler will do this behind your back. It gives you a way to mimic other langauges that pass by reference.