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...

--

[Alf P. Steinbach]

* 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;
1) Style: Don't use all uppercase except for macros, in C or C++.
2) Style: Don't use a typedef for a struct in C++ code.

Just do

struct t_star{ int x; int y; int stellar_class; };
t_star StarArray[243]={
{.....},
};
If this is meant to be a constant, use 'const'.

Instead of stating the number of elements, compute them.

t_star const StarArray[] = { ... };
size_t const StarArrayCount = sizeof(StarArra y)/sizeof(*StarArr ay);
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?
There no "the" correct way.

A good way would be to do the same as you'd do in C.
having global data is frowned upon,
Having global _variables_ is frowned on, for good reasons.

you can't put it in the class
header as this is against ansi conventions....
There's no such thing as class header (presumably you mean header file)
and there's no such thing as ansi conventions for C++ programming.

You can put data definitions in a header file.

The easiest way is to just declare the data 'const'; then it has
internal linkage.

If you want the data to be guaranteed to occur only once in the program
you can use a number of tricks.

One such trick is a function that returns a reference to the data.
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....

There's no such thing as "class creation tool" in C++.

Formally there's not even such a thing as stack space, but for that it
is (in contrast to the other things) not difficult to understand what
you mean.

However, you're wrong about that.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?

[Victor Bazarov]

Stainless wrote:

I have a public class Globals, which obviously holds all my global data.
Don't make it a "public class". You're probably going to be better off
with a namespace.
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?
There are several ways.
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....

No, you're supposed to make those members 'static' and define them outside
of the class definition, and initialise them there.

V

[Benry]

> 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?
Alright, I most likely do this the wrong way, but I like to use
standard container classes rather than arrays for things like structs.
The simpliest (not tested) example of this I can come up with:

Globals.h
-------------
class CGlobals{
public:
CGlobals::CGlob als();
CGlobals::~CGlo bals();
struct STAR
{
int x;
int y;
int stellar_class;
}t_star;

}

foo.h
-------
include "Globals.h"
class foo{
foo::foo();
foo::~foo();

std::list<CGlob als> StarArray;
}

foo.cpp
----------

static void main(){
CGlobals bar;
bar.t_star.x = 1;
bar.t_star.y = 2;
bar.t_star.stel lar_class = 4;

StarArray.push_ back(bar);
}

This way, you can have a dynamic array (list in this case), and still
use structs...

HOWEVER...if you're only using this struct and array in one class,
declare it as a private or protected member, and utilize it that way.
If you want the array global, make it a public member, and just include
that class header file whenever you want to use it.

An easier way would be to make a class with the three int's you want,
and then make a std::list of that class. This would eliminate the
struct altogether.

C++ is amazing and I hope I didn't confuse you at all. I do that too
myself sometimes.
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....
What IDE are you using?
puzzled...

If you're working with C, you won't be puzzled for very long :).

-ben

[Stainless]

> 1) Style: Don't use all uppercase except for macros, in C or C++.

2) Style: Don't use a typedef for a struct in C++ code.
Style varies depending on where you work, the typedef is the required
format for many places I have worked.
If this is meant to be a constant, use 'const'.
Not constant

Instead of stating the number of elements, compute them.

t_star const StarArray[] = { ... };
size_t const StarArrayCount = sizeof(StarArra y)/sizeof(*StarArr ay);
I only put the size in to give people an idea of the amount of data I
had to store.
Having global variables is frowned on, for good reasons.
I reduced flash usage in a mobile phone by 1437 bytes, and ram usage by
538 bytes by making a single variable global.

I can see problems in multi-threaded environments, but a lot of "don't
do this" coding standards are designed to stop crap coders screwing
things up. Using global variables correctly can be a massive advantage
for a real world application.

There's no such thing as class header (presumably you mean header
file) and there's no such thing as ansi conventions for C++
programming.
Well try initialising a variable in a class definition and see what
your compiler says .
Formally there's not even such a thing as stack space, but for that it
is (in contrast to the other things) not difficult to understand what
you mean.

However, you're wrong about that.

errr no, I have spent a lot of time hacking about with x86 code created
by c++ compilers and I know very well what crap they can generate.

C and C++ are stack based languages, variables and local storage all
come from the stack, the first thing you find in most subroutines is

mov ebp,esp
add esp,<some value>

then variable accesses are all

mov eax,[ebp+<offset]
mov [ebp+<offset],ebx

defining any local variables increases stack usage.

I don't know what would happen if I had a const array in the tool,
possibly the compiler could be smart enough to put that elsewhere, but
I would still have two copies of the entire array in memory somewhere.

The x,y,and stellar_class will be constant, but other booleans I will
be adding to the structure will be dynamic.

[Stainless]

>

No, you're supposed to make those members 'static' and define them
outside of the class definition, and initialise them there.

V

This is one of those c++ static problems, when I use static inside a
function it means "retain value", but outside a class definition, on my
compiler at least it reduces visibility.

Defining the array as static makes it invisible to code outside the
current class implementation.

This would mean I have to add handlers for the array to the class

t_star getStar(int n);
void setFlag(int n, int flag);
etc.

which is just code bloat
--

[Stainless]

I see what you mean, but you still end up manually filling the array.

I have seen a lot of people using lists in c++, but I am very suspicous
about how efficent the code will be.

I can see how the compiler will generate code for arrays of struct's
It will generate an array of pointers, the same way it does for
multi-dimensional arrays.

Accessing an element then becomes very efficent.

With lists I am not so sure what the compiler will generate, and
without time to experiment I am loath to use them.

[Stainless]

While I am thinking about a clean solution, I am currently using a
frigg.

I have written a c tool that writes the array to disc, I then read this
into the array when the class is created.

Swapped disc space for memory in effect

[Gavin Deane]

Stainless wrote:

No, you're supposed to make those members 'static' and define them
outside of the class definition, and initialise them there.

V

This is one of those c++ static problems, when I use static inside a
function it means "retain value", but outside a class definition, on my
compiler at least it reduces visibility.

Defining the array as static makes it invisible to code outside the
current class implementation.

This would mean I have to add handlers for the array to the class

t_star getStar(int n);
void setFlag(int n, int flag);
etc.

which is just code bloat

Doesn't this work for you? I think it is what Victor suggested. Note
that he also suggested that you might just as well use a namespace
instead of a class full of only static data.

// Globals.h
struct t_star
{
int x;
int y;
int stellar_class;
};

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

// Globals.cpp
t_star Globals::StarAr ray[243] = { ... }; // Initialise the array
----------------------------------------------------------------
#include "globals.h"
int main()
{
Globals::StarAr ray[0].x = 1;
int i = Globals::StarAr ray[0].stellar_class;
}

Gavin Deane

[Alf P. Steinbach]

* Stainless:

[confused]

Well.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?