์คํธ๋ฆผ(stream) ์ด๋?
์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ๋ฐ์ดํธ(byte)๋ค์ ํ๋ฆ์ผ๋ก ์๊ฐํ๋ ๊ฒ์ด๋ค.
์๋ฅผ ๋ค์ด, ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฑฐ๋, ๋คํธ์ํฌ๋ฅผ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ ์กํ ๋, ์คํธ๋ฆผ์ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๋ค.
์คํธ๋ฆผ์๋ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ฒํผ(Buffer)๊ฐ ํฌํจ๋์ด ์๋๋ฐ, ์ด๋ ๋ฐ์ดํฐ๋ฅผ ์์๋ก ์ ์ฅํด ๋๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ด๋ค.
ํ์ค ์ ์ถ๋ ฅ ์คํธ๋ฆผ
์ ์ถ๋ ฅ ํจ์์ ๋ถ๋ฅ
์ผ๋ฐ ์คํธ๋ฆผ
- ํ์ผ ์ ์ถ๋ ฅ์ ์ฒ๋ฆฌํ๊ธฐ ์ํ ํจ์
- ์ด ํจ์๋ค์ ์ผ๋ฐ์ ์ผ๋ก ํ์ผ ์คํธ๋ฆผ์ ํตํด ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ฑฐ๋ ์ฐ๋ ๋ฐ ์ฌ์ฉ
fprintf
- file print formatted์ ์ฝ์
- fprintf๋ ํฌ๋งท์ ์ง์ ํ์ฌ ๋ฐ์ดํฐ๋ฅผ ํ์ผ์ ์ถ๋ ฅํ๋ ํจ์
- ํ ์คํธ ํ์ผ์ ์ํ๋ ํ์์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ์ธ ๋ ์ฌ์ฉ
FILE *fp = fopen("example.txt", "w");
if (fp != NULL) {
int age = 25;
fprintf(fp, "My age is %d years old.\n", age);
fclose(fp);
}
fscanf
- file scan formatted์ ์ฝ์
- fscanf๋ ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด ๋ค์ฌ ํน์ ํ์์ผ๋ก ๋ณํํ๋ ํจ์
- ํ์ผ๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์ ๋ณ์์ ์ ์ฅํ ๋ ์ฌ์ฉ
FILE *fp = fopen("example.txt", "r");
if (fp != NULL) {
int age;
fscanf(fp, "My age is %d years old.", &age);
printf("Read age: %d\n", age);
fclose(fp);
}
printf()๋ฅผ ์ด์ฉํ ์ถ๋ ฅ
ํ๋๊ทธ
์์
%d : ์ฃผ๋ก ์ ์ ๋ฐ์ดํฐ๋ฅผ 10์ง์(decimal) ํ์์ผ๋ก ์ถ๋ ฅํ๊ฑฐ๋ ์ ๋ ฅ๋ฐ์ ๋ ์ฌ์ฉ
%010d : 010์ ์๋ฆฟ์๋ฅผ ์๋ฏธํ๋ค.
- 0: ์ถ๋ ฅ ์, ์ซ์๊ฐ ์ฐจ์งํ์ง ์๋ ์๋ฆฟ์๋ฅผ 0์ผ๋ก ์ฑ์ฐ๋ผ๋ ์๋ฏธ
- 10: ์ถ๋ ฅํ ์ ์ฒด ์๋ฆฌ ์๋ฅผ 10์๋ฆฌ๋ก ๋ง์ถ๋ผ๋ ์๋ฏธ์ ๋๋ค. ์ฆ, ์ถ๋ ฅ๋๋ ์ ์ ๊ฐ์ด 10์๋ฆฌ์ ๋ฏธ์น์ง ๋ชปํ ๊ฒฝ์ฐ, ๊ทธ ์๋ถ๋ถ์ 0์ผ๋ก ์ฑ์์ 10์๋ฆฌ๋ก ์ถ๋ ฅํ๊ฒ ๋๋ค
%#x : ์ ์๋ฅผ 16์ง์(ํฅ์ฌ) ํ์์ผ๋ก ์ถ๋ ฅํ ๋ ์ฌ์ฉ๋จ. ์ด๋ # ๋ฌธ์๋ 16์ง์ ์ถ๋ ฅ์ 0x ์ ๋์ฌ๋ฅผ ์ถ๊ฐํ๋ผ๋ ์๋ฏธ
- %x: ์ ์๋ฅผ 16์ง์ ์๋ฌธ์ ํ์์ผ๋ก ์ถ๋ ฅ.
- #: #์ 16์ง์ ์ถ๋ ฅ ์, 0x ์ ๋์ฌ๋ฅผ ๋ถ์ฌ์ค. ์ด ์ ๋์ฌ๋ 16์ง์์์ ๋ํ๋ด๊ธฐ ์ํด ์ฌ์ฉ
ํ๋ํญ๊ณผ ์ ๋ฐ๋
- ํ๋ ํญ์ ์ ํ ์ ์๊ณ , ์ ๋ ฌํ ์ ์๋ค.
- %f๋ ์์์ ์ดํ 6์๋ฆฌ๊น์ง ์ถ๋ ฅ
- %.3f๋ ์์์ ์ดํ 3์๋ฆฌ๊น์ง๋ง ์ถ๋ ฅ
- %10.3f๋ ์์์ ์ดํ 3์๋ฆฌ๊น์ง ์ถ๋ ฅํ๋ฉด์ ์ ์ฒด ์ถ๋ ฅ ํญ์ 10์๋ฆฌ๋ก ๋ง์ถค
- %.3f๋ ์์์ ์ดํ 3์๋ฆฌ๊น์ง ์ถ๋ ฅํ๊ณ , ์ ์ฒด ํญ์ 10์๋ฆฌ๋ก ๋ง์ถ๋, ์ข์ธก ์ ๋ ฌ
ํ์ ์ง์ ์
scanf()๋ฅผ ์ด์ฉํ ์ ๋ ฅ
- ๋ฌธ์์ด ํํ์ ์ ๋ ฅ์ ์ฌ์ฉ์๊ฐ ์ํ๋ ํ์์ผ๋ก ๋ณํํ๋ค.
์์
#include <stdio.h>
int main(void)
{
int a, b;
printf("6๊ฐ์ ์ซ์๋ก ์ด๋ฃจ์ด์ง ์ ์๋ฅผ ์
๋ ฅํ์์ค:");
scanf("%3d%3d", &a, &b);
printf("์
๋ ฅ๋ ์ ์๋ %d, %d\n", a, b);
return 0;
}
8์ง์, 16์ง์ ์ ๋ ฅ
#include <stdio.h>
int main(void)
{
int d, o, x;
scanf("%d %o %x", &d, &o, &x);
printf("d=%d o=%d x=%d\n", d, o, x);
return 0;
}
d=10 (10์ง์๋ก ์ ๋ ฅํ 10 ๊ทธ๋๋ก ์ถ๋ ฅ)
o=8 (8์ง์ 10์ 10์ง์๋ก ๋ณํํ 8์ ์ถ๋ ฅ)
x=16 (16์ง์ 10์ 10์ง์๋ก ๋ณํํ 16์ ์ถ๋ ฅ)
- %d: 10์ง์(decimal) ์ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค
- %o: 8์ง์(octal) ์ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค
- %x: 16์ง์(hexadecimal) ์ ์๋ฅผ ์ ๋ ฅ๋ฐ๋๋ค
๋ฌธ์์ ๋ฌธ์์ด ์ฝ๊ธฐ
ํ์ ์ง์ ์์ ๊ณต๋ฐฑ :
%d, %f, %s ๋ฑ๊ณผ ๊ฐ์ ํ์ ์ง์ ์๋ ๊ณต๋ฐฑ์ ๋ฌด์ํ๊ณ ๋ค์ ๋ฐ์ดํฐ ํญ๋ชฉ์ ์ฐพ๋๋ค
์๋ฅผ ๋ค์ด, %d๋ ๊ณต๋ฐฑ์ ํฌํจํ ๋ฌธ์์ด์์ ์ฒซ ๋ฒ์งธ ์ ์๋ฅผ ์ฝ์ด์จ๋ค
%s๋ ๊ณต๋ฐฑ์ ๋ง๋ ๋๊น์ง ๋ฌธ์์ด์ ์ฝ๋๋ค. ์ฆ, ํ ๋ฒ์ ํ ๋จ์ด๋ง ์ฝ๋๋ค
%c๋ ๊ณต๋ฐฑ์ ํฌํจํ ๋ชจ๋ ๋ฌธ์๋ฅผ ์ฝ๋๋ค. ๋ฐ๋ผ์ ์ ๋ ฅ์์ ๊ณต๋ฐฑ์ ํฌํจํ ๋ฌธ์๋ฅผ ์ฝ์ ์ ์๋ค
#include <stdio.h>
int main(void)
{
char c;
char s[80], t[80];
printf("์คํ์ด์ค๋ก ๋ถ๋ฆฌ๋ ๋ฌธ์์ด์ ์
๋ ฅํ์์ค:";
scanf("%s%c%s", s, &c, t);
printf("์
๋ ฅ๋ ์ฒซ๋ฒ์งธ ๋ฌธ์์ด=%s\n", s);
printf("์
๋ ฅ๋ ๋ฌธ์=%c\n", c);
printf("์
๋ ฅ๋ ๋๋ฒ์งธ ๋ฌธ์์ด=%s\n", t);
return 0;
}
๋ฌธ์ ์งํฉ์ผ๋ก ์ฝ๊ธฐ
#include <stdio.h>
int main(void)
{
char s[80]
printf("๋ฌธ์์ด์ ์
๋ ฅํ์์ค:";
scanf("%[abc]", s);
printf("์
๋ ฅ๋ ๋ฌธ์์ด=%s\n, s);
return 0;
}
scanf ๋ฐํ๊ฐ ์ด์ฉ
- ์๋ฌ์ฒ๋ฆฌ ํ ์ ์๋ค.
scanf() ์ฌ์ฉ์ ์ฃผ์์
(1)
- scanf ํจ์๋ ์ ๋ ฅ๊ฐ์ ์ ์ฅํ ๋ณ์์ ์ฃผ์๋ฅผ ์ ๋ฌ๋ฐ์์ผ ํ๋ค
- scanf์ ํ์ ์ง์ ์์ ํด๋นํ๋ ๋ณ์์ ์ฃผ์๊ฐ ์ผ์นํด์ผ ์ฌ๋ฐ๋ฅธ ์ ๋ ฅ ์ฒ๋ฆฌ๊ฐ ์ด๋ฃจ์ด์ง
์ ์ํ ๋ณ์์ ๋ํ scanf ์ฌ์ฉ
์ ๋ ฅ๊ฐ์ ์ ์ฅํ ๋ณ์์ ์ฃผ์๋ฅผ ์ ๋ฌ
- int i;
- scanf("%d", i); //์ค๋ฅ!!!
- scanf("%d", &i); //์ฌ๋ฐ๋ฆ
- "%d" ํ์ ์ง์ ์๋ ์ ์ํ ๋ณ์๋ฅผ ๊ธฐ๋ํ๋ค
- ๋ฐ๋ผ์, ์ ์ํ ๋ณ์ i์ ์ฃผ์์ธ &i๋ฅผ ์ ๋ฌํด์ผ ํ๋ค.
- scanf("%d", i); ๋ i์ ์ฃผ์๋ฅผ ์ ๋ฌํ์ง ์๊ณ , ๋ณ์ ์์ฒด๋ฅผ ์ ๋ฌํ๊ณ ์์ผ๋ฏ๋ก ์ค๋ฅ
- scanf๋ ์ฃผ์๋ฅผ ํตํด ๋ณ์๋ฅผ ์์ ํ๊ธฐ ๋๋ฌธ์, &i๋ฅผ ์ ๋ฌํด์ผ ํจ
๋ฌธ์์ด ๋ฐฐ์ด์ ๋ํ scanf ์ฌ์ฉ
๋ฐฐ์ด์ ์ด๋ฆ์ ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ
-int str[80];
-scanf("%s", str) //์ฌ๋ฐ๋ฆ
-scanf("%s", &str) //์ค๋ฅ!!
- "%s" ํ์ ์ง์ ์๋ ๋ฌธ์์ด์ ๊ธฐ๋ํจ
- ๋ฐฐ์ด str์ ์ด๋ฆ์ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํจ๋ค. ๋ฐ๋ผ์ str๋ง ์ ๋ฌํ๋ฉด ๋จ
- &str์ ๋ฐฐ์ด ์ ์ฒด์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํจ๋ค. ์ด ์ฃผ์๋ ๋ฐฐ์ด์ ์ฃผ์๋ก, ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ๊ฐ ์๋๋ค.
- scanf๋ ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๋ฅผ ๊ธฐ๋ํ๊ธฐ ๋๋ฌธ์ &str์ด ์๋ str์ ์ ๋ฌํด์ผ ํ๋ค.
(2)
- scanf๋ฅผ ์ฌ์ฉํ ๋ ์ ๋ ฅ์ ๋ฐ์ ๋ณ์๋ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ถฉ๋ถํ ํ๋ณดํด์ผ ํ๋ค.
- ์ ๋ ฅ์ด ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ด๊ณผํ๋ฉด ๋ฒํผ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ์ ์์ผ๋ฉฐ, ์ด๋ ํ๋ก๊ทธ๋จ์ ์๊ธฐ์น ์์ ๋์์ด๋ ํฌ๋์๋ฅผ ์ ๋ฐํ ์ ์๋ค
๋ฒํผ ์ค๋ฒํ๋ก์ฐ
- int str[80];
- scanf("%s", str); // ์ ๋ จ๋ ๋ฌธ์์ ๊ฐ์๊ฐ 79๋ฅผ ์ด๊ณผํ๋ฉด ์น๋ช ์ ์ธ ์ค๋ฅ ๋ฐ์ !!
- scanf("%d\n", &i); // ์๋ชป๋จ!!
- scanf("%79s", str); // ์ต๋ 79 ๋ฌธ์๊น์ง ์ ๋ ฅ๋ฐ๊ณ , ๋ง์ง๋ง์ NULL ๋ฌธ์ ์ถ๊ฐ
์ ์ฝ๋์์ ๋ฐฐ์ด str์ 80์์ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ์๋ค. ํ์ง๋ง scanf("%s", str)์ ์ ๋ ฅ๋ ๋ฌธ์์ด์ ๊ธธ์ด๋ฅผ ์ ํํ์ง ์๊ธฐ ๋๋ฌธ์, ์ฌ์ฉ์๊ฐ 80์๋ฅผ ์ด๊ณผํ๋ ์ ๋ ฅ์ ํ๋ฉด ๋ฐฐ์ด์ ๊ฒฝ๊ณ๋ฅผ ๋์ด์ค ์ ์๋ค. ์ด๋ ๋ฒํผ ์ค๋ฒํ๋ก์ฐ๋ฅผ ๋ฐ์์ํค๊ณ , ํ๋ก๊ทธ๋จ์ ์์ ์ฑ์ ์ ํดํ ์ ์๋ค.
scanf์์ %d์ ๊ฐ์ด ํ์ ์ง์ ์๋ฅผ ์ฌ์ฉํ ๋๋ ๊ฐํ ๋ฌธ์๋ฅผ ํฌํจํ์ง ์๋๋ค. ๊ฐํ ๋ฌธ์๋ ์ ๋ ฅ ํ ์๋์ผ๋ก ์ฒ๋ฆฌ๋๊ธฐ ๋๋ฌธ์ด๋ค. "%d\n"๋ ์ ์ํ ์ ๋ ฅ ํ ๊ฐํ ๋ฌธ์๋ฅผ ๊ธฐ๋ํ์ง๋ง, scanf๋ ๊ฐํ ๋ฌธ์๋ฅผ ์๋์ผ๋ก ์ฒ๋ฆฌํ๋ค. ๋ฐ๋ผ์, ์ ๋ ฅ๊ฐ์ด ๋ค์ด์จ ํ ๊ฐํ ๋ฌธ์๊ฐ ์ฒ๋ฆฌ๋์ด์, \n์ scanf๊ฐ ์๋์ผ๋ก ์ฒ๋ฆฌํ๊ณ ์๋ฌด๋ฐ ํจ๊ณผ๋ฅผ ์ฃผ์ง ์๋๋ค.
'C Programming Language > C' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
C์ธ์ด ๋์ ํ ๋น๊ณผ ์ฐ๊ฒฐ ๋ฆฌ์คํธ (0) | 2024.08.13 |
---|---|
C์ธ์ด์ ์ ์ถ๋ ฅ๊ณผ ํ์ผ ์คํธ๋ฆผ(stream)์ ๋ํด ์์๋ณด๊ธฐ (2) (2) | 2024.08.12 |
C์ธ์ด ํฌ์ธํฐ์ ํ์ฉ : const, volatile, void ํฌ์ธํฐ (0) | 2024.08.12 |
C์ธ์ด ํฌ์ธํฐ์ ํ์ฉ : ์ด์ค ํฌ์ธํฐ, ํฌ์ธํฐ ๋ฐฐ์ด, ํจ์ ํฌ์ธํฐ (0) | 2024.08.02 |
C์ธ์ด ๊ตฌ์กฐ์ฒด union, enum, typedef ๋? (0) | 2024.08.02 |