[C] strlen vs sizeof
์ด์ ์ ์๊ณ ๋ฆฌ์ฆ ๋ฌธ์ ๋ฅผ ํ๋ค๊ฐ char array์ strlen
์ ์ธ ์ ์๋์ง ๊ถ๊ธํ๋ ์ ์ด ์์๋ค.
๊ทธ๋ ์จ๋ดค๋๋ฐ ์์ธ๋ก ์ ๋๋ก ๋์ํ์ง๋ง ๋ชจ๋ฅด๊ณ ์ฐ๊ธฐ์๋ ์ฐ์ฐํด์ ์ ๋ฆฌํด๋๊ณ ๋์ด๊ฐ๋ ค๊ณ ํ๋ค.
๋ ์๊ฐํด๋ณด๋ ๋์ ์ฐจ์ด๋ ์ข ์ ๋งคํ๊ฒ ์๊ณ ์๋ ๊ฒ ๊ฐ์์ ์ง๊ณ ๋์ด๊ฐ๋ ค๊ณ ํ๋ค.
โผ๏ธ์ฐ์ ๋ด๊ฐ ๊ฐ์ฅ ํฌ๊ฒ ์ฐฉ๊ฐํ๊ณ ์๋ ์ !
C์๋ string์๋ฃํ์ด ์๋ค. string์ ๊ฐ๋ ์ ๊ฐ๊น์ด ๋๋์ด๊ณ ์ฌ์ค์์ null-terminated char array์ด๋ค..!
๊ทธ๋๊น char array์ธ๋ฐ \0
์ผ๋ก ๋๋๋ฉด string์ด๋ผ๊ณ ํ ์ ์๋ค๋ ์๋ฏธ์ด๋ค.
strlen vs sizeof
string.h์์๋ ๋ฌธ์์ด์ ๊ด๋ จ๋ ์ฌ๋ฌ ํจ์๋ฅผ ์ ๊ณตํ๋ค.
์ฌ๋ฌ๊ฐ์ง๊ฐ ์๋๋ฐ ๋ํ์ ์ผ๋ก strcpy
, strlen
, strcat
, strcmp
๋ฑ์ด ์๋ค.
์ด ์ค ๋ด๊ฐ ๊ถ๊ธํ๋ ๊ฑด ์ char array์์ strlen
์ด ์ ๋๋ก ์๋ํ๋๊ฐ์, sizeof
์ ๋ด๋ถ์ ์ผ๋ก ์ด๋ค ์ฐจ์ด๊ฐ ์๋๋์๋ค.
strlen
๋จผ์ strlen
์ ๊ตฌํ ์์ ๋ฅผ ๋จผ์ ํ์ธํด๋ณด๋ฉด ์๋์ ๊ฐ๋ค.
size_t strlen(const char *s) {
const char *eos = s;
while (*eos++);
return (int)(eos - s - 1);
}
eos(end of string)์ด 0 (\0
)๋๋ฉด \0
์ด ๋ค์ด์๋ ์ฃผ์๊ฐ๊ณผ ์์ ์ฃผ์๊ฐ์ ์ฐจ๋ฅผ ๊ตฌํด์ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ๊ตฌํ๋ค.
๊ทธ๋ฌ๋๊น ์ฌ์ค ๋ฌธ์์ด ๋ด์ ๋ฌธ์๊ฐ ๋ช ๊ฐ ์๋ ๋ณด๋ค๋ ์์์ฃผ์๋ถํฐ \0
์ ๊น์ง ๋ช ๋ฐ์ดํธ๊ฐ ์๋๋ฅผ ๋ฐํํ๊ฒ ๋๋ค.
๊ทธ๋์ ์ค์ ๋ก โ์๋
โ
๊ฐ์ ํ๊ธ์ ๋ฃ๊ฒ ๋๋ฉด UTF-8 ๊ธฐ์ค ํ๊ธ์ ๊ฐ ๊ธ์๋ง๋ค 3๋ฐ์ดํธ ํฌ๊ธฐ๋ฅผ ์ฐจ์งํ๋ฏ๋ก 6์ ๋ฐํํ๊ฒ ๋๋ค.
#include <stdio.h>
#include <string.h>
int main() {
int l = strlen("์๋
"); //"์" 3byte , "๋
" 3byte
printf("%d",l); //output : 6
}
sizeof
์ฌ์ค ์ง์ง ๋ง์ด ์ฐ๋ ํจ์์ธ๋ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง๋ ๋ฑํ ์๊ฐ ์ ํด๋ดค๋ค. ๊ทธ๋ฅ ์์์ ์ ํ๊ฒ ๊ฑฐ๋ ํ๊ณ ์ผ๋ค.
๊ทผ๋ฐ ์ด๊ฒ๋ ์๊ณ ๋ณด๋ ๊ฝค ์ฌ๋ฐ๋ค.
์ผ๋จ sizeof๋ ํจ์๊ฐ ์๋๋ผ ์ฐ์ฐ์์๋ค!!๐คฏ
๊ทธ๋์ ๋ฌด๋ ค ๊ดํธ๊ฐ ์์ด๋ ์ธ ์ ์๋ค.
int main() {
char a[] ="abc";
char b[] ="abcd";
size_t la = sizeof a;
size_t lb = sizeof(b);
printf("%d %d",la,lb); //4 5
}
๋ํ ์ปดํ์ผ ํ์์ ๊ณ์ฐ๋๊ธฐ ๋๋ฌธ์ ๋ฐํ์์์ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ์ง ์๋๋ค.
๋ณ์๋ ํ์ ์ด๋ ์๊ด์์ด ํด๋น ๊ฐ์ฒด๊ฐ ์ฐจ์งํ๋ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๋ฐํํ๋ค.
ํด๋น ๊ฐ์ฒด๊ฐ ์ฐจ์งํ๋ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๊ณ์ฐํ๋ ๋ฐฉ๋ฒ์ ์ปดํ์ผ๋ฌ๊ฐ ์ฌ์ ์ ๊ฐ์ง๊ณ ์๋ ์ ๋ณด๋ฅผ ํ์ฉํ๋ค.
์ strlen๊ฐ char array์์ ์ ๋๋ก ๋์ํ ์ ์์๋๐ค
์ฌ์ค์ ์ด๊ฒ ๊ฐ์ฅ ๊ถ๊ธํ๋ ๋ถ๋ถ์ด๋ค.
strlen์ \0
์ด์ ๊น์ง์ ๋ฐ์ดํธ ์๋ฅผ ๋ฐํํ๋ ํจ์์ธ๋ฐ ์ด๋ป๊ฒ char array์์ ์ ๋๋ก ๋์ํ ์ ์์์๊น?
๋ด๊ฐ ์ถ์ธกํ๋ ์์ธ์ ๋ ๊ฐ์ง์ด๋ค.
- ์ฒ์๋ถํฐ char array๊ฐ (
\0
์ ํฌํจํ๋) ๋ฌธ์์ด ํํ๋ก ์ด๋ฃจ์ด์ ธ ์์ด์ ์ข ๋ฃ ๋ฌธ์๊ฐ ํฌํจ๋์ด์์๋ค. (์ด๊ฑฐ์ผ ๊ฐ๋ฅ์ฑ์ด ๋๋ค) - ์ด์ด ์ข๊ฒ char array๊ฐ ๋๋๋ ์์ญ ์ดํ์ 0 ์ด ๋ค์ด์์ด์ ์ด๋ฅผ
\0
์ผ๋ก ์ธ์ํ๊ณ ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ค.
์คํ
๊ฐ์ค์ ํ์ธํ๊ธฐ ์ํด ์คํ์ ํด๋ดค๋๋ฐ ๊ทธ๋ฅ ๊ทธ๋๋ ๋ด๊ฐ ์ด์ด ์ข์๋ ๊ฒ ๊ฐ๋ค.
#include <stdio.h>
#include <string.h>
int main() {
char a[] = {'a','b','c'};
for(int i=0;i<5;i++){
printf("%d ",*(a+i)); //97 98 99 -99 0
}
printf("\nres : %d",strlen(a)); //4
}
\0
์ด ์๋ char array์ strlen
์ ์ผ๋๋ ์๋ชป๋ ๊ฒฐ๊ณผ๊ฐ ๋์๋ค. ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ณด๋ ๊ทธ๋ฅ 0์ด์๋๊ณณ๊น์ง ๊ณ์ ์ฝ๋๋ค.
#include <stdio.h>
#include <string.h>
int main() {
char a[] = {'a','b','c'};
char b[] = {'d','e','f'};
printf("a_addr : %p, b_addr : %p\n",a,b); //a_addr : 0x7ffc12cbc3d2, b_addr : 0x7ffc12cbc3d5
printf("%d",strlen(a)); //7
}
์ด๊ฒ๋ ๋ง์ฐฌ๊ฐ์ง๋ก \0
์ด์๋ char array๋ฅผ ๋๊ฐ ์ฐ๋ฌ์ ๋ถ์ฌ ์ ์ธํ๋๋ strlen
์์ ๋์ ๋ํ๊ฒ๋ณด๋ค ์ฝ๊ฐ ๋ ํฐ๊ฐ์ด ๋์๋ค.
#include <stdio.h>
#include <string.h>
int main() {
char a[] = "abc";
printf("res : %d",strlen(a)); //3
}
๋ญ ์ด๊ฑด ๋น์ฐํ ๊ฑฐ์ง๋ง ๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง char array์์๋ ์ ํํ ๊ฐ์ด ๋์๋ค.
๊ฒฐ๋ก
๋ฌธ์์ด ๋ฐ์ดํฐ๊ฐ ์๋ char array์ strlen์ ํจ๊ป ์ฌ์ฉํ๋ฉด ์๋๋ค.
๋ฌธ์์ด ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ง char array์์๋ ๋ฌธ์ ๊ฐ ์์์ง๋ง ๊ทธ๋ ์ง ์์ char array์์๋ ๊ณ์ํด์ ์ข
๋ฃ ๋ฌธ์(\0
)์ ์ฐพ์ผ๋ฉฐ ๋ฉ๋ชจ๋ฆฌ ๊ฒฝ๊ณ๋ฅผ ๋์ด ์ฐ๋ ๊ธฐ ๊ฐ์ ์ฝ๋๋ค.
๊ทธ๋ฌ๋ค ์ ๊ทผ ๊ถํ์ด ์๋ ๋ฉ๋ชจ๋ฆฌ๊น์ง ๊ฐ๋ฒ๋ฆฌ๋ฉด segmentation fault๊ฐ ๋ฐ์ํ๊ฒ ๋๋ค.
์์ผ๋ก๋ ๋ค์ด๊ฐ๋ ๋ฐ์ดํฐ๋ฅผ ์ ์๊ฐํ๊ณ ์ฃผ์ํด์ strlen์ ์จ์ผ ํ ๊ฒ ๊ฐ๋ค.
sizeof vs strlen
๊ณต๋ถ๋ฅผ ํ๋ค๋ณด๋ strlen๊ณผ sizeof๋ ์๊ฐ ๋ณด๋ค ๋ง์ด ๋ค๋ฅด๋ค.
์ ๋ฆฌํ์๋ฉด ์๋์ ๊ฐ๋ค.
-
strlen : ๋ฌธ์์ด ํํ์ ๋ฐ์ดํฐ์
\0
๊น์ง์ ๊ธธ์ด๋ฅผ ์ฐพ๋ ์ฉ๋. -
sizeof : ์ปดํ์ผ ํ์์ ์คํ๋๋ฉฐ ๋ฏธ๋ฆฌ ์๊ณ ์๋ ์ ๋ณด๋ฅผ ํ์ฉํ์ฌ ๊ฐ์ฒด์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ ํฌ๊ธฐ๋ฅผ ๊ตฌํ๋ ์ฐ์ฐ์.
+) char pointer, char array
๊ณต๋ถํ๋ค ๋ณด๋ ์๊ฐ๋ณด๋ค ์ฌ๋ฐ๋ ๋ถ๋ถ์ด ์ข ๋ ์์ด์ ๋ฉ๋ชจํ ๊ฒธ ์ถ๊ฐํด๋๋ค.
char* c1 = "abcd"; //"abcd"๋ .rodata์ ์ ์ฅ๋๋ฉฐ ์์ ํ ์ ์๋ค.
char c2[] = "efgh"; // "efgh"๋ stack์์ญ์ ์ ์ฅ๋๋ฉฐ ์์ ์ด ๊ฐ๋ฅํ๋ค.
์ฐธ๊ณ
https://www.ibm.com/docs/ko/i/7.3?topic=functions-strlen-determine-string-length#strlen
๋๊ธ๋จ๊ธฐ๊ธฐ