Re: 3 dimensional array

From:

Mark P <usenet@fall2005REMOVE.fastmailCAPS.fm>

Newsgroups:

comp.lang.c++

Date:

Tue, 18 Sep 2007 17:33:26 -0700

Message-ID:

<s7_Hi.4838$7P7.1314@newssvr19.news.prodigy.net>

desktop wrote:

Mark P wrote:

desktop wrote:

Victor Bazarov wrote:

desktop wrote:

I am simulating a display that consists of 20x20 pixels. All pixels
are per default white but I would like to be able to turn on some or
all the pixels.

By "turn on" you mean make them black?

My idea was to create a 3 dimensional array:

in a[][][]

I believe you meant

int a[][][]

where the first index is the potential numbers of pixels that I would
like to paint (20x20). The following two index should be the
coordinates for the pixels that should be painted. If I want to paint
3 pixels (2,4), (17,9), (10,3) the following should be made:

a[0][2][4];
a[1][17][9];
a[2][10][3];

What's the meaning of [2]? What does it mean "shoudl be made"?

But when I declare a 3-dim array:

a[][][];

I get:

error: declaration of ?a? as multidimensional array must have bounds
for all dimensions except the first

Yes. Any array needs its size defined.

I have then tried:

a[20*20][20*20][20*20];

But is there not some way to accomplish my above 3 pixels without
making such a huge array?

Each pixel can be modelled by a single element in the array. That
means you need

    char a[20][20] = {}; // initially zero

and if you want to set certain pixels to something, do

    a[2][4] = 1;
    a[17][9] = 1;
    a[10][3] = 1;

(or any other non-zero value). You could even use 'bool', but then
if you suddenly want 255 levels of gray, you'd have to rewrite it.

V

But now I have to iterate through the whole matrix with a nested for
loop to print/draw only 3 pixels.

Instead I would like to iterate an array corresponding to the number
of pixels that I want to draw (in this case 3) and for each index
extract the coordinate.

I was thinking of making a vector consisting of std::pair's instead
since the idea of double or triple indexing a binary value seems to
expensive (later I want to extend the window to 1024x768).

This seems to be a data structure problem. You have two basic choices
here: 1) make a 2D array where each element corresponds to a single
pixel; 2) make a list where each element is a single pixel that is
turned on. Each has its pros and cons-- an array allows you to
quickly determine if a *particular* pixel is turned on, a list allows
you to quickly iterate over *all* pixels that are turned on. Without
knowing what you intend to do, we can't recommend one over the other.

FWIW, array vs. list is a ubiquitous issue in all sorts of programming
problems. Weigh the pros and cons and see which better suits your
needs, or make your own structure if neither is sufficient.

I think I have found a solution. I just make two global int arrays and a
global pointer:

int x[20*20];
int y[20*20];
int counter = 0;

Each time I want to store a pixel I just do the following:

x[counter] = x_coord;
y[counter] = y_coord;
counter++;

I can then read the coordinates from the two arrays afterwards...seems
pretty simple and efficient.

But not very good, I would say. You're taking a fundamental piece of
data, an (x,y) coordinate, and dividing it into two separate data
structures connected by an essentially meaningless counter variable.

typedef std::pair<int,int> Point;
std::list<Point> allPoints;

or

std::vector<Point> allPoints;

or even

std::set<Point> allPoints;

makes a lot more sense to me.