1. ํฌ์ธํฐํฌ์ธํฐ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ก, ์ผ๋ฐ ๋ณ์๋ ๊ฐ์ ์ ์ฅํ์ง๋ง, ํฌ์ธํฐ๋ ํด๋น ๊ฐ์ด ์ ์ฅ๋ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅ์ฃผ์ ์ฐ์ฐ์: &int a = 10;int *pa = &a; // ๋ณ์ a์ ์ฃผ์๋ฅผ ํฌ์ธํฐ pa์ ์ ์ฅ 2. ์ฃผ์ ์ถ๋ ฅ์ฃผ์๋ฅผ ์ถ๋ ฅํ ๋๋ ํฌ์ธํฐ ์ ์ฉ ํ์ ์ง์ ์ %p๋ฅผ ์ฌ์ฉํด์ผ ํ๋ฉฐ, ์ด๋ 16์ง์๋ก ์ถ๋ ฅprintf("%p\n", &a); // a์ ์ฃผ์๋ฅผ 16์ง์๋ก ์ถ๋ ฅ10์ง์๋ก ์ถ๋ ฅํ๋ ค๋ฉด %u ํ์ ์ง์ ์๋ฅผ ์ฌ์ฉprintf("%u\n", (unsigned int)&a); // ์ฃผ์๋ฅผ 10์ง์๋ก ์ถ๋ ฅ 3. ํฌ์ธํฐ์ ๊ฐ์ ์ฐธ์กฐ ์ฐ์ฐ์: *ํฌ์ธํฐ ๋ณ์๊ฐ ๊ฐ๋ฆฌํค๋ ๊ฐ์ ์ฐธ์กฐํ๋ ค๋ฉด, ๊ฐ์ ์ฐธ์กฐ ์ฐ์ฐ์ *๋ฅผ ์ฌ์ฉํฌ์ธํฐ pa๊ฐ ๊ฐ๋ฆฌํค๋ ๋ณ์ a๋, *pa๋ก ๊ฐ์ ์ ๊ทผํ ์ ์์ผ๋ฉฐ ..
๐ปโ๏ธ์ ๊ณต๊ณต๋ถ
1. ๋ฐฐ์ด๋์ผํ ์๋ฃํ์ ๋ฐ์ดํฐ๋ฅผ ์ฐ์์ ์ผ๋ก ์ ์ฅํ๋ ์๋ฃ ๊ตฌ์กฐC์์ ๋ฐฐ์ด์ ๊ณ ์ ๋ ํฌ๊ธฐ๋ฅผ ๊ฐ์ง๋ฉฐ, ๋ฐฐ์ด์ ๊ฐ ์์๋ ์ธ๋ฑ์ค๋ฅผ ํตํด ์ ๊ทผ ๊ฐ๋ฅ ๋ฐฐ์ด์ ์ ์ธ๋ฐฐ์ด์ ์ ์ธ ์ ์๋ฃํ๊ณผ ๋ฐฐ์ด์ ํฌ๊ธฐ๋ฅผ ์ง์ int arr[5]; // ํฌ๊ธฐ๊ฐ 5์ธ ์ ์ํ ๋ฐฐ์ด ์ ์ธ ๋ฐฐ์ด ์ด๊ธฐํint arr[5] = {1, 2, 3, 4, 5}; // ๋ฐฐ์ด ์ ์ธ๊ณผ ๋์์ ์ด๊ธฐํint arr[] = {1, 2, 3}; // ํฌ๊ธฐ๋ฅผ ์๋ตํ๋ฉด ์ด๊ธฐํ๋ ๊ฐ์ ๊ฐ์์ ๋ง์ถฐ ๋ฐฐ์ด ํฌ๊ธฐ๊ฐ ๊ฒฐ์ ๋จ sizeof ์ฐ์ฐ์๋ฅผ ํ์ฉํ ๋ฐฐ์ด ํฌ๊ธฐ ํ์ธint arr[5] = {1, 2, 3, 4, 5};int size = sizeof(arr) / sizeof(arr[0]); // ๋ฐฐ์ด์ ์์ ๊ฐ์๋ฅผ ๊ณ์ฐ 2. ๋ฌธ์ ๋ฐฐ์ด๋ฌธ์๋ค์ ์ ์ฅํ๋ ๋ฐฐ์ด๋ก, ๋ฌธ์์ด์..
1. ํจ์ ์ ์๋ฐํํ ํจ์๋ช
(๋งค๊ฐ๋ณ์1, ๋งค๊ฐ๋ณ์2) { // ํจ์์ ์ฝ๋ return ๋ฐํ๊ฐ;}๋ฐํํ: ํจ์๊ฐ ์์
์ ์ํํ ํ ๋ฐํํ ๊ฐ์ ์๋ฃํ, ๊ฐ์ ๋ฐํํ์ง ์์ผ๋ฉด void๋ฅผ ์ฌ์ฉํจ์๋ช
: ํจ์์ ์ด๋ฆ๋งค๊ฐ๋ณ์: ํจ์๊ฐ ํธ์ถ๋ ๋ ํจ์๋ก ์ ๋ฌ๋๋ ์
๋ ฅ๊ฐreturn: ํจ์๊ฐ ๋ฐํํ ๊ฐ์ ๋ช
์ํ๋ค. voidํ ํจ์๋ return์ด ์๊ฑฐ๋, ๋จ์ํ return; ์ ์ฌ์ฉ 2. ํจ์ ํธ์ถํธ์ถ ์์ ํจ์๋ช
๊ณผ ๊ดํธ ์์ ํ์ํ ์ธ์(๋งค๊ฐ๋ณ์)๋ฅผ ๋ฃ๋๋ค.int result = ํจ์๋ช
(์ธ์1, ์ธ์2); 3. ํจ์ ์ ์ธ(ํ๋กํ ํ์
)ํจ์ ์ฌ์ฉ ์ ์ ํด๋น ํจ์๊ฐ ์ด๋ป๊ฒ ์๊ฒผ๋์ง ์ปดํ์ผ๋ฌ์๊ฒ ์๋ ค์ฃผ๊ธฐ ์ํด ์ ์ธ์ ๋ฏธ๋ฆฌ ํ๋ค.ํจ์ ์ ์ธ์ด ์์ผ๋ฉด ํจ์ ์ ์๋ ํญ์ ํจ์ ํธ์ถ ์ด์ ์ ์์ด์ผ ํ๋ค.๋ฐํํ ํจ์๋ช
(๋งค..
๊ฐ๋
์ค๋ช
while๋ฌธ์กฐ๊ฑด์ ๋ฌผ์ด๋ณด๊ณ ๋ง์กฑํ๋ ๋์ ์คํ๋ฌธ์ ์คํํ๋ค.while (์กฐ๊ฑด์){ ์คํ๋ฌธ;}for๋ฌธ์ด๊ธฐ๊ฐ์ ๋จผ์ ์ค์ ํ๊ณ ์กฐ๊ฑด์ ๋ฌผ์ด๋ณธ ํ์ ์คํ๋ฌธ์ ์คํํ๊ณ , ์ฆ๊ฐ์์ ์คํํ๊ณ ๋ค์ ์กฐ๊ฑด์ ํ์ธํ๋ค.for (์ด๊ธฐ์; ์กฐ๊ฑด์; ์ฆ๊ฐ์){ ์คํ๋ฌธ;}do~while๋ฌธ์คํ๋ฌธ์ ๋ฌด์กฐ๊ฑด ์คํํ๊ณ ์กฐ๊ฑด์ ํ์ธํ ํ ๋ค์ ์คํ๋ฌธ์ ์คํํ๋ค.do{ ์คํ๋ฌธ;} while (์กฐ๊ฑด์); while๋ฌธ์กฐ๊ฑด์ ๋จผ์ ๊ฒ์ฌํ ํ, ์กฐ๊ฑด์ด ์ฐธ์ธ ๋์ ๋ฐ๋ณต ์ํ๋ฐ๋ณต ํ์๊ฐ ๋ช
ํํ์ง ์๊ฑฐ๋, ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ฐ๋ณต์ด ์ข
๋ฃ๋ ๋ ์ ์ฉ#include int main() { int count = 1; while (count for๋ฌธ๋ฐ๋ณต ํ์๊ฐ ์ ํด์ง ๊ฒฝ์ฐ ์ฌ์ฉ#include int main() { int ..
์ ์ด๋ฌธ์กฐ๊ฑด๋ฌธif, switch ~ case๋ฐ๋ณต๋ฌธfor, while, do ~ while๋ถ๊ธฐ๋ฌธbreak, continue, goto, return ์ด์ค์์ ์กฐ๊ฑด๋ฌธ์ ์ข
๋ฅ๋ค์ ๋ํด์ ์์๋ณด์์กฐ๊ฑด๋ฌธ์ ํฌ๊ฒ if๋ฌธ๊ณผ switch~case๋ฌธ์ผ๋ก ๋๋ ์ง๋ค. if๋ฌธ์กฐ๊ฑด์ด ์ฐธ์ผ๋๋ง ๊ณ ๋ ค#include int main() { int number = 5; if (number > 3) { printf("number๋ 3๋ณด๋ค ํฝ๋๋ค.\n"); } return 0;} if ~else ๋ฌธ์กฐ๊ฑด์ ์ฐ์์ผ๋ก ํ์ธ#include int main() { int number = 2; if (number > 3) { printf("number๋ 3๋ณด๋ค ํฝ๋๋ค.\n"); } els..
์ฐ์ ์ฐ์ฐ์๊ธฐ๋ณธ์ ์ธ ์ํ์ฐ์ฐ ์ํ#include int main() { int a = 10; int b = 3; printf("๋ง์
: %d\n", a + b); // 13 printf("๋บ์
: %d\n", a - b); // 7 printf("๊ณฑ์
: %d\n", a * b); // 30 printf("๋๋์
: %d\n", a / b); // 3 printf("๋๋จธ์ง: %d\n", a % b); // 1 return 0;} ๋์
์ฐ์ฐ์'='์ ์ด์ฉํ ๊ธฐ๋ณธ ๋์
์ฐ์ฐ์'+=', '-=', '*=', '/=', '%=' ์ ์ด์ฉํ ๋ณตํฉ ๋์
์ฐ์ฐ์#include int main() { int a = 10; int b = 5; ..
์์const: ๋ณ์๊ฐ ๋ณ๊ฒฝ๋์ง ์๋ ๊ฐ์ ๊ฐ๊ณ ์ ํ ๋ ๋ณ์๋ฅผ ์์ํ ์ํฌ ์ ์๋ค.#define: ๋งคํฌ๋ก ์์, #์ผ๋ก ์์ -> ์ ์ฒ๋ฆฌ๊ธฐ์ ์ํด ํด์๋จ๋๋ณด๊ธฐ'#'์ผ๋ก ์์ํ๋ ๊ตฌ๋ฌธ์ ์ปดํ์ผ ์ ์ ์ ์ฒ๋ฆฌ๊ธฐ๊ฐ ๋จผ์ ํด์ํจ#include int main(void){ const int x = 8 //10์ง์ 8 ์ถ๋ ฅ printf("%d\n", x); // ๋ฌธ์๋ ์์ ๋ฐ์ดํ('')๋ก ๋ฌถ๋๋ค printf("%c\n", 'A'); // ๋ฌธ์ 'A' ์ถ๋ ฅ // ๋ฌธ์์ด์ ํฐ ๋ฐ์ดํ("")๋ก ๋ฌถ๋๋ค printf("%s\n", "A"); // ๋ฌธ์์ด "A" ์ถ๋ ฅ return 0;}๋ณ์#include int main(void){ // ๋ณ์ ์ ..
์ถ๋ ฅprintf("์ ์: %d \n", 500);printf("์ค์: %f \n", 4.5);printf("๋ฌธ์: %c \n", 'B');๋ฌธ์์ด ํ๋ฉด์ ์ถ๋ ฅ#include #stdio: standard input outputint main(void){ printf("Hi"); return 0;}๋งจ๋ ํ์ด์ฌ, ์๋ฐ๋ง ์ฐ๋ค๋ณด๋ ; ๋ถ์ด๋๊ฒ ๋๋ฌด ์ด์ํ๋ค. ๊ทธ๋ฆฌ๊ณ #include ์ ์ฐ๊ณ ์ถ๋ค...stdio.h -> ์
์ถ๋ ฅํจ์ ํฌํจ๋จ ์ ์ด๋ฌธ์๊ฐํ: \nํญ: \t์บ๋ฆฌ์ง ๋ฆฌํด(์ถ๋ ฅ ์์น ์ค ๋งจ ์์ผ๋ก): \r๋ฐฑ์คํ์ด์ค: \b#include int main(void){ printf("Hi1\n"); //๊ฐํ ์ํด์ \nํ์ printf("Hi\t2"); //8์นธ ๋์ด์ฐ๊ธฐ ํด์ค๋ค. ..