Cookies to whoever solves this one. I found the following code on this page and I'm wondering how to modify it to 3d? I also don't get the typedef part since I never use typedefs.

#include <stdio.h>
#include <stdlib.h>

int main(int argc, char **argv) {

typedef double (array5k_t)[5000];

array5k_t *array5k = new array5k_t[5000];

array5k[4999][4999] = 10;
printf("array5k[4999][4999] == %f\n", array5k[4999][4999]);

return 0;
}

edit: Oh and how do I delete the whole thing.

I tried this:

These were the errors

In function 'int main(int, char**)':|
|9|error: array bound forbidden after parenthesized type-id|
|9|note: try removing the parentheses around the type-id|
|11|error: 'i' was not declared in this scope|
|13|error: array bound forbidden after parenthesized type-id|
|13|note: try removing the parentheses around the type-id|
|18|error: 'cout' is not a member of 'std'|
|18|error: 'endl' is not a member of 'std'|
||=== Build finished: 5 errors, 0 warnings ===|

I also tried this

I'd just get rid of that typedef and do it the normal way:

The point is that you allocate an array of arrays all at once. It doesn't matter how many dimensions the array has.

#include <stdio.h>
#include <stdlib.h>
 
int main() {
 
  typedef double array10_10_t[10][10];
 
  array10_10_t *arr = new array10_10_t[20];
 
  arr[15][2][0] = 10;
  printf("arr[15][2][0] == %f\n", arr[15][2][0]);
  delete[] arr;
  return 0;
}

So that it looks more compact than Oscars way? Or it takes a few lines less code?

Would it not be simpler (both in complexity and in understanding what is doing what) if you just used a struct?

typedef struct 3d{
   double x,y,z;
} 3d;

I don't see in what way you'll ever be using a 3D array like what you're suggesting: Every single point (5000*5000*5000) will have a single double in it: not a 3D coordinate; just a single floating-point value.

This won't really be useful to you. If you're trying to conceptualize something in 3-space, and you have 5000 points scattered around that space, you want 5000*3 to mark each particle's coordinates.

What you WANT is a coordinate for each particle (be it a point, a polygon, or even a sprite), and you can get 5000 of those easily (particle pumps).

Use a simple class, a one dimensional array, and an accessor function to take care of finding the right index for a given z,y,x triplet.

Well, it's {3 MULT, 2 ADD, 1 ACCESS} vs. {3 ACCESS}. The second way is probably somewhat faster, but then you have to deal with dereferencing three arrays, and they aren't stored sequentially like the first version would be. You'd have to profile it to see.

Well, there is a difference between a 3D compile time array, and a 3D run time array that you manually allocate as an array of arrays of arrays. The compile time array will be faster, but it's size has to be determined at compile time.

Google / profile FTW.

No, I meant 'Google' or 'Profile' For The Win. Not Google 'profile ftw'.

For some reason I'm tempted to ask if its better than std::vector?

I dissassembled the following code in codeblocks with GDB 7.2:

int main()
{
  int array[10];

  //array[1] = 0;

  //int value = array[1];

  //return 0;
}

00401318  push   %ebp
00401319  mov    %esp,%ebp
0040131B  and    $0xfffffff0,%esp
0040131E  sub    $0x30,%esp
00401321  call   0x401720 <__main>
00401326  mov    $0x0,%eax
0040132B  leave
0040132C  ret

Does the line:

 call   0x401720 <__main>

relate to,

int main()

or the exit of main?

Notice I have no return and yet it has it.

Is this the way its looked up BTW?

array[z*w*h + y*w + x];

like Edgar had it?

I thought C++ was supposed to do that by design.