Array!

[stoic gust]

It gives me an error for variable-sized object may not be initialized except with an empty initializer: int mxn[row][column] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};

#include <stdio.h>

void transpose(int a[][3], int b[][3], int row, int column) {

}

int main() {
    int row = 3;
    int column = 3;

    int mxn[row][column] = {{1, 2, 3}, {4, 5, 6}, {7, 8, 9}};
    int nxm[row][column];

    transpose(mxn, nxm, row, column);

    return 0;
}

[still apex]

When your question is answered use !solved to mark the question as resolved.

Remember to ask specific questions, provide necessary details, and reduce your question to its simplest form. For tips on how to ask a good question use !howto ask.

[pearl edge]

row and column are not considered constant expressions so you're creating a variable size array

not an array that necessarily changes size, just one that's size isn't known until runtime

But 3 is known before runtime

The problem is since the compiler thinks its size isn't known until runtime it doesn't want you trying to initialize it with an initializer which assumes a certain width and height

since... they might be wrong

But 3 is constant

So you can either replace occurances of row and column with 3 every time or you can make row and column const, which makes them constant expressions in this case, so its no longer a variable size array, its a fixed size array of size 3

Or you could use the preprocessor to achieve a similar thing to replaceing row and column with 3

There are many solutions

[stone vapor]

that's not correct

making them const is not the same thing as making them constant expressions

consider const int row = rand() % 3 + 1

[old hawk]

I prefer this example:

;compile

const int x = 4;
printf("const x = %d\n", x);
int *ptr = (int *) &x;
*ptr = 5;
printf("const x = %d\n", x);

[flat garden]

Program Output

const x = 4
const x = 5

elmonkeking#0000 | 64ms | c | x86-64 gcc 13.2 | godbolt.org

[stone vapor]

;compile -O

[flat garden]

Program Output

const x = 4
const x = 4

abcq2#0000 | 108ms | c | x86-64 gcc 13.2 | godbolt.org

[old hawk]

oh, it's UB?

[delicate rock]

Definitely

[pearl edge]

I thought in c if it was const and was initialized by a constant expression then it became a constant expression

[stone vapor]

you thought wrong.

it's just a non-modifiable lvalue, like an array

[pearl edge]

;compile

const int x = 4;
int arr[x] = {1, 2, 3, 4};

[flat garden]

Compiler Output

<source>: In function 'main':
<source>:5:14: error: variable-sized object may not be initialized except with an empty initializer
    5 | int arr[x] = {1, 2, 3, 4};
      |              ^
Build failed

veeloxfire#0000 | c | x86-64 gcc 13.2 | godbolt.org

[pearl edge]

huj yeah

wtf I swear Ive seen this done before

wait is it true with globals

[old hawk]

sizeof and #define work

[pearl edge]

Obviously I know const is not the same as constant expressions lol

[delicate rock]

Jacob Sorber made a video on this exact discrepancy:
https://youtu.be/8a3HyL1VN0Q?si=hd6YvIPNNiMzsrkJ

[pearl edge]

I could swear Ive seen someone use const in a weird way in c to somehow make a constant expression

maybe im going insane

[delicate rock]

You may be thinking of constexpr in C++?

[old hawk]

;compile

static const int x = 4;
int main() {
    int xs[x] = {1, 2, 3, 4};
}

[flat garden]

Compiler Output

<source>: In function 'main':
<source>:3:17: error: variable-sized object may not be initialized except with an empty initializer
    3 |     int xs[x] = {1, 2, 3, 4};
      |                 ^
Build failed

elmonkeking#0000 | c | x86-64 gcc 13.2 | godbolt.org

[pearl edge]

okay yeah apparently im going insane

;compile

const int x = 4;
int arr[x] = {1, 2, 3, 4};

[flat garden]

Compilation successful

No output.

veeloxfire#0000 | 72ms | c++ | x86-64 gcc 13.2 | godbolt.org

[pearl edge]

okay

turns out im not insane

its a feature of c++ not c

mb

I knew one had it I just forgot which lol

C adopted the const qualifier from C++, but unlike in C++, expressions of const-qualified type in C are not constant expressions
c baited me with this one

When they are used as array sizes, the resulting arrays are VLAs

so yeah that specific answer is not true

[old hawk]

👍

[delicate rock]

I didn't know that, very cool

[stone vapor]

also enum