ํ์ผ์ ์ฝ๊ณ ์ธ ๋๋ fputs(), fgets() ํจ์์ fprintf(), fscanf() ํจ์๋ฅผ ์ฌ์ฉ. ํ ์์ผ๋ก ์ด๋ฃจ์ด์ง ํ์ผ์์ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ์ธ ๋๋ ๋จผ์ fopen() ํจ์๋ก ํ์ผ์ ์ด์ด์ ํ์ผ ํฌ์ธํฐ๋ฅผ ์ป์ด์ผ ํ๋ค. ํ์ผ ํฌ์ธํฐ๋ fopen() ํจ์๋ฅผ ํตํด ๋ฌด์จ ํ์ผ์ ์ด์๋์ง, ํ์ผ์ ์ด๋๊น์ง ์ฝ์๋์ง, ํ์ผ์ ๋์ ๋๋ฌํ๋์ง ๋ฑ์ ์ ๋ณด๋ฅผ ๋ด๋๋ค. ํ์ผ ํฌ์ธํฐ๋ฅผ ์ป๋ ๋ฐฉ๋ฒ FILE * ํฌ์ธํฐ๋ช
= fopen(ํ์ผ๋ช
, ํ์ผ๋ชจ๋); ํ์ผ ๋ชจ๋ : r ์ฝ๊ธฐ ์ ์ฉ, w ์ฐ๊ธฐ ์ ์ฉ, a ์ด์ด ์ฐ๊ธฐ ์ฝ๊ธฐ, ์ฐ๊ธฐ ์ ์ฉ ๋ค์๋ t์ b๋ฅผ ๋ถ์ผ ์ ์๋๋ฐ, t๋ ํ
์คํธ๋ฅผ ์๋ฏธ, b๋ ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ๋ฅผ ์๋ฏธ ํ
์คํธ = ์ฌ๋์ด ์ฝ์ ์ ์๋ ๋ฌธ์์ด, ๋ฐ์ด๋๋ฆฌ ๋ฐ์ดํฐ = ์ปดํจํฐ๊ฐ ์ฝ์ ์ ์๋ 0๊ณผ 1๋ก ๋ ..
๐ฉ๐ป ํ๋ก๊ทธ๋๋ฐ/๐ญ C
struct ๊ตฌ์กฐ์ฒด๋ช
{ ์๋ฃํ1 ๋ณ์๋ช
1; ์๋ฃํ2 ๋ณ์๋ช
2; ์๋ฃํ3 ๋ณ์๋ช
3; ... }; ๊ตฌ์กฐ์ฒด๋ ๋ณดํต ์ ์ญํจ์์ ๋ง์ฐฌ๊ฐ์ง๋ก main() ํจ์ ์ ์ ์ญ ์์น์ ์ ์ํ๋ค. ์ฌ์ฉ์ ์ ์ ์๋ฃํ struct GameInfo { char* name; int year; int price; char* company; }; ๊ตฌ์กฐ์ฒด ์ ์ธ : struct ๊ตฌ์กฐ์ฒด๋ช
๋ณ์๋ช
; struct GameInfo gameInfo1; typedef๋ก ๊ตฌ์กฐ์ฒด ์ ์ธํ๊ธฐ ๋๋ณด๊ธฐ typedef : ์๋ฃํ์ ์๋ก ์ด๋ฆ์ ๋ถ์ผ ๋ ์ฌ์ฉ int i = 1; typedef int ์ ์; // int == ์ ์ ์ ์ ์ ์๋ณ์ = 3; // int i = 3; typedef float ์ค์; ์ค์ ์ค์๋ณ์ = 3.23f; // float f =..
int arr[2][5]; = ์๋ฃํ ๋ฐฐ์ด๋ช
[์ธ๋กํฌ๊ธฐ][๊ฐ๋กํฌ๊ธฐ]; 5๊ฐ์ ์ฐ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๊ฐ์ง 1์ฐจ์ ๋ฐฐ์ด์ด 2๊ฐ ์๋ค. ์ด ์์๋ 5 x 2 =10๊ฐ 2์ฐจ์ ๋ฐฐ์ด์ 1์ฐจ์ ๋ฐฐ์ด์ ์๋ฏธํ๋ ๋๊ดํธ์ ๋๊ดํธ๊ฐ ํ๋ ๋ ์ถ๊ฐ๋๋ค. 2์ฐจ์ ๋ฐฐ์ด์ด 2๊ฐ ์ด์ ์ฐ์๋๋ฉด, 3์ฐจ์ ๋ฐฐ์ด int arr[3][3][3]; 3๊ฐ์ ์ฐ์๋ ๊ณต๊ฐ์ ๊ฐ์ง 1์ฐจ์ ๋ฐฐ์ด์ด 3๊ฐ ์๊ณ , ์ด๋ฐ 2์ฐจ์ ๋ฐฐ์ด์ด ๋ค์ 3๊ฐ ์๋ค๋ ๋ป ์ฆ, 3 x 3ํฌ๊ธฐ์ 2์ฐจ์ ๋ฐฐ์ด์ด 3๊ฐ ์์ผ๋ฉฐ, ์ด ์์๋ 3 x 3 x 3 = 27๊ฐ์ด๋ค. ์ธ๋ก ํฌ๊ธฐ๋ ์๋ต ๊ฐ๋ฅ int arr[][2]; ๊ฐ์ ๋ชจ์์ ์นด๋ ๋ง์ถ๊ธฐ ๊ฒ์ ๋๋ณด๊ธฐ #include #include #include int arrayAnimal[4][5]; char* strAnimal[10..
int ์ฒ ์ = 1; ๋ฉ๋ชจ๋ฆฌ์ ์ฒ ์๋ผ๋ ๊ณต๊ฐ์ด ์๊ธด๋ค. ๊ทธ๋ฆฌ๊ณ ์ฒ ์๋ผ๋ ๊ณต๊ฐ์ ์์น๋ฅผ ๋ํ๋ด๋ ์ฃผ์๊ฐ ์๋ค. ์ฐ๋ฆฌ๋ 101ํธ๋ผ๊ณ ์ฝ์ง๋ง, ์ค์ ๋ฉ๋ชจ๋ฆฌ์์๋ ์ด๋ค ๊ฐ์ผ์ง ๋ชจ๋ฅธ๋ค. ์ฃผ์๊ฐ์ ์์๋ด๋ ค๋ฉด ๋ณ์๋ช
์์ &๋ฅผ ๋ถ์ฌ ์ถ๋ ฅํ๋ฉด ๋๋ค. ์ฃผ์๊ฐ์ ์ถ๋ ฅํ๊ณ ์ถ๋ค๋ฉด ์์์ง์ ์ %d ๋์ %p (ํฌ์ธํฐ)๋ฅผ ์ฌ์ฉํ๋ค. ๊ทธ๋ฌ๋ฉด ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ 16์ง์ ํํ๋ก ์ถ๋ ฅํ๋ค. #include int main(void) { int ์ฒ ์ = 1; int ์ํฌ = 2; int ๋ฏผ์ = 3; printf("์ฒ ์๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &์ฒ ์, ์ฒ ์); printf("์ํฌ๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &์ํฌ, ์ํฌ); printf("๋ฏผ์๋ค ์ฃผ์ : %p, ์ํธ : %d\n", &๋ฏผ์, ๋ฏผ์); return..
๋ฐฐ์ด : ๋์ผํ ์๋ฃํ์ ๊ฐ ์ฌ๋ฌ ๊ฐ๋ฅผ ์ ์ฅํ๋ ์ฐ์๋ ๊ณต๊ฐ ์๋ฃํ ๋ฐฐ์ด๋ช
[๋ฐฐ์ด ํฌ๊ธฐ]; int subway_array[3]; ์์ : ๋ฐฐ์ด์์ ๋ณ์ ํ๋์ ํด๋นํ๋ ๊ณต๊ฐ, ์ธ๋ฑ์ค๋ก ๊ตฌ๋ถ #include int main(void) { int subway[3]; subway[0] = 30; // [30][][] subway[1] = 40; // [30][40][] subway[2] = 50; // [30][40][50] for (int i = 0; i < 3; ++i) { printf("์งํ์ฒ %dํธ์ฐจ์ %d๋ช
์ด ํ๊ณ ์์ต๋๋ค \n", i + 1, subway[i]); } return 0; } int size = 10; int array[size]; // ๋ถ๊ฐ๋ฅ. ์์๋ง ๊ฐ๋ฅ int array[10]; /..
ํจ์ : ๊ฐ์ ์
๋ ฅ๋ฐ์ ์ด๋ค ์์
์ ํ ํ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์ถ๋ ฅํ๋ ๊ฒ ๋ฐํํ ํจ์๋ช
(์ ๋ฌ๊ฐ); // ํจ์ ์ ์ธ int main(void){ ํจ์๋ช
(์ ๋ฌ๊ฐ); // ํจ์ ํธ์ถ } ๋ฐํํ ํจ์๋ช
(์ ๋ฌ๊ฐ){ // ํจ์ ์ ์ // ์ํํ ๋ฌธ์ฅ } ์์น ์ฃผ์. main ์ ์๋๋ก ๋๋๋ค. ์ฌ์น์ฐ์ฐ ์์ #include void p(int num); int main(void) { int num = 2; p(num); num += 3; p(num); num -= 1; p(num); num *= 3; p(num); num /= 6; p(num); return 0; } void p(int num) { printf("num์ %d ์
๋๋ค.\n", num); } ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ด์ 2๊ฐ์ง 1. ์ฝ๋ ์ค๋ณต์ ๋ฐฉ์งํ๊ณ ํจ์จ์ ์ผ๋ก..
break for๋ฌธ์ ์ํํ๋ค๊ฐ break ๋ง๋๋ฉด for๋ฌธ ํ์ถ. ๋ฐ๋ก ๋ฐ๋ณต๋ฌธ ํ์ถ ์ด์ค for๋ฌธ์ผ ๊ฒฝ์ฐ, break๊ฐ ์๋ for๋ฌธ๋ง ํ์ถ #include int main(void) { for (int i = 1; i = 6) { printf("๋๋จธ์ง ํ์์ ์ง์ ๊ฐ์ธ์ \n"); break; } printf("%d๋ฒ ํ์ ๋ฐํ\n", i); } return 0; } continue ์ด๋ฒ ๋ฐ๋ณต๋ฌธ๋ง ์ข
๋ฃํ๊ณ , ๋ค์ ๋ฐ๋ณต๋ฌธ์ผ๋ก ๋์ด๊ฐ. ๋ฐ๊นฅ์ชฝ if๋ฌธ์ ์ํ๋ printf()๋ฌธ์ ์ํํ์ง ์๊ณ i++์ ์ํํ ํ ๋ค์ ๋ฐ๋ณต์ผ๋ก ๋์ด๊ฐ #include int main(void) { for (int i = 1; i 0) { coffee = 3500; } printf("์ฃผ๋ฌธํ์ ๋ฉ๋ด์ ์ด ๊ธ์ก์ %d ์
๋๋ค.",..
230822 230828 230921 ์ ์์ฐ์ฐ์ : ++x, ๋จผ์ 1์ฆ๊ฐ ์ฐ์ฐ์ ํ ํ์ ์ถ๋ ฅ ์ํ ํ์์ฐ์ฐ์ : x++, ๋จผ์ ์ถ๋ ฅ ์์
ํ์ 1์ฆ๊ฐ ์ฐ์ฐ ์ํ do-while๋ฌธ ์ ์ธ; do{ // ์ํํ ๋ฌธ์ฅ } while(์กฐ๊ฑด); ๋ฌด์กฐ๊ฑด ํ ๋ฒ์ ์คํ๋จ ๋ฌดํ ๋ฐ๋ณต์ ๊ฑธ๋ ค ์๋ฌ๋ฅผ ๋ฑ์ ๋, ctrl+c ๋ฅผ ๋๋ฌ ๊ฐ์ ์ข
๋ฃ ๊ฐ๋ฅ! ์์ (0 1 2 3 ์ถ๋ ฅ๋จ) #include int main(void) { int i = 0; do { printf("%d\n", i); i++; } while (i < 5); return 0; } ๊ตฌ๊ตฌ๋จ ์ถ๋ ฅ #include int main(void) { for (int i = 2; i
= ๋ฑํธ : ๋์
์ฐ์ฐ์. ๊ฐ์ ์ ์ฅํ๋ค. ๋ณ์๋ฅผ ๋ง๋๋ ์ด์ : ํ๋ก๊ทธ๋๋ฐ์์ ๊ฐ์ ์ฌ์ฉํ๋ ค๋ฉด ์ปดํจํฐ๊ฐ ๊ฐ์ ๊ธฐ์ตํด์ผ ํจ. ๊ฐ์ ๊ธฐ์ตํ๋ ์ญํ ์ ๋ฉ๋ชจ๋ฆฌ. ๋ฉ๋ชจ๋ฆฌ์ ๋ณ์๋ช
์ผ๋ก ๊ณต๊ฐ์ ํ ๋น => ๋ณ์ ์ ์ธ ๋ณ์์ ์ฒ์ ๋ฃ๋ ๊ฐ : ์ด๊น๊ฐ (์ด๊ธฐํ) "%d\n"์์ %d : ์ ์ํ ๊ฐ์ ์ถ๋ ฅํ๋ผ๋ ์๋ฏธ. ์์ ์ง์ ์(ํ์ ์ง์ ์). ์ถ๋ ฅํ ๊ฐ์ ์๋ฃํ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง๋ค. ์๋ฃํ ์์ ์ง์ ์ ์ค๋ช
int %d ๊ฐ์ด ์ ์ float %.nf ๊ฐ์ด ์ค์์ผ ๋, n์ ์ถ๋ ฅํ ์์์ ์ดํ ์๋ฆฟ์, n+1 ์๋ฆฌ์์ ๋ฐ์ฌ๋ฆผ double %.nlf char %c, %s ๊ฐ์ด ๋ฌธ์, ๋ฌธ์์ด ์ฃผ์์ฒ๋ฆฌ ๋จ์ถํค : ctrl + k, c ์ฃผ์์ฒ๋ฆฌ ํด์ ๋จ์ถํค : ctrl + k, u printf () ํจ์๋ ์ค์ํ ๋ณ์์ ๊ฐ์ ์ถ๋ ฅ..
ctrl + shift + a : ์์ค ์ถ๊ฐ ~.c : C ํ์ฅ์ " /n " : ์ค๋ฐ๊ฟ C ์์ ์ถ๋ ฅ๋ฌธ์ printf ctrl + f5 : ๋๋ฒ๊ทธํ์ง ์๊ณ ์์ (๋๋ฒ๊น
) #include : ์ ์ฒ๋ฆฌ๊ธฐ ์ง์๋ฌธ C์ธ์ด๋ฅผ ์ฝ๋๋ก ์์ฑํ๋ฉด ์ด๋ฅผ ์ปดํจํฐ๊ฐ ์์๋ค์ ์ ์๋ ๊ธฐ๊ณ์ด๋ก ๋ฒ์ญํ๋ ๊ณผ์ (์ปดํ์ผ)์ด ํ์ ์ด ์ญํ ์ ํ๋ ํ๋ก๊ทธ๋จ(์ปดํ์ผ๋ฌ) ์ : ๋น์ฃผ์ผ ์คํ๋์ค ์ฝ๋๋ฅผ ์์ฑํ๋ ์ฌ๋์ ์ปดํ์ผํ๊ธฐ ์ ์ ์ปดํ์ผ์ ํ์ํ ๊ฒ๋ค์ ์ปดํ์ผ๋ฌ์ ์๋ ค ์ค์ผ ํ๋ค. ์ด ๋ ์ฌ์ฉํ๋ ๊ฒ์ด ์ ์ฒ๋ฆฌ๊ธฐ ์ง์๋ฌธ ์ ์ฒ๋ฆฌ๊ธฐ ์ง์๋ฌธ์ #์ผ๋ก ์์ํ๊ณ , ๋ค์ ๋ถ๋ ์ง์์์ ๋ฐ๋ผ ์ฉ๋๊ฐ ๋ฌ๋ผ์ง๋ค. #include๋ ๊ฐ์ฅ ๋ง์ด ์ฌ์ฉํ๋ ์ง์๋ฌธ์ผ๋ก, ์ง์ ํ ํ์ผ์ ์ฝ๋์ ํฌํจํ๋ผ๋ ๋ป : ์ปดํ์ผ๋ฌ๊ฐ ์๋ ํด๋์์ ํด๋น ํ์ผ์ ์ฐพ์. ๋ณดํต ..
์ฑ
๏ผ ๋๋์ฝ๋ฉ ๏ผฃ์ธ์ด ์
๋ฌธ int ๋ณ์๋ช
= ๊ฐ; // ์ ์ํ ๋ณ์ ์ ์ธ ๋ฐ ์ด๊ธฐํ printf("%d\n", ๋ณ์๋ช
); // ์ ์ํ ๋ณ์์ ๊ฐ ์ถ๋ ฅ ๋ณ์๋ช
= ๊ฐ; // ๋ณ์์ ๊ฐ ๋ฐ๊พธ๊ธฐ ์ค์ํ float f = 46.5f double d = 43.22; Q. ์ float ์๋ฃํ ๊ฐ ๋ค์๋ f๋ฅผ ๋ถ์ฌ์ผ ํ๋๊ฐ? ๋๋ณด๊ธฐ f๋ฅผ ์ฐ์ง ์์ผ๋ฉด double๋ก ์ธ์ํ๋ค. float์ 4๋ฐ์ดํธ, double์ 8๋ฐ์ดํธ์ธ๋งํผ์ ๊ณต๊ฐ์ ์ฌ์ฉํ๋ค. float์ double๋ก ์ธ์ํ๋ฉด ๋ณ์ ํฌ๊ธฐ์ธ 4๋ฐ์ดํธ๊ฐ ์ด๊ณผ๋๋ ๊ฐ์ ์๋ฆฐ๋ค๋ ๊ฒฝ๊ณ ๋ฉ์์ง๋ฅผ ์ถ๋ ฅํ๋ค. ์์ ์ง์ ์๏ผํ์ ์ง์ ์๏ผ int %d float %.nf (n=์์์ ์๋ ์๋ฆฟ์) double %.nlf (n=์์์ ์๋ ์๋ฆฟ์) char %c (๋ฌธ์) %s ..