storing arrays in cpp

[Stainless]

I have a public class Globals, which obviously holds all my global data.

I have an array of 243 items, currently structs of type

typedef struct STAR
{
int x;
int y;
int stellar_class;
}t_star;

t_star StarArray[243]={
{.....},
};
If I was doing this app in C I would just have the array as a seperate
C source file, compile it in, and have extern t_star StarArray[] where
ever I needed it.

What's the correct way to do this in cpp?

having global data is frowned upon, you can't put it in the class
header as this is against ansi conventions....

Are you supposed to define the empty array in the class header then
fill it in the class creation tool? What a waste of stack space....

puzzled...

--

[Benry]

I guess that would work too.

I'm assuming you're writing this for an RTOS since you're worried about
overhead. The compiler (well..gcc/gpp) will only include those
functions that you're using with std::list, which normally you would
write yourself for a linked list in C.

But, you still want an array :). I'm going to stop pushing it because
there is quite a bit of overhead compared with arrays.

Ok, I just read your replies to the other guys. Obviously for embedded
systems. I guess my next question is why c++ when you're using C fine?
I think for what you're trying to do, a class isn't the answer anyway.
I haven't been working in the "real world" for long, but my roots are
in C programming, so I remember thinking stacks, bitwise, memory
allocation on my 16bit motorolas, etc...

When I learned C++ I was scared everyday about overhead that it was
creating.

Basically, I use a struct now when I want a very basic structure, which
no methods belonging to it. I use a class when there are routines that
this class has, and that can be inherited or derived from other
classes...gah, I'm losing it.

Uh, for your example I would use a struct, and not even worry about
classes. If there is some abstraction that requires you to include
this struct in a greater combonation of variables, then, the struct is
part of the class, but don't replace it :). You can then use a global
array of that class member, with minimal changes to your code.

(very winded, sorry) Lastly, I think that your coding style is fine for
the application. If my assumption is correct, then there is no reason
that I will frown seeing some global variables. I mean, the compilier
allows them for a reason, right? To answer your original question, the
correct way is the way you can get it to work with your requirements in
your application while sticking to your employer's coding standards. I
would personally change very little with your code when porting from c
to c++.

[Stainless]

>class Globals

{
public:
static t_star StarArray[];
};
----------------------------------------------------------------

// Globals.cpp
t_star Globals::StarAr ray[243] = { ... }; // Initialise the array

Thank you, this worked.

To me this was counter intuative, I would have expected it to be thrown
out by the compiler syaing something like

"StarArray already defined "

I knew there had to be a work around, but probably wouldn't have found
it by experimentation .

[Stainless]

Ok, I just read your replies to the other guys. Obviously for
embedded systems. I guess my next question is why c++ when you're
using C fine?
I am writing portable code that will run on several target OS's.

Thus it has to be c++, as some of the target OS's don't have C
compilers.

The hassle is that all the OS's have different problems, in this case
all the global data for the app has to be in a single holder (could be
a struct but it is far more convenient to be able to have the attached
methods as well). This is for the Symbion port. In there "wisdom" they
decided to make global data illegal for app's. You get a single pointer
which they call "thread local storage", and that's it.

When I learned C++ I was scared everyday about overhead that it was
creating.

For the last, well at least ten years, I have been noticing a trend of
bloated code being prefered to clean code. As an example, when I was
first tasked with evaluating Symbion as a target platform we had a
device on the market, sold tens of millions of units, everybody was
happy with it, and it contained 1Meg of flash and 250K of ram.

Symbion's basic spec required a MINIMUM of 5Meg ram and 5Meg flash.

When you consider that at the time the 1Meg flash comprised almost 25%
of the materials cost for the device, we were looking at a major cost
increase.

I despise working on Symbion now, they have tried to be everything to
everybody, and ended up with a complete mess.

[Ben Pope]

Stainless wrote:

class Globals
{
public:
static t_star StarArray[];
//Declaration
};
----------------------------------------------------------------

// Globals.cpp
t_star Globals::StarAr ray[243] = { ... }; // Initialise the array

//Definition

Thank you, this worked.

To me this was counter intuative, I would have expected it to be thrown
out by the compiler syaing something like

"StarArray already defined "

It's only defined once and the declaration is compatible.

Ben Pope
--
I'm not just a number. To many, I'm known as a string...

[Benry]

Stainless wrote:

Ok, I just read your replies to the other guys. Obviously for
embedded systems. I guess my next question is why c++ when you're
using C fine?

I am writing portable code that will run on several target OS's.

Thus it has to be c++, as some of the target OS's don't have C
compilers.

The hassle is that all the OS's have different problems, in this case
all the global data for the app has to be in a single holder (could be
a struct but it is far more convenient to be able to have the attached
methods as well). This is for the Symbion port. In there "wisdom" they
decided to make global data illegal for app's. You get a single pointer
which they call "thread local storage", and that's it.

So this thread local storage is your array? Is it dynamic or like a
buffer? It's actually a pointer, so what is the max mem allocation you
are allowed for it?

I can understand where you're coming from. I would probably use the
Linux v. Windows comparison as an analagy. When looking for Linux
programs, you search for a couple things:
1. How you want to compile it (be it rpm, Makefile, gcc, etc)
2. What platform you're running
3. What options you want.

When installing, you may be missing some libraries!

Where, in Windows, it's all there for you (most of the time), even
though it hardly ever works 100%.

I think customers are Windows, and Programmers/Engineers are Linux.
They didn't mix in the 1950s(people, not OSs), and as much as our
marketing departments wish, it's a huge hurdle to get them to do that
today.

When I learned C++ I was scared everyday about overhead that it was
creating.

For the last, well at least ten years, I have been noticing a trend of
bloated code being prefered to clean code. As an example, when I was
first tasked with evaluating Symbion as a target platform we had a
device on the market, sold tens of millions of units, everybody was
happy with it, and it contained 1Meg of flash and 250K of ram.

Thank God I have a giant brain and use code ACAP (as clean as
possible). I'm joking, but we did learn to consider your registers,
cache requirements, memory allocation/leaks, etc when writing any level
of code in college. The more stuff I see, though, the more I pull my
hair out wondering what I'm really supposed to be doing! (I graduated
only a short time ago).

I will not continue, because my skills are far inferior and anything I
have to say will be wasting people's time.
-ben