Multidimenstional array semi-dynamic declaration

[beacon]

I haven't seen anything that would suggest this is possible, although I'm hoping it is, but is there a way to write a function that will return a value entered by the user and place that value as the indices for the array?

For example:

1. ReadArraySize asks the user for a number. If a number is entered it is returned. If no number is entered, the user is prompted again.
2. In main(), an integer array is declared with the returned value the user entered in ReadArraySize as the index for both dimensions of the array.
3. ReadArraySize returns 4.
4. In main(), int x = ReadArraySize();
5. The array is declared as int array [x][x];

I'm getting errors when I attempt this, but it would seem like it would be possible to achieve this since the value is unchanging in main().

I'm using C++, by the way...

[hoggy]

this is an intrestin question anyhow what kind of errors d u see

[beacon]

Here are the errors:

error C2057: expected constant expression
error C2466: cannot allocate an array of constant size 0
error C2057: expected constant expression
error C2466: cannot allocate an array of constant size 0
error C2087: '<Unknown>' : missing subscript

[weaknessforcats]

Certainly, you can do this.

C++, like C, only has one dimensional arrays. That means the number of elements must be known when the array is created. That make shti code:

int array [x][x];

not compilable since the number of elements is unknown.

But you can do this:

int* array = new int[x * x];
 

But wait, you say, I need a 2D array.

Read this:

First, there are only one-dimensional arrays in C or C++. The number of elements in put between brackets:

int array[5];
 

That is an array of 5 elements each of which is an int.

int array[];
 

won't compile. You need to declare the number of elements.

Second, this array:

int array[5][10];
 

is still an array of 5 elements. Each element is an array of 10 int.

int array[5][10][15];
 

is still an array of 5 elements. Each element is an array of 10 elements where each element is an array of 15 int.

int array[][10];
 

won't compile. You need to declare the number of elements.

Third, the name of an array is the address of element 0

int array[5];
 

Here array is the address of array[0]. Since array[0] is an int, array is the address of an int. You can assign the name array to an int*.

int array[5][10];
 

Here array is the address of array[0]. Since array[0] is an array of 10 int, array is the address of an array of 10 int. You can assign the name array to a pointer to an array of 10 int:

int array[5][10];
 
int (*ptr)[10] = array;
 

Fourth, when the number of elements is not known at compile time, you create the array dynamically:

int* array = new int[value];
int (*ptr)[10] = new int[value][10];
int (*ptr)[10][15] = new int[value][10][15];
 

In each case value is the number of elements. Any other brackets only describe the elements.

Using an int** for an array of arrays is incorrect and produces wrong answers using pointer arithmetic. The compiler knows this so it won't compile this code:

int** ptr = new int[value][10];    //ERROR
 

new returns the address of an array of 10 int and that isn't the same as an int**.

Likewise:

int*** ptr = new int[value][10][15];    //ERROR
 

new returns the address of an array of 10 elements where each element is an array of 15 int and that isn't the same as an int***.

With the above in mind this array:

int array[10] = {0,1,2,3,4,5,6,7,8,9};
 

has a memory layout of

0 1 2 3 4 5 6 7 8 9

Wheras this array:

int array[5][2] = {0,1,2,3,4,5,6,7,8,9};
 

has a memory layout of

0 1 2 3 4 5 6 7 8 9

Kinda the same, right?

So if your disc file contains

0 1 2 3 4 5 6 7 8 9

Does it make a difference wheher you read into a one-dimensional array or a two-dimensional array? No.

Therefore, when you do your read use the address of array[0][0] and read as though you have a
one-dimensional array and the values will be in the correct locations.

[beacon]

Thanks for the help weakness.

I was aware that I could create the arrays dynamically with pointers, but I was hoping to avoid it for the sake of the assignment. It was my fault for not being specific.

If I go and use pointers, my professor may not accept it since we are just working with 2D arrays.

The following isn't my original code, but this is what I'm trying to do:

void main(){
 
    int three = 3, five = 5, seven = 7, nine = 9;
    int square3[three][three];
    int square5[five][five];
    int square7[seven][seven];
    int square9[nine][nine];
 

[Ganon11]

I don't think there is a way to dynamically allocate memory without the use of pointers. That is, if you want to allow your program to support 2x2, 5x5, and 9x9 matrices, you must use pointers. You may be able to work around this by declaring the array as some large size (e.g. 10x10) and only using a certain portion of the array (say, the first 6 rows and columns), but this is overkill and not a good programming practice.

[beacon]

That's actually probably more along the lines of what my professor had in mind, come to think of it Gannon.

If I was only going to use a portion of it, would I just have to test the location everytime in reference to a starting location to make sure I didn't travel outside of the grid that I'm using at that given time?

Also, if the previous question is true, would I just mod the current location by the size of the matrix to return to the opposite side?

[weaknessforcats]

Keep in mind that when you use an array you are using a pointer. That is, the array name is the address of element 0. When you use the array name you are using the array address. *array is the same as array[0].