๊ณผ์ฐ ์ค๊ธฐ๋ ๋ช ํธ์ ๋ถ์๊น? ์๊ฐํ๊ธฐ ์ซ๋ค..

โกํ๋ก ํธ์๋ ๊ฐ๋ณด๊ธฐ ํด๋ณธ ์ฝ๋ฉ๋ฐ๋ณด๋ฅผ ์ํ React๋ก C์ธ์ด ์ดํดํ ๋ด์ฉ ์ ์ด๋ณด๊ธฐ
1. #include <stdio.h> == import React from 'react'
๋งจ ์์ค ์ํธ๋ฌธ์ ๊ฑ ๋จ์ด ๋ง๋ ๋๊ตฌ์์ ์ํฌํธ ํด์ค๋ ๊ฑฐ๋ค.
๋ฆฌ์กํธ์์ ์ปดํฌ๋ํธ๋ฅผ ๋ง๋ค๊ธฐ ์ ์ ์ธ๋ถ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ํ ์ ๋ถ๋ฌ์ค๋ import ๋ฌธ๋ฒ๊ณผ ์์ ํ ๊ฐ์ ์ญํ .
stdio.h๋ผ๋ ๊ฑด '์คํ ๋ค๋ ์ธํ ์์ํ'์ ์ฝ์๋ก, ํ๋ฉด์ ๊ธ์๋ฅผ ๋์ฐ๊ธฐ(printf) ์ํด ๋จ์ด ๋ฏธ๋ฆฌ ๋ง๋ค์ด๋ ๊ธฐ๋ณธ ๋๊ตฌ์์๋ฅผ ๋ด ํ์ผ๋ก ์ํฌํธํด์ค๋ ๊ณผ์
2. int main() { ... } == function App() { ... }
์ต์์ App ์ปดํฌ๋ํธ๋ ๊ฐ์ ๊ธฐ๋ฅ(?)
์ฝ๋๊ฐ ๋ช ์ค์ด๊ฑด ์ปดํจํฐ๋ ๋ฌด์กฐ๊ฑด main์ผ๋ก ์ง์งํด์ ์์์ ์๋๋ก ์ฝ์ด๋ด๋ฆผ. ํ๋ก๊ทธ๋จ ์ง์ ์ ์ฒ๋ผ ๋์.
3. ๋ณ์ ์ ์ธ๋ถ (int a = 1;) == ์ํ๊ฐ ์ด๊ธฐํ (useState ๋๋ let a = 1;)
๋ฉ์ธ ํจ์ ์ด๋ฆฌ์๋ง์ ๋ณ์๋ถํฐ ๊น๋ ๊ฑด ์ปดํฌ๋ํธ ์ต์๋จ์์ ์ํ๊ฐ ์ธํ ํ๋ ๊ฑฐ๋ ๊ฐ๋ค.
์ํ ๋ฌธ์ ์์ 'x=1, y=2์ผ ๋...' ํ๊ณ ์กฐ๊ฑด์ ๋์ ธ์ฃผ๋ ๊ฑฐ์.
4. ๋ณธ๊ฒฉ์ ์ธ ๋ก์ง (for, if ๋ฑ) == ์ปดํฌ๋ํธ ๋ด๋ถ์ ๋น์ฆ๋์ค ๋ก์ง
์ด๊ธฐ๊ฐ ์ธํ ๋๋ฌ์ผ๋ฉด for๋ฌธ, if๋ฌธ ๋๋ ค์ ๋ฐ์ดํฐ ์๋ฆฌํ๋ ๊ตฌ๊ฐ์ด๋ค.
๋ฆฌ์กํธ์์ ๋ ๋๋งํ๊ธฐ ์ ์ ๋ฐ์ดํฐ ํํฐ๋งํ๊ณ ๊ฒฐ๊ณผ๊ฐ ๋ฝ์๋ด๋ ๊ฑฐ๋ ๋๊ฐ์. for๋ฌธ์ผ๋ก ๋ ธ๊ฐ๋ค ๋ฐ๋ณต ๋๋ฆฌ๊ณ , if๋ฌธ์ผ๋ก ์กฐ๊ฑด์ ๋ฐ์ ธ๊ฐ๋ฉฐ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๊ณตํ๋ค. ๋ฆฌ์กํธ ์ปดํฌ๋ํธ ์์์ map()์ ๋๋ฆฌ๊ฑฐ๋ ํน์ ์กฐ๊ฑด์ ๋ฐ๋ผ ๋ฐ์ดํฐ๋ฅผ ํํฐ๋งํ์ฌ ์ฐ๋ฆฌ๊ฐ ์ํ๋ ์ต์ข ๊ฒฐ๊ณผ๊ฐ์ ๋ง๋ค์ด๋ด๋ ์ค์ง์ ์ธ ์์ ๊ณต๊ฐ์ด๋ค.
5. printf(...) == return ( <div>...</div> )
๋ก์ง ๋ค ๋๋ ค์ ๊ฒฐ๊ณผ ๋์์ผ๋ฉด ํ๋ฉด์ ๋์์ผ์ฃ ~?
๋ฆฌ์กํธ๊ฐ return์ผ๋ก ๋ทฐ ๋ ๋๋งํ๋ฏ, C์ธ์ด๋ printf๋ก ์ฝ์์ ์ถ๋ ฅํ๋ค.
์์ฝ: ์ํฌํธ -> App ์ด๊ธฐ -> ์ํ ์ธํ -> ๋ก์ง ์์ฑ -> ๋ ๋๋ง.
- ๋๊ตฌ ์ํฌํธํ๊ธฐ (#include)
- ๋ฉ์ธ ์ปดํฌ๋ํธ ์ด๊ธฐ (main())
- ์ด๊ธฐ ์ํ๊ฐ ์ธํ (int ๋ณ์ = ์ด๊ธฐ๊ฐ)
- ๋ฐ์ดํฐ ๊ฐ๊ณต ๋ก์ง ๋๋ฆฌ๊ธฐ (for, if)
- ํ๋ฉด์ ๋ ๋๋งํ๊ธฐ (printf)
...์ ๋ฏธ๋์ด ํผ์ (์ ๋ขฐ๋ ๊ธํ๋ฝ), "์ค๊ธฐ ์ํ์ ๋ฌด์กฐ๊ฑด, 1000% ๋์ค๋ C์ธ์ด ํต์ฌ ํจํด 3๊ฐ์ง"
๐ฅ ํจํด 1: ์ง์/ํ์ ๊ณจ๋ผ์ ๋ฐ๊ตฌ๋์ ๋ด๊ธฐ (๋ฐ๋ณต๋ฌธ + ์กฐ๊ฑด๋ฌธ)
์ถ์ ํฌ์ธํธ: "๋ฐ๋ณต๋ฌธ ๋๋ฆฌ๋ฉด์ ํน์ ์กฐ๊ฑด์ผ ๋๋ง ๋ณ์์ ๊ฐ์ ๋์ ํ ์ ์๋๊ฐ?"
#include <stdio.h> // React์ 'import React' ์ฒ๋ผ, C์ธ์ด ๊ธฐ๋ณธ ๊ธฐ๋ฅ(printf ๋ฑ)์ ๊ฐ์ ธ์ค๋ ์ฃผ๋ฌธ
int main() { // App() ์ปดํฌ๋ํธ ์์! C์ธ์ด๋ ๋ฌด์กฐ๊ฑด main ์์์ ์คํ๋ผ.
// 1. ์ด๊ธฐ ์ธํ
(JS์ let sum = 0; let i; ์ ๊ฐ์)
int sum = 0; // ๊ฒฐ๊ณผ๋ฅผ ์ฐจ๊ณก์ฐจ๊ณก ๋ด์ ๋น ๋ฐ๊ตฌ๋ ์ค๋น
int i; // ๋ฐ๋ณต๋ฌธ์ ๋๋ฆฌ๊ธฐ ์ํ ์นด์ดํฐ ๋ณ์
// 2. ๋ณธ๊ฒฉ์ ์ธ ๋ก์ง (for๋ฌธ)
// i๊ฐ 1๋ถํฐ ์์ํด์, 10๋ณด๋ค ์๊ฑฐ๋ ๊ฐ์ ๋๊น์ง, 1์ฉ ์ฆ๊ฐ(i++)ํ๋ฉด์ ๋น๊ธ๋น๊ธ ๋๋ค!
for(i = 1; i <= 10; i++) {
// i๋ฅผ 2๋ก ๋๋ ๋๋จธ์ง(%)๊ฐ 0์ด๋ผ๋ฉด? -> ์ฆ, "์ง์๋ผ๋ฉด!"
if(i % 2 == 0) {
sum = sum + i; // ๋ด ๋ฐ๊ตฌ๋(sum)์ ๊ทธ ์ง์(i)๋ฅผ ๋ํด์ ๋ค์ ๋ฃ์ด๋ผ.
}
}
// 3. ํ๋ฉด์ ์ถ๋ ฅ (React์ return)
// %d๋ "์ด ์๋ฆฌ์ ์ ์(์ซ์)๋ฅผ ๋ฃ์ด๋ผ"๋ ๋ป์ ์๋ฆฌ ํ์์์ผ. ๊ทธ ๋ค์ sum์ ์ฐ๊ฒฐํด์ค.
printf("%d", sum);
return 0; // ํ๋ก๊ทธ๋จ ๋ฌด์ฌํ ๋๋ฌ์! (main ์ข
๋ฃ)
}
๐ ํฌ์ธํธ: "%๋ ๋๋จธ์ง ๊ตฌํ๋ ๊ฑฐ๋๊น 2๋ก ๋๋ ์ 0์ด๋ฉด ์ง์.
๊ทธ๊ฑธ ๋ฐ๊ตฌ๋(sum)์ ๊ณ์ ๋ํ๋ค"
๐ฅ ํจํด 2: ํฌ์ธํฐ ๊ธฐ์ด (์ด๊ฒ๋ง ์๋ฉด ํฌ์ธํฐ ์ ๋ฌด์์)
์ถ์ ํฌ์ธํธ: "ํฌ์ธํฐ ๊ธฐํธ *์ ์ฃผ์ ๊ธฐํธ &์ ์ฐจ์ด๋ฅผ ์๋๊ฐ?"
#include <stdio.h>
int main() {
// 1. ์ด๊ธฐ ์ธํ
int a = 10; // a๋ผ๋ ์ด๋ฆ์ ์์๋ฅผ ๋ง๋ค๊ณ 10์ ๋ฃ์ (์ผ๋ฐ ๋ณ์)
// ํต์ฌ!! int *p ๋ "๋๋ ์ฃผ์๋ง ๋ด๋ ํน์ ๋ณ์(ํฌ์ธํฐ)์ผ!" ๋ผ๊ณ ์ ์ธํ๋ ๊ฒ.
// &a ๋ "a ์์๊ฐ ์๋ ์ง ์ฃผ์"๋ฅผ ๋ปํจ.
// ์ฆ, p๋ผ๋ ํฌ์ธํฐ์ a์ ์ง ์ฃผ์๋ฅผ ์๋ ค์ค. (p๋ ์ด์ a๋ค ์ง์ด ์ด๋์ง ์๋ค!)
int *p = &a;
// 2. ๋ณธ๊ฒฉ์ ์ธ ๋ก์ง
// ๊ทธ๋ฅ p๋ '์ง ์ฃผ์'์ง๋ง, ์์ *์ ๋ถ์ธ *p ๋ "๊ทธ ์ง ์ฃผ์๋ก ์ณ๋ค์ด๊ฐ์ ๋ด์ฉ๋ฌผ์ ๊ฑด๋๋ ค๋ผ!"๋ ๋ป.
// ์ฆ, a๋ค ์ง์ผ๋ก ์ณ๋ค์ด๊ฐ์ 10์ 20์ผ๋ก ๋ฐ๊ฟ๋ฒ๋ฆผ!
*p = 20;
// 3. ์ถ๋ ฅ
// ๋ถ๋ช
์์์ a = 10 ์ด๋ผ๊ณ ํ์ง๋ง, *p ๊ฐ ๋ชฐ๋ ์ณ๋ค์ด๊ฐ์ 20์ผ๋ก ๋ฐ๊ฟจ์ผ๋ฏ๋ก 20์ด ์ถ๋ ฅ๋จ!
printf("%d", a);
return 0;
}
๐ ๊น์ง ํฌ์ธํธ: "&๋ ์ง ์ฃผ์! *๋ ๊ทธ ์ง ๋ฌธ ๋ฐ๊ณ ๋ค์ด๊ฐ์ ๋ฌผ๊ฑด ๊บผ๋ด๊ธฐ!
*p = 20 ํ๋๊น ์๋ณธ a๊ฐ 20์ผ๋ก ๋ฐ๋๋๊ตฌ๋!"
๐ฅ ํจํด 3: ๋ฐฐ์ด๊ณผ ํฌ์ธํฐ ์ฝค๋ณด (์ค๊ธฐ ๋จ๊ณจ 1์์)
์ถ์ ํฌ์ธํธ: "๋ฐฐ์ด์ ์ด๋ฆ์ด ๊ณง ์ฒซ ๋ฒ์งธ ์นธ์ ์ฃผ์๋ผ๋ ๊ฑธ ์๋๊ฐ? ์ฃผ์์ +1์ ํ๋ฉด ์ด๋ป๊ฒ ๋๋๊ฐ?"
#include <stdio.h>
int main() {
// 1. ์ด๊ธฐ ์ธํ
(JS์ const arr = [10, 20, 30]; ๊ณผ ๊ฐ์)
int arr[3] = {10, 20, 30};
// C์ธ์ด์์ "๋ฐฐ์ด์ ์ด๋ฆ(arr)"์ ๋ฌด์กฐ๊ฑด "๋ฐฐ์ด์ ์ฒซ ๋ฒ์งธ ์นธ(10)์ ์ง ์ฃผ์"๋ ๋๊ฐ์!
// ๊ทธ๋์ & ๊ธฐํธ ์์ด ๊ทธ๋ฅ int *p = arr; ๋ผ๊ณ ์จ๋ p๊ฐ arr์ ์ฒซ ์ฃผ์๋ฅผ ์๊ฒ ๋จ.
int *p = arr;
// 2. ๋ก์ง & ์ถ๋ ฅ (์ด ์ค์ด ์ํ์ 99% ๋์ด)
// p๋ ํ์ฌ ์ฒซ ๋ฒ์งธ ์นธ(10)์ ์ฃผ์์ผ.
// p + 1 ์? "์ฃผ์๋ฅผ ํ ์นธ ์์ผ๋ก ์ด๋ํด๋ผ!" -> ์ฆ, ๋ ๋ฒ์งธ ์นธ(20)์ ์ฃผ์๊ฐ ๋จ.
// *(p + 1) ์? "๊ทธ ๋ ๋ฒ์งธ ์นธ ์ฃผ์๋ก ๋ฌธ ๋ฐ๊ณ ๋ค์ด๊ฐ์ ๊ฐ์ ๊บผ๋ด๋ผ!" -> 20์ด ๋์ด.
// ๊ฒฐ๊ตญ 20 + 5 ๋ฅผ ํ๋ผ๋ ๋ป์ด๋๊น 25๊ฐ ๋จ!
printf("%d", *(p + 1) + 5);
return 0;
}
๐ ๊น์ง ํฌ์ธํธ: "๋ฐฐ์ด ์ด๋ฆ์ ๊ณง ์ฒซ ๋ฒ์งธ ์ฃผ์! p + 1 ํ๋ฉด ๋ค์ ์นธ์ผ๋ก ์ด๋!
๊ดํธ ์น๊ณ ์์ * ๋ถ์ด์์ผ๋ฉด ๊ฑฐ๊ธฐ๋ก ์ณ๋ค์ด๊ฐ์ ์ซ์ ๊บผ๋ด๊ธฐ!"
๐ก ์์ฝ
- %d: Decimal(์ ์). ์ซ์ ์ถ๋ ฅํ ๋ ์.
- %s: String(๋ฌธ์์ด). ๋จ์ด ์ถ๋ ฅํ ๋ ์.
- &: ์ฐํผ์๋๋ "์ฃผ์ํ(Address)".
- *: ๋ณํ๋ "๊ทธ ์ฃผ์๋ก ์ณ๋ค์ด๊ฐ๊ธฐ(Value)".
- p + 1: ๋ฐฐ์ด์์ ํ ์นธ(์ธ๋ฑ์ค 1) ์์ผ๋ก ์ด๋ํ๊ธฐ. (arr[1]์ด๋ ์๋ฒฝํ ๊ฐ์ ๋ป)