I'll grant you that, but the method I posted was valid for decades. I'm curious. How bad is casting, and why is it considered bad form/dangerous now? I get that doing something stupid like casting a float to a string in the hopes that you could print the float is dumb, but in this case, it is casing a pointer to a pointer.

Well first, a c-style cast gives no indication as to what it's actually doing under the covers (and it's very hard to search for these kind of casts in code). For pointer to pointer, under the covers it'll actually end up doing either a static_cast or reinterpret_cast depending on what the two types are.

A static_cast is "safer" in that it requires the two pointer types to be related, and applies the correct pointer arithmetic as needed. A reinterpret_cast is "more dangerous" in that it converts from any type to another without requiring the types be related and without changing the numerical value. You're essentially losing any type safety, and so seeing a reinterpret_cast should call special attention to that piece of code. I think the only place I ever use it is when calling legacy C apis that take pointers as integers and such.

So at the very least, you may as well use c++ casts - and in this case a reinterpret_cast will call attention to the fact that you're doing something sketchy (although it is correct).

A c-style cast could bite you if you had code that relied on the compiler treating it as static_cast, say; and then you changed one of the types causing the cast to actually be like a reinterpret_cast. Now you might have unexpectedly different pointer values as a result (whereas if you had been using an actual static_cast, you'd now be alerted to the problem by a compile error). Can't think of a good example off-hand....

while the vector version will be much safer, i believe the correct old school syntax should be:

void foo(int * a, int sizeX, int sizeY, int value)

{

a[sizeY*sizeof(int)+sizeX]=value;

}

void main()

{

int arr[10*10];

Yes i want to be able to pass all my different arrays (typically 2-dimensions) to the function.

address resolution will depend on the dimensionality of the array.

1D:

int array[max_x];

array[x]=value;

2D:

int array[max_y][max_x]; or int array[max_y*max_x];

array[y*max_x+x]=value;

3D:

int array[max_z][max_y][max_x]; or int array[max_z*max_y*max_x];

array[z*max_y*max_x+y*max_x+x]=value; (i _think_ that's right, i prefer multi dimensional arrays to avoid such BS math junk)

and you'll need to know the size of the array to resolve the address. so you end up passing array, x, y, max_x, and max_y for both one and two dimensional arrays!

of course you can hard code max_x and max_y so you don't have to pass them, but we all know hard coded magic numbers are frowned upon. if you change your array size you break your code.

so you might as well have two methods, one for 2D arrays and one for 1D.

when you have an API like that, with 1d and 2d versions, studies show its better to do a 1d api and a 2d api, rather than an all-in-one 1d and 2d API. with the all in one API you end up passing data or flags you don't have to.

or better yet, why bother with setter methods at all when you can just do array[x][y]=value and get on with life? you might be over-engineering things. is there some reason why a simple assignment statement won't work?