๐ ์ฒ์์ผ๋ก ๋ฐฐ์ ๋ C์ธ์ด, ์ด์ ๋๊น์ง ๋ชจ๋ ๊ฐ๋ ์ ์ ๋๋ก ์ ๋ฆฝํ๋ค๋ ์๋ฏธ๋ก ์งํํด๋ณด์
1. ์ด๊ฒ์ด C์ธ์ด๋ค
โ ์ปดํ์ผ๋ฌ๋ ์ธ๊ฐ์ด ์์ฑํ C์ธ์ด๋ฅผ ์ปดํจํฐ๊ฐ ์ดํดํ ์ ์๋ ๊ธฐ๊ณ์ด๋ก ๋ฐ๊ฟ์ฃผ๋ ์ญํ ์ ๋ด๋นํ๋ค. ์ฆ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ ์ฌ๋๊ณผ ์ปดํ์ผ๋ฌ๊ฐ ์ดํดํ ์ ์๋ ์ฝ์๋ ํํ์ ์ธ์ด
Q. What best describes the role of a compiler?
(A) Debug one's code
(B) Run the written program
(C) Distinguish between functions and arguments
(D) Turn source code into machine code
โก C์ธ์ด์ ํน์ง
→ ์ ์ฐจ์งํฅ์ฑ) ์ ํด์ง ์์์ ์คํํ๋ฆ์ ์ค์. ์ธ๊ฐ์ ์ผ๋ฐ์ ์ธ ์๊ฐ๋ฐฉ์์ ๊ฐ๊น์
→ ์ด์์ฑ์ด ์ข์) C์ธ์ด๋ก ์์ฑ๋ ํ๋ก๊ทธ๋จ์ CPU์ ์ข ๋ฅ์ ์๊ด์์ด ์คํ์ด ๊ฐ๋ฅํ๊ณ , ์ด์์ฒด์ ์ ์ฐจ์ด์๋ ๋ ๋ฏผ๊ฐ
→ ์ข์ ์ฑ๋ฅ) ์ฌ์ฉํ๋ ๋ฉ๋ชจ๋ฆฌ์ ์์ด ์๋์ ์ผ๋ก ์ ๊ณ , ์๋๋ฅผ ์ ํ์ํค๋ ์์๋ฅผ ์ต์ํํ ์ธ์ด
→ ๋ค๋ง, ์ ๊ธ์ธ์ด(low-level)์ ํน์ง์ ํจ๊ป ์ง๋๊ธฐ ๋๋ฌธ์ ๊ณ ๊ธ์ธ์ด์ ๋นํด ์ข ๋ ์ฃผ์ํด์ ์ฌ์ฉ
(๊ณ ๊ธ์ธ์ด์ ๊ฐ๊น์ธ์๋ก ์ฌ๋์ด ์ดํดํ๊ธฐ ์ฌ์ด ์ธ์ด / ์ ๊ธ์ธ์ด์ ๊ฐ๊น์ธ์๋ก ์ปดํจํฐ๊ฐ ์ดํดํ๊ธฐ ์ฌ์ด ์ธ์ด)
2. ํ๋ก๊ทธ๋จ์ ๊ธฐ๋ณธ๊ตฌ์ฑ
โข ํจ์์ ๊ตฌ์ฑ - ์ ๋ ฅ(์ธ์)๊ณผ ์ถ๋ ฅ
→ ์ฆ C์ธ์ด๋ ์ ํด์ง ์์์ ์ํด์ ์งํ๋๋ ํจ์์ ํธ์ถ์ด ๊ณง C์ธ์ด ํ๋ก๊ทธ๋จ์ ํฐ ํ๋ฆ์ด ๋๋ค.
ex) int main(void)
→ int๋ ํจ์ ์ถ๋ ฅ ํํ(๋ฐํํ return type)
→ main์ ํจ์ ์ด๋ฆ
→ void๋ ํจ์ ์ ๋ ฅ ํํ
int main(void) {
return 0;
}
→ C์ธ์ด์์์ ํจ์๋ ์ค๊ดํธ ์์ ํํ์ด ๋๋ค.
→ ํจ์ ๋ด์ ์กด์ฌํ๋ ๋ฌธ์ฅ์ ๋์๋ ์ธ๋ฏธ์ฝ๋ก ; ์ ๋ถ์ฌ ์ค๋ค. (๋ชจ๋ ๋ฌธ์ฅ์ ์ธ๋ฏธ์ฝ๋ก ์ด ๋ถ์ง๋ ์๋๋ค. ์ดํ ์กฐ๊ฑด๋ฌธ๊ณผ ๋ฐ๋ณต๋ฌธ๊ณผ ๊ฐ์ ์ปจํธ๋กค ๋ฌธ์ฅ์๋ ์ธ๋ฏธ์ฝ๋ก ์ด ๋ถ์ง ์๋๋ค)
โฃ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ printf ํจ์
#include <stdio.h>
printf("Hello world!\n");
→ ํจ์๋ฅผ ํธ์ถํ ๋ ์๊ดํธ ์์ ํจ์ ํธ์ถ ์ ์ ๋ฌํ ์ธ์์ ๋ณด ์ ์ฅ
→ ์ printf() ํจ์๋ ์ง์ ๋ง๋ค์ง ์์๋ ํธ์ถ์ด ๊ฐ๋ฅํ, ๊ธฐ๋ณธ์ ์ผ๋ก ์ ๊ณต๋๋ ํจ์. ์ด๋ฅผ 'ํ์คํจ์'๋ผ ํ๊ณ ํ์คํจ์๋ค์ ๋ชจ์์ ๊ฐ๋ฆฌ์ผ 'ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ'๋ผ๊ณ ํ๋ค.
โค ํค๋ํ์ผ
→ ์ printf() ํจ์๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด์ stdio.h๋ผ๋ ํค๋ํ์ผ์ ์ ์ธํด์ผ ํ๊ณ , main ํจ์ ์ ์ ์ด์ ์ ์์ผ ํ๋ค.
→ ์ดํ ํค๋ํ์ผ์ ๊ด๋ จ๋ ์์ธํ ๊ณต๋ถ
โฅ return ๋ฌธ
→ (1) ํจ์๋ฅผ ํธ์ถํ ์์ญ์ผ๋ก ๊ฐ์ ์ ๋ฌ(๋ฐํ) + (2) ํ์ฌ ์คํ์ค์ธ ํจ์์ ์ข ๋ฃ
(+) main ํจ์๋ ํ๋ก๊ทธ๋จ์ด ์์๋๋ฉด ์๋์ผ๋ก ํธ์ถ๋๋ ํจ์. ํธ์ถ์ ์ฃผ์ฒด๋ ์ด์์ฒด์ . ์ฆ return ๋ค์ 0์ ์ด์์ฒด์ ์๊ฒ ์ ๋ฌ๋จ. ๊ทธ๋ฆฌ๊ณ 0์ด๋ผ๋ ๊ฐ์ ํ๋ก๊ทธ๋จ์ ์ข ๋ฃ์ํ๋ฅผ ์๋ฆฌ๋ ์ฉ๋๋ก ์ฌ์ฉ๋จ. 0์ ์ ์์ ์ธ ์ข ๋ฃ / 0์ด ์๋ ๊ฐ์ ๋น์ ์์ ์ธ ์ข ๋ฃ ์ํฉ
ex) ์์
#include <stdio.h>
int main(void) {
printf("Ryan\nR y a n\nR y a n\n");
return 0;
}
/*
Ryan
R y a n
R y a n
*/
โฆ ์ฃผ์
/*
๋ธ๋ก
๋จ์
์ฃผ์
*/
//ํ ๋จ์ ์ฃผ์
โง printf ํจ์
→ ์์ ์ถ๋ ฅํ ๊ฑด ๋ฌธ์์ด, ๋ฌธ์์ด ์ด์ธ์ ๋ค์ํ ๋ฐ์ดํฐ ์ถ๋ ฅ ๊ฐ๋ฅ
#include <stdio.h>
int main(void) {
printf("%d\n",1234);
return 0;
}
//1234
→ printf() ํจ์๋ ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ ๋ฌ๋ ๋ฌธ์์ด์ ์ถ๋ ฅํ๋ค.
→ ๋ฌธ์์ด ์์ ์๋ %d๋ conversion specifier(์์๋ฌธ์)๋ผ๊ณ ํ๋ฉฐ ์ถ๋ ฅ์ ํํ๋ฅผ ์ง์ ํ๋ ์ฉ๋.
→ conversion specifier์ ์ถ๋ ฅ์ด ๋์์ด ๋๋ ๊ฑด ๋ ๋ฒ์งธ ์ ๋ฌ์ธ์. %d๊ฐ ์ฌ๋ฌ ๊ฐ ์๋ค๋ฉด %d์ ๊ฐ์๋งํผ ๋ค์ ์ธ์์ ๊ฐ์๊ฐ ๋์ด๋จ.
→ %d conversion specifier๋ ์ฃผ์ด์ง ์ธ์๋ฅผ 10์ง์ ์ ์ํํ๋ก ์ถ๋ ฅํด์ค
#include <stdio.h>
int main(void) {
printf("%d + %d = %d\n",1234,1234,1234+1234);
return 0;
}
//---------------------------------
#include <stdio.h>
int main(void) {
printf("%d x %d = %d\n",1234,1234,1234*1234);
return 0;
}
3. ๋ณ์์ ์ฐ์ฐ์
โจ ์ฐ์ฐ์(operator): ํน์ ์ฐ์ฐ์ ์๊ตฌํ ๋ ์ฌ์ฉํ๋ ์ฝ์๋ ๊ธฐํธ
→ ex) ๋ง์ ์ฐ์ฐ์ ํ๊ณ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ๋ ๊ฐ์ ์ถ๋ ฅํด์ผ ํ๋ค
→ ๋ณ์(variable)์ ์ด์ฉํด์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅ
(๋ณ์๋ ๊ฐ์ ์ ์ฅํ ์ ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ๋ถ์ ์ด๋ฆ, ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ ์์ฒด)
→ ๋์ ์ฐ์ฐ์) =์ด๋ฉฐ ๋์ ์ฐ์ฐ์์ ์ค๋ฅธํธ์ ์ค๋ ๊ฐ์ ์ผํธ์ ์ค๋ ๋ณ์์ ์ ์ฅํ๋ ํํ๋ก ์ฌ์ฉ
#include <stdio.h>
int main(void) {
int num1, num2;
int num3 = 30, num4 = 40;
printf("num1: %d, num2: %d\n",num1, num2);
num1 = 10;
num2 = 20;
int num5 = 10;
printf("num1: %d, num2: %d\n", num1, num2);
printf("num3: %d, num4: %d\n", num3, num4);
printf("num5: %d\n", num5);
return 0;
}
/*
num1: 10, num2: 20
num1: 10, num2: 20
num3: 30, num4: 40
num5: 10
*/
โฉ ๋ณ์์ ์ด๋ฆ ๊ท์น
→ ๋ณ์์ ์ด๋ฆ์ ์ํ๋ฒณ, ์ซ์, ์ธ๋๋ฐ๋ก ๊ตฌ์ฑ
→ C์ธ์ด๋ ๋์๋ฌธ์ ๊ตฌ๋ถ
→ ๋ณ์์ ์ด๋ฆ์ ์ซ์๋ก ์์ํ ์ ์๊ณ , ํค์๋๋ ๋ณ์๋ก ์ฌ์ฉ ๋ถ๊ฐ๋ฅ
(ํค์๋๋ ์ด๋ฏธ ๊ธฐ๋ฅ์ ์๋ฏธ๊ฐ ์ ํด์ง ๋จ์ด๋ก, C์ธ์ด์ ๋ฌธ๋ฒ์ ๊ตฌ์ฑํ๋ ๋จ์ด๋ค์ด๋ค. ํค์๋๋ ๋ณ์๋ ํจ์์ ์ด๋ฆ์ผ๋ก ์ง์ ํ ์ ์๋ค. ์ด๋ฏธ ์ฉ๋๊ฐ ๊ฒฐ์ ๋ ๋จ์ด๋ค)
→ ์ฌ์ด์ ๊ณต๋ฐฑ ์ฝ์ ๋ถ๊ฐ๋ฅ (๋์ ์ธ๋๋ฐ)
โช ๋ณ์์ ์๋ฃํ
→ ์ ์ํ ๋ณ์: ์ ์์ ์ ์ฅ์ ๋ชฉ์ ์ผ๋ก ์ ์ธ๋ ๋ณ์
→ ์ค์ํ ๋ณ์: ์์์ ์ดํ์ ๊ฐ์ ์ง๋๋ ์ค์์ ์ ์ฅ์ ๋ชฉ์ ์ผ๋ก ์ ์ธ๋ ๋ณ์
→ ์ ์์ธ์ง ์ค์์ธ์ง์ ๋ฐ๋ผ์ ๊ฐ์ด ๋ฉ๋ชจ๋ฆฌ ๊ณต๊ฐ์ ์ ์ฅ ๋ฐ ์ฐธ์กฐ๋๋ ๋ฐฉ์์ด ๋ค๋ฆ. ์ ์ํ ๋ณ์๋ ๋ณ์์ ํฌ๊ธฐ์ ๋ฐ๋ผ์ charํ, shortํ, intํ, longํ ๋ณ์๋ก ๋๋๊ณ / ์ค์ํ ๋ณ์๋ ํฌ๊ธฐ์ ๋ฐ๋ผ์ floatํ, doubleํ ๋ณ์๋ก ๋๋๋ค.
โซ ์ดํญ์ฐ์ฐ์
→ = ๋์ ์ฐ์ฐ์ / + ๋ง์ ์ฐ์ฐ์ / - ๋บ์ ์ฐ์ฐ์ / * ๊ณฑ์ ์ฐ์ฐ์ / / ๋ชซ ์ฐ์ฐ์ / % ๋๋จธ์ง ์ฐ์ฐ์
โฌ ๋ณตํฉ๋์ ์ฐ์ฐ์
→ += / *= / %=
โญ ๋จํญ์ฐ์ฐ์: ์์ ๋ถํธ๋ฅผ ๋ฐ๊ฟ์ฃผ๋ ์ฐ์ฐ์
→ + / -
โฎ ์ฆ๊ฐ / ๊ฐ์ ์ฐ์ฐ์: ๋ณ์์ ์ ์ฅ๋ ๊ฐ์ 1 ์ฆ๊ฐ ๋ฐ ๊ฐ์์ํค๋ ๊ฒฝ์ฐ์ ์ฌ์ฉ๋๋ ์ฐ์ฐ์
→ ++num: ๊ฐ์ 1์ฆ๊ฐ ํ ํ, ์ํ ๋ฌธ์ฅ์ ๋๋จธ์ง๋ฅผ ์งํ
→ num++: ์ํ ๋ฌธ์ฅ์ ๋จผ์ ์งํํ ํ, ๊ฐ์ 1 ์ฆ๊ฐ
→ --num: ๊ฐ์ 1 ๊ฐ์ ํ, ์ํ ๋ฌธ์ฅ์ ๋๋จธ์ง ์งํ
→ num--: ์ํ ๋ฌธ์ฅ์ ๋จผ์ ์งํํ ํ, ๊ฐ์ 1 ๊ฐ์
#include <stdio.h>
int main(void) {
int num1 = 12;
printf("num1: %d\n", num1);
printf("num1++: %d",num1++);
printf("--num1: %d\n",--num1);
int num2 = (num1--)+2;
int num3 = num1+2;
printf("num2, num3: %d, %d\n", num2, num3);
return 0;
}
โฏ ๊ด๊ณ์ฐ์ฐ์(๋น๊ต์ฐ์ฐ์)
→ <, >, <=, >=, ==, !=
→ ์กฐ๊ฑด์ ๋ง์กฑํ๋ฉด 1(true), ๋ง์กฑํ์ง ์์ผ๋ฉด 0(false)์ ๋ฐํ
โฐ ๋ ผ๋ฆฌ์ฐ์ฐ์
→ &&(๊ทธ๋ฆฌ๊ณ ), ||(๋๋), !(NOT)
→ 0๋ง ๊ฑฐ์ง์ด๊ณ ๋๋จธ์ง ์ซ์๋ ๋ชจ๋ ์ฐธ์ผ๋ก ์ธ์
#include <stdio.h>
int main(void) {
int num1 = 10, num2 = 12;
int res1, res2, res3;
res1 = (num1==10 && num2==12);
res2 = (num1<12 || num2>12);
res3 = (!num1);
printf("res1: %d\n",res1);
printf("res2: %d\n",res2);
printf("res3: %d\n",res3);
return 0;
}
/*
res1: 1
res2: 1
res3: 0
*/
โฑ ์ฐ์ฐ์ ์ฐ์ ์์ ์ ๋ฆฌ
โฒ scanf
→ ํค๋ณด๋๋ก๋ถํฐ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ๋ ํจ์
(1) ๋จผ์ ํค๋ณด๋๋ก๋ถํฐ ์ ๋ ฅ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ์ ์ฅํ ๊ณต๊ฐ ๋ณ์ num์ ์์ฑํ๋ค
(2) scanf() ํจ์๋ฅผ ์ฌ์ฉํด ์ฒซ ๋ฒ์งธ ์ธ์๋ก ์ด๋ค ํ์์ผ๋ก ์ ๋ ฅ ๋ฐ์ ๊ฒ์ธ์ง conversion specifier๋ฅผ ๋ช ์ํ๊ณ , ๋ ๋ฒ์งธ ์ธ์๋ก ์ ๋ ฅ ๋ฐ์ ๋ฐ์ดํฐ๋ฅผ ๋ฃ์ ๊ณต๊ฐ์ ๋ช ์ํ๋ค.
#include <stdio.h>
int main(void) {
int num;
scanf("%d",&num);
printf("num is %d\n",num);
return 0;
}
→ ํ ๋ฒ์ scanf๋ก ๋ ์ด์์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅ๋ฐ์ ์ ์๋ค.
→ ์ฌ๋ฌ ๋ฐ์ดํฐ๋ฅผ ์ ๋ ฅํ ๋ scanf ํจ์๋ ๊ณต๋ฐฑ์ ๊ธฐ์ค์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๊ตฌ๋ถ(์คํ์ด์ค๋ฐ, ํญ ๋๋ ์ํฐ ํค)
#include <stdio.h>
int main(void) {
int num1, num2, num3;
scanf("%d %d %d",&num1, &num2, &num3);
printf("num1, num2, num3: %d, %d, %d\n",num1, num2, num3);
return 0;
}
ex) ์์
#include <stdio.h>
int main(void) {
int num1, num2, num3;
scanf("%d %d %d",&num1, &num2, &num3);
printf("result is %d\n",(num1-num2)*(num2+num3)*(num3%num1));
return 0;
}
/*
10
20
30
result is 0
*/
* ์ถ์ฒ) ์ค์ฑ์ฐ <์ดํ Cํ๋ก๊ทธ๋๋ฐ>
* ์ฐ์ฐ์ ์ฐ์ ์์ ํ ์ถ์ฒ) https://marinelifeirony.tistory.com/12
'C, C++ > Fundamentals' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
C Basics 5/ (์ดํ ํ๋ก๊ทธ๋๋ฐ) (0) | 2023.07.26 |
---|---|
C Basics 4/ (์ดํ ํ๋ก๊ทธ๋๋ฐ) (0) | 2023.07.05 |
C Basics 3/ (์ดํ Cํ๋ก๊ทธ๋๋ฐ) (0) | 2023.06.27 |
C Basics 2/ (์ดํ Cํ๋ก๊ทธ๋๋ฐ) (0) | 2023.06.26 |
C fundamentals (1) (1) | 2023.06.16 |
๋๊ธ