컴공과 대학생 질문드립니다) C99 컴파일 관련

해보면 되겠쥬?

#include <stdio.h>

int main(int argc, char* argv[])
{
    int a[3] = {1,2,3,4,5};
    for (int i = 0 ; i < 3 ; i++) {
        printf("%d\n", a[i]);
    }
    return 0;
}

컴파일 하면

cc     bigger_array_init.c   -o bigger_array_init
bigger_array_init.c: In function ‘main’:
bigger_array_init.c:5:27: warning: excess elements in array initializer
    5 |         int a[3] = {1,2,3,4,5};
      |                           ^
bigger_array_init.c:5:27: note: (near initialization for ‘a’)
bigger_array_init.c:5:29: warning: excess elements in array initializer
    5 |         int a[3] = {1,2,3,4,5};
      |                             ^
bigger_array_init.c:5:29: note: (near initialization for ‘a’)

gcc는 에러는 아니고 워닝이네요.

코드를 요래 수정 하면

for (int i = 0 ; i < 5 ; i++) {

결과는

1
2
3
311017216
1466569650

컴파일러가 알아서 배열 크기만큼만 짤라서 초기화하니깐 워닝으로도 충분한가봅니다.

int fsize3(int n)
{
    char b[n+3]; // variable length array
    return sizeof b; // execution time sizeof
}

요건 가변 배열에 대한 sizeof 함수고요

int fsize3(void)
{
    char b[23]; // variable length array
    return sizeof b; // execution time sizeof
}

요건 고정 배열에 대한 sizeof 함수입니다.

컴파일해서 역어셈블 해 보면

0000000000001169 <fsize3>:
    1169:   f3 0f 1e fa             endbr64
    116d:   55                      push   %rbp
    116e:   48 89 e5                mov    %rsp,%rbp
    1171:   48 83 ec 30             sub    $0x30,%rsp
    1175:   89 7d dc                mov    %edi,-0x24(%rbp)
    1178:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
    117f:   00 00 
    1181:   48 89 45 f8             mov    %rax,-0x8(%rbp)
    1185:   31 c0                   xor    %eax,%eax
    1187:   48 89 e0                mov    %rsp,%rax
    118a:   48 89 c7                mov    %rax,%rdi
    118d:   8b 45 dc                mov    -0x24(%rbp),%eax
    1190:   8d 48 03                lea    0x3(%rax),%ecx
    1193:   48 63 c1                movslq %ecx,%rax
    1196:   48 83 e8 01             sub    $0x1,%rax
    119a:   48 89 45 e8             mov    %rax,-0x18(%rbp)
    119e:   48 63 c1                movslq %ecx,%rax
    11a1:   ba 10 00 00 00          mov    $0x10,%edx
    11a6:   48 83 ea 01             sub    $0x1,%rdx
    11aa:   48 01 d0                add    %rdx,%rax
    11ad:   be 10 00 00 00          mov    $0x10,%esi
    11b2:   ba 00 00 00 00          mov    $0x0,%edx
    11b7:   48 f7 f6                div    %rsi
    11ba:   48 6b c0 10             imul   $0x10,%rax,%rax
    11be:   48 89 c6                mov    %rax,%rsi
    11c1:   48 81 e6 00 f0 ff ff    and    $0xfffffffffffff000,%rsi
    11c8:   48 89 e2                mov    %rsp,%rdx
    11cb:   48 29 f2                sub    %rsi,%rdx
    11ce:   48 39 d4                cmp    %rdx,%rsp
    11d1:   74 12                   je     11e5 <fsize3+0x7c>
    11d3:   48 81 ec 00 10 00 00    sub    $0x1000,%rsp
    11da:   48 83 8c 24 f8 0f 00    orq    $0x0,0xff8(%rsp)
    11e1:   00 00 
    11e3:   eb e9                   jmp    11ce <fsize3+0x65>
    11e5:   48 89 c2                mov    %rax,%rdx
    11e8:   81 e2 ff 0f 00 00       and    $0xfff,%edx
    11ee:   48 29 d4                sub    %rdx,%rsp
    11f1:   48 89 c2                mov    %rax,%rdx
    11f4:   81 e2 ff 0f 00 00       and    $0xfff,%edx
    11fa:   48 85 d2                test   %rdx,%rdx
    11fd:   74 10                   je     120f <fsize3+0xa6>
    11ff:   25 ff 0f 00 00          and    $0xfff,%eax
    1204:   48 83 e8 08             sub    $0x8,%rax
    1208:   48 01 e0                add    %rsp,%rax
    120b:   48 83 08 00             orq    $0x0,(%rax)
    120f:   48 89 e0                mov    %rsp,%rax
    1212:   48 83 c0 00             add    $0x0,%rax
    1216:   48 89 45 f0             mov    %rax,-0x10(%rbp)
    121a:   48 89 fc                mov    %rdi,%rsp
    121d:   89 c8                   mov    %ecx,%eax
    121f:   48 8b 55 f8             mov    -0x8(%rbp),%rdx
    1223:   64 48 2b 14 25 28 00    sub    %fs:0x28,%rdx
    122a:   00 00 
    122c:   74 05                   je     1233 <fsize3+0xca>
    122e:   e8 2d fe ff ff          call   1060 <__stack_chk_fail@plt>
    1233:   c9                      leave
    1234:   c3                      ret

졸라 길죠? 누가 봐도 run time에 뭘 하고 있는 코드입니다.

그러면 고정 배열일 때는?

0000000000001169 <fsize3>:
    1169:   f3 0f 1e fa             endbr64
    116d:   55                      push   %rbp
    116e:   48 89 e5                mov    %rsp,%rbp
    1171:   48 83 ec 20             sub    $0x20,%rsp
    1175:   64 48 8b 04 25 28 00    mov    %fs:0x28,%rax
    117c:   00 00 
    117e:   48 89 45 f8             mov    %rax,-0x8(%rbp)
    1182:   31 c0                   xor    %eax,%eax
    1184:   b8 17 00 00 00          mov    $0x17,%eax
    1189:   48 8b 55 f8             mov    -0x8(%rbp),%rdx
    118d:   64 48 2b 14 25 28 00    sub    %fs:0x28,%rdx
    1194:   00 00 
    1196:   74 05                   je     119d <fsize3+0x34>
    1198:   e8 c3 fe ff ff          call   1060 <__stack_chk_fail@plt>
    119d:   c9                      leave
    119e:   c3                      ret

짧쥬? 중간에 0x17을 eax에 넣는 코드가 보입니다. 0x17은 23이니깐 컴파일 타임에 int로 변환하는거 맞네요.