์คํธ๋ฆผ
- ์คํธ๋ฆผ(stream)์ด๋, ํ๋ก๊ทธ๋จ๊ณผ ์ ์ถ๋ ฅ์ฅ์น ์ฌ์ด์์ ์ ์ถ๋ ฅ์๋ฃ๋ค์ ์ฐ๊ฒฐ์์ผ ์ฃผ๋ ์ญํ
- ๋ชจ๋ํฐ์ ํค๋ณด๋ ๊ฐ์ ์ธ์ฅ๊ธฐ๊ธฐ๋ ํ๋ก๊ทธ๋จ๊ณผ ์ฐ๊ฒฐ๋์ด ์์ง ์์ต๋๋ค.
- ๋ฐ๋ผ์ ์ด ๊ธฐ๊ธฐ๋ค์ ํ๋ก๊ทธ๋จ๊ณผ ์ฐ๊ฒฐ์์ผ ์ฃผ๋ ๋ค๋ฆฌ๊ฐ ํ์ํ๊ณ ์ด ๋ค๋ฆฌ ์ญํ ์ ํ๋ ๋งค๊ฐ์ฒด๊ฐ ๋ฐ๋ก '์คํธ๋ฆผ'์ด๋ค.
์ด๋ฆ | ์คํธ๋ฆผ์ ์ข ๋ฅ | ์ ์ถ๋ ฅ์ฅ์น |
stdin | ํ์ค ์ ๋ ฅ ์คํธ๋ฆผ | ํค๋ณด๋ ๋์์ผ๋ก ์ ๋ ฅ |
stdout | ํ์ค ์ถ๋ ฅ ์คํธ๋ฆผ | ๋ชจ๋ํฐ ๋์์ผ๋ก ์ถ๋ ฅ |
stderr | ํ์ค ์๋ฌ ์คํธ๋ฆผ | ๋ชจ๋ํฐ ๋์์ผ๋ก ์ถ๋ ฅ |
๋ฒํผ
- ์คํธ๋ฆผ์ ๋ด๋ถ์ ๋ฌธ์ ๋ฐฐ์ด ํํ์ ๋ฒํผ(buffer)๋ผ๋ ์์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง๊ณ ์๋ค.
- ๋ฒํผ๋ฅผ ์ด์ฉํ๋ฉด ์ ๋ ฅ๊ณผ ์ถ๋ ฅ์ ์ข ๋ ํจ์จ์ ์ผ๋ก ์ฒ๋ฆฌํ ์ ์๊ฒ ๋๋ค.
fflush() ํจ์
- ๊ฐ๋ ์ถ๋ ฅ๋ฒํผ๋ฅผ ๋น์์ผํ ๋๊ฐ ์๋ค. ๋ฒํผ์ ์ฐ๊บผ๊ธฐ๋ค์ด ๋จ์ ์๊ธฐ ๋๋ฌธ์ ์ ์๋์์ ํ์ง ์์ ์ ์๊ธฐ ๋๋ฌธ์ด๋ค.
- ๊ทธ๋ ์ฐ๋ ๊ฒ fflush() ํจ์์ด๋ค.
- fflushํจ์๋ ์ธ์๋ก ์ ๋ฌ๋ ์คํธ๋ฆผ์ ์ฐ๊ฒฐ๋ ๋ฒํผ๋ฅผ ๋น์์ค๋ค.
- ์ถ๋ ฅ๋ฒํผ๋ฅผ ๋น์ด๋ค๋ ๊ฒ์ ์ถ๋ ฅ๋ฒํผ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ง์ฐ๋ ๊ฒ์ด ์๋๋ผ, ์ถ๋ ฅ๋ฒํผ์ ์ ์ฅ๋ ๋ฐ์ดํฐ๋ฅผ ์ต์ข ์ ์กํจ์ ๋ปํ๋ค.
int fflush(FILE * stream);
โถ ํจ์ ํธ์ถ ์ฑ๊ณต ์ 0, ์คํจ ์ EOF ๋ฐํ
โ EOF๋ End Of File์ ๋ป์ผ๋ก, ์ค๋ฅ๊ฐ ๋ฐ์ํ๋์ง ๋๋ ํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ์ฝ์๋์ง ํ์ธํ ๋ ์ฌ์ฉํ๋ค.
์ค์ ๋ก ์ด ๊ฐ์ -1์ ๋ํ๋ธ๋ค.
์ ๋ ฅ ๋ฒํผ์ ๋์
- ์ ๋ ฅ ๋ฒํผ ๋ฌธ์ ๋ ๋ฌธ์ ํ์์ ๋ฐ์ ๋ ์ผ์ด๋๋ค.
- ์ ๋ ฅ ๋ฒํผ์ ๋จ์์๋ ๋ฌธ์ ๋๋ฌธ์, ์ํ๋ ๋์์ด ์ผ์ด๋์ง ์์ ์ ์๋๋ฐ ๋๊ฐ ์ํฐํค์ ์์ฌ๋ฌผ์ธ \n ๋๋ฌธ์ด๋ค.
- scanf ํจ์์ฒ๋ผ ํ์์ ๋ง๊ฒ ์ ๋ ฅ์ ๋ฐ์ ๋ ์ฌ์ฉ์์ ์ ๋ ฅ ๋ด์ฉ์ด ํ์ ๋ฌธ์์ด๋ณด๋ค ๋ ๋ง์ ๋ด์ฉ์ ํฌํจํ๊ณ ์์ผ๋ฉด ๋ฒํผ์ ์ฒ๋ฆฌ๋์ง ์์ ๋ฐ์ดํฐ๊ฐ ๋จ๊ฒ ๋๋ค.
โถ scanf ํจ์๋ก๋ ํ๋ฒ์ ์ ๋ ฅ๋ฐ๊ณ , fgets ํจ์๋ก๋ ์ด๋ฆ์ ์ ๋ ฅ๋ฐ๋ ํ๋ก๊ทธ๋จ
#include <stdio.h>
int main(void)
{
int num;
char name[10];
printf("ํ๋ฒ์ ์
๋ ฅํ์ธ์ : ");
scanf("%d", &num);
printf("์ด๋ฆ์ ์
๋ ฅํ์ธ์ : ");
fgets(name, sizeif(name), stdin);
printf("ํ๋ฒ : %d\n", num);
ptintf("์ด๋ฆ : %s\n", name);
return 0;
}
์คํ๊ฒฐ๊ณผ
ํ๋ฒ์ ์
๋ ฅํ์ธ์ : 1234(์
๋ ฅ)
์ด๋ฆ์ ์
๋ ฅํ์ธ์ : ํ๋ฒ : 1234
์ด๋ฆ :
- ํ๋ฒ์ ์ ๋ ฅํ ๋ค ์ํฐ ํค๋ฅผ ๋๋ฅด๋ฉด ์ด๋ฆ ์ ๋ ฅ ๋ถ๋ถ์ ๊ทธ๋๋ก ๋์ด๊ฐ๋ฒ๋ฆฐ๋ค.
- scanf ํจ์๋ก ๊ฐ์ ์ ๋ ฅํ๊ณ ์ํฐ๋ฅผ ์ ๋ ฅํ๋ฉด ๋ฒํผ์ \n ๊ฐ์ด ๋จ๊ฒ ๋๋๋ฐ, ๋จ๊ฒจ์ง \n๋ฅผ ๋ค์์ ํธ์ถ๋๋ fgets ํจ์๊ฐ ๋ฐ์ดํฐ๋ก ๋ฐ์๋ค์ด๊ธฐ ๋๋ฌธ์ด๋ค.
while(getchar() != '\n');
โถ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๋ฉด ์ ๋ ฅ ๋ฒํผ๋ฅผ ๋น์ฐ๋ ํจ์๋ฅผ ๋ง๋ค์ด์ค์ผ ํ๋ค.
์ ๋ ฅ ๋ฒํผ์์ ๋ฌธ์๋ฅผ ๊ณ์ ๊บผ๋ด๊ณ \n๋ฅผ ๊บผ๋ด๋ฉด ๋ฐ๋ณต์ ์ค๋จํ๋ ํจ์์ด๋ค.
while(getchar() != '\n');
#include <stdio.h>
void clearInputBuffer(void)
{
while (getchar() != '\n');
}
int main(void)
{
int num;
char name[10];
printf("ํ๋ฒ์ ์
๋ ฅํ์ธ์ : ");
scanf("%d", &num);
clearInputBuffer();
printf("์ด๋ฆ์ ์
๋ ฅํ์ธ์ : ");
scanf("%s", name);
printf("ํ๋ฒ : %d\n", num);
printf("์ด๋ฆ : %s\n", name);
return 0;
}
์คํ๊ฒฐ๊ณผ
ํ๋ฒ์ ์
๋ ฅํ์ธ์ : 1234(์
๋ ฅ)
์ด๋ฆ์ ์
๋ ฅํ์ธ์ : ๊น์ธ์ข
(์
๋ ฅ)
ํ๋ฒ : 1234
์ด๋ฆ : ๊น์ธ์ข
ํ์ผ์ ๊ฐ๋ฐฉ๋ชจ๋
- ์คํธ๋ฆผ์ ์ข ๋ฅ๋ ๋ค์ํ๋ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ค์ ๋ ๊ฐ์ง ๊ธฐ์ค์ ํตํด์ ์คํธ๋ฆผ์ ๊ตฌ๋ถํ๊ฒ ๋๋ค.
- ์ฝ๊ธฐ ์ํ ์คํธ๋ฆผ? ์ฐ๊ธฐ ์ํ ์คํธ๋ฆผ?
- ํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์ฐ๋๋ฐ ์ฌ์ฉํ๋ ์คํธ๋ฆผ๊ณผ ๋ฐ์ดํฐ๋ฅผ ์ฝ๋๋ฐ ์ฌ์ฉํ๋ ์คํธ๋ฆผ์ผ๋ก ๊ตฌ๋ถ
- ํ
์คํธ ๋ฐ์ดํฐ๋ฅผ ์ํ ์คํธ๋ฆผ? ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์ํ ์คํธ๋ฆผ?
- ์ถ๋ ฅ์ ๋์์ด ๋๋ ๋ฐ์ดํฐ์ ์ข ๋ฅ์ ๋ฐ๋ผ์ ํ ์คํธ ๋ชจ๋์ ๋ฐ์ด๋๋ฆฌ ๋ชจ๋ ๋ ๊ฐ์ง๋ก ๋๋๋ค.
โถ ์คํธ๋ฆผ์ ๋ฐ์ดํฐ ์ด๋๋ฐฉํฅ์ ๊ธฐ์ค์ผ๋ก ๋ค์๊ณผ ๊ฐ์ด 4๊ฐ์ง๋ก ๊ตฌ๋ถํ ์ ์๋ค.
๋ฐ์ดํฐ READ ์คํธ๋ฆผ | ๋ฐ์ดํฐ WRITE ์คํธ๋ฆผ | ๋ฐ์ดํฐ APPEND ์คํธ๋ฆผ | ๋ฐ์ดํฐ READ/WRITE ์คํธ๋ฆผ |
์ฝ๊ธฐ๋ง ๊ฐ๋ฅ | ์ฐ๊ธฐ๋ง ๊ฐ๋ฅ | ๋ง๋ถ์ฌ ์ฐ๊ธฐ๋ง ๊ฐ๋ฅ | ์ฝ๊ธฐ, ์ฐ๊ธฐ ๋ชจ๋ ๊ฐ๋ฅ |
โถ C์ธ์ด์์๋ ์ด๋ฅผ ๋ฐํ์ผ๋ก 6๊ฐ์ง๋ก ์คํธ๋ฆผ์ ์ธ๋ถํํ๋ค.
๋ชจ๋ | ์คํธ๋ฆผ์ ์ฑ๊ฒฉ | ํ์ผ์ด ์์ผ๋ฉด |
r | ์ฝ๊ธฐ ๊ฐ๋ฅ | ์๋ฌ |
w | ์ฐ๊ธฐ ๊ฐ๋ฅ | ์์ฑ |
a | ํ์ผ์ ๋์ ๋ง๋ถ์ฌ ์ฐ๊ธฐ ๊ฐ๋ฅ | ์์ฑ |
r+ | ์ฝ๊ธฐ/์ฐ๊ธฐ ๊ฐ๋ฅ | ์๋ฌ |
w+ | ์ฝ๊ธฐ/์ฐ๊ธฐ ๊ฐ๋ฅ | ์์ฑ |
a+ | ์ฝ๊ธฐ/๋ง๋ถ์ฌ ์ฐ๊ธฐ ๊ฐ๋ฅ | ์์ฑ |
โ ์ฌ๋งํ๋ฉด r,w,a๋ฅผ ์ฌ์ฉํ์ฌ ์ ๋ ฅ์คํธ๋ฆผ๊ณผ ์ถ๋ ฅ์คํธ๋ฆผ์ ๋ฐ๋ก ์์ฑํด ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
+๊ฐ ๋ค์ด๊ฐ ๊ฐ๋ฐฉ ๋ชจ๋๋ ์ฝ๊ธฐ์์ ์ฐ๊ธฐ๋ก, ์ฐ๊ธฐ์์ ์ฝ๊ธฐ๋ก ์์ ์ ๋ณ๊ฒฝํ ๋๋ง๋ค ๋ฉ๋ชจ๋ฆฌ ๋ฒํผ๋ฅผ ๋น์์ค์ผ ํ๋ ๋ฑ์ ๋ถํธํจ๊ณผ ๋๋ถ์ด ์๋ชป๋ ์ฌ์ฉ์ ์ํ์ฑ๋ ๋ค๋ฐ๋ฅด๊ธฐ ๋๋ฌธ์ด๋ค.
โถ ์คํธ๋ฆผ์ ์ฑ๊ฒฉ์ ๋ฐ์ดํฐ์ ์ข ๋ฅ์ ๋ฐ๋ผ์ ๋ค์๊ณผ ๊ฐ์ด ๋ ๊ฐ์ง๋ก ๋๋๋ค.
ํ ์คํธ ๋ชจ๋ ์คํธ๋ฆผ | ๋ฐ์ด๋๋ฆฌ ๋ชจ๋ ์คํธ๋ฆผ |
๋ฌธ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์คํธ๋ฆผ | ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ์คํธ๋ฆผ |
- ํ ์คํธ ํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์์คํค์ฝ๋ ๋๋ ์ ๋์ฝ๋ ๊ฐ์ ๋ฐ๋ผ ์ ์ฅํ ๊ฒ์ด๋ฉฐ, ๊ทธ ์ธ์ ๋ฐฉ์์ผ๋ก ์ ์ฅ๋ ํ์ผ์ ๋ฐ์ด๋๋ฆฌ ํ์ผ์ด๋ค.
- ํ ์คํธ ํ์ผ์ ๋ฉ๋ชจ์ฅ๊ณผ ๊ฐ์ ํ๋ก๊ทธ๋จ์์ ํ์ธํ ์ ์์ผ๋ฉฐ, ๋ฐ์ด๋๋ฆฌ ํ์ผ์ ํด๋น ๊ธฐ๋ก ๋ฐฉ์์ ์ ์ฉํ ๋ณ๋์ ํ๋ก๊ทธ๋จ์ ์ฌ์ฉํด์ผ ํ๋ค.
- ์๋ก, ํ ์คํธ ํ์ผ์ ๋ฉ๋ชจ์ฅ ํ๋ก๊ทธ๋จ์์ ๋ด์ฉ์ ํ์ธํ ์ ์์ผ๋ ๊ทธ๋ฆผ ํ์ผ์ ๋ณด๊ธฐ ์ํด์๋ ๊ทธ๋ฆผํ ํ๋ก๊ทธ๋จ์ ์ฌ์ฉํด์ผ ํ๋ค.
ํ ์คํธ ํ์ผ | ๋ฐ์ด๋๋ฆฌ ํ์ผ |
|
๋ฐ์ด๋๋ฆฌ ํ์ผ์ ์ ์ฉ ํ๋ก๊ทธ๋จ์ด ์๋ ๋ฉ๋ชจ์ฅ์์ ์ฌ์ฉํ๋ฉด ์์ ๊ฐ์ด ์ ์ ์๋ ๋ฌธ์๋ก ํ์๋๋ค. |
.txt | .jpg, .png, .mp3, .exe ๋ฑ |
- r, w, a, r+, w+, a+ ์ต์ ์ด์ธ์๋ ๊ฐ๋ฐฉ ๋ชจ๋๋ฅผ ์กฐํฉํด ํ ์คํธ ๋ชจ๋(rt, wt, at)๋ก ์ด์ง, ๋ฐ์ด๋๋ฆฌ ๋ชจ๋(rb, wb, ab)๋ก ์ด์ง ์ด๋ ๊ฒ ์ต์ ์ ์ถ๊ฐํ ์ ์๋ค.
- ๊ธฐ๋ณธ์ ์ผ๋ก ์๋ฌด๊ฒ๋ ์ ๋ ฅํ์ง ์์ผ๋ฉด ํ ์คํธ ๋ชจ๋๋ก ํ์ผ์ ์ ๊ทผํ๋ค.
ํ์ผ ๊ฐ๋ฐฉ ํจ์
ํ์ผ ์ด๊ธฐ (fopen)
- fopen ํจ์๋ ์คํธ๋ฆผ์ ํ์ฑํ ๋ ํธ์ถํ๋ ํจ์์ด๋ค.
- ์คํธ๋ฆผ ํ์ผ์ ๋ง๋๋ ๊ฒ์ ํ์ผ ๊ฐ๋ฐฉ์ด๋ผ๊ณ ํ๋ฉฐ f๋ file์ ๋งํ๋ค. ์ฆ file open์ด๋ผ๋ ํจ์์ด๋ค.
FILE * fopen(const char * filename, const char * mode);
โถ ๊ฐ๋ฐฉ์ ์ฑ๊ณตํ๋ฉด FILE ๊ตฌ์กฐ์ฒด ๋ณ์์ ์ฃผ์๊ฐ(ํฌ์ธํฐ), ์คํจํ๋ฉด ๋(NULL) ํฌ์ธํฐ ๋ฐํ
๊ฐ๋ฐฉํ ํ์ผ์ ํ์ฌ์ ์์
ํ๋ก์ ํธ ๋๋ ํ ๋ฆฌ์์ ์์ฑ๋๋ค.
FILE * fp = fopen("sejong.txt", "w");
๊ฒฝ๋ก๋ฅผ ํฌํจํด์ ๋ค์๊ณผ ๊ฐ์ด ํ์ผ์ ์ด๋ฆ์ ์ง์ ํด๋ ๋๋ค.
FILE * fp = fopen("C:\\project\\sejong.txt","w");
๋ฌธ์์ด ์์ ๋ฐฑ์ฌ๋์๋ ์ ์ด ๋ฌธ์์ ์์์ ๋ปํ๋ค.
๋๋ ํ ๋ฆฌ๋ฅผ ํ์ํ๋ ๋ฐฑ์ฌ๋์๋ ๋ฌธ์์ด ์์ ์์ผ๋ฏ๋ก ๋ ๋ฒ ์ฌ์ฉํ๋ค.
- fopen ํจ์๊ฐ ๊ฐ๋ฐฉ์ ์ฑ๊ณตํ๋ฉด ์คํธ๋ฆผํ์ผ์ ๋ง๋ค๊ณ ํ์ผํฌ์ธํฐ๋ฅผ ๋ฐํํ๋ค.
- ์คํธ๋ฆผํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ๋ ๋ฒํผ์ ๋ฒํผ๋ฅผ ๊ด๋ฆฌํ๋ ์ฌ๋ฌ ์ ๋ณด๋ฅผ ํ์ผ ๊ตฌ์กฐ์ฒด๋ณ์์ ์ ์ฅํ๊ณ ์๋ค.
- ์ด ๊ตฌ์กฐ์ฒด๋ณ์์ ํฌ์ธํฐ๋ฅผ ํ์ผํฌ์ธํฐ๋ผ๊ณ ํ๋ค.
- ํ์ผํฌ์ธํฐ๋ฅผ ํฌ์ธํฐ๋ณ์์ ์ ์ฅํ๋ฉด ์ ์ถ๋ ฅ ์ค๋น์์ ์ด ๋๋ ๊ฒ์ด๋ค.
FILE * fp;
fp = fopen("sejong.txt" , "w");
ํ์ผํฌ์ธํฐ๋ฅผ fp๋ผ๋ ์ด๋ฆ์ผ๋ก ์์ฑํ๊ณ ,ํ์ผ์ ์ด์ด์ fp๊ฐ ๊ทธ ์์น๋ฅผ ๊ธฐ์ตํ๊ฒ ํด์ฃผ๋ ๊ฒ์ด๋ค.
if(fp == NULL)
{
printf("ํ์ผ์ด ์์ต๋๋ค.");
return 1;
}
ํ์ผ ๊ฐ๋ฐฉ์ ์คํจํ๋ฉด fopenํจ์๋ ๋ ํฌ์ธํฐ๋ฅผ ๋ฐํํ๋ค.
๋ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด ์คํํ ๋ ์๋ฌ๊ฐ ๋ฐ์ํ๋ฏ๋ก ๋ฐ๋์ ๊ฐ๋ฐฉ์ ์ฑ๊ณต ํ๋์ง๋ฅผ ๊ฒ์ฌํด์ผ ํ๋ค.
ํ์ผ ๋ซ๊ธฐ(fclose)
int fclose(FILE *);
โถ ์ฑ๊ณตํ๋ฉด 0, ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ EOF
- ์ฌ์ฉ์ด ๋๋ ํ์ผ์ ๋ซ์์ ์คํธ๋ฆผํ์ผ์ ์ ๊ฑฐํด ์ค๋ค.
- ํ์ผ ์ด๊ธฐ๋ฅผ ํตํด ๋ง๋ค์ด์ง ์คํธ๋ฆผํ์ผ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฐ๋ฐ, ํ์ผ์ ๋ซ์์ฃผ์ง ์์ผ๋ฉด ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋จ์์๊ฒ ๋์ด, ๊ทธ๋งํผ์ ์์์์ค์ ์ด๋ํ๋ค.
- ๋ํ ์คํธ๋ฆผํ์ผ์ ๋จ์์๋ ๋ฐ์ดํฐ๊ฐ ์ฅ์น์ ๊ธฐ๋ก๋๊ธฐ ์ ์ ์ง์์ง ์ ์์ผ๋ฏ๋ก ์ฌ์ฉ์ด ๋๋ ํ์ผ์ ๋ซ์์ ์คํธ๋ฆผํ์ผ์ ๋ฐ์ดํฐ๋ฅผ ์ฅ์น์ ๊ธฐ๋กํ๋ ๊ฒ์ด ์ข๋ค.
- โ ๊ฐ๋ฐฉ๋ ํ์ผ์ ํ๋ก๊ทธ๋จ์ด ์ข ๋ฃ๋๋ฉด ์๋์ผ๋ก ๋ซํ๋ฉด์ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๊ฑฐ๋์ง๋ง ์์ ์ฑ์ ์ํด ๋ช ์์ ์ผ๋ก ๋ซ๋ ๊ฒ์ด ์ข๋ค.
ํ์ผ์ ์ด๊ณ ๋ซ๋ ํ๋ก๊ทธ๋จ
- ๋ฐ์ดํฐ๋ฅผ ์ ์ถ๋ ฅํ๊ธฐ ์ ์๋ ํ์ผ์ ์ฌ๋ ๊ณผ์ ์ด ํ์ํ๊ณ ์ฌ์ฉ์ด ๋๋๋ฉด ํ์ผ์ ๋ซ๋ ๊ณผ์ ์ด ํ์ํ๋ค.
- fopen ํจ์๋ ํ์ผ์ ์ด๊ณ , fclose ํจ์๋ ํ์ผ์ ๋ซ์ต๋๋ค.
// ์ค์ ๋ก ํ์ผ์ ๋ฐ์ดํฐ๊ฐ ์ ์ฅ๋๋์ง ํ์ธํด๋ณด๋ ์์
#include <stdio.h>
int main(void)
{
FILE * fp = fopen("sejong.txt", "w"); // ์ถ๋ ฅ ์คํธ๋ฆผ ํ์ฑ
if (fp == NULL) // fp๊ฐ ๋ ํฌ์ธํฐ๋ฉด
{
printf("ํ์ผ ์ด๊ธฐ ์คํจ\n");
return -1; // ๋น์ ์์ ์ข
๋ฃ๋ฅผ ์๋ฏธํ๊ธฐ ์ํด -1 ๋ฐํ
}
fputc('s', fp); // fp๊ฐ ์ง์นญํ๋ ํ์ผ sejong.txt์ s ์ ์ฅ
fputc('j', fp); // fp๊ฐ ์ง์นญํ๋ ํ์ผ sejong.txt์ j ์ ์ฅ
fputc('u', fp); // fp๊ฐ ์ง์นญํ๋ ํ์ผ sejong.txt์ u ์ ์ฅ
fclose(fp);
return 0;
}
โ ์ถ๋ ฅ์ ์ฉ ๋ชจ๋๋ ๊ฐ์ ์ด๋ฆ์ ํ์ผ์ด ์์ ๋ ๊ทธ ๋ด์ฉ์ ๋ชจ๋ ์ญ์ ํ๊ณ ๊ฐ๋ฐฉํ๋ฏ๋ก ์ฃผ์ํด์ผ ํ๋ค.
์ผ๋จ ์ฝ๊ธฐ ์ ์ฉ ๋ชจ๋๋ก ๊ฐ๋ฐฉํ ํ์ ํ์ผ ์กด์ฌ์ฌ๋ถ๋ฅผ ํ์ธํ๊ณ ๋ค์ ์ถ๋ ฅ์ ์ฉ์ผ๋ก ๊ฐ๋ฐฉํ ์ ์๋ค.
ifp = fopen("sejong.txt", "r");
if (ifp == NULL)
{
fp = fopen("sejong.txt", "w");
}
โ
Visual Studio 2013 ๋ฒ์ ์ด์๋ถํฐ scanf() ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด ์๋ฌ๊ฐ ๋๋ฉด์ ์ปดํ์ผ์ด ์๋ฉ๋๋ค.
์๋ฌ ๋ฉ์์ง๋ฅผ ๋ณด๋ฉด C4996 'scanf': This function or variable may be unsafe. Consider using scanf_s instead. To disable deprecation,
use _CRT_SECURE_NO_WARNINGS. ๋ผ๊ณ ๋์ต๋๋ค.
๋ฌธ์ ์ ์ถ๋ ฅ ํจ์
๋ฌธ์ ์ถ๋ ฅ(fputc)
- fputc ํจ์๋ File Put Character๋ฅผ ์กฐํฉํ ๊ธ์๋ก, ํ์ผ์์๋ถํฐ ๊ธ์๋ฅผ ํ๋์ฉ ์ฐ๋ ํจ์์ด๋ค.
int fputc(int, FILE *)
โถ ์ถ๋ ฅํ ๋ฌธ์, ์ค๋ฅ๊ฐ ๋ฐ์ํ ๊ฒฝ์ฐ๋ EOF
- fputcํจ์๊ฐ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ ๋๋ fgetcํจ์์ ๋ง์ฐฌ๊ฐ์ง๋ก ๊ฐ๋ฐฉ๋ ์คํธ๋ฆผ ํ์ผ์ ๋ฒํผ๋ฅผ ์ฌ์ฉํ๋ค.
- ํ ๋ฌธ์๋ฅผ ์ถ๋ ฅํ ๋๋ง๋ค ์ผ๋ฐ ๋ฒํผ์ ์ถ๋ ฅ์ด ๋ ํ์ ๊ฐํ๋ฌธ์๊ฐ ์ถ๋ ฅ๋๋ฉด ํ๋๋์คํฌ์ ํ์ผ๋ก ์ถ๋ ฅ๋๋ค.
#include <stdio.h>
int main(void)
{
FILE * fp = fopen("sejong.txt", "w");
char ch;
if (fp == NULL)
{
printf("ํ์ผ ์ด๊ธฐ ์คํจ\n");
return 1;
}
printf("๋ฐ์ดํฐ๋ฅผ ์
๋ ฅํ์ธ์.\n");
while(1)
{
ch = getchar(); // ํค๋ณด๋ ์
๋ ฅ
if (ch == EOF)
break;
fputc(ch, fp); // ํ์ผ ์ถ๋ ฅ
}
fclose(fp);
return 0;
}
์คํ๊ฒฐ๊ณผ
๋ฐ์ดํฐ๋ฅผ ์
๋ ฅํ์ธ์.
sejong(์
๋ ฅ)
^Z(์
๋ ฅ์ข
๋ฃ)
- ํค๋ณด๋๋ก๋ถํฐ ์ ๋ ฅ๋๋ ๋ฐ์ดํฐ๋ฅผ ํ์ผ๋ก ์ถ๋ ฅํ๋ ์์ ์ด๋ค.
- EOF ๊ฐ์ ๋ณดํต ํ ์คํธํ์ผ์ ๋์์ ์ป์ ์ ์๋ ๊ฐ์ด์ง๋ง ํค๋ณด๋์ 'ctrl+z'๋ฅผ ๋๋ฅด๊ณ ์ํฐํค๋ฅผ ๋๋ฅด๋ฉด getchar ํจ์๊ฐ -1์ ๋ฐํํ๋ค.
๋ฌธ์ ์ ๋ ฅ(fgetc)
- fgetc ํจ์๋ File Get Character๋ฅผ ์กฐํฉํ ๊ธ์๋ก, ํ์ผ์์๋ถํฐ ๊ธ์๋ฅผ ํ๋ํ๋ ์ฝ๋๋ค๋ ๋ป์ ํจ์์ด๋ค.
int fgetc(FILE *)
โถ ์ ๋ ฅํ ๋ฌธ์, ์ค๋ฅ๋ ํ์ผ์ ๋ฐ์ดํฐ๊ฐ ์์ ๋ EOF
- fgetc ํจ์๋ ์คํธ๋ฆผํ์ผ์ ๋ฒํผ์์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์จ๋ค.
- ์ฒ์์๋ ๋ฒํผ๊ฐ ๋น์ด์์ผ๋ฏ๋ก ํ์ผ์์ ๋ฒํผ ํฌ๊ธฐ๋งํผ์ ๋ฐ์ดํฐ๋ฅผ ๊ฐ์ ธ์ ํ ๋ฒ์ ๋ฒํผ๋ก ์ฝ์ด ๋ค์ ๋๋ค.
- ํ์ผ์ด ํฌ๊ธฐ๊ฐ ๋ฒํผ๋ณด๋ค ์์ผ๋ฉด ๋ชจ๋ ๋ฐ์ดํฐ๊ฐ ํ ๋ฒ์ ๋ฒํผ์ ์ ์ฅ๋๋ค.
- ๊ทธ ์ดํ์ ํธ์ถ๋๋ ์ ๋ ฅํจ์๋ ๋ฒํผ์ ๋ฐ์ดํฐ๊ฐ ์์ ๋๊น์ง ๋ฒํผ๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ๋ค.
- ๋ฒํผ๋ก๋ถํฐ์ ์ ๋ ฅ ์์น๋ ํ์ผ๊ตฌ์กฐ์ฒด์ ๋ฉค๋ฒ์ธ ์์น์ง์์๋ก ํ์ธํ๋ค.
- ์คํธ๋ฆผํ์ผ์๋ ๋ฌธ์๋ฅผ ์ ๋ ฅํ ๋ฒํผ์ ์์น๋ฅผ ์๋ ค์ฃผ๋ ์ง์์๊ฐ ์๋ค.
- ์์น์ง์์๋ 0์ผ๋ก ์์ํ๋ฉฐ fgetc ํจ์๊ฐ ํ ๋ฌธ์์ฉ ์ฝ์ ๋ 1์ฉ ์ฆ๊ฐํ๋ค.
- ์์น์ง์์์ ๊ฐ์ด ํ์ผ์ ํฌ๊ธฐ์ ๊ฐ์์ง๋ฉด ๋ฐ์ดํฐ๋ฅผ ๋ชจ๋ ์ฝ์ ๊ฒ์ด ๋๋ฉฐ, ์ด๋ ํจ์๋ EOF๋ฅผ ๋ฐํํ๋ค.
#include <stdio.h>
int main(void)
{
FILE * fp = fopen("sejong.txt", "r");
char ch;
if (fp == NULL)
{
printf("ํ์ผ ์ด๊ธฐ ์คํจ\n");
return 1;
}
while (1) // ๋ฌดํ ๋ฐ๋ณต
{
ch = fgetc(fp); // ๊ฐ๋ฐฉํ ํ์ผ๋ก๋ถํฐ ํ ๋ฌธ์ ์
๋ ฅ
if ( ch == EOF) // ๋ฐํ๊ฐ์ด EOF๋ฉด
break; // ๋ฐ๋ณต ์ข
๋ฃ
putchar(ch); // ์ฝ์ด๋ค์ธ ๋ฌธ์๋ฅผ ํ๋ฉด์ ์ถ๋ ฅ
}
fclose(fp);
return 0;
}
์คํ๊ฒฐ๊ณผ
sejong
โถ ๊ฐ๋ฐฉํ ํ์ผ๋ก๋ถํฐ ํ ๋ฌธ์๋ฅผ ์ ๋ ฅ, ์ฝ์ด ๋ค์ธ ๋ฌธ์๋ฅผ ํ๋ฉด์ ์ถ๋ ฅ์ ๋ฌดํ ๋ฐ๋ณต.
์๋ณธ ํ์ผ์ ๋๊น์ง ๋๋ฌํ๊ฒ ๋๋ฉด ๋ฐํ๊ฐ์ด EOF๊ฐ ๋์ด break๋ฅผ ์ฌ์ฉํด while ๋ฌธ์ ๋น ์ ธ๋๊ฐ๋ค.
ํ์ผ ์ ์ถ๋ ฅ ํจ์
๋ฌธ์์ด ์ถ๋ ฅ (fputs)
- fputs ํจ์๋ ๋ฌธ์์ด์ ํ ๋ฒ์ ์ถ๋ ฅํ ๋ ์ฌ์ฉ
- ์ฒซ ๋ฒ์งธ ์ธ์์๋ ์ถ๋ ฅํ ๋ฌธ์์ด์ ์ฃผ์๊ฐ์ ์ฃผ๊ณ ๋ ๋ฒ์งธ ์ธ์๋ฅผ ํตํด์๋ ํ์ผํฌ์ธํฐ๋ฅผ ์ธ์๋ก ์ค๋ค.
int fputs(const char *, FILE *);
โถ ์ถ๋ ฅ์ ์ฑ๊ณตํ๋ฉด ์์๊ฐ ์๋ ๊ฐ, ์คํจํ๋ฉด EOF
#include <stdio.h>
int main(void)
{
char str[20] = "I have a dream.";
FILE * fp = fopen("fputs_test.txt","w");
fputs(str, fp);
fclose(fp);
return 0;
}
โ fputs ๋์ puts ํจ์๋ฅผ ์ฌ์ฉํ ์๋ ์์ง๋ง, puts ํจ์๋ ํญ์ ์ค์ ๋ฐ๊พธ๋ฏ๋ก ๋ฌธ์์ด์ ์ด์ด์ ์ถ๋ ฅํ ์ ์๋ค.
๋ฐ๋ผ์ ๋ฌธ์์ด์ ์ถ๋ ฅ์ ์์ ํ๊ณ ์ ํํ๊ฒ ์ํ๋๋ fputs ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
๋ฌธ์์ด ์ ๋ ฅ (fgets)
- fgets ํจ์๋ ๋ฌธ์์ด์ ํ๋ฒ์ ์ ๋ ฅํ ๋ ์ฌ์ฉ
char * fgets(char *, int, FILE *)
โถ ์ ๋ ฅํ char ๋ฐฐ์ด, ํ์ผ์ ๋์ด๋ฉด NULL
- fgets ํจ์๋ ์ธ์๊ฐ 3๊ฐ์ด๋ค.
- ํ์ผํฌ์ธํฐ์ ์ฐ๊ฒฐ๋ ํ์ผ๋ก๋ถํฐ ๋ ๋ฒ์งธ ์ ๋ฌ์ธ์๋ก ์ฃผ์ด์ง ๋ฐ์ดํธ ์์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด์์ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ฃผ์ด์ง ๋ฐฐ์ด์ ์ ์ฅํ๋ค.
fgets(str, sizeof(str), fp);
str(์ฒซ ๋ฒ์งธ ์ธ์): ํ์ผ์์ ๊ฐ์ง๊ณ ์จ ๋ฌธ์์ด์ ๋ฃ๋ ๋ณ์, ์ฝ์ด ๋ค์ธ ๋ฌธ์์ด์ ์ ์ฅํ char ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ
sizeof(str)(๋ ๋ฒ์งธ ์ธ์): ํ ๋ฒ์ ๊ฐ์ง๊ณ ์ฌ ๋ฌธ์์ด์ ๊ธธ์ด ์ ๋ณด ๋ณ์, ์ผ๋ฐ์ ์ผ๋ก str๋ก ์ ๋ฌ๋ ๋ฐฐ์ด์ ๊ธธ์ด(๋ง์ง๋ง NULL ๋ฌธ์ ํฌํจ)๊ฐ ์ฌ์ฉ
fp(์ธ ๋ฒ์งธ ์ธ์): ๋ฌธ์๋ฅผ ์ฝ์ ์คํธ๋ฆผ์ ์๋ณํ๋ ํ์ผํฌ์ธํฐ
5๋ฐ์ดํธ์ ํฌ๊ธฐ๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ ๋ฌธ์์ด์ ์
๋ ฅ ๋ฐ๋ ๊ฒฝ์ฐ
#include <stdio.h>
int main(void)
{
char str[5]; // ํ์ผ์ ์ฝ์ ๋ ์ฌ์ฉํ ์์ ๊ณต๊ฐ
FILE * fp = fopen("fgets_test.txt", "r");
fgets(str, sizeof(str), fp);
printf("%s\n", str);
fclose(fp);
return 0;
}
์คํ๊ฒฐ๊ณผ
Sejo
๋๋ฌธ์๊ฐ ์ ์ฅ๋ ๊ณต๊ฐ์ ์ ์ธํ๊ณ 4๋ฐ์ดํธ๋ง ์
๋ ฅ๋๋ค.
20๋ฐ์ดํธ์ ํฌ๊ธฐ๋ฅผ ๊ฐ๋ ๋ฐฐ์ด์ ๋ฌธ์์ด์ ์
๋ ฅ ๋ฐ๋ ๊ฒฝ์ฐ
#include <stdio.h>
int main(void)
{
char str[20]; // ํ์ผ์ ์ฝ์ ๋ ์ฌ์ฉํ ์์ ๊ณต๊ฐ
FILE * fp = fopen("fgets_test.txt","r");
fgets(str, sizeof(str), fp);
printf("%s\n", str);
fclose(fp);
return 0;
}
์คํ๊ฒฐ๊ณผ
Sejong University
์
๋ ฅ ๋ฐ์ ๋ฐ์ดํฐ์ ํฌ๊ธฐ๋ณด๋ค ํ์ผ์ ํฌ๊ธฐ๊ฐ ์์ผ๋ฉด ํ์ผ ๋๊น์ง ์ฝ์ด๋ค์ธ๋ค.
(๋จ, ์ค๊ฐ์ \n(๊ฐํ๋ฌธ์)๊ฐ ์์ด์ผ ํ๋ค.)
โ fgets ๋์ gets ํจ์๋ฅผ ์ฌ์ฉํ ์๋ ์์ง๋ง, gets ํจ์๋ ์ ๋ ฅํ ์ ์ฅ ๊ณต๊ฐ์ ํฌ๊ธฐ๋ฅผ ์ธ์๋ก ์ค ์ ์์ผ๋ฏ๋ก ๋ฌธ์์ด์ ์ ๋ ฅํ ๋ ํ ๋นํ์ง ์์ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์นจ๋ฒํ ๊ฐ๋ฅ์ฑ์ด ์๋ค.
๋ฐ๋ผ์ ๋ฌธ์์ด์ ์ ๋ ฅ์ ์์ ํ๊ณ ์ ํํ๊ฒ ์ํ๋๋ fgets ํจ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์ข๋ค.
๋ณํ ์ถ๋ ฅ (fprintf)
- fprintf ํจ์๋ printf ํจ์์ ์ฌ์ฉ๋ฒ์ด ๊ฐ๋ค.
- ๋จ, ์ถ๋ ฅ ๋์์ ํ์ผํฌ์ธํฐ๋ก ์ง์ ํด ์ค ์ ์๋ค.
- ์ฒซ ๋ฒ์งธ ์ ๋ฌ์ธ์๊ฐ ํ์ผ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ์ด๋ค.
- ๊ทธ๋์ printf์ ๋ฌ๋ฆฌ fprintf๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ ๋ฌ๋ ํ์ผ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ๊ฐ ์ง์นญํ๋ ํ์ผ๋ก ์ถ๋ ฅ์ด ์ด๋ฃจ์ด์ง๋ค.
int fprintf(FILE *, const char *, ...);
โถ ์ถ๋ ฅํ ๋ฌธ์์ ๋ฐ์ดํธ ์, ์คํจํ๋ฉด ์์
#include <stdio.h>
int main(void)
{
int number = 21012345;
char name[10] = "๊น์ธ์ข
";
FILE * fp = fopen("student.txt", "w");
if (fp == NULL)
printf("ํ์ผ ์ด๊ธฐ ์คํจ\n");
else
{
fprintf(fp, "%d %s", number, name);
fclose(fp);
}
return 0;
}
๋ณํ ์ ๋ ฅ (fscanf)
- fscanf ํจ์๋ scanf ํจ์์ ์ฌ์ฉ๋ฒ์ด ๊ฐ๋ค.
- ๋จ, ์ ๋ ฅ ๋์์ ํ์ผํฌ์ธํฐ๋ก ์ง์ ํด ์ค ์ ์๋ค.
- ์ฒซ ๋ฒ์งธ ์ธ์๋ก ํ์ผ๊ตฌ์กฐ์ฒด์ ํฌ์ธํฐ๊ฐ ์ ๋ฌ๋๋ค.
- ๋ฐ๋ผ์ fscanf๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ ๋ฌ๋ ํฌ์ธํฐ๊ฐ ์ง์นญํ๋ ํ์ผ๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ฝ์ด ๋ค์ธ๋ค.
int fscanf(FILE *, const char *, ...);
โถ ์ ๋ ฅ์ ์ฑ๊ณตํ ๋ฐ์ดํฐ ์, ํ์ผ์ ๋ฐ์ดํฐ๊ฐ ์์ ๋ EOF
#include <stdio.h>
int main(void)
{
int number;
char name[10];
FILE * fp = fopen("student.txt", "r");
if (fp == NULL)
printf("ํ์ผ ์ด๊ธฐ ์คํจ");
else
{
fscanf(fp, "%d %d", &number, name);
printf("%d %s\n", number, name);
fclose(fp);
}
return 0;
}
์คํ ์, student.txt์ ์ ์ฅ๋๋ "21012345 ๊น์ธ์ข
"์ด ๋ณ์ number, name์ ์
๋ ฅ๋ ๊ฒ์ ํ์ธํ ์ ์๋ค.
์คํ๊ฒฐ๊ณผ
21012345 ๊น์ธ์ข
'ํ๋ก๊ทธ๋๋ฐ > C์ธ์ด' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
๊ตฌ์กฐ์ฒด (0) | 2024.08.21 |
---|---|
ํฌ์ธํฐ & ํจ์ (0) | 2024.08.16 |
ํฌ์ธํฐ & ๋ฐฐ์ด (0) | 2024.08.16 |
ํฌ์ธํฐ (0) | 2024.08.15 |
๋ฐฐ์ด (0) | 2024.08.14 |