Do You Coding?
[library] atoi ๊ตฌํํ๊ธฐ ๋ณธ๋ฌธ

๐ ๋งค๋ด์ผ (Linux)
NAME
atoi - convert a string to an integer
: ๋ฌธ์์ด์ ์ ์๋ก ๋ณํํ๋ ํจ์
SYNOPSIS
#include <stdlib.h>
int atoi(const char *nptr);
DESCRIPTION
The atoi() function converts the initial portion of the string pointed to by nptr to int.
The behavior is the same as
strtol(nptr, NULL, 10);
except that atoi() does not detect errors.
: atoi() ํจ์๋ nptr๊ฐ ๊ฐ๋ฆฌํค๋ ๋ฌธ์์ด์ ์ฒ์ ๋ถ๋ถ์ ์ ์๋ก ๋ณํํฉ๋๋ค.
๋์ ๋ฐฉ์์ ๋ค์ ์ฝ๋์ ๋์ผํฉ๋๋ค.
strtol(nptr, NULL, 10);
์ฆ, strtol() ํจ์๋ฅผ base 10(์ญ์ง๋ฒ)์ผ๋ก ์ฌ์ฉํ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
ํ์ง๋ง atoi()๋ ์ค๋ฅ๋ฅผ ๊ฐ์งํ์ง ์์ต๋๋ค.
(strtol()์ ๋ณํ ๊ณผ์ ์์ ์ค๋ฅ๋ฅผ ๊ฐ์งํ ์ ์์ง๋ง, atoi()๋ ๊ทธ๋ ์ง ์์.)
RETURN VALUE
The converted value or 0 on error.
: ๋ณํ๋ ์ ์ ๊ฐ์ ๋ฐํํฉ๋๋ค.
๋ณํํ ์ ์๋ ๊ฒฝ์ฐ 0์ ๋ฐํํฉ๋๋ค.
๐ ์์ฑ ์ฝ๋
int do_atoi(const char *nptr)
{
long long int sign;
long long int n;
int i;
sign = 1;
n = 0;
i = 0;
while (nptr[i] == 32 || (nptr[i] >= 9 && nptr[i] <= 13))
i ++;
if (nptr[i] == '+' || nptr[i] == '-')
{
if (nptr[i] == '-')
sign = -1;
i ++;
}
while (nptr[i] >= '0' && nptr[i] <= '9')
{
n = 10 * n + (nptr[i] - 48);
i ++;
}
return (sign * n);
}
๐ ์ฝ๋ ๋ฆฌ๋ทฐ
shell์์ ์ด๋ค ํ๋ก๊ทธ๋จ์ ์คํํ ๋, ์ด๋ค ์ธ์๋ฅผ ์์ฑํด์ ๋ฐ๊ฒ ๋๋ฉด
char **argv๋ฅผ ํตํด ๋ฌธ์์ด๋ก ๋ฐ๊ฒ ๋์ด ์๋ค๋ณด๋, ๋ฌธ์์ด๋ก ์จ ์ซ์๊ฐ์ ์ ์ํ์ผ๋ก ๋ณํํ ๋ฐฉ๋ฒ์ด ํ์ํ๋ค.
๋ฐ๋ผ์ atoi ํจ์๊ฐ ์ฌ๊ธฐ์ ์ฐฐ๋ก๊ฐ์ด ์ฐ์ด๊ฒ ๋์๋ค.
atoi ํจ์๋ itoa์ ๋ฐ๋๋ก alphabet to int ์ ์ฝ์๋ก, ๋ฌธ์์ด๋ก ๋ฐ์ ์ธ์๋ฅผ ์ ์๋ก ๋ณํํ์ฌ ๋ฐํํด์ฃผ๋ ํจ์์ด๋ค.
"12345" ๋ผ๋ ๋ฌธ์์ด์ ์ ์๊ฐ 12345๋ก ๋ฐ๊ฟ ๋ฐํํ๋ค.
์์ ์ฝ๋๋ฅผ ํ๋ํ๋ ์์ฐจ์ ์ผ๋ก ๋ฏ์ด๋ณด์.
์ฐ์ while๋ฌธ์ ํตํด ๊ณต๋ฐฑ์ด๋ tab๊ณผ ๊ฐ์ whitespace๋ฅผ ๊ฑด๋๋ฐ๋ ์์ ์ ํด์ฃผ์๋ค.
๊ทธ ํ, +๋ - ๊ฐ ์์ผ๋ฉด ์ธ๋ฑ์ค๋ฅผ ํ๋ ๊ฑด๋ ๋ฐ๊ธฐ์ํ if๋ฌธ์ ์์ฑํ๋ค.
๋ํ '-' ์ผ๋๋ ์ถํ์ ์์๋ก ๋ณํํด์ค์ผํ๋ฏ๋ก, sign์ด๋ผ๋ ๋ณ์๋ฅผ ํตํด ๋ถํธ๊ฐ์ -1๋ก ์ง์ ํ๋ค.
๊ทธ ์ดํ, while๋ฌธ์ ํตํด ์ซ์๊ฐ์ด ๋์ฌ ๋์ ์๋ฆฌ์๋ฅผ ๋์ฌ๊ฐ๋ฉด์ ๊ฐ์ ์ ์ฅํด์ฃผ๋ ๊ณผ์ ์ ๊ฑฐ์ณค๋ค.
long long int๋ก ๊ฐ๋ค์ ์ ์ธํ๊ณ , ์๋ atoi์ ๋์ผํ๊ฒ ๋ฐ๋ก overflow์ ๋ํ ์ฒ๋ฆฌ๋ฅผ ํ์ง ์์๋ค.
(๋ฐํ์ด int์ด๋ฏ๋ก, ๊ฐ์ด ๋์ณค์ ๋๋ ์์์ overflow ๋๋๋ก ๋ .)
๊ทธ๋ฆฌ ์ด๋ ต์ง๋ ์์ ์ฝ๋์ด๋, ๋์ค์ ๋ค๋ฅธ ์ฝ๋์ ์ ์ฉ์์ผ๋ณด๋,
overflow error handling์ด ์๋๊ฒ ๋๋ฌด ๋ถํธํ๋ค. (์ค์ atoi ํจ์๋ ์๋ค. -> ๋์: strtol ํจ์๋ ์ค๋ฅ ๊ฐ์ง ํด์ค๋ค.)
๊ทธ๋ฌ๋ค๋ณด๋ upgrade ver. ๋ฅผ ํ๋ ๋ง๋ค์ด๋๋ค.
* atoi_upgrade
int do_atoi_upgrade(char *nptr, int *v)
{
long long int sign;
long long int n;
int i;
i = 0;
n = 0;
sign = 1;
if (nptr[i] == '-')
{
sign = -1;
i ++;
}
while (nptr[i] >= '0' && nptr[i] <= '9')
{
n = 10 * n + (nptr[i] - 48);
i ++;
if ((sign * n) > 2147483647 || (sign * n) < -2147483648)
{
(*v) = 1;
return (0);
}
}
return ((int)sign * (int)n);
}
์ฐ์ , whitespace ๋ถ๋ถ์ ๋ด๋ถ์์ ๊ณ ๋ คํ์ง์๊ณ ,
์ธ๋ถ ์ฝ๋์์ ์ซ์๊ฐ๋ง parsingํด์ ๋ค์ด์จ๋ค๋ ๊ฐ์ ํ์ ์์ฑํ๋ค.
๋ฐ๋ผ์ ์์ ๋ถ๋ถ์ '-'๊ฐ ์์ผ๋ฉด sign๊ฐ๋ง ๋ณ๊ฒฝํ๊ณ ,
+๋ก ์์ํ๋ ์ซ์๋ parsing์์ +๊ฐ ์ฌ๋ผ์ ธ์ ๋ค์ด์ค๊ฑฐ๋, ๋ฏธ๋ฆฌ ๊ฑธ๋ฌ์ง๊ฒ ๋๋ค.
๋ค๋ฅธ ๋ถ๋ถ์ ๊ฐ์ง๋ง, while๋ฌธ๋ด์์ int๊ฐ overflow์ ๋ํ error handling ํํธ๋ฅผ ํ๋ ๋ฃ์๋ค.
๋งค๋ฒ ์๋ฆฌ์๊ฐ ์ฌ๋ผ๊ฐ ๋๋ง๋ค, ๋ฐํํ ๊ฐ์ด int overflow๊ฐ ๋์๋์ง ํ๋ณํ๊ฒ ๋ง๋ค์ด,
error flag์ธ v์ ๊ฐ์ 1๋ก ๋ฐ๊พธ๋๋ก ์ค์ ํด๋์๋ค.
๊ธฐ์กด์ ๋ง๋ค๋ while๋ฌธ ๋ฐ์ ์ด๋ฅผ ์ ์ด๋์๋๋ฐ, ์ด๋ ์น๋ช ์ ์ธ ๋ฌธ์ ๊ฐ ์์๋ค.
-> overflow ๋ ๊ฒฐ๊ณผ๊ฐ int ๋ฒ์ ์์ชฝ์ด ๋์ด๋ฒ๋ฆฌ๋ ์ํฉ์์, ์ด๋ฅผ ์ค๋ฅ๋ก ๋ณด์ง ๋ชปํ๋ค๋ ๊ฒ.
(longlong MAX ๋ณด๋ค ๋ ํฌ๋ฉด์ longlong MAX + int MAX ๋ณด๋ค ์์ ๊ฐ์ด ๋ค์ด๊ฐ๋ฉด overflow์ธ์ง ๋ชจ๋ฆ ..)
๋ฐ๋ผ์ while๋ฌธ ์์ ๋ฃ์ด int overflow ๋ ์ดํ์ ๋ฐ๋ก return ํด๋ฒ๋ฆฌ๋๋ก ํ์ถ๊ตฌ๋ฅผ ๋ง๋ จํ๋ค.
์ด๋ก์จ, int๊ฐ์ด ๋์ด๊ฐ๋ ๊ฐ์ flag๋ฅผ ํตํด ๊ฑธ๋ฌ์ฃผ๋ atoi_upgrade ๋ฅผ ๋ง๋ค๊ฒ ๋์๋ค..
+) ํ์คํ ๊ธฐ์กด์ ์๋ ํจ์๋ฅผ ๋์ด์์ ๊ฐ๊ณตํ๋ ค๋ ์ฝ์ง์๋ค๊ณ ์๊ฐ์ด ๋ค์๊ณ ,
๊ฐ๋จํ ํจ์๋ ์๊ฐํ ๋ถ๋ถ๋ค์ด ์ ๋ง ๋ง๋ค๊ณ ๋๊ผ๋ค. ์๋ฌด๋๋ ์์ ์ฝ๋๋ ๋ถ์กฑํ ๋ถ๋ถ์ด๋ ํ์ ์ด ์์ ์ ์๋ค..
์ต๋ํ ๋ค์ํ ๊ด์ ์์ ์ฝ๋ฉ์ ํด๋ด์ผํ ๋ฏํจ.
'CS & Engineering > C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
| [function] pthread_detach ํจ์ ์์๋ณด๊ธฐ (2) | 2024.09.18 |
|---|---|
| [function] pthread_join ํจ์ ์์๋ณด๊ธฐ (8) | 2024.09.07 |
| [function] pthread_create ํจ์ ์์๋ณด๊ธฐ (5) | 2024.09.07 |
| [utility] get_next_line ๊ตฌํํ๊ธฐ (3) | 2024.08.31 |
| [library] itoa ๊ตฌํํ๊ธฐ (0) | 2024.06.29 |
