int scores[์ธ๋ฑ์ค];
float scores[์ธ๋ฑ์ค];
char scores[์ธ๋ฑ์ค];
...
์ธ๋ฑ์ค(index) : ๋ฐฐ์ด ์์์ ๋ฒํธ 0~n-1
- ๋ฐฐ์ด ์์์๋ ์ธ๋ฑ์ค๋ก ์ ๊ทผํ ์ ์๋ค.
- ์ธ๋ฑ์ค ์์ ์์๋ ์์ฑํ ์ ์๋ค.
score[i] = 100;
score[i + 2] = 100;
- ๋ฐฐ์ด์ ๊ฐ์ฅ ํฐ ์ฅ์ ์ ๋ฐ๋ณต๋ฌธ์ ์ฌ์ฉํ์ฌ์ ๋ฐฐ์ด์ ์์๋ฅผ ๊ฐํธํ๊ฒ ์ฒ๋ฆฌํ ์ ์๋ค๋ ์ ์ด๋ค.
์ธ๊ทธ๋จผํ ์ด์ ํฌํธ(segmentation fault)
- ์ธ๊ทธ๋ฉํ ์ด์ (segmentation)์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๊ธฐ๋ฒ ์ค ํ๋๋ก, ํ๋ก์ธ์ค๊ฐ ์ฌ์ฉํ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์๋ก ๋ค๋ฅธ ํฌ๊ธฐ์ ๋ ผ๋ฆฌ์ ๋จ์์ธ ์ธ๊ทธ๋จผํธ(segment)๋ก ๋๋์ด ๊ด๋ฆฌํ๋ ๋ฐฉ๋ฒ
- ์ด ๊ธฐ๋ฒ์ ์ฃผ์ ๊ณต๊ฐ์ ๋ ผ๋ฆฌ์ ์ผ๋ก ๋ถํ ํจ์ผ๋ก์จ ๋ฉ๋ชจ๋ฆฌ ๋ณดํธ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ์ฉ์ดํ๊ฒ ํจ
- ์ธ๊ทธ๋ฉํ ์ด์ ํฌํธ(segmentation fault)๋ ํ๋ก๊ทธ๋จ์ด ์๋ชป๋ ๋ฉ๋ชจ๋ฆฌ ์ ๊ทผ์ ์๋ํ ๋ ๋ฐ์ํ๋ ์ค๋ฅ๋ฅผ ์๋ฏธํจ
(์๋ชป๋ ์ธ๋ฑ์ค)
- ์ธ๋ฑ์ค๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ๋ฒ์ด๋๊ฒ ๋๋ฉด ํ๋ก๊ทธ๋จ์ ์น๋ช ์ ์ธ ์ค๋ฅ๋ฅผ ๋ฐ์์ํจ๋ค.
- ์๊ธฐ์น ์์ ๋์์ด๋ ํ๋ก๊ทธ๋จ์ ๋น์ ์ ์ข ๋ฃ๋ฅผ ์ด๋ํ ์ ์๋ค.
ex)
#include <stdio.h>
int main() {
int arr[5] = {1, 2, 3, 4, 5};
int *ptr = arr; // ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ
// ์ ํจํ ์ธ๋ฑ์ค ๋ฒ์ ๋ด์ ์๋ ์์์ ์ ๊ทผ
printf("Before out-of-bound access: arr[3] = %d\n", arr[3]);
// ๋ฐฐ์ด ๋ฒ์๋ฅผ ๋์ด์๋ ๊ณณ์ ์ ๊ทผํ์ฌ ๋ฐ์ดํฐ ์ ์ฅ
ptr[10] = 100; // arr ๋ฐฐ์ด์ ๋ฒ์๋ฅผ ๋์ด์๋ ์ธ๋ฑ์ค์ ๋ฐ์ดํฐ ์ ์ฅ
// ์ ํจํ ์ธ๋ฑ์ค ๋ฒ์ ๋ด์ ์์ ๊ฐ ํ์ธ
printf("After out-of-bound access: arr[3] = %d\n", arr[3]);
printf("Value at ptr[10] (out-of-bound access): %d\n", ptr[10]);
return 0;
}
๋ฐฐ์ด์ ์ด๊ธฐ๊ฐ๊ณผ ์ด๊ธฐํ
// ์์์ ์ด๊ธฐ๊ฐ์ ์ฝค๋ง๋ก ๋ถ๋ฆฌํ์ฌ ์ค๊ดํธ ์์ ๋์ดํ๋ค
int scores[5] = { 10, 20, 30, 40, 50 }
// ์ด๊ธฐ๊ฐ์ ์ผ๋ถ๋ง ์ฃผ๋ฉด ๋๋จธ์ง ์์๋ค์ 0์ผ๋ก ์ด๊ธฐํ๋๋ค.
int scores[5] = { 10, 20, 30 }
// ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ์ฃผ์ด์ง์ง ์์ ๊ฒฝ์ฐ์๋ ์ด๊ธฐ๊ฐ์ ๊ฐ์๊ฐ ๋ฐฐ์ด์ ํฌ๊ธฐ๊ฐ ๋๋ค
// ์ฆ, ์ค๋ฅธ์ชฝ ์ค๊ดํธ ์์ ๊ฐ์๋งํผ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ก ์ง์ ๋๋ค.
int scores[] = { 10, 20, 30, 40, 50 };
์ด๊ธฐํ ํ๋ ๋ฐฉ๋ฒ
int score[์ธ๋ฑ์ค] = { 0 };
- ์ด๊ธฐํ ํ์ง ์์ผ๋ฉด ์ฐ๋ ๊ธฐ๊ฐ์ด ๋จ์์ ๋ฐฐ์ด์ ์ด์ํ ๊ฒ์ด ์์นํ ์ ์์ผ๋ ์ด๊ธฐํ ํด์ผ ํ๋ค.
๋ฐฐ์ด์ ๋น๊ต
- ๋ค๋ฅธ ๊ณต๊ฐ์ ํ ๋น๋์์ผ๋ฏ๋ก a์ b๋ ๊ฐ์ง ์๋ค.
#include <stdio.h>
#define SIZE 5
int main(void) {
int i;
int a[SIZE] = { 1, 2, 3, 4, 5 };
int b[SIZE] = { 1, 2, 3, 4, 5 };
return 0;
// ์ฌ๋ฐ๋ฅด์ง ์์ ๋ฐฐ์ด ๋น๊ต
if( a == b )
printf("์๋ชป๋ ๊ฒฐ๊ณผ์
๋๋ค.\n");
else
printf("์๋ชป๋ ๊ฒฐ๊ณผ์
๋๋ค.\n");
// ์ฌ๋ฐ๋ฅธ ๋ฐฐ์ด ๋น๊ต
for( i = 0 ; i < SIZE ; i++ )
{
if( a[i] != b[i] )
{
printf("a[]์ b[]๋ ๊ฐ์ง ์์ต๋๋ค.\n");
return 0;
}
}
}
๋ฐฐ์ด๊ณผ ํจ์
(๋ฐฐ์ด์ด ํจ์์ ์ธ์์ธ ๊ฒฝ์ฐ)
- ๋ฐฐ์ด์ด ํจ์์ ์ธ์๋ก ์ ๋ฌ๋ ๋, C ์ธ์ด์์๋ ๋ฐฐ์ด์ ์ฃผ์๊ฐ ์ ๋ฌ๋๋ค.
- ์ด๋ ํจ์์ ๋ฐฐ์ด์ ์ ๋ฌํ ๋ ๋ฐฐ์ด์ ๋ณต์ฌ๋ณธ์ด ์๋๋ผ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๊ฐ ์ ๋ฌ๋๋ ๊ฒ์ ์๋ฏธํ๋ค.
- ๋ฐ๋ผ์ ํจ์ ๋ด์์ ๋ฐฐ์ด์ ์๋ณธ ๊ฐ์ ๋ณ๊ฒฝํ๋ฉด, ํธ์ถ๋ ๊ณณ์์๋ ํด๋น ๋ณ๊ฒฝ ์ฌํญ์ด ๋ฐ์๋๋ค.
#include <stdio.h>
#define SIZE 7
void square_array(int a[], int size);
void print_array(int a[], int size);
int main(void)
{
int list[SIZE] = { 1, 2, 3, 4, 5, 6, 7 };
print_array(list, SIZE);
square_array(list, SIZE);
print_array(list, SIZE);
return 0;
}
void square_array(int a[], int size)
{
int i;
for(i = 0 ; i < size ; i++)
a[i] = a[i] * a[i];
}
void print_array(int a[], int size)
{
int i;
for(i = 0 ; i < size ; i++)
printf("%3d", a[i]);
printf("\n");
}
์๋ณธ ๋ฐฐ์ด์ ๋ณ๊ฒฝ์ ๊ธ์งํ๋ ๋ฐฉ๋ฒ
void print_array(const int a[], int size) //ํจ์ ์์์ a[]๋ ๋ณ๊ฒฝํ ์ ์๋ค
{
...
a[0] = 100; //์ปดํ์ผ ์ค๋ฅ๊ฐ ๋๋ค.
}
'C Programming Language > C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
C์ธ์ด ํฌ์ธํฐ(pointer)์ ๊ฐ๋ ํ์ตํ๊ธฐ (0) | 2024.07.02 |
---|---|
C์ธ์ด ์ ๋ ฌ๊ณผ ํ๋ ฌ์ ๋ํด ํ์ตํ๊ธฐ (0) | 2024.07.01 |
C์ธ์ด ์ฌ๊ท์ ์๊ณ ๋ฆฌ์ฆ : ํ๋ ธ์ด ํ ๋ฌธ์ (0) | 2024.06.19 |
C์ธ์ด static, register, volatile ์ง์ ์ ๊ฐ๋ (2) | 2024.06.19 |
C์ธ์ด ์ ์ญ๋ณ์์ ์ง์ญ๋ณ์, ๋งค๊ฐ๋ณ์(+๊ฐ๋ณ๋งค๊ฐ๋ณ์)์ ๊ฐ๋ (2) | 2024.06.19 |