1. ํฌ์ธํฐ ์ ์: ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ก, ์คํ์ค์ธ ํ๋ก์ธ์ค์ ์์ ์ฃผ์์ ์ ๊ทผ ํ ์ ์๊ฒ ํ๋ค.ํฌ์ธํฐ๋ฅผ ์ด์ฉํ์ฌ ํ๋ก์ธ์ค์ ์ํ๋ ์์ญ์ ์ ๊ทผ ๊ฐ๋ฅํ๋ค. ํฌ์ธํฐ ์๋ฃํ์ข
๋ฅ: ํฌ์ธํฐ ๋ณ์, ๋ฐฐ์ด ํฌ์ธํฐ, ํฌ์ธํฐ ๋ฐฐ์ด, ํจ์ ํฌ์ธํฐ, ๋ค์ค ํฌ์ธํฐ, voidํ ํฌ์ธํฌ์ธํฐ ๋ณ์: ๋ค๋ฅธ ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ์ฃผ์๋ฅผ ์ ์ฅํ๋ ๋ณ์๋ฐฐ์ด ํฌ์ธํฐ: ๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์์์ ์ฃผ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ex) int (*arrPtr)[10]; (10๊ฐ์ ์ ์๋ฅผ ๊ฐ์ง ๋ฐฐ์ด์ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ)ํฌ์ธํฐ ๋ฐฐ์ด: ํฌ์ธํฐ๋ฅผ ์์๋ก ๊ฐ์ง๋ ๋ฐฐ์ด ex) int *ptrArray[10]; (์ ์ํ ํฌ์ธํฐ 10๊ฐ๋ฅผ ๊ฐ์ง ๋ฐฐ์ด)ํจ์ ํฌ์ธํฐ: ํจ์๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ ex) void (*funcPtr)(int); (์ ์๋ฅผ ์ธ์๋ก ๋ฐ๋ ํจ์ ํฌ์ธํฐ)..
๐ปโ๏ธ์ ๊ณต๊ณต๋ถ/C์ธ์ด
๋ฐฐ์ดํ๋์ ์ด๋ฆ์ผ๋ก ์ฐธ์กฐ๋๋ ๊ฐ์ ์๋ฃํ์ ๊ฐ๋ ๋ฐ์ดํฐ๋ค์ ์งํฉ(๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ธ ๊ณต๊ฐ)int count[10]; //๋ฐฐ์ด ์ ์ธcount[0] = 100, count[1] = 200; //๋ฐฐ์ด์์์ ๊ฐ ํ ๋น ์ด๊ธฐํ๋ฐฐ์ด์ ์ ์ธ์ ํ๊ณ ์ด๊ธฐํ๋ฅผ ํด์ผ ํ๋ค. ๋ํ ์ ์ธ๊ณผ ๋์์ ๊ฐ์ ์ด๊ธฐํํ ์ ์๋ค. ๋ฐฐ์ด์ ์ ์ธํ๊ณ ์ด๊ธฐํํ์ง ์์ผ๋ฉด, ์คํ ์์ญ์ ํ ๋น๋ ๋ฐฐ์ด์ ์ฐ๋ ๊ธฐ ๊ฐ์ ์ ์ฅํ๋ค.int count[5] = {10, 20, 30, 40, 50};# ๋ฐฐ์ด ์ด๊ธฐํ ์ ์์ ์๋ณด๋ค ์ ์ ์ธ์๋ฅผ ์ฌ์ฉํ๋ฉด, ๋๋จธ์ง ์์ญ์ 0์ผ๋ก ์ด๊ธฐํ๋๋ค.int arr[5] = {1,2,3}; ๋ฐฐ์ด์ ๋ฉ๋ชจ๋ฆฌ์ ์ฐ์์ ์ผ๋ก ํ ๋น ๋ฐ๋๋ค.์์์ ๊ฐ ์ฌ์ฉ ์ ๋ฐฐ์ด๋ณ์[์ฒจ์] ์์ ์ฃผ์ ์ฌ์ฉ ์ &๋ฐฐ์ด๋ณ์[์ฒจ์]#include int mai..
๋ฐฐ์ธ ๊ฒ๋ณ์ ๋ฒ์, ๋ฉ๋ชจ๋ฆฌ ํ ๋น๊ตฌ์กฐ์ ์ญ๋ณ์, ์ง์ญ๋ณ์ ์ฐจ์ดstatic์์ ์, extern์์ ์ 1. ๋ณ์์ ๋ฉ๋ชจ๋ฆฌ ์ ์ฅ ์์น ๋ฉ๋ชจ๋ฆฌ ํ ๋น ๊ตฌ์กฐ์ฝ๋ ์์ญ: ํ๋ก๊ทธ๋จ ์คํ ์ฝ๋ ์ ์ฅ๋ฐ์ดํฐ ์์ญ (ํ๋ฒ๋ง ์ด๊ธฐํ)๋ฐ์ดํฐ: ์ด๊ธฐํ๋ ์ ์ญ ๋ณ์, ์ ์ ๋ณ์ ์ ์ฅBSS: ์ด๊ธฐํ๋์ง ์์ ์ ์ญ ๋ณ์, ์ ์ ๋ณ์ ์ ์ฅํ ์์ญ: ๋์ ๋ฉ๋ชจ๋ฆฌ ํ ๋น ์์ญ์คํ ์์ญ: ํจ์ ํธ์ถ ์ ์ง์ญ๋ณ์, ๋งค๊ฐ๋ณ์ ์ ์ฅ (๋งค๋ฒ ์ด๊ธฐํ) ์คํ vs ๋ฐ์ดํฐ ๋ฐ์ดํฐ๋ณ์ ํ ๋น์ ํ๋ก์ธ์ค ์ข
๋ฃ๊น์ง ๋ณ์ ์์ญ ์ ์งํ๋ก๊ทธ๋จ ์ข
๋ฃ๋ ๋๊น์ง ๋ณ์๋ ๊ฐ ์ ์ง ๋ณ์๊ฐ ํ ๋น๋ ์์ญ์ ํญ์ 0๋ถํฐ ์์์คํ์ฌํ์ฉ๋๋ ๊ณต๊ฐ์ง์ญ๋ณ์๋ ์์ฑ๊ณผ ์๋ฉธ ๋ฐ๋ณต๋ณ์ ํ ๋น ์์ญ์ 0์ ๋ณด์ฅ๋ฐ์ง ๋ชปํ๋ค. 2. ๋ณ์์ ์ข
๋ฅ ์ง์ญ๋ณ์์คํ์์ญ์ ์ ์ฅ๊ฐ๋
: ํจ์ ๋ด์ ์ ์ธ๋๋ฉฐ, ํจ์๊ฐ ํธ..
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..