์ด์ „์— ์•Œ๊ณ ๋ฆฌ์ฆ˜ ๋ฌธ์ œ๋ฅผ ํ’€๋‹ค๊ฐ€ 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์—์„œ ์ œ๋Œ€๋กœ ๋™์ž‘ํ•  ์ˆ˜ ์žˆ์—ˆ์„๊นŒ?

๋‚ด๊ฐ€ ์ถ”์ธกํ•˜๋Š” ์›์ธ์€ ๋‘ ๊ฐ€์ง€์ด๋‹ค.

  1. ์ฒ˜์Œ๋ถ€ํ„ฐ char array๊ฐ€ (\0 ์„ ํฌํ•จํ•˜๋Š”) ๋ฌธ์ž์—ด ํ˜•ํƒœ๋กœ ์ด๋ฃจ์–ด์ ธ ์žˆ์–ด์„œ ์ข…๋ฃŒ ๋ฌธ์ž๊ฐ€ ํฌํ•จ๋˜์–ด์žˆ์—ˆ๋‹ค. (์ด๊ฑฐ์ผ ๊ฐ€๋Šฅ์„ฑ์ด ๋†’๋‹ค)
  2. ์šด์ด ์ข‹๊ฒŒ 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

https://modoocode.com/106

https://velog.io/@french_ruin/C-์–ธ์–ด-String

ํƒœ๊ทธ: , ,

์นดํ…Œ๊ณ ๋ฆฌ:

์—…๋ฐ์ดํŠธ:

๋Œ“๊ธ€๋‚จ๊ธฐ๊ธฐ