CTRL + F ๋ก ํค์๋ ๊ฒ์
๋ณธ ๊ธ์ ํ์๊ฐ C์ธ์ด๋ฅผ ๊ณต๋ถํ๋ฉด์ ์ฐ๋ ์ผ์ข ์ ์ ์ฅ ๋ ธํธ์ ๋๋ค.
ํ์๋ ๋ฐฐ์ฐ๋ ์ ์ฅ์ผ๋ก
ํ์ํ์ ๋ถ ๋ค์ ์ ์ ํ ์ฌ์ฉํ๋ฉด ์ข์ ๋ฏ ํ๋ค.
โ Stream
์คํธ๋ฆผ : ํ ๋ฐฉํฅ์ผ๋ก ํ๋ฅด๋ ๋ฐ์ดํฐ์ ํ๋ฆ
์ฝ๊ฒ ๋งํด ๋ฐ์ดํฐ์ ์ด๋ ๊ฒฝ๋ก, ์ฆ ๋ค๋ฆฌ(Bridge)๋ฅผ ์๋ฏธ
์ฝ์ ์
์ถ๋ ฅ : ํค๋ณด๋, ๋ชจ๋ํฐ๋ฑ๊ณผ ๊ฐ์ ์
์ถ๋ ฅ์ ์๋ฏธ
ใดprintf , scanf ํจ์๋ฅผ ์ฌ์ฉํ๋ฉด์ ์คํธ๋ฆผ ์์ฑ ๊ด๋ จ ์ฝ๋๋ฅผ ์ง์ ์์ฑํ์ง ์์
์ด ๋ง์ ์ฝ์ ์ ์ถ๋ ฅ์ ์ํ "์ ๋ ฅ ์คํธ๋ฆผ"๊ณผ "์ถ๋ ฅ ์คํธ๋ฆผ"์
ํ๋ก๊ทธ๋จ์ด ์คํ๋๋ฉด ์๋ ์์ฑ ํ ์๋ ์๋ฉธ ์คํธ๋ฆผ
stdin : ํ์ค ์ ๋ ฅ ์คํธ๋ฆผ / ํค๋ณด๋ ๋์ ์ ๋ ฅ
stdout : ํ์ค ์ถ๋ ฅ ์คํธ๋ฆผ / ๋ชจ๋ํฐ ๋์ ์ถ๋ ฅ
stderr : ํ์ค ์๋ฌ ์คํธ๋ฆผ / ๋ชจ๋ํฐ ๋์ ์ถ๋ ฅ
โ putchar , fputc #๋ฌธ์ ์ถ๋ ฅ ํจ์
#include <stdio.h>
int putchar(int a);
int fputc(int a, FILE * stream);
fputc ํจ์๋ ๋ฌธ์๋ฅผ ์ ์กํ ์คํธ๋ฆผ์ ์ง์ ๊ฐ๋ฅ
์ฆ stdout(๋ชจ๋ํฐ ์ถ๋ ฅ)๋ง ์๋๋ผ ํ์ผ ๋์์ผ๋ก๋ ์ ์ก ๊ฐ๋ฅ
โ getchar, fgetc #๋ฌธ์ ์ ๋ ฅ ํจ์
int getchar(void);
int fgetc(FILE *stream)
fgetc ํจ์ ์ญ์ ๋ฌธ์๋ฅผ ์ ๋ ฅ ๋ฐ์ ์คํธ๋ฆผ ์ง์ ๊ฐ๋ฅ
์ฆ stdin(ํค๋ณด๋ ์ ๋ ฅ)๋ง ์๋๋ผ ํ์ผ๋ ๊ฐ๋ฅ
์ฌ๊ธฐ์ ํ์ธํ ์ ์ด๊ฒ๋ค์ ๋ฐํํ์ด int๋ค
๊ทธ ์ด์ ์ ๋ํด...
char ๋ฅผ unsinged char๋ก ์ปดํ์ผ๋ฌ๊ฐ ์กด์ฌํจ.
(์ด ๋ง์ ์์๊ฐ ์ ์ฅ ์ ๋จ, MSB ๋ถํธ๋ฅผ ๋ํ๋ด๋ ๋นํธ๋ ๊ฐ์ ์ ์ฅํ๋ ํํ๋ก ์ฐ์)
EOF๋ -1๋ก ์ ์๋ ์์๋ค.
charํ์ด ๋ฐํ์ด๋ฉด unsigne char๋ก ์ฒ๋ฆฌํ๋ ์ปดํ์ผ๋ฌ์์ ์ค๋ฅ ๋ฐ์
#define _CRT_SECURE_NO_WARNINGS
#include <stdio.h>
int main(void)
{
int a1, a2;
a1 = getchar();
a2 = fgetc(stdin);
putchar(a1);
fputc(a2, stdout);
return 0;
}
โ EOF / End Of File
ํ์ผ์ ๋์ ํํํ๊ธฐ ์ํด ์ ์ํ ์์
ํ์ผ ๋์์ผ๋ก fgetc ํจ์ ํธ์ถ ๊ฒฐ๊ณผ๊ฐ EOF ์ด๋ฉด
ํ์ผ ๋์ ๋๋ฌ ํ๋ค๋ ์๋ฏธ๋ค.
ํค๋ณด๋ ๋์์์ fgetc , getchar ํจ์๊ฐ EOF ๋ฐํํ ๋๋ ๋ค์๊ณผ ๊ฐ์ ์ํฉ์ด๋ค
1 . ํจ์ ํธ์ถ ์คํจ
2 . CTRL + Z ํค ์
๋ ฅ or CTRL + D (๋ฆฌ๋
์ค)
prtinf scanf์ ๊ฐ์ ํจ์๋ฅผ ์ฌ์ฉํด์๋ ์ ,์ถ๋ ฅ์ด ๊ฐ๋ฅํ๋
๋ฌธ์ ํ๋์ ๊ฒฝ์ฐ๋ ์์ ํจ์๋ค์ ์ฐ๋๊ฒ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ , ์ฐ์ฐ ์๋์์ ์ด์ ์ด ์๋ค.
โ puts , fputs #๋ฌธ์์ด ์ถ๋ ฅ ํจ์
#include <stdio.h>
int puts(const char *s);
int fputs(const char * s, FILE * stream);
์ด ๋์ ์ฐจ์ด
pust ํจ์๋ ์ถ๋ ฅ ํ ๊ฐํ( New line)์ด ์คํ๋์ง๋ง
fputs ํจ์๋ ๊ฐํ(New line)์ด ์คํ ์ ๋๋ฏ๋ก \n ๋ฐ๋ก ์ถ๋ ฅ ํด์ค์ผ ํ๋ค.
โ gets , fgets #๋ฌธ์์ด ์ ๋ ฅ ํจ์
#include <stdio.h>
char * gets(char *s);
char * fgets(char * s, int n, FILE * stream);
์คํ ์์
fgets ํจ์ ํธ์ถํ 012345678910 ์ ๋ ฅ์ ํ๋ฉดsizeof(str) ๋ฐํ๊ฐ 7๋ณด๋ค 1์์
6๋งํผ์ ๋ฌธ์์ด๋ง str ์ ์ฅ
๊ทธ ์ด์ ์์จ ๋ฐฐ์ด ๋ฌธ์์ด์ ๋์๋ ํญ์ ๋์ ๋ํ๋ด๋ ๋(\0)๊ฐ ์กด์ฌํ๊ธฐ ๋๋ฌธ์ด๋ค.
fgets ํจ์๋ \n์ ๋ง๋ ๋ ๊น์ง์ ๋ฌธ์์ด์ ์ฝ๋๋ค.
๋ฐ๋ผ์ ๊ณต๋ฐฑ๋ ๊ฐ์ด ์ ๋ ฅ ๋ฐ์ ์ ์๋ค.
โ Standard ์ ,์ถ๋ ฅ๊ณผ ๋ฒํผ (Buffer)
ํ์ค ์ ์ถ๋ ฅ ํจ์๋ค(printf , scanf , fputc ๋ฑ๋ฑ)
๋ก ๋ฐ์ดํฐ๋ฅผ ์ ,์ถ๋ ฅ ํ ๊ฒฝ์ฐ
์ด๊ฒ๋ค์ ๋ฉ๋ชจ๋ฆฌ ๋ฒํผ๋ฅผ ์ง๋๊ฐ๋ค.
fgets ํจ์๋ฅผ ํตํด ๋ฌธ์์ด์ ์ ๋ ฅํ ๋
"์ํฐ(Enter)"ํค๋ฅผ ์น๋ ์๊ฐ ์ ๋ ฅ ๋ฒํผ๋ก ๋ค์ด๊ฐ๋ค.
๋ฐ์ดํฐ๊ฐ ๋ฒํผ๋ฅผ ๊ฑฐ์น๋ ์ด์
๋ฐ์ดํฐ ์ ์ก ํจ์จ์ฑ : ๋ง์ฝ ๋ฒํผ๋ง ์์ด ์คํ๋๋ค๋ฉด
ํค๋ณด๋์์ GSG ๋ผ๊ณ ์ ๋ ฅํ ๊ฒฝ์ฐ
G์ ์ก S ์ ์ก G ์ ์ก ์ด๋ ๊ฒ 3๋ฒ ์ ์ก์ ํ๊ฒ ๋๋ค.
์ด๋ด ๋ฐ์
์ ๋ ฅ ๋ฒํผ์ GSG๋ฅผ ํ ๋ฐฉ์ ๋ฌถ์ด์ ๋ณด๋ด๋๊ฒ ํจ์จ์ ์ด๋ค.
โ fflush ํจ์ #์ถ๋ ฅ ๋ฒํผ ๋น์ฐ๊ธฐ
์ถ๋ ฅ ๋ฒํผ๋ฅผ ๋น์ด๋ค๋ ๊ฒ์ ์๋ฏธ
์ด ๋ป์ ๋ค๋ฅด๊ฒ ์๊ฐํ๋ฉด ์ถ๋ ฅ ๋ฒํผ์ ์๋ ๋ฐ์ดํฐ๊ฐ ์ด๋ฏธ ์ ์ก๋์๋ค๋ ๋ง๋ก๋ ์ดํด๊ฐ ๊ฐ๋ฅํ๋ค.
#include <stdio.h>
int fflush(FILE * stream);
fflush(stdout) : ํ์ค ์ถ๋ ฅ ๋ฒํผ ๋น์ฐ๊ธฐ
fflush(stdin) : ์ปดํ์ผ๋ฌ๋ง๋ค ๋ค๋ฅธ ์๋ฏธ๋ฅผ ๋ํ๋ (๋ฒํผ๊ฐ ์ ๋น์์ง ์ ์์)
์ ๋ ฅ ๋ฒํผ๋ฅผ ์ง์ฐ๋ ๋ฐฉ๋ฒ
void Clear(void)
{
while(getchar()!='\n');
}
getchar๋ ๋ฌธ์ ํ๋ ํ๋๋ฅผ ์ฝ๋ ํจ์๋ค.
๊ทธ๋์ ํ๋์ฉ ์ฝ์ผ๋ฉด์ \n๋ฅผ ๋ง๋๋ฉด ์ข ๋ฃ ๋๊ณ ์ ๋ ฅ ๋ฒํผ๊ฐ ๋น์์ง๊ฒ ๋๋ค.
โ strlen #๋ฌธ์์ด ๊ธธ์ด ๋ฐํ ํจ์
strlen : ํค๋ํ์ผ #string.h ์ ์๋ ํจ์
#include <string.h>
size_t strlen(const char * s);
์ฌ๊ธฐ์ size_t์ ์๋ฏธ
unsigned int = size_t
strlen์ด ๋ฐํํ์ด unsigned int ์ด๋ฏ๋ก
์ถ๋ ฅํ ๋๋ %u ๊ฐ ํ์ํ๋ค. (%d๋ ๊ฐ๋ฅ)
โ str ๋ฌธ์์ด ํจ์๋ค
strcpy(n1,n2) : ๋ฌธ์์ด ๋ณต์ฌ
strncpy(n1,n2,sizeof(n1)) : ์๋ ์ฐจ์ด์ ์ n2์ ๋ฌธ์ ๊ธธ์ด๊ฐ 100์ด๊ณ n1์ด 50์ด๋ผ๋ฉด
50์ด๋ผ๋ ์ ๋ฐ์ ๋ณต์ฌ๊ฐ ์ ๋๋ค.
strncpy์ 3๋ฒ์งธ ์ธ์ : ๋ ๋ฌธ์๋ฅผ ์ ์ธํ ๊ณต๊ฐ์ ์ค์ผ ํ๋ค.๋ฐ๋ผ์ sizeof(n1)-1 ์ด ์๋ง๋ค.
strcat(n1,n2) : n1๋ค์ n2๋ฅผ ๋ถ์ธ๋ค.
n1์ ๋ ๋ฌธ์ ์๋ฆฌ ๋์ ์ n2 ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ๋ค์ด๊ฐ๋ค.
strncat(n1,n2, X ) : n2์ ๋ฌธ์์ด์ค ์ต๋ X๊ฐ๋ฅผ n1๋ค์ ๋ถ์ธ๋ค.
n2์ ๊ธธ์ด๊ฐ X๋ฅผ ์ด๊ณผํ๋ฉด X๊ธธ์ด ๋งํผ ๋ถ์ด๋๊ฑด๋ฐ
X๊ฐ์๋ ๋ ๋ฌธ์๊ฐ ํฌํจ๋์ง ์์ผ๋ฏ๋ก X+1๊ฐ๊ฐ ๋ถ๋๋ค.
์์ strncpy ์ ๋ค๋ฅด๊ฒ ์๋์ผ๋ก ๋ ๋ฌธ์ ์ฝ์ ์ด ๋๋ค.
strcmp(n1,n2) : n1์ด ํฌ๋ฉด 0๋ณด๋ค ํฐ ๊ฐ , n2๊ฐ ํฌ๋ฉด 0๋ณด๋ค ์์ ๊ฐ , ๊ฐ์ผ๋ฉด 0
strncmp(n1,n2,X) : X๊ฐ๋ง ๋น๊ต
int atoi(const char * str) : ๋ฌธ์์ด ๋ด์ฉ์ int๋ก ๋ณํ
long atol ~~ : ๋ฌธ์์ด ๋ด์ฉ์ long์ผ๋ก ๋ณํ
double atof ~~ : ๋ฌธ์์ด ๋ด์ฉ์ผ๋ก double๋ก ๋ณํ ;
๋ง์ง๋ง ์ ๋ฐ์ดํธ 2023 06 05