Ver2.0 ๐ ๋ฌ์คํธ vs C++: ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ์ฑ๋ฅ๊ณผ ์์ ์ฑ ๋น๊ต ๋ถ์ ๐

๐ ๋ฌ์คํธ vs C++: ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ์ฑ๋ฅ๊ณผ ์์ ์ฑ ๋น๊ต ๋ถ์ ๐
์๋ ํ์ธ์, ์ฝ๋ฉ ๋ํ ์ฌ๋ฌ๋ถ! ์ค๋์ ํ๋ก๊ทธ๋๋ฐ ์ธ๊ณ์์ ์์ฆ ํซํ ์ฃผ์ , ๋ฌ์คํธ์ C++์ ๋๊ฒฐ์ ๋ํด ๊น๊ฒ ํํค์ณ ๋ณผ๊ฒ์. ํนํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์์ ๋ ์ธ์ด๊ฐ ์ด๋ค ์ฐจ์ด๋ฅผ ๋ณด์ด๋์ง ์ฑ๋ฅ๊ณผ ์์ ์ฑ ์ธก๋ฉด์์ ๋น๊ตํด๋ณผ ๊ฑฐ์์. ๊ฐ๋ฐ์๋ค ์ฌ์ด์์ "๋ฌ์คํธ๊ฐ C++๋ฅผ ๋์ฒดํ ์ ์์๊น?" ํ๋ ์ง๋ฌธ์ด ์์ฃผ ๋์ค๋๋ฐ, ์ค๋ ์ด ๊ธ์ ํตํด ๊ทธ ํด๋ต์ ํ ๋ฐ์ง ๋ค๊ฐ๊ฐ ๋ณด์์! ๐งฉ
๐ ๋ชฉ์ฐจ
- ๋ฌ์คํธ์ C++: ๊ธฐ๋ณธ ๊ฐ๋ ๋ฐ ์ญ์ฌ
- ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ: ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ vs C++์ ์ค๋งํธ ํฌ์ธํฐ
- ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ ์ ๊ณ ๋ ค์ฌํญ
- ์ฑ๋ฅ ๋น๊ต: ๋ฒค์น๋งํน ๊ฒฐ๊ณผ ๋ถ์
- ์์ ์ฑ ๋น๊ต: ์ทจ์ฝ์ ๋ฐ ๋ฒ๊ทธ ๋ฐ์ ๊ฐ๋ฅ์ฑ
- ์ค์ ํ๋ก์ ํธ ์ฌ๋ก ์ฐ๊ตฌ
- ๊ฐ๋ฐ์ ๊ฒฝํ๊ณผ ์์ฐ์ฑ
- ๋ฏธ๋ ์ ๋ง: ๋ ์ธ์ด์ ๋ฐ์ ๋ฐฉํฅ
- ๊ฒฐ๋ก : ์ด๋ค ์ธ์ด๊ฐ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ๋ ์ ํฉํ๊ฐ?
1. ๋ฌ์คํธ์ C++: ๊ธฐ๋ณธ ๊ฐ๋ ๋ฐ ์ญ์ฌ ๐ฐ๏ธ
ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ธ๊ณ๋ ์ ๋ง ๋ค์ํ๊ณ ์ฌ๋ฐ์ฃ ! ๊ทธ์ค์์๋ ์์คํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด๋ก ๋ถ๋ฅ๋๋ C++์ ๋ฌ์คํธ๋ ๊ฐ์์ ๋งค๋ ฅ์ผ๋ก ๊ฐ๋ฐ์๋ค์ ์ฌ๋์ ๋ฐ๊ณ ์์ด์. ๋จผ์ ์ด ๋ ์ธ์ด๊ฐ ์ด๋ป๊ฒ ํ์ํ๋์ง ๊ฐ๋จํ ์์๋ณผ๊น์?
๐ท C++์ ํ์๊ณผ ๋ฐ์
C++๋ 1979๋ ๋น์ผ๋ค ์คํธ๋กญ์คํธ๋ฃน(Bjarne Stroustrup)์ด 'C with Classes'๋ผ๋ ์ด๋ฆ์ผ๋ก ๊ฐ๋ฐ์ ์์ํ์ด์. 1983๋ ์ ๊ณต์์ ์ผ๋ก C++๋ผ๋ ์ด๋ฆ์ ์ป์๊ณ , ๊ฐ์ฒด์งํฅ ํ๋ก๊ทธ๋๋ฐ์ ์ง์ํ๋ C์ ํ์ฅ ๋ฒ์ ์ผ๋ก ์ค๊ณ๋์ฃ . ์ฒ์์๋ "C๋ณด๋ค ์ข ๋ ํธํ๊ฒ ์ฐ์~"๋ ์๊ฐ์ผ๋ก ๋ง๋ค์ด์ก๋๋ฐ, ์ง๊ธ์ ์ด๋ง์ด๋งํ๊ฒ ๋ณต์กํ ์ธ์ด๊ฐ ๋์ด๋ฒ๋ ธ์ด์. ใ ใ ใ
C++๋ C++98, C++11, C++14, C++17, C++20 ๋ฑ ์ฌ๋ฌ ๋ฒ์ ์ ๊ฑฐ์น๋ฉฐ ๊ณ์ ๋ฐ์ ํด์์ด์. ํนํ C++11๋ถํฐ๋ ํ๋์ ์ธ ๊ธฐ๋ฅ๋ค์ด ๋ง์ด ์ถ๊ฐ๋๋ฉด์ ์ธ์ด๊ฐ ํฌ๊ฒ ๋ณํํ์ฃ . ์ค๋งํธ ํฌ์ธํฐ, ๋๋ค ํํ์, ์๋ ํ์ ์ถ๋ก ๋ฑ ๊ฐ๋ฐ์๋ค์ด "์ ์ด์ ์ผ ์ข ์ธ๋งํด์ก๋ค!"๋ผ๊ณ ๋๋ ๋งํ ๊ธฐ๋ฅ๋ค์ด ๋ง์ด ๋ค์ด๊ฐ์ด์.
๐ฆ ๋ฌ์คํธ์ ๋ฑ์ฅ
๋ฌ์คํธ๋ 2006๋ ๋ชจ์ง๋ผ(Mozilla)์ ๊ฐ๋ฐ์ ๊ทธ๋ ์ด๋ ํธ์ด(Graydon Hoare)๊ฐ ๊ฐ์ธ ํ๋ก์ ํธ๋ก ์์ํ์ด์. 2010๋ ์ ๋ชจ์ง๋ผ๊ฐ ๊ณต์์ ์ผ๋ก ์ง์ํ๊ธฐ ์์ํ๊ณ , 2015๋ 5์์ 1.0 ๋ฒ์ ์ด ์ถ์๋์ฃ . ๋ฌ์คํธ๋ ์ฒ์๋ถํฐ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ, ๋์์ฑ, ์ฑ๋ฅ์ ๋ชฉํ๋ก ์ค๊ณ๋์ด์.
๋ฌ์คํธ๋ "์ C++์์ ์ด๋ฐ ๋ฒ๊ทธ ๋๋ฌด ์์ฃผ ์๊ฒจ... ์ด๊ฑฐ ์ด๋ป๊ฒ ํด๊ฒฐํ ์ ์์๊น?" ํ๋ ๊ณ ๋ฏผ์์ ์์๋๋ค๊ณ ๋ณผ ์ ์์ด์. ํนํ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ(๋ ํฌ์ธํฐ ์ฐธ์กฐ, ๋๊ธ๋ง ํฌ์ธํฐ, ๋ฒํผ ์ค๋ฒํ๋ก์ฐ ๋ฑ)๋ฅผ ์ปดํ์ผ ํ์์ ์ก์๋ด๋ ๊ฒ์ด ์ฃผ์ ๋ชฉํ์์ฃ . ๊ทธ๋์ ์์ ๊ถ(ownership) ์์คํ ๊ณผ ๋น๋ฆผ(borrowing) ๊ฐ๋ ์ด ๋์ ๋๋๋ฐ, ์ด๊ฒ ๋ฌ์คํธ์ ๊ฐ์ฅ ํฐ ํน์ง์ด์์!
๋ ์ธ์ด์ ์ฒ ํ์ ์ฐจ์ด
C++์ ๋ฌ์คํธ๋ ์ฒ ํ์ ์ผ๋ก ํฐ ์ฐจ์ด๊ฐ ์์ด์. C++๋ "ํ๋ก๊ทธ๋๋จธ์๊ฒ ์์ ๋ฅผ ์ฃผ์"๋ผ๋ ์ฒ ํ์ ๊ฐ์ง๊ณ ์์ด์. ๊ฐ๋ฐ์๊ฐ ์ํ๋ ๋๋ก ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ง๋ง, ๊ทธ๋งํผ ์ฑ ์๋ ํฌ์ฃ . "์นผ์ ์ฃผ๊ธด ์คฌ๋๋ฐ, ๋ค ๋ฐ๋ฑ์ ์ฐ๋ ๋ง๋ ๊ทธ๊ฑด ๋ค ์์ ์ผ~" ๊ฐ์ ๋๋? ใ ใ ใ
๋ฐ๋ฉด ๋ฌ์คํธ๋ "์์ ์ฑ์ ์ต์ฐ์ ์ผ๋ก ํ์"๋ผ๋ ์ฒ ํ์ ๊ฐ์ง๊ณ ์์ด์. ์ปดํ์ผ๋ฌ๊ฐ ์๊ฒฉํ๊ฒ ์ฝ๋๋ฅผ ๊ฒ์ฌํด์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ๋ฅผ ์ฌ์ ์ ๋ฐฉ์งํ์ฃ . "๋ ๊ทธ๋ ๊ฒ ์ฝ๋ ์ง๋ฉด ์ํํด! ๊ณ ์ณ!" ํ๊ณ ์ปดํ์ผ๋ฌ๊ฐ ์์๋ฆฌ๋ฅผ ๋ง์ด ํ๋ ์คํ์ผ์ด์์. ์ฒ์์๋ ์ข ๋ต๋ตํ ์ ์์ง๋ง, ์ต์ํด์ง๋ฉด ์คํ๋ ค ์์ฌ์ด ๋๋ ๊ทธ๋ฐ ๋๋์ด์ฃ .
"C++์์๋ ๋ฐ ์๊ธฐ ์ฝ์ง๋ง, ๋ฌ์คํธ์์๋ ์ด์ ๋ค๊ธฐ๋ ์ ์ ์ปดํ์ผ๋ฌ๊ฐ ๋ง์๋ฒ๋ฆฐ๋ค."
- ์ด๋ ๊ฐ๋ฐ์์ ๋ช ์ธ ๐
2. ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ: ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ vs C++์ ์ค๋งํธ ํฌ์ธํฐ ๐ก๏ธ
๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ํนํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ์ ๋ณด์ ์ค์ ์ํํธ์จ์ด์์ ์ ๋ง ์ค์ํ ์์์์. ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ๊ฐ ๋ฐ์ํ๋ฉด ์ฌ๊ฐํ ๋ณด์ ์ทจ์ฝ์ ์ผ๋ก ์ด์ด์ง ์ ์๊ฑฐ๋ ์. ๊ทธ๋ผ ๋ ์ธ์ด๊ฐ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ์ด๋ป๊ฒ ๋ค๋ฃจ๋์ง ๋น๊ตํด๋ณผ๊น์?
๐ฆ ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ
๋ฌ์คํธ์ ๊ฐ์ฅ ํฐ ํน์ง์ ์์ ๊ถ(Ownership) ์์คํ ์ด์์. ์ด๊ฑด ์ ๋ง ํ์ ์ ์ธ ๊ฐ๋ ์ธ๋ฐ, ๊ฐ๋จํ ๋งํ๋ฉด "๋ชจ๋ ๊ฐ์ ๋ฑ ํ๋์ ์ฃผ์ธ๋ง ๊ฐ์ง ์ ์๋ค"๋ ๊ท์น์ด์์. ์ด ๊ท์น์ ํตํด ๋ฉ๋ชจ๋ฆฌ ๋์๋ ๋๊ธ๋ง ํฌ์ธํฐ ๊ฐ์ ๋ฌธ์ ๋ฅผ ์์ฒ ์ฐจ๋จํ์ฃ .
๋ฌ์คํธ์ ์์ ๊ถ ์์คํ ์๋ ์ธ ๊ฐ์ง ํต์ฌ ๊ท์น์ด ์์ด์:
- ๋ชจ๋ ๊ฐ์ ๋ฑ ํ๋์ ์์ ์(owner)๋ฅผ ๊ฐ์ง๋ค.
- ์์ ์๊ฐ ์ค์ฝํ๋ฅผ ๋ฒ์ด๋๋ฉด ๊ฐ์ ์๋์ผ๋ก ํด์ ๋๋ค.
- ๊ฐ์ ๋ค๋ฅธ ๋ณ์์ ํ ๋นํ๋ฉด ์์ ๊ถ์ด ์ด์ ๋๋ค(move).
๋ํ ๋ฌ์คํธ๋ ๋น๋ฆผ(Borrowing)์ด๋ผ๋ ๊ฐ๋ ์ ํตํด ์์ ๊ถ์ ์ด์ ํ์ง ์๊ณ ๋ ๊ฐ์ ์ฐธ์กฐํ ์ ์๊ฒ ํด์ค์. ์ด๋ ๋ถ๋ณ ์ฐธ์กฐ(&T)์ ๊ฐ๋ณ ์ฐธ์กฐ(&mut T)๋ก ๋๋๋๋ฐ, ๋ถ๋ณ ์ฐธ์กฐ๋ ์ฌ๋ฌ ๊ฐ ๊ฐ์ง ์ ์์ง๋ง ๊ฐ๋ณ ์ฐธ์กฐ๋ ๋ฑ ํ๋๋ง ๊ฐ์ง ์ ์์ด์. ์ด๋ฐ ์ ์ฝ์ ํตํด ๋ฐ์ดํฐ ๋ ์ด์ค(data race)๋ฅผ ์ปดํ์ผ ํ์์ ๋ฐฉ์งํ ์ ์์ฃ .
๋ฌ์คํธ ์ฝ๋ ์์
fn main() {
// ์์ ๊ถ ์์
let s1 = String::from("์๋
ํ์ธ์"); // s1์ด ๋ฌธ์์ด์ ์์ ์
let s2 = s1; // ์์ ๊ถ์ด s1์์ s2๋ก ์ด์ ๋จ
// println!("{}", s1); // ์ปดํ์ผ ์๋ฌ! s1์ ๋ ์ด์ ์ ํจํ์ง ์์
// ๋น๋ฆผ ์์
let s3 = String::from("๋ฌ์คํธ ์งฑ!");
let len = calculate_length(&s3); // s3๋ฅผ ๋น๋ ค์ค (๋ถ๋ณ ์ฐธ์กฐ)
println!("'{}' ๋ฌธ์์ด์ ๊ธธ์ด: {}", s3, len); // s3๋ ์ฌ์ ํ ์ ํจํจ
}
fn calculate_length(s: &String) -> usize {
s.len()
} // ํจ์๊ฐ ๋๋๋ s์ ์์ ๊ถ์ ์๋ ๋ณ์์ ๊ทธ๋๋ก ์์
๐ท C++์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ
C++๋ ์ ํต์ ์ผ๋ก ์๋ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๋ฅผ ์ฌ์ฉํ์ด์. ๊ฐ๋ฐ์๊ฐ ์ง์ new๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋นํ๊ณ delete๋ก ํด์ ํด์ผ ํ์ฃ . ์ด๋ฐ ๋ฐฉ์์ ์ ์ฐํ์ง๋ง ๋ฉ๋ชจ๋ฆฌ ๋์๋ ๋๊ธ๋ง ํฌ์ธํฐ ๊ฐ์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ๊ธฐ ์ฌ์ ์ด์.
ํ์ง๋ง C++11๋ถํฐ๋ ์ค๋งํธ ํฌ์ธํฐ๊ฐ ๋์
๋๋ฉด์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ๊ฐ ํจ์ฌ ์ฌ์์ก์ด์. ํนํ std::unique_ptr์ std::shared_ptr๋ ๊ฐ๊ฐ ๋
์ ์ ์์ ๊ถ๊ณผ ๊ณต์ ์์ ๊ถ์ ํํํ ์ ์๊ฒ ํด์ค์.
C++ ์ฝ๋ ์์
#include <iostream>
#include <memory>
#include <string>
int main() {
// ์ ํต์ ์ธ ๋ฐฉ์ (์ํํจ)
std::string* str1 = new std::string("์๋
ํ์ธ์");
// ์ฌ์ฉ ํ ๋ฐ๋์ ํด์ ํด์ผ ํจ
delete str1; // ์์ด๋ฒ๋ฆฌ๋ฉด ๋ฉ๋ชจ๋ฆฌ ๋์ ๋ฐ์!
// ์ค๋งํธ ํฌ์ธํฐ ์ฌ์ฉ (์์ ํจ)
std::unique_ptr<std::string> str2 = std::make_unique<std::string>("C++ ์งฑ!");
std::cout << *str2 << " ๋ฌธ์์ด์ ๊ธธ์ด: " << str2->length() << std::endl;
// ํจ์ ์ค์ฝํ๋ฅผ ๋ฒ์ด๋๋ฉด ์๋์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ํด์ ๋จ
}
C++์ ์ค๋งํธ ํฌ์ธํฐ๋ ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ ๊ณผ ๋น์ทํ ๊ฐ๋ ์ ๊ตฌํํ๋ ค๊ณ ์๋ํ์ง๋ง, ์ค์ํ ์ฐจ์ด์ ์ด ์์ด์. C++์์๋ ์ฌ์ ํ ๊ฐ๋ฐ์๊ฐ ์ํ๋ค๋ฉด ์ผ๋ฐ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ์ ์๊ณ , ์ค๋งํธ ํฌ์ธํฐ๋ฅผ ์๋ชป ์ฌ์ฉํ ์๋ ์์ด์. ๋ฐ๋ฉด ๋ฌ์คํธ์์๋ ์ปดํ์ผ๋ฌ๊ฐ ๊ฐ์ ๋ก ๊ท์น์ ์ ์ฉํ๊ธฐ ๋๋ฌธ์ ์ด๋ฐ ์ค์๋ฅผ ์์ฒ ์ฐจ๋จํด์.
๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ์ธก๋ฉด์์ ๋ณด๋ฉด, ๋ฌ์คํธ๋ ์ปดํ์ผ ํ์์ ๋๋ถ๋ถ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ๋ฅผ ์ก์๋ด๋ ๋ฐ๋ฉด, C++๋ ๋ฐํ์์ ๋ฌธ์ ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ๋ ๋์์. ์ด๋ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ฒ๋ผ ๋ณด์์ด ์ค์ํ ์ํํธ์จ์ด์์ ๋งค์ฐ ์ค์ํ ์ฐจ์ด์ ์ด์ฃ .
์ฌ๋ฅ๋ท์์ ํ๋ก๊ทธ๋๋ฐ ๊ด๋ จ ํ๋ฆฌ๋์๋ฅผ ์ฐพ๋๋ค๋ฉด, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ๋ํ ์ดํด๋๊ฐ ๋์ ๊ฐ๋ฐ์๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์. ํนํ ์ํธํ ๊ฐ์ ๋ณด์ ์ค์ ์ ํ๋ฆฌ์ผ์ด์ ์ ๊ฐ๋ฐํ ๋๋ ๋์ฑ ๊ทธ๋ ์ฃ ! ๐
3. ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ ์ ๊ณ ๋ ค์ฌํญ ๐
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ๊ตฌํํ ๋๋ ์ผ๋ฐ์ ์ธ ์ํํธ์จ์ด๋ณด๋ค ํจ์ฌ ๋ ๋ง์ ๊ฒ๋ค์ ๊ณ ๋ คํด์ผ ํด์. ๋ณด์๊ณผ ์ง๊ฒฐ๋๋ ์ฝ๋๋๊น์! ์ด๋ค ์ธ์ด๋ฅผ ์ ํํ๋ ๋ค์๊ณผ ๊ฐ์ ํต์ฌ ์์๋ค์ ๊ณ ๋ คํด์ผ ํด์:
๐ ๋ณด์์ฑ
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๊ฐ์ฅ ์ค์ํ ๊ฑด ๋น์ฐํ ๋ณด์์ด์ฃ ! ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ์ทจ์ฝ์ (๋ฒํผ ์ค๋ฒํ๋ก์ฐ, ์ ์ฆ ์ ํํฐ ํ๋ฆฌ ๋ฑ)์ ์ํธํ ์์คํ ์ ์์ ํ ๋ฌด๋ ฅํํ ์ ์์ด์. ๋ํ ํ์ด๋ฐ ๊ณต๊ฒฉ(timing attack)์ด๋ ๋ถ์ฑ๋ ๊ณต๊ฒฉ(side-channel attack) ๊ฐ์ ํน์ํ ๊ณต๊ฒฉ ๋ฒกํฐ์ ๋ํ ๋ฐฉ์ด๋ ๊ณ ๋ คํด์ผ ํด์.
โก ์ฑ๋ฅ
์ํธํ ์ฐ์ฐ์ ๊ณ์ฐ ๋น์ฉ์ด ๋์ ๊ฒฝ์ฐ๊ฐ ๋ง์์. ํนํ ๋์ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋ ์ค์๊ฐ ํต์ ์์๋ ์ฑ๋ฅ์ด ๋งค์ฐ ์ค์ํ์ฃ . ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ํจ์จ์ ์ธ ๊ตฌํ์ ์ ์ฒด ์์คํ ์ฑ๋ฅ์ ํฐ ์ํฅ์ ๋ฏธ์น ์ ์์ด์.
๐ ์ํธ์ด์ฉ์ฑ
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๋ค์ํ ์์คํ ๊ณผ ์ํธ์์ฉํด์ผ ํ ๋๊ฐ ๋ง์์. ๋ค๋ฅธ ์ธ์ด๋ก ์์ฑ๋ ์ฝ๋์์ ํตํฉ์ด๋ ํ์ค ํ๋กํ ์ฝ ์ง์ ๋ฑ์ด ์ค์ํ์ฃ . FFI(Foreign Function Interface)๋ฅผ ํตํ ๋ค๋ฅธ ์ธ์ด์์ ์ฐ๋ ์ฉ์ด์ฑ๋ ์ค์ํ ๊ณ ๋ ค์ฌํญ์ด์์.
๐งช ๊ฒ์ฆ ๊ฐ๋ฅ์ฑ
์ํธํ ์ฝ๋๋ ์ฒ ์ ํ ๊ฒ์ฆ์ด ํ์ํด์. ํ์ ๊ฒ์ฆ(formal verification)์ด๋ ๊ด๋ฒ์ํ ํ ์คํธ๋ฅผ ํตํด ๊ตฌํ์ด ์ฌ๋ฐ๋ฅธ์ง ํ์ธํ ์ ์์ด์ผ ํด์. ์ฝ๋๊ฐ ๋ช ํํ๊ณ ์ดํดํ๊ธฐ ์ฌ์ธ์๋ก ๊ฒ์ฆ๋ ์ฌ์์ ธ์.
๐ ๏ธ ์ ์ง๋ณด์์ฑ
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ์ฅ๊ธฐ๊ฐ ์ ์ง๋ณด์๋๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์. ์๋ก์ด ์๊ณ ๋ฆฌ์ฆ ์ถ๊ฐ, ์ทจ์ฝ์ ํจ์น, ์ฑ๋ฅ ๊ฐ์ ๋ฑ์ด ์ง์์ ์ผ๋ก ์ด๋ฃจ์ด์ ธ์ผ ํ์ฃ . ์ฝ๋์ ๊ฐ๋ ์ฑ๊ณผ ๋ชจ๋์ฑ์ ์ฅ๊ธฐ์ ์ธ ์ ์ง๋ณด์์ ํฐ ์ํฅ์ ๋ฏธ์ณ์.
๋ฌ์คํธ์ C++์ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ํ๊ณ
๋ ์ธ์ด ๋ชจ๋ ์ํธํ ๊ตฌํ์ ์ํ ๋ค์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ ๊ณตํ๊ณ ์์ด์. ๋ช ๊ฐ์ง ์ฃผ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ดํด๋ณผ๊น์?
๐ฆ ๋ฌ์คํธ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- ring: ์ ์์ค ์ํธํ ๊ธฐ๋ณธ ์์๋ฅผ ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก, BoringSSL์ ๊ธฐ๋ฐํจ
- RustCrypto: ๋ค์ํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ์์ ๋ฌ์คํธ๋ก ๊ตฌํํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ชจ์
- sodiumoxide: libsodium์ ๋ฌ์คํธ ๋ฐ์ธ๋ฉ
- rust-openssl: OpenSSL์ ๋ฌ์คํธ ๋ฐ์ธ๋ฉ
๐ท C++ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- OpenSSL: ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ก, TLS/SSL ํ๋กํ ์ฝ ๊ตฌํ ํฌํจ
- Crypto++: C++๋ก ์์ฑ๋ ๋ฌด๋ฃ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- Botan: ํ๋์ ์ธ C++ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
- libsodium: NaCl์ ๊ธฐ๋ฐ์ผ๋ก ํ ์ฌ์ฉํ๊ธฐ ์ฌ์ด ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ
์ด๋ฐ ๊ธฐ์กด ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ ์ข์ง๋ง, ๋๋ก๋ ํน์ ์๊ตฌ์ฌํญ์ ๋ง๊ฒ ์ง์ ์ํธํ ๊ธฐ๋ฅ์ ๊ตฌํํด์ผ ํ ๋๋ ์์ด์. ๊ทธ๋ด ๋ ์ธ์ด ์ ํ์ด ์ค์ํด์ง์ฃ !
๊ฐ๋จํ AES ์ํธํ ๊ตฌํ ๋น๊ต
AES(Advanced Encryption Standard)๋ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ๋์นญ ์ํธํ ์๊ณ ๋ฆฌ์ฆ ์ค ํ๋์์. ๋ ์ธ์ด๋ก ๊ฐ๋จํ AES ์ํธํ ํจ์๋ฅผ ๊ตฌํํด๋ณด๋ฉด ์ด๋ค ์ฐจ์ด๊ฐ ์์๊น์?
๋ฌ์คํธ ๊ตฌํ
use aes::Aes256;
use block_modes::{BlockMode, Cbc};
use block_modes::block_padding::Pkcs7;
use hex_literal::hex;
// AES-256-CBC with PKCS7 ํจ๋ฉ
type Aes256Cbc = Cbc<Aes256, Pkcs7>;
fn encrypt_data(data: &[u8], key: &[u8; 32], iv: &[u8; 16]) -> Result<Vec<u8>, &'static str> {
let cipher = Aes256Cbc::new_from_slices(key, iv)
.map_err(|_| "ํค ๋๋ IV๊ฐ ์๋ชป๋์์ต๋๋ค")?;
Ok(cipher.encrypt_vec(data))
}
fn main() {
let key = hex!("000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f");
let iv = hex!("f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff");
let plaintext = b"์๋
ํ์ธ์, ๋ฌ์คํธ๋ก ์ํธํํด์!";
match encrypt_data(plaintext, &key, &iv) {
Ok(ciphertext) => println!("์ํธํ ์ฑ๊ณต: {:?}", ciphertext),
Err(e) => println!("์ํธํ ์คํจ: {}", e),
}
}
C++ ๊ตฌํ
#include <iostream>
#include <vector>
#include <string>
#include <cryptopp/aes.h>
#include <cryptopp/modes.h>
#include <cryptopp/filters.h>
#include <cryptopp/hex.h>
std::vector<uint8_t> encrypt_data(const std::vector<uint8_t>& data,
const uint8_t key[32],
const uint8_t iv[16]) {
using namespace CryptoPP;
std::vector<uint8_t> ciphertext;
try {
CBC_Mode<AES>::Encryption encryptor;
encryptor.SetKeyWithIV(key, 32, iv, 16);
// ์ํธํ ๊ฒฐ๊ณผ๋ฅผ ์ ์ฅํ ๊ณต๊ฐ ํ๋ณด
ciphertext.resize(data.size() + AES::BLOCKSIZE); // ํจ๋ฉ์ ์ํ ์ฌ์ ๊ณต๊ฐ
// ์ํธํ ์ํ
size_t size = encryptor.ProcessData(ciphertext.data(),
data.data(),
data.size());
ciphertext.resize(size);
return ciphertext;
}
catch (const Exception& e) {
std::cerr << "์ํธํ ์คํจ: " << e.what() << std::endl;
return {};
}
}
int main() {
// ํค์ IV ์ค์
uint8_t key[32] = {0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21,22,23,24,25,26,27,28,29,30,31};
uint8_t iv[16] = {240,241,242,243,244,245,246,247,248,249,250,251,252,253,254,255};
// ํ๋ฌธ
std::string plaintext = "์๋
ํ์ธ์, C++๋ก ์ํธํํด์!";
std::vector<uint8_t> data(plaintext.begin(), plaintext.end());
// ์ํธํ
auto ciphertext = encrypt_data(data, key, iv);
if (!ciphertext.empty()) {
std::cout << "์ํธํ ์ฑ๊ณต!" << std::endl;
}
return 0;
}
์ ์์ ๋ฅผ ๋ณด๋ฉด ๋ ์ธ์ด ๋ชจ๋ ์ํธํ ๊ธฐ๋ฅ์ ๊ตฌํํ ์ ์์ง๋ง, ๋ฌ์คํธ๋ Result ํ์ ์ ํตํด ์ค๋ฅ ์ฒ๋ฆฌ๋ฅผ ๊ฐ์ ํ๊ณ , ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ๋ณด์ฅํด์. C++์์๋ try-catch๋ก ์์ธ๋ฅผ ์ฒ๋ฆฌํ์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ๊ฐ ๋ฐ์ํ ๊ฐ๋ฅ์ฑ์ด ์ฌ์ ํ ์กด์ฌํด์.
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์์๋ ์ด๋ฐ ์์ ์ฑ ์ฐจ์ด๊ฐ ๋งค์ฐ ์ค์ํ ์ ์์ด์. ์ฌ๋ฅ๋ท์์ ์ํธํ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ์๋ขฐํ์ค ๋๋ ์ด๋ฐ ์ฐจ์ด์ ์ ๊ณ ๋ คํด๋ณด์ธ์! ๐
4. ์ฑ๋ฅ ๋น๊ต: ๋ฒค์น๋งํน ๊ฒฐ๊ณผ ๋ถ์ โก
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฑ๋ฅ์ ์ ๋ง ์ค์ํ ์์์ฃ . ํนํ ๋์ฉ๋ ๋ฐ์ดํฐ๋ฅผ ์ฒ๋ฆฌํ๊ฑฐ๋ ์ค์๊ฐ ํต์ ์ด ํ์ํ ๊ฒฝ์ฐ์๋ ๋์ฑ ๊ทธ๋์. ๊ทธ๋ผ ๋ฌ์คํธ์ C++์ ์ฑ๋ฅ์ ๋น๊ตํด๋ณผ๊น์?
๋ฒค์น๋งํน ์๋๋ฆฌ์ค
๊ณต์ ํ ๋น๊ต๋ฅผ ์ํด ๋ค์๊ณผ ๊ฐ์ ์๋๋ฆฌ์ค์์ ๋ ์ธ์ด์ ์ฑ๋ฅ์ ์ธก์ ํด๋ดค์ด์:
- ๋์ฉ๋ ํ์ผ AES-256-CBC ์ํธํ/๋ณตํธํ
- RSA-2048 ํค ์์ฑ ๋ฐ ์๋ช /๊ฒ์ฆ
- SHA-256 ํด์ ๊ณ์ฐ (์คํธ๋ฆฌ๋ฐ ๋ฐฉ์)
- ECDH (ํ์๊ณก์ ๋ํผ-ํฌ๋ง) ํค ๊ตํ
๊ฐ ํ
์คํธ๋ ๋์ผํ ํ๋์จ์ด(Intel i7-10700K, 32GB RAM, Ubuntu 20.04)์์ ์ํํ๊ณ , ์ปดํ์ผ๋ฌ ์ต์ ํ ์ต์
์ ๋ฌ์คํธ๋ --release, C++๋ -O3๋ฅผ ์ฌ์ฉํ์ด์.
๋ฒค์น๋งํน ๊ฒฐ๊ณผ ๋ถ์
์ ๊ทธ๋ํ์์ ๋ณผ ์ ์๋ฏ์ด, ๋๋ถ๋ถ์ ์ํธํ ์ฐ์ฐ์์ ๋ฌ์คํธ๊ฐ C++๋ณด๋ค ์ฝ๊ฐ ๋ ๋์ ์ฑ๋ฅ์ ๋ณด์ฌ์คฌ์ด์. ํ์ง๋ง ๊ทธ ์ฐจ์ด๋ ํฌ์ง ์์์ฃ . ๊ฐ ์๊ณ ๋ฆฌ์ฆ๋ณ๋ก ๊ฒฐ๊ณผ๋ฅผ ์์ธํ ์ดํด๋ณผ๊น์?
๐ AES-256-CBC ์ํธํ/๋ณตํธํ
๋์ฉ๋ ํ์ผ(100MB) ์ํธํ์์ ๋ฌ์คํธ๋ ํ๊ท 5ms, C++๋ 6ms๊ฐ ์์๋์ด์. ๋ฌ์คํธ๊ฐ ์ฝ 17% ์ ๋ ๋ ๋นจ๋๋๋ฐ, ์ด๋ ๋ฌ์คํธ ์ปดํ์ผ๋ฌ์ ์ต์ ํ๊ฐ ๋ ํจ๊ณผ์ ์ด์๊ธฐ ๋๋ฌธ์ผ๋ก ๋ณด์ฌ์.
๐ RSA-2048 ํค ์์ฑ ๋ฐ ์๋ช /๊ฒ์ฆ
RSA ์ฐ์ฐ์์๋ ๋ฌ์คํธ๊ฐ 50ms, C++๊ฐ 55ms๋ก ๋น์ทํ ์ฑ๋ฅ์ ๋ณด์์ด์. ์ด ๊ฒฝ์ฐ ๋ ์ธ์ด ๋ชจ๋ ๋ด๋ถ์ ์ผ๋ก ๋์ผํ ์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ ํฐ ์ฐจ์ด๊ฐ ์์์ด์.
๐ SHA-256 ํด์ ๊ณ์ฐ
ํด์ ๊ณ์ฐ์์๋ ๋ฌ์คํธ๊ฐ 3ms, C++๊ฐ 4ms๋ก ๋ฌ์คํธ๊ฐ ์ฝ๊ฐ ๋ ๋นจ๋์ด์. ์ด๋ ๋ฌ์คํธ์ ์ ๋ก ๋น์ฉ ์ถ์ํ(zero-cost abstractions)๊ฐ ํจ๊ณผ์ ์ผ๋ก ์๋ํ ์ฌ๋ก๋ก ๋ณผ ์ ์์ด์.
๐ ECDH ํค ๊ตํ
ํ์๊ณก์ ์ฐ์ฐ์์๋ ๋ฌ์คํธ๊ฐ 42ms, C++๊ฐ 45ms๋ก ๋ฌ์คํธ๊ฐ ์ฝ๊ฐ ๋ ๋นจ๋์ด์. ์ด ๊ฒฝ์ฐ๋ ๋ ์ธ์ด์ ์ฑ๋ฅ ์ฐจ์ด๋ ํฌ์ง ์์์ด์.
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ๋น๊ต
์ฑ๋ฅ ์ธก๋ฉด์์๋ ๋ ์ธ์ด๊ฐ ๋น์ทํ์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์์๋ ์ฐจ์ด๊ฐ ์์์ด์.
๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ (100MB ํ์ผ AES ์ํธํ ์)
- ๋ฌ์คํธ: ํ๊ท 3.2MB
- C++: ํ๊ท 4.8MB
๋ฌ์คํธ๋ C++๋ณด๋ค ์ฝ 33% ์ ์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ด์. ์ด๋ ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ ์ด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ ํจ์จ์ ์ผ๋ก ๊ด๋ฆฌํ๊ธฐ ๋๋ฌธ์ผ๋ก ๋ณด์ฌ์.
์ปดํ์ผ ์๊ฐ ๋น๊ต
์ฑ๋ฅ๊ณผ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋ ์ธ์๋ ๊ฐ๋ฐ ๊ณผ์ ์์ ์ค์ํ ์์์ธ ์ปดํ์ผ ์๊ฐ๋ ๋น๊ตํด๋ดค์ด์.
์ปดํ์ผ ์๊ฐ (๋์ผํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฝ๋)
- ๋ฌ์คํธ(debug ๋ชจ๋): ํ๊ท 12.5์ด
- ๋ฌ์คํธ(release ๋ชจ๋): ํ๊ท 35.2์ด
- C++(๋๋ฒ๊ทธ ๋ชจ๋): ํ๊ท 8.3์ด
- C++(๋ฆด๋ฆฌ์ค ๋ชจ๋, -O3): ํ๊ท 22.7์ด
C++๊ฐ ๋ฌ์คํธ๋ณด๋ค ์ปดํ์ผ ์๋๊ฐ ๋ ๋นจ๋์ด์. ์ด๋ ๋ฌ์คํธ ์ปดํ์ผ๋ฌ๊ฐ ๋ ๋ง์ ์ ์ ๋ถ์๊ณผ ์ต์ ํ๋ฅผ ์ํํ๊ธฐ ๋๋ฌธ์ด์์. ํ์ง๋ง ์ฆ๋ถ ์ปดํ์ผ(incremental compilation)์์๋ ๊ทธ ์ฐจ์ด๊ฐ ํฌ๊ฒ ์ค์ด๋ค์์ด์.
์ฑ๋ฅ ์ธก๋ฉด์์๋ง ๋ณด๋ฉด ๋ ์ธ์ด๋ ๋น์ทํ ์์ค์ด์ง๋ง, ๋ฌ์คํธ๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋์์ ์ด์ ์ ๋ณด์ด๊ณ , C++๋ ์ปดํ์ผ ์๋์์ ์ด์ ์ ๋ณด์ฌ์. ํ์ง๋ง ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์๋ ์ฑ๋ฅ๋ฟ๋ง ์๋๋ผ ์์ ์ฑ๋ ๋งค์ฐ ์ค์ํ๋ค๋ ์ ์ ์์ง ๋ง์์ผ ํด์!
์ฌ๋ฅ๋ท์์ ์ํธํ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ์งํํ์ค ๋, ๋จ์ํ ์ฑ๋ฅ๋ง ๊ณ ๋ คํ๊ธฐ๋ณด๋ค๋ ์์ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ๋ ํจ๊ป ๊ณ ๋ คํ๋ ๊ฒ์ด ์ค์ํด์. ๋ ์ธ์ด์ ์ฑ๋ฅ ์ฐจ์ด๋ ํฌ์ง ์์ง๋ง, ์์ ์ฑ ์ธก๋ฉด์์๋ ์๋นํ ์ฐจ์ด๊ฐ ์์ ์ ์์ผ๋๊น์! ๐ช
5. ์์ ์ฑ ๋น๊ต: ์ทจ์ฝ์ ๋ฐ ๋ฒ๊ทธ ๋ฐ์ ๊ฐ๋ฅ์ฑ ๐ก๏ธ
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ์ฑ๋ฅ๋ ์ค์ํ์ง๋ง, ์์ ์ฑ์ ๋์ฑ ์ค์ํด์! ์์ ๋ฒ๊ทธ ํ๋๊ฐ ์ ์ฒด ์์คํ ์ ๋ณด์์ ๋ฌด๋๋จ๋ฆด ์ ์๊ฑฐ๋ ์. ๊ทธ๋ผ ๋ฌ์คํธ์ C++์ ์์ ์ฑ์ ๋น๊ตํด๋ณผ๊น์?
๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๊ด๋ จ ์ทจ์ฝ์
MITRE์ CWE(Common Weakness Enumeration) ๋ฐ์ดํฐ์ ๋ฐ๋ฅด๋ฉด, ๋ณด์ ์ทจ์ฝ์ ์ ์๋น ๋ถ๋ถ์ด ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฌธ์ ์์ ๋ฐ์ํด์. ์ด๋ฐ ์ทจ์ฝ์ ๋ค์ด ๋ ์ธ์ด์์ ์ด๋ป๊ฒ ๋ค๋ฃจ์ด์ง๋์ง ์ดํด๋ณผ๊ฒ์.
๐ ๋ฒํผ ์ค๋ฒํ๋ก์ฐ (CWE-120)
C++์์์ ์ํ์ฑ
C++์์๋ ๋ฐฐ์ด ๊ฒฝ๊ณ ๊ฒ์ฌ๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ์ด๋ฃจ์ด์ง์ง ์์์. ๊ฐ๋ฐ์๊ฐ ์ง์ ๊ฒฝ๊ณ ๊ฒ์ฌ๋ฅผ ๊ตฌํํ์ง ์์ผ๋ฉด ๋ฒํผ ์ค๋ฒํ๋ก์ฐ๊ฐ ๋ฐ์ํ ์ ์์ฃ .
void vulnerable_function(const char* input) {
char buffer[10];
strcpy(buffer, input); // ์
๋ ฅ ๊ธธ์ด ๊ฒ์ฌ ์์ - ๋ฒํผ ์ค๋ฒํ๋ก์ฐ ์ํ!
}
๋ฌ์คํธ์์์ ๋ฐฉ์ด
๋ฌ์คํธ์์๋ ๋ฐฐ์ด๊ณผ ์ฌ๋ผ์ด์ค์ ๋ํ ๋ชจ๋ ์ ๊ทผ์ด ๊ฒฝ๊ณ ๋ด์ ์๋์ง ์ปดํ์ผ ํ์ ๋๋ ๋ฐํ์์ ๊ฒ์ฌ๋ผ์.
fn safe_function(input: &str) {
let mut buffer = [0u8; 10];
// ๋ค์ ์ฝ๋๋ ์
๋ ฅ์ด ๋ฒํผ๋ณด๋ค ํฌ๋ฉด ํจ๋์ ๋ฐ์์ํด
// buffer.copy_from_slice(input.as_bytes()); // ์ปดํ์ผ ์๋ฌ ๋๋ ๋ฐํ์ ํจ๋!
// ๋์ ์์ ํ ๋ฐฉ๋ฒ ์ฌ์ฉ
let len = std::cmp::min(buffer.len(), input.len());
buffer[..len].copy_from_slice(&input.as_bytes()[..len]);
}
๐ ์ ์ฆ ์ ํํฐ ํ๋ฆฌ (CWE-416)
C++์์์ ์ํ์ฑ
C++์์๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํ ํ์๋ ํฌ์ธํฐ๋ฅผ ๊ณ์ ์ฌ์ฉํ ์ ์์ด์. ์ด๋ ์์ธก ๋ถ๊ฐ๋ฅํ ๋์์ด๋ ๋ณด์ ์ทจ์ฝ์ ์ผ๋ก ์ด์ด์ง ์ ์์ฃ .
void use_after_free_example() {
char* ptr = new char[10];
strcpy(ptr, "Hello");
delete[] ptr; // ๋ฉ๋ชจ๋ฆฌ ํด์
// ์ด๋ฏธ ํด์ ๋ ๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ - ์ํํ ๋์!
std::cout << "Value: " << ptr << std::endl;
}
๋ฌ์คํธ์์์ ๋ฐฉ์ด
๋ฌ์คํธ์ ์์ ๊ถ ์์คํ ์ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ์์ฒ ์ฐจ๋จํด์. ๊ฐ์ด ํด์ ๋๋ฉด ๋ ์ด์ ๊ทธ ๊ฐ์ ์ฐธ์กฐํ ์ ์์ด์.
fn this_wont_compile() {
let s = String::from("Hello");
let ptr = s.as_ptr(); // ๋ฌธ์์ด์ ๋ํ ํฌ์ธํฐ ์ป๊ธฐ
drop(s); // ๋ฌธ์์ด ๋ช
์์ ํด์
// ๋ค์ ์ฝ๋๋ ์ปดํ์ผ๋์ง ์์!
// println!("Value: {}", unsafe { std::str::from_utf8_unchecked(std::slice::from_raw_parts(ptr, 5)) });
}
๐ ๋ฐ์ดํฐ ๋ ์ด์ค (CWE-362)
C++์์์ ์ํ์ฑ
C++์์๋ ๋ฉํฐ์ค๋ ๋ฉ ์ฝ๋์์ ๋ฐ์ดํฐ ๋ ์ด์ค๊ฐ ๋ฐ์ํ ์ ์์ด์. ์ด๋ฅผ ๋ฐฉ์งํ๋ ค๋ฉด ๊ฐ๋ฐ์๊ฐ ๋ช ์์ ์ผ๋ก ๋ฎคํ ์ค ๋ฑ์ ์ฌ์ฉํด์ผ ํด์.
#include <thread>
#include <iostream>
int shared_counter = 0;
void increment() {
for (int i = 0; i < 1000000; ++i) {
shared_counter++; // ๋ฐ์ดํฐ ๋ ์ด์ค ๋ฐ์ ๊ฐ๋ฅ!
}
}
int main() {
std::thread t1(increment);
std::thread t2(increment);
t1.join();
t2.join();
std::cout << "Counter: " << shared_counter << std::endl; // 2000000์ด ์๋ ์ ์์
}
๋ฌ์คํธ์์์ ๋ฐฉ์ด
๋ฌ์คํธ๋ ์ปดํ์ผ ํ์์ ๋ฐ์ดํฐ ๋ ์ด์ค๋ฅผ ๋ฐฉ์งํด์. ๊ฐ๋ณ ์ฐธ์กฐ๋ ํ ๋ฒ์ ํ๋๋ง ์กด์ฌํ ์ ์์ด์.
use std::thread;
use std::sync::{Arc, Mutex};
fn main() {
let counter = Arc::new(Mutex::new(0));
let mut handles = vec![];
for _ in 0..2 {
let counter_clone = Arc::clone(&counter);
let handle = thread::spawn(move || {
for _ in 0..1000000 {
let mut num = counter_clone.lock().unwrap();
*num += 1; // ์์ ํ ์ ๊ทผ
}
});
handles.push(handle);
}
for handle in handles {
handle.join().unwrap();
}
println!("Counter: {}", *counter.lock().unwrap()); // ํญ์ 2000000
}
์ํธํ ๊ด๋ จ ํน์ ์ทจ์ฝ์
์ํธํ ์ฝ๋์๋ ์ผ๋ฐ์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ์ธ์๋ ํน์ํ ์ทจ์ฝ์ ๋ค์ด ์์ด์. ์ด๋ฐ ์ทจ์ฝ์ ๋ค์ ๋ํด ๋ ์ธ์ด๊ฐ ์ด๋ป๊ฒ ๋์ํ๋์ง ์ดํด๋ณผ๊ฒ์.
โฑ๏ธ ํ์ด๋ฐ ๊ณต๊ฒฉ (Timing Attacks)
์ํธํ ์ฐ์ฐ์ ์คํ ์๊ฐ์ ๋ถ์ํด ๋น๋ฐ ์ ๋ณด๋ฅผ ์ถ์ถํ๋ ๊ณต๊ฒฉ์ด์์.
C++์์์ ๋์
C++์์๋ ํ์ด๋ฐ ๊ณต๊ฒฉ์ ๋ฐฉ์งํ๊ธฐ ์ํด ์์ ์๊ฐ ์๊ณ ๋ฆฌ์ฆ์ ์ง์ ๊ตฌํํด์ผ ํด์. ์ปดํ์ผ๋ฌ ์ต์ ํ๊ฐ ์ด๋ฐ ๋ฐฉ์ด๋ฅผ ๋ฌด๋ ฅํํ ์๋ ์์ด์.
๋ฌ์คํธ์์์ ๋์
๋ฌ์คํธ๋ ๊ธฐ๋ณธ์ ์ผ๋ก๋ ํ์ด๋ฐ ๊ณต๊ฒฉ์ ์ทจ์ฝํ ์ ์์ง๋ง, subtle ํฌ๋ ์ดํธ ๊ฐ์ ๋๊ตฌ๋ฅผ ํตํด ์์ ์๊ฐ ์ฐ์ฐ์ ๋ ์ฝ๊ฒ ๊ตฌํํ ์ ์์ด์.
๐งน ๋ฉ๋ชจ๋ฆฌ ์์ฌ๋ฌผ (Memory Residue)
๋ฏผ๊ฐํ ๋ฐ์ดํฐ(ํค, ๋น๋ฐ๋ฒํธ ๋ฑ)๊ฐ ๋ฉ๋ชจ๋ฆฌ์ ๋จ์ ์์ผ๋ฉด ๊ณต๊ฒฉ์๊ฐ ์ด๋ฅผ ์ถ์ถํ ์ ์์ด์.
C++์์์ ๋์
C++์์๋ ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ฅผ ๋ด์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ช ์์ ์ผ๋ก ์ ๋กํ(zeroing)ํด์ผ ํด์.
void handle_sensitive_data() {
char password[64];
// ๋น๋ฐ๋ฒํธ ์ฒ๋ฆฌ...
// ๋ฉ๋ชจ๋ฆฌ ์ ๋กํ
memset(password, 0, sizeof(password));
// ํ์ง๋ง ์ปดํ์ผ๋ฌ ์ต์ ํ๋ก ์ธํด ์ด ์ฝ๋๊ฐ ์ ๊ฑฐ๋ ์ ์์!
}
๋ฌ์คํธ์์์ ๋์
๋ฌ์คํธ์์๋ zeroize ํฌ๋ ์ดํธ๋ฅผ ํตํด ๋ฏผ๊ฐํ ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ์ ๊ฑฐํ ์ ์์ด์.
use zeroize::Zeroize;
fn handle_sensitive_data() {
let mut password = [0u8; 64];
// ๋น๋ฐ๋ฒํธ ์ฒ๋ฆฌ...
// ์์ ํ ๋ฉ๋ชจ๋ฆฌ ์ ๋กํ
password.zeroize();
}
์ค์ ์ทจ์ฝ์ ํต๊ณ
์ค์ ๋ก C++์ ๋ฌ์คํธ๋ก ์์ฑ๋ ํ๋ก์ ํธ์์ ๋ฐ๊ฒฌ๋ ์ทจ์ฝ์ ํต๊ณ๋ฅผ ์ดํด๋ณด๋ฉด ์ฐจ์ด๊ฐ ๋ ๋ช ํํด์ ธ์.
2020-2022๋ ๋ฐ๊ฒฌ๋ ์ทจ์ฝ์ (๋์ผํ ๊ท๋ชจ์ ํ๋ก์ ํธ ๋น๊ต)
- C++ ํ๋ก์ ํธ: ํ๊ท 12.3๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๊ด๋ จ ์ทจ์ฝ์
- ๋ฌ์คํธ ํ๋ก์ ํธ: ํ๊ท 0.7๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๊ด๋ จ ์ทจ์ฝ์
๋ฌ์คํธ ํ๋ก์ ํธ์์ ๋ฐ๊ฒฌ๋ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ์ทจ์ฝ์ ์ ๋๋ถ๋ถ unsafe ๋ธ๋ก ๋ด์์ ๋ฐ์ํ์ด์. ์ด๋ ๋ฌ์คํธ์ ์์ ์ฑ ๋ณด์ฅ์ด ํจ๊ณผ์ ์ผ๋ก ์๋ํ๊ณ ์์์ ๋ณด์ฌ์ฃผ์ฃ .
์ ๊ทธ๋ํ์์ ๋ณผ ์ ์๋ฏ์ด, ๋ฌ์คํธ๋ C++์ ๋นํด ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ์ทจ์ฝ์ ์ด ํ์ ํ ์ ์ด์. ํนํ ๋ฒํผ ์ค๋ฒํ๋ก์ฐ๋ ์ ์ฆ ์ ํํฐ ํ๋ฆฌ ๊ฐ์ ์ทจ์ฝ์ ์ ๋ฌ์คํธ์์๋ ๊ฑฐ์ ๋ฐ์ํ์ง ์์ฃ .
์์ ์ฑ ์ธก๋ฉด์์ ๋ฌ์คํธ๋ ํ์คํ ์ด์ ์ ๊ฐ์ง๊ณ ์์ด์. ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ฒ๋ผ ๋ณด์์ด ์ค์ํ ์ํํธ์จ์ด์์๋ ์ด๋ฐ ์์ ์ฑ ์ฐจ์ด๊ฐ ๋งค์ฐ ์ค์ํ ์ ์์ด์. ์ฌ๋ฅ๋ท์์ ์ํธํ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ์๋ขฐํ์ค ๋, ์์ ์ฑ์ ์ค์ํ๊ฒ ์๊ฐํ๋ค๋ฉด ๋ฌ์คํธ๋ฅผ ๊ณ ๋ คํด๋ณด๋ ๊ฒ๋ ์ข์ ์ ํ์ผ ์ ์์ด์! ๐
6. ์ค์ ํ๋ก์ ํธ ์ฌ๋ก ์ฐ๊ตฌ ๐
์ด๋ก ์ ์ธ ๋น๊ต๋ ์ข์ง๋ง, ์ค์ ํ๋ก์ ํธ์์ ๋ ์ธ์ด๊ฐ ์ด๋ป๊ฒ ์ฌ์ฉ๋๊ณ ์๋์ง ์ดํด๋ณด๋ ๊ฒ๋ ์ค์ํด์. ์ฌ๋ฌ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ณด์ ์ค์ ํ๋ก์ ํธ์์ ๋ฌ์คํธ์ C++๊ฐ ์ด๋ป๊ฒ ํ์ฉ๋๊ณ ์๋์ง ์์๋ณผ๊ฒ์!
๐ ์ฃผ์ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฌ๋ก
OpenSSL (C ๊ธฐ๋ฐ)
OpenSSL์ ๊ฐ์ฅ ๋๋ฆฌ ์ฌ์ฉ๋๋ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ค ํ๋๋ก, C๋ก ์์ฑ๋์์ด์(C++๋ ์๋์ง๋ง C++ ํ๋ก์ ํธ์์ ์์ฃผ ์ฌ์ฉ๋จ). 1998๋ ๋ถํฐ ๊ฐ๋ฐ๋์ด ์๊ณ , TLS/SSL ํ๋กํ ์ฝ ๊ตฌํ๊ณผ ๋ค์ํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ์ ๊ณตํด์.
ํ์ง๋ง 2014๋ ํํธ๋ธ๋ฆฌ๋(Heartbleed) ์ทจ์ฝ์ ์ผ๋ก ์ธํด ํฐ ๋ฌธ์ ๊ฐ ๋ฐ์ํ์ด์. ์ด ์ทจ์ฝ์ ์ ๋ฒํผ ์ค๋ฒ๋ฆฌ๋(buffer over-read) ๋ฌธ์ ๋ก, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ด ๋ณด์ฅ๋์ง ์๋ C ์ธ์ด์ ํน์ฑ ๋๋ฌธ์ ๋ฐ์ํ์ฃ . ์ด ์ฌ๊ฑด์ ์์คํ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ์ค์์ฑ์ ๋ค์ ํ๋ฒ ์ผ๊นจ์์คฌ์ด์.
BoringSSL (C ๊ธฐ๋ฐ, ๊ตฌ๊ธ)
๊ตฌ๊ธ์ OpenSSL์ ํฌํฌ์ธ BoringSSL์ ๊ฐ๋ฐํ์ด์. ์ด ํ๋ก์ ํธ๋ OpenSSL์ ๋ณต์ก์ฑ์ ์ค์ด๊ณ ๋ณด์์ฑ์ ๊ฐํํ๋ ๋ฐ ์ค์ ์ ๋๊ณ ์์ฃ . ์ฌ์ ํ C๋ก ์์ฑ๋์ด ์์ง๋ง, ๊ตฌ๊ธ์ ์ฝ๋ ํ์ง๊ณผ ์์ ์ฑ์ ๋์ด๊ธฐ ์ํด ๋ง์ ๋ ธ๋ ฅ์ ๊ธฐ์ธ์ด๊ณ ์์ด์.
ring (๋ฌ์คํธ ๊ธฐ๋ฐ)
ring์ BoringSSL์ ์ํธํ ๊ธฐ๋ฅ์ ๋ฌ์คํธ๋ก ๋ํํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. ์ ์ฐจ C ์ฝ๋๋ฅผ ๋ฌ์คํธ๋ก ๋์ฒดํด ๋๊ฐ๊ณ ์์ผ๋ฉฐ, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ๊ณผ ํ๋์ ์ธ API๋ฅผ ์ ๊ณตํ๋ ๊ฒ์ด ๋ชฉํ์์.
ring์ Firefox์ ์ผ๋ถ ๊ตฌ์ฑ ์์์ ๋ค์ํ ๋ฌ์คํธ ํ๋ก์ ํธ์์ ์ฌ์ฉ๋๊ณ ์์ด์. ํนํ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ด ์ค์ํ ์น ๋ธ๋ผ์ฐ์ ํ๊ฒฝ์์ ์ข์ ์ ํ์ง๋ก ์๋ฆฌ์ก๊ณ ์์ฃ .
libsodium (C ๊ธฐ๋ฐ)
libsodium์ ์ฌ์ฉํ๊ธฐ ์ฌ์ด ๊ณ ์์ค ์ํธํ API๋ฅผ ์ ๊ณตํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์. C๋ก ์์ฑ๋์์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ ๋์ด๊ธฐ ์ํ ๋ค์ํ ๊ธฐ๋ฒ์ ์ ์ฉํ๊ณ ์์ด์.
ํฅ๋ฏธ๋ก์ด ์ ์ libsodium ๊ฐ๋ฐ์๋ค์ด ๋ฌ์คํธ๋ก ์ฌ์์ฑํ๋ ๊ฒ์ ๊ณ ๋ คํ๊ณ ์๋ค๋ ์ ์ด์์. ์ด๋ ๋ฌ์คํธ์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ด ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์ผ๋ง๋ ์ค์ํ์ง๋ฅผ ๋ณด์ฌ์ฃผ๋ ์ฌ๋ก์ฃ .
๐ ์ธ์ด ์ ํ ์ฌ๋ก
๊ธฐ์กด C/C++ ์ฝ๋๋ฒ ์ด์ค๋ฅผ ๋ฌ์คํธ๋ก ์ ํํ ์ฌ๋ก๋ค๋ ์ดํด๋ณผ๊น์?
Mozilla Firefox
๋ชจ์ง๋ผ๋ Firefox์ ์ฌ๋ฌ ๊ตฌ์ฑ ์์๋ฅผ C++์์ ๋ฌ์คํธ๋ก ์ ์ง์ ์ผ๋ก ์ ํํ๊ณ ์์ด์. ํนํ Stylo(CSS ์์ง)์ Quantum(๋ ๋๋ง ์์ง)์ ์ผ๋ถ๊ฐ ๋ฌ์คํธ๋ก ์ฌ์์ฑ๋์์ฃ .
๋ชจ์ง๋ผ์ ๋ณด๊ณ ์ ๋ฐ๋ฅด๋ฉด, ๋ฌ์คํธ๋ก ์ ํํ ํ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ณด์ ์ทจ์ฝ์ ์ด 70% ์ด์ ๊ฐ์ํ๋ค๊ณ ํด์. ์ด๋ ๋ฌ์คํธ์ ์์ ์ฑ์ด ์ค์ ๋๊ท๋ชจ ํ๋ก์ ํธ์์๋ ํจ๊ณผ์ ์์ ๋ณด์ฌ์ฃผ๋ ์ฌ๋ก์์.
Dropbox
Dropbox๋ ํต์ฌ ํ์ผ ๋๊ธฐํ ์์ง์ ์ผ๋ถ๋ฅผ C++์์ ๋ฌ์คํธ๋ก ์ ํํ์ด์. ์ด ๊ณผ์ ์์ ์ฑ๋ฅ์ ์ ์งํ๋ฉด์๋ ์ฝ๋์ ์์ ์ฑ๊ณผ ์ ์ง๋ณด์์ฑ์ ํฌ๊ฒ ํฅ์์์ผฐ๋ค๊ณ ๋ณด๊ณ ํ์ฃ .
ํนํ Dropbox ์์ง๋์ด๋ค์ ๋ฌ์คํธ์ ์์ ๊ถ ์์คํ ์ด ๋์์ฑ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐ ํฐ ๋์์ด ๋์๋ค๊ณ ์ธ๊ธํ์ด์. ํ์ผ ๋๊ธฐํ์ฒ๋ผ ๋ณต์กํ ๋์์ฑ ๋ฌธ์ ๊ฐ ์๋ ์์คํ ์์ ์ด๋ ๋งค์ฐ ์ค์ํ ์ด์ ์ด์ฃ .
Microsoft
๋ง์ดํฌ๋ก์ํํธ๋ ๋ณด์์ด ์ค์ํ ์ฌ๋ฌ ๊ตฌ์ฑ ์์์์ ๋ฌ์คํธ๋ฅผ ๋์ ํ๊ณ ์์ด์. ํนํ Windows์ ์ผ๋ถ ๊ตฌ์ฑ ์์์ Azure ์๋น์ค์ ๋ฌ์คํธ๋ฅผ ์ฌ์ฉํ๊ธฐ ์์ํ์ฃ .
๋ง์ดํฌ๋ก์ํํธ์ ๋ณด์ ์ฐ๊ตฌํ์ ์ง๋ 10๋ ๊ฐ ๋ฐ๊ฒฌ๋ ๋ณด์ ์ทจ์ฝ์ ์ 70%๊ฐ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๋ฌธ์ ์๋ค๊ณ ๋ฐํ์ด์. ์ด ๋๋ฌธ์ ๋ฌ์คํธ์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ ์์ ์ธ์ด๋ก์ ์ ํ์ ์ ๊ทน ๊ฒํ ํ๊ณ ์๋ ์ํฉ์ด์ฃ .
๐ ์ฑ๊ณต ์ฌ๋ก ๋ถ์
์ ์ฌ๋ก๋ค์ ๋ถ์ํด๋ณด๋ฉด ๋ช ๊ฐ์ง ๊ณตํต๋ ํจํด์ด ๋ณด์ฌ์:
- ์ ์ง์ ์ ํ: ๋๋ถ๋ถ์ ๊ธฐ์ ์ ์ ์ฒด ์ฝ๋๋ฒ ์ด์ค๋ฅผ ํ ๋ฒ์ ์ ํํ์ง ์๊ณ , ๋ณด์์ด ์ค์ํ ๊ตฌ์ฑ ์์๋ถํฐ ์ ์ง์ ์ผ๋ก ์ ํํ์ด์.
- ์์ ์ฑ ํฅ์: ๋ฌ์คํธ๋ก ์ ํ ํ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ณด์ ์ทจ์ฝ์ ์ด ํฌ๊ฒ ๊ฐ์ํ์ด์.
- ์ฑ๋ฅ ์ ์ง: ๋๋ถ๋ถ์ ๊ฒฝ์ฐ ๋ฌ์คํธ๋ก ์ ํํด๋ ์ฑ๋ฅ ์ ํ๊ฐ ๊ฑฐ์ ์์๊ฑฐ๋ ์คํ๋ ค ํฅ์๋ ๊ฒฝ์ฐ๋ ์์์ด์.
- ๊ฐ๋ฐ์ ์์ฐ์ฑ: ์ด๊ธฐ ํ์ต ๊ณก์ ์ดํ์๋ ๊ฐ๋ฐ์ ์์ฐ์ฑ์ด ํฅ์๋์๋ค๋ ๋ณด๊ณ ๊ฐ ๋ง์์ด์.
์ด๋ฐ ์ฌ๋ก๋ค์ ๋ณด๋ฉด, ํนํ ๋ณด์์ด ์ค์ํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๋ฌ์คํธ๊ฐ C++์ ๊ฐ๋ ฅํ ๋์์ด ๋ ์ ์์์ ์ ์ ์์ด์. ๋ฌผ๋ก ๋ชจ๋ ์ํฉ์ ๋ฌ์คํธ๊ฐ ์ต์ ์ ์ ํ์ ์๋์ง๋ง, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ด ์ค์ํ ๊ฒฝ์ฐ์๋ ๋ถ๋ช ํ ์ด์ ์ ์ ๊ณตํ์ฃ .
์ฌ๋ฅ๋ท์์ ์ํธํ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ๊ณํํ๊ณ ๊ณ์ ๋ค๋ฉด, ์ด๋ฐ ์ค์ ์ฌ๋ก๋ค์ ์ฐธ๊ณ ํด ํ๋ก์ ํธ์ ๊ฐ์ฅ ์ ํฉํ ์ธ์ด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์. ๋๋ก๋ C++์ ์ํ๊ณ์ ์ฑ์๋๊ฐ ์ค์ํ ์ ์๊ณ , ๋๋ก๋ ๋ฌ์คํธ์ ์์ ์ฑ์ด ๋ ์ค์ํ ์ ์์ผ๋๊น์! ๐
7. ๊ฐ๋ฐ์ ๊ฒฝํ๊ณผ ์์ฐ์ฑ ๐จโ๐ป
์ธ์ด ์ ํ์์ ๊ธฐ์ ์ ์ธ ์ธก๋ฉด๋ ์ค์ํ์ง๋ง, ๊ฐ๋ฐ์ ๊ฒฝํ๊ณผ ์์ฐ์ฑ๋ ๋งค์ฐ ์ค์ํ ์์์์. ์๋ฌด๋ฆฌ ์ข์ ์ธ์ด๋ผ๋ ๊ฐ๋ฐํ๊ธฐ ๋๋ฌด ์ด๋ ต๊ฑฐ๋ ์์ฐ์ฑ์ด ๋จ์ด์ง๋ค๋ฉด ์ค์ ํ๋ก์ ํธ์์ ์ฌ์ฉํ๊ธฐ ์ด๋ ต๊ฒ ์ฃ ? ๊ทธ๋ผ ๋ฌ์คํธ์ C++์ ๊ฐ๋ฐ์ ๊ฒฝํ์ ๋น๊ตํด๋ณผ๊น์?
๐ ํ์ต ๊ณก์
๋ ์ธ์ด ๋ชจ๋ ์ด๋ณด์์๊ฒ๋ ์ฝ์ง ์์ ์ธ์ด๋ก ์๋ ค์ ธ ์์ด์. ํ์ง๋ง ํ์ต ๊ณก์ ์ ํน์ฑ์ ์กฐ๊ธ ๋ฌ๋ผ์.
C++์ ํ์ต ๊ณก์
C++๋ ์ด๊ธฐ์๋ ๋น๊ต์ ์ฝ๊ฒ ์์ํ ์ ์์ด์. ํนํ C ์ธ์ด๋ฅผ ์๊ณ ์๋ค๋ฉด ๊ธฐ๋ณธ ๋ฌธ๋ฒ์ ์ตํ๋ ๊ฒ์ ์ด๋ ต์ง ์์ฃ . ํ์ง๋ง ๊น์ด ๋ค์ด๊ฐ์๋ก ๋ณต์ก๋๊ฐ ๊ธฐํ๊ธ์์ ์ผ๋ก ์ฆ๊ฐํด์.
ํ ํ๋ฆฟ ๋ฉํํ๋ก๊ทธ๋๋ฐ, ๋ค์ค ์์, ์ฐ์ฐ์ ์ค๋ฒ๋ก๋ฉ, ๋ฉ๋ชจ๋ฆฌ ๊ด๋ฆฌ ๋ฑ ๊ณ ๊ธ ๊ธฐ๋ฅ๋ค์ ๋งค์ฐ ๋ณต์กํ๊ณ ์ดํดํ๊ธฐ ์ด๋ ค์ธ ์ ์์ด์. "C++๋ฅผ ์์ ํ ๋ง์คํฐํ๋ค"๊ณ ๋งํ ์ ์๋ ๊ฐ๋ฐ์๋ ๊ฑฐ์ ์์ ์ ๋๋ก ์ธ์ด๊ฐ ๋ฐฉ๋ํ๊ณ ๋ณต์กํด์. ใ ใ ใ
๋ํ C++๋ ์ฌ๋ฌ ๋ฒ์ (C++98, C++11, C++14, C++17, C++20 ๋ฑ)์ ๊ฑธ์ณ ๊ณ์ ๋ฐ์ ํด์๊ธฐ ๋๋ฌธ์, ์ค๋๋ ์ฝ๋์ ํ๋์ ์ธ ์ฝ๋์ ์คํ์ผ์ด ํฌ๊ฒ ๋ค๋ฅผ ์ ์์ด์. ์ด๋ ํ์ต์ ๋ ๋ณต์กํ๊ฒ ๋ง๋๋ ์์์ฃ .
๋ฌ์คํธ์ ํ์ต ๊ณก์
๋ฌ์คํธ๋ ์ด๊ธฐ ์ง์ ์ฅ๋ฒฝ์ด ๋์ ํธ์ด์์. ์์ ๊ถ ์์คํ , ์๋ช (lifetime), ๋น๋ฆผ ์ฒด์ปค ๋ฑ์ ๊ฐ๋ ์ ์ฒ์ ์ ํ๋ ๊ฐ๋ฐ์์๊ฒ ๋ฏ์ค๊ณ ์ด๋ ค์ธ ์ ์์ฃ . ๋ง์ ๊ฐ๋ฐ์๋ค์ด "๋ฌ์คํธ ์ปดํ์ผ๋ฌ์ ์ธ์ฐ๋ ๋จ๊ณ"๋ฅผ ๊ฑฐ์น๋ค๊ณ ํํํด์.
ํ์ง๋ง ์ด๋ฐ ์ด๊ธฐ ์ด๋ ค์์ ๋์ด์๋ฉด, ๋ฌ์คํธ์ ์ผ๊ด๋ ์ค๊ณ์ ๋ช ํํ ๊ท์น ๋๋ถ์ ํ์ต ๊ณก์ ์ด ์๋งํด์ ธ์. ๋ํ ๋ฌ์คํธ๋ ์ฒ์๋ถํฐ ํ๋์ ์ธ ์ธ์ด๋ก ์ค๊ณ๋์๊ธฐ ๋๋ฌธ์, ๋ ๊ฑฐ์ ์ฝ๋์ ๋ถ๋ด์ด ์ ๊ณ ์ผ๊ด๋ ์คํ์ผ์ ์ ์งํ๊ณ ์์ด์.
๋ฌ์คํธ ์ปค๋ฎค๋ํฐ๋ "๋ฌ์คํธ ์ฑ (The Rust Book)"๊ณผ ๊ฐ์ ๋ฐ์ด๋ ํ์ต ์๋ฃ๋ฅผ ์ ๊ณตํ๊ณ ์์ด, ์ฒด๊ณ์ ์ธ ํ์ต์ด ๊ฐ๋ฅํ๋ค๋ ์ ๋ ์ฅ์ ์ด์์.
๐ ๏ธ ๊ฐ๋ฐ ๋๊ตฌ
๊ฐ๋ฐ ๋๊ตฌ์ ํ์ง์ ๊ฐ๋ฐ์ ์์ฐ์ฑ์ ํฐ ์ํฅ์ ๋ฏธ์ณ์. ๋ ์ธ์ด์ ๊ฐ๋ฐ ๋๊ตฌ๋ฅผ ๋น๊ตํด๋ณผ๊น์?
C++ ๊ฐ๋ฐ ๋๊ตฌ
C++๋ ์ค๋ ์ญ์ฌ๋ฅผ ๊ฐ์ง ์ธ์ด์ธ ๋งํผ ๋ค์ํ๊ณ ์ฑ์ํ ๊ฐ๋ฐ ๋๊ตฌ๊ฐ ์์ด์:
- IDE: Visual Studio, CLion, Qt Creator ๋ฑ ๊ฐ๋ ฅํ IDE๊ฐ ๋ง์์.
- ๋๋ฒ๊ฑฐ: GDB, LLDB, Visual Studio Debugger ๋ฑ ์ฑ์ํ ๋๋ฒ๊น ๋๊ตฌ๊ฐ ์์ด์.
- ๋น๋ ์์คํ : CMake, Make, Ninja ๋ฑ ๋ค์ํ ๋น๋ ์์คํ ์ ์ง์ํด์.
- ์ ์ ๋ถ์ ๋๊ตฌ: Clang Static Analyzer, Coverity, PVS-Studio ๋ฑ์ด ์์ด์.
ํ์ง๋ง C++์ ๋ณต์ก์ฑ ๋๋ฌธ์ ๋๊ตฌ๊ฐ ์๋ฒฝํ๊ฒ ์๋ํ์ง ์๋ ๊ฒฝ์ฐ๋ ์์ด์. ํนํ ํ ํ๋ฆฟ ๋ฉํํ๋ก๊ทธ๋๋ฐ์ด๋ ๋ณต์กํ ๋งคํฌ๋ก๋ฅผ ์ฌ์ฉํ ๋ IDE์ ์ฝ๋ ์ธํ ๋ฆฌ์ผ์ค๊ฐ ์ ๋๋ก ์๋ํ์ง ์์ ์ ์์ฃ .
๋ฌ์คํธ ๊ฐ๋ฐ ๋๊ตฌ
๋ฌ์คํธ๋ ๋น๊ต์ ์๋ก์ด ์ธ์ด์ง๋ง, ์ฒ์๋ถํฐ ๊ฐ๋ฐ์ ๊ฒฝํ์ ์ค์์ํ์ด์:
- Cargo: ๋ฌ์คํธ์ ํจํค์ง ๋งค๋์ ์ด์ ๋น๋ ์์คํ ์ผ๋ก, ์์กด์ฑ ๊ด๋ฆฌ, ๋น๋, ํ ์คํธ, ๋ฌธ์ํ ๋ฑ์ ํตํฉ์ ์ผ๋ก ์ฒ๋ฆฌํด์.
- Rustfmt: ์ฝ๋ ํฌ๋งทํ ๋๊ตฌ๋ก, ์ผ๊ด๋ ์ฝ๋ ์คํ์ผ์ ์ ์งํ๋ ๋ฐ ๋์์ ์ค์.
- Clippy: ๋ฆฐํฐ(linter)๋ก, ์ฝ๋ ํ์ง์ ํฅ์์ํค๋ ๋ค์ํ ์ ์์ ์ ๊ณตํด์.
- Rust Analyzer: ๊ฐ๋ ฅํ ์ธ์ด ์๋ฒ ํ๋กํ ์ฝ(LSP) ๊ตฌํ์ฒด๋ก, ๋ค์ํ IDE์ ์๋ํฐ์์ ์ฝ๋ ์์ฑ, ์ ์ ์ด๋ ๋ฑ์ ๊ธฐ๋ฅ์ ์ ๊ณตํด์.
๋ฌ์คํธ์ ๋๊ตฌ๋ค์ ์ธ์ด์ ์ผ๋ถ๋ก ์ค๊ณ๋์๊ธฐ ๋๋ฌธ์ ํตํฉ์ด ์ ๋์ด ์๊ณ ์ฌ์ฉํ๊ธฐ ์ฌ์์. ํนํ Cargo๋ C++์ ๋ณต์กํ ๋น๋ ์์คํ ์ค์ ์ ๋นํด ํจ์ฌ ๊ฐ๋จํ๊ณ ์ง๊ด์ ์ด์ฃ .
๐ฅ ์ปค๋ฎค๋ํฐ์ ์ํ๊ณ
์ธ์ด์ ์ปค๋ฎค๋ํฐ์ ์ํ๊ณ๋ ๊ฐ๋ฐ์ ๊ฒฝํ์ ํฐ ์ํฅ์ ๋ฏธ์ณ์.
C++ ์ปค๋ฎค๋ํฐ์ ์ํ๊ณ
C++๋ ์์ญ ๋ ์ ์ญ์ฌ๋ฅผ ๊ฐ์ง ์ธ์ด๋ก, ๋ฐฉ๋ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ํ๋ถํ ์๋ฃ๊ฐ ์์ด์. ๊ฑฐ์ ๋ชจ๋ ๋ถ์ผ์ ๋ํ C++ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ฅผ ์ฐพ์ ์ ์์ฃ .
ํ์ง๋ง C++์ ์ํ๊ณ๋ ๋ค์ ๋ถ์ฐ๋์ด ์์ด์. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ธ์๋ ์ค์ํ๋ ํจํค์ง ๊ด๋ฆฌ ์์คํ ์ด ์์ด, ๋ผ์ด๋ธ๋ฌ๋ฆฌ ํตํฉ์ด ๋ณต์กํ ์ ์์ฃ . vcpkg, conan ๊ฐ์ ๋๊ตฌ๊ฐ ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ค๊ณ ํ์ง๋ง, ์์ง ์๋ฒฝํ์ง๋ ์์์.
C++ ์ปค๋ฎค๋ํฐ๋ ํฌ๊ณ ํ๋ฐํ์ง๋ง, ๋๋ก๋ ์ ํต๊ณผ ํ์ ์ฌ์ด์์ ์๊ฒฌ ์ถฉ๋์ด ์๊ธฐ๋ ํด์. ์ธ์ด์ ๋ณต์ก์ฑ ๋๋ฌธ์ ์ด๋ณด์๊ฐ ๋์์ ๊ตฌํ๊ธฐ ์ด๋ ค์ธ ์ ์์ฃ .
๋ฌ์คํธ ์ปค๋ฎค๋ํฐ์ ์ํ๊ณ
๋ฌ์คํธ๋ ๋น๊ต์ ์๋ก์ด ์ธ์ด์ง๋ง, ๋งค์ฐ ํ๋ฐํ๊ณ ์น์ ํ ์ปค๋ฎค๋ํฐ๋ก ์ ๋ช ํด์. "๋ฌ์คํธ ์ปค๋ฎค๋ํฐ๊ฐ ๋๋ฌด ์น์ ํด์ ๋๋๋ค"๋ ์ด์ผ๊ธฐ๋ฅผ ์์ฃผ ๋ค์ ์ ์์ฃ .
๋ฌ์คํธ์ ๊ณต์ ํจํค์ง ์ ์ฅ์์ธ crates.io๋ ์ค์ํ๋ ํจํค์ง ๊ด๋ฆฌ๋ฅผ ์ ๊ณตํด, ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฐพ๊ธฐ์ ํตํฉ์ด ์ฌ์์. ๋ํ docs.rs๋ฅผ ํตํด ๋ชจ๋ ํฌ๋ ์ดํธ(crate, ๋ฌ์คํธ์ ํจํค์ง)์ ๋ฌธ์๋ฅผ ์ผ๊ด๋ ํ์์ผ๋ก ๋ณผ ์ ์์ด์.
๋ฌ์คํธ ์ปค๋ฎค๋ํฐ๋ ์ฝ๋ ํ์ง๊ณผ ์์ ์ฑ์ ์ค์์ํ๋ฉฐ, ์คํ ์์ค ๊ธฐ์ฌ๋ฅผ ์ฅ๋ คํด์. ํ์ง๋ง C++์ ๋นํด ์ํ๊ณ๊ฐ ์์ง ์ฑ์ ๋จ๊ณ์ ์์ด, ์ผ๋ถ ํน์ํ ๋ถ์ผ์์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๊ฐ ๋ถ์กฑํ ์ ์์ด์.
๐๏ธ ์ค์ ๊ฐ๋ฐ ์์ฐ์ฑ
์ค์ ํ๋ก์ ํธ์์์ ๊ฐ๋ฐ ์์ฐ์ฑ์ ๋น๊ตํด๋ณผ๊น์?
๊ฐ๋จํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ ์๊ฐ ๋น๊ต (๊ฒฝํ ์๋ ๊ฐ๋ฐ์ ๊ธฐ์ค)
- ๊ธฐ๋ณธ ๊ธฐ๋ฅ ๊ตฌํ: C++ ์ฝ 40์๊ฐ, ๋ฌ์คํธ ์ฝ 45์๊ฐ
- ๋ฒ๊ทธ ์์ ๋ฐ ๋๋ฒ๊น : C++ ์ฝ 30์๊ฐ, ๋ฌ์คํธ ์ฝ 15์๊ฐ
- ํ ์คํธ ์์ฑ: C++ ์ฝ 25์๊ฐ, ๋ฌ์คํธ ์ฝ 20์๊ฐ
- ๋ฌธ์ํ: C++ ์ฝ 20์๊ฐ, ๋ฌ์คํธ ์ฝ 15์๊ฐ
- ์ด ์๊ฐ: C++ ์ฝ 115์๊ฐ, ๋ฌ์คํธ ์ฝ 95์๊ฐ
๋ฌ์คํธ๋ ์ด๊ธฐ ๊ตฌํ์ ์ฝ๊ฐ ๋ ์๊ฐ์ด ๊ฑธ๋ ธ์ง๋ง, ๋๋ฒ๊น ๊ณผ ํ ์คํธ์์ ์๊ฐ์ ์ ์ฝํด ์ ์ฒด์ ์ผ๋ก ๋ ํจ์จ์ ์ด์์ด์. ์ด๋ ๋ฌ์คํธ์ ์ปดํ์ผ ํ์ ๊ฒ์ฌ๊ฐ ๋ง์ ๋ฒ๊ทธ๋ฅผ ์ฌ์ ์ ๋ฐฉ์งํ๊ธฐ ๋๋ฌธ์ด์ฃ .
๊ฐ๋ฐ์ ๊ฒฝํ ์ธก๋ฉด์์ ๋ณด๋ฉด, C++๋ ์ด๊ธฐ ์ง์ ์ด ์ฝ๊ณ ํ๋ถํ ์ํ๊ณ๊ฐ ์ฅ์ ์ธ ๋ฐ๋ฉด, ๋ฌ์คํธ๋ ๊ฐ๋ ฅํ ๋๊ตฌ์ ์น์ ํ ์ปค๋ฎค๋ํฐ, ๊ทธ๋ฆฌ๊ณ ์ฅ๊ธฐ์ ์ธ ์์ฐ์ฑ ํฅ์์ด ์ฅ์ ์ด์์.
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ์ ๋ณต์กํ๊ณ ์์ ์ฑ์ด ์ค์ํ ํ๋ก์ ํธ์์๋, ์ด๊ธฐ ํ์ต์ ์๊ฐ์ ํฌ์ํ๋๋ผ๋ ์ฅ๊ธฐ์ ์ผ๋ก ๋ฒ๊ทธ์ ์ทจ์ฝ์ ์ ์ค์ผ ์ ์๋ ๋ฌ์คํธ๊ฐ ์ข์ ์ ํ์ผ ์ ์์ด์. ์ฌ๋ฅ๋ท์์ ํ๋ก์ ํธ๋ฅผ ์๋ขฐํ ๋, ๊ฐ๋ฐ์์ ์ธ์ด ์๋ จ๋์ ํ๋ก์ ํธ์ ํน์ฑ์ ๊ณ ๋ คํด ์ ์ ํ ์ธ์ด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์! ๐จโ๐ป
8. ๋ฏธ๋ ์ ๋ง: ๋ ์ธ์ด์ ๋ฐ์ ๋ฐฉํฅ ๐ฎ
์ง๊ธ๊น์ง ๋ฌ์คํธ์ C++์ ํ์ฌ ์ํฉ์ ๋น๊ตํด๋ดค๋๋ฐ, ๋ฏธ๋์๋ ์ด๋ป๊ฒ ๋ ๊น์? ๋ ์ธ์ด์ ๋ฐ์ ๋ฐฉํฅ๊ณผ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์ ๋ฏธ์น ์ํฅ์ ์์ธกํด๋ณผ๊ฒ์!
C++์ ๋ฏธ๋ ๋ฐฉํฅ
C++23๊ณผ ๊ทธ ์ดํ
C++๋ ๊ณ์ํด์ ๋ฐ์ ํ๊ณ ์์ด์. C++23์์๋ ๋ชจ๋ ์์คํ ๊ฐ์ , ์ฝ๋ฃจํด ๊ฐํ, ๋ฒ์ ๊ธฐ๋ฐ ์๊ณ ๋ฆฌ์ฆ ํ์ฅ ๋ฑ์ด ์์ ๋์ด ์์ฃ . ํนํ ์์ ์ฑ ํฅ์์ ์ํ ๊ธฐ๋ฅ๋ค์ด ๋ง์ด ์ถ๊ฐ๋๊ณ ์์ด์.
C++ ํ์ค ์์ํ๋ "C++๋ฅผ ๋ ์์ ํ๊ฒ ๋ง๋ค์"๋ ๋ชฉํ๋ฅผ ๊ฐ์ง๊ณ ์์ด์. ์๋ฅผ ๋ค์ด, ๊ฒฝ๊ณ ๊ฒ์ฌ๊ฐ ์๋ std::span, ์์ ๊ถ์ ๋ช
ํํ ํ๋ std::unique_ptr์ std::shared_ptr ๋ฑ์ ๊ธฐ๋ฅ์ด ์ด๋ฏธ ๋์
๋์๊ณ , ์์ผ๋ก๋ ์ด๋ฐ ๋ฐฉํฅ์ฑ์ ๊ณ์๋ ๊ฑฐ์์.
์์ ์ฑ์ ๋ํ ์ ๊ทผ
C++๋ "์ ๋ก ์ค๋ฒํค๋ ์์น(zero-overhead principle)"์ ์ค์์ํด์. ์ฆ, ์ฌ์ฉํ์ง ์๋ ๊ธฐ๋ฅ์ ๋ํด์๋ ๋น์ฉ์ ์ง๋ถํ์ง ์์์ผ ํ๋ค๋ ์์น์ด์ฃ . ์ด ๋๋ฌธ์ ์์ ์ฑ ๊ธฐ๋ฅ๋ ์ ํ์ ์ผ๋ก ์ฌ์ฉํ ์ ์๊ฒ ์ค๊ณ๋๋ ๊ฒฝํฅ์ด ์์ด์.
์๋ฅผ ๋ค์ด, ๋ฐฐ์ด ๊ฒฝ๊ณ ๊ฒ์ฌ๋ ๋๋ฒ๊ทธ ๋ชจ๋์์๋ง ํ์ฑํ๋๊ฑฐ๋, ๋ช ์์ ์ผ๋ก ์์ ํ ์ปจํ ์ด๋๋ฅผ ์ ํํด์ผ ํ๋ ๊ฒฝ์ฐ๊ฐ ๋ง์์. ์ด๋ ์ฑ๋ฅ๊ณผ ์์ ์ฑ ์ฌ์ด์์ ๊ฐ๋ฐ์์๊ฒ ์ ํ๊ถ์ ์ฃผ๋ ์ ๊ทผ ๋ฐฉ์์ด์ฃ .
๋ ๊ฑฐ์ ์ฝ๋์์ ํธํ์ฑ
C++์ ํฐ ๊ณผ์ ์ค ํ๋๋ ์์ญ ๋ ๋์ ์ถ์ ๋ ๋ ๊ฑฐ์ ์ฝ๋์์ ํธํ์ฑ์ ์ ์งํ๋ ๊ฒ์ด์์. ์ด๋ ์ธ์ด๊ฐ ๊ธ๊ฒฉํ๊ฒ ๋ณํํ๋ ๊ฒ์ ์ด๋ ต๊ฒ ๋ง๋ค์ฃ .
ํ์ง๋ง C++20๋ถํฐ ๋์ ๋ ๋ชจ๋ ์์คํ ์ ์ด๋ฐ ๋ฌธ์ ๋ฅผ ์ผ๋ถ ํด๊ฒฐํ ์ ์๋ ๊ฐ๋ฅ์ฑ์ ์ ์ํด์. ๋ชจ๋์ ํตํด ํ๋์ ์ธ C++ ์ฝ๋์ ๋ ๊ฑฐ์ ์ฝ๋๋ฅผ ๋ถ๋ฆฌํ ์ ์๊ฒ ๋๋ฉด์, ์๋ก์ด ์ฝ๋์์๋ ๋ ์์ ํ๊ณ ํ๋์ ์ธ ์ ๊ทผ ๋ฐฉ์์ ์ฑํํ ์ ์๊ฒ ๋์ด์.
๋ฌ์คํธ์ ๋ฏธ๋ ๋ฐฉํฅ
์์ ์ฑ๊ณผ ์ฑ์๋
๋ฌ์คํธ๋ ์ด๋ฏธ 1.0 ์ถ์ ์ดํ ์์ ์ ์ธ ์ธ์ด๋ก ์๋ฆฌ์ก์์ง๋ง, ์ฌ์ ํ ํ๋ฐํ๊ฒ ๋ฐ์ ํ๊ณ ์์ด์. ํนํ ๋น๋๊ธฐ ํ๋ก๊ทธ๋๋ฐ, ์๋ฒ ๋๋ ์์คํ ์ง์, ์ปดํ์ผ ์๊ฐ ๊ฐ์ ๋ฑ์ ์ค์ ์ ๋๊ณ ์์ฃ .
๋ฌ์คํธ ํ์ "์๋์ (edition)" ์์คํ ์ ํตํด ํ์ ํธํ์ฑ์ ์ ์งํ๋ฉด์๋ ์ธ์ด๋ฅผ ๋ฐ์ ์ํค๋ ๋ฐฉ๋ฒ์ ์ฐพ์์ด์. ์ด๋ฅผ ํตํด ๊ธฐ์กด ์ฝ๋๋ฅผ ๊นจ์ง ์์ผ๋ฉด์๋ ์๋ก์ด ๊ธฐ๋ฅ๊ณผ ๊ฐ์ ์ฌํญ์ ๋์ ํ ์ ์์ฃ .
์ํ๊ณ ํ์ฅ
๋ฌ์คํธ์ ์ํ๊ณ๋ ๋น ๋ฅด๊ฒ ์ฑ์ฅํ๊ณ ์์ด์. ํนํ ์น ์ด์ ๋ธ๋ฆฌ(WASM), ์๋ฒ ๋๋ ์์คํ , ๋คํธ์ํน, ๊ฒ์ ๊ฐ๋ฐ ๋ฑ ๋ค์ํ ๋ถ์ผ๋ก ํ์ฅ๋๊ณ ์์ฃ .
์ํธํ ๋ถ์ผ์์๋ ๋ฌ์คํธ์ ์ ์ง๊ฐ ๊ฐํ๋๊ณ ์์ด์. RustCrypto ํ๋ก์ ํธ๋ ๋ค์ํ ์ํธํ ์๊ณ ๋ฆฌ์ฆ์ ์์ ๋ฌ์คํธ๋ก ๊ตฌํํ๊ณ ์๊ณ , ring๊ณผ ๊ฐ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ ๊ธฐ์กด C ๊ธฐ๋ฐ ์ํธํ ์ฝ๋๋ฅผ ์์ ํ๊ฒ ๋ํํ๊ณ ์์ฃ .
๊ธฐ์ ์ฑํ ์ฆ๊ฐ
๋ฌ์คํธ๋ ์ต๊ทผ ๋ช ๋ ๊ฐ ์ฃผ์ ๊ธฐ์ ๋ค์ ์ฑํ์ด ํฌ๊ฒ ์ฆ๊ฐํ์ด์. Mozilla๋ฟ๋ง ์๋๋ผ Google, Microsoft, Amazon, Facebook ๋ฑ ๋ํ ๊ธฐ์ ๊ธฐ์ ๋ค์ด ๋ฌ์คํธ๋ฅผ ๋์ ํ๊ณ ์์ฃ .
ํนํ Microsoft๋ Windows์ Azure์ ์ผ๋ถ ๊ตฌ์ฑ ์์๋ฅผ ๋ฌ์คํธ๋ก ์ฌ์์ฑํ๊ณ ์์ผ๋ฉฐ, Google์ Android์ ์ผ๋ถ์ Fuchsia OS์ ๋ฌ์คํธ๋ฅผ ์ฌ์ฉํ๊ณ ์์ด์. ์ด๋ฐ ๊ธฐ์ ๋ค์ ์ง์์ ๋ฌ์คํธ์ ์ฅ๊ธฐ์ ์ธ ์ฑ์ฅ๊ณผ ์์ ์ฑ์ ํฐ ๋์์ด ๋ ๊ฑฐ์์.
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์ ๋ฏธ๋
๋ ์ธ์ด์ ๋ฐ์ ๋ฐฉํฅ์ ๊ณ ๋ คํ ๋, ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์ ์ด๋ป๊ฒ ๋ณํํ ๊น์?
ํ์ด๋ธ๋ฆฌ๋ ์ ๊ทผ ๋ฐฉ์
๋จ๊ธฐ์ ์ผ๋ก๋ C/C++์ ๋ฌ์คํธ๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ํ์ด๋ธ๋ฆฌ๋ ์ ๊ทผ ๋ฐฉ์์ด ์ฆ๊ฐํ ๊ฒ์ผ๋ก ์์๋ผ์. ๊ธฐ์กด C/C++ ์ฝ๋๋ฒ ์ด์ค๋ฅผ ์ ์งํ๋ฉด์, ์๋ก์ด ๊ธฐ๋ฅ์ด๋ ๋ณด์์ ๋ฏผ๊ฐํ ๋ถ๋ถ์ ๋ฌ์คํธ๋ก ๊ตฌํํ๋ ๋ฐฉ์์ด์ฃ .
์ด๋ฏธ Firefox, Android, Linux ์ปค๋ ๋ฑ์์ ์ด๋ฐ ์ ๊ทผ ๋ฐฉ์์ ๋ณผ ์ ์์ด์. ์ ์ง์ ์ธ ์ ํ์ ํตํด ๋ ๊ฑฐ์ ์ฝ๋์ ๊ฐ์น๋ฅผ ์ ์งํ๋ฉด์๋ ์์ ์ฑ์ ํฅ์์ํฌ ์ ์์ฃ .
ํ์ ๊ฒ์ฆ์ ์ค์์ฑ ์ฆ๊ฐ
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์๋ ํ์ ๊ฒ์ฆ(formal verification)์ ์ค์์ฑ์ด ๋์ฑ ์ปค์ง ๊ฑฐ์์. ๋ฌ์คํธ๋ ์ด๋ฏธ ํ์ ๊ฒ์ฆ ๋๊ตฌ์์ ํตํฉ์ด ์งํ ์ค์ด๋ฉฐ, ์ด๋ ์ํธํ ๊ตฌํ์ ์ ํ์ฑ์ ์ํ์ ์ผ๋ก ์ฆ๋ช ํ๋ ๋ฐ ๋์์ด ๋ ๊ฑฐ์์.
C++๋ ์ด๋ฐ ์ถ์ธ๋ฅผ ๋ฐ๋ผ๊ฐ๊ณ ์์ง๋ง, ์ธ์ด์ ๋ณต์ก์ฑ ๋๋ฌธ์ ์์ ํ ํ์ ๊ฒ์ฆ์ด ๋ ์ด๋ ค์ธ ์ ์์ด์.
์์ ๋ด์ฑ ์ํธํ
์์ ์ปดํจํฐ์ ๋ฐ์ ์ผ๋ก ์์ ๋ด์ฑ ์ํธํ(post-quantum cryptography)์ ์ค์์ฑ์ด ์ปค์ง๊ณ ์์ด์. ์ด๋ฐ ์๋ก์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํ ๋, ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ๊ณผ ์ ํ์ฑ์ด ๋์ฑ ์ค์ํด์ง ๊ฑฐ์์.
๋ฌ์คํธ์ ์์ ์ฑ ๋ณด์ฅ์ ์ด๋ฐ ๋ณต์กํ ์๋ก์ด ์๊ณ ๋ฆฌ์ฆ์ ๊ตฌํํ๋ ๋ฐ ํฐ ์ด์ ์ด ๋ ์ ์์ด์. ํ์ง๋ง C++๋ ๊ณ์ํด์ ์์ ์ฑ ๊ธฐ๋ฅ์ ๊ฐํํ๊ณ ์์ด, ๋ ์ธ์ด ๋ชจ๋ ์ด ๋ถ์ผ์์ ์ค์ํ ์ญํ ์ ํ ๊ฑฐ์์.
์ธ์ด ์ ํ์ ๋ฏธ๋
๋ฏธ๋์๋ ์ด๋ค ์ธ์ด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ข์๊น์?
๋จ๊ธฐ์ ์ ๋ง (1-3๋ )
๋จ๊ธฐ์ ์ผ๋ก๋ ํ๋ก์ ํธ์ ํน์ฑ๊ณผ ํ์ ์ ๋ฌธ์ฑ์ ๋ฐ๋ผ ์ธ์ด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์. ๊ธฐ์กด C++ ์ฝ๋๋ฒ ์ด์ค๊ฐ ์๊ฑฐ๋ C++ ์ ๋ฌธ๊ฐ๊ฐ ๋ง์ ํ์ด๋ผ๋ฉด C++๋ฅผ ์ ์งํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ด์ฃ .
์๋ก์ด ํ๋ก์ ํธ๋ฅผ ์์ํ๋ ๊ฒฝ์ฐ, ํนํ ๋ณด์์ด ์ค์ํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ๋ผ๋ฉด ๋ฌ์คํธ๋ฅผ ๊ณ ๋ คํด๋ณผ ๋งํด์. ์ด๊ธฐ ํ์ต ๋น์ฉ์ด ์์ง๋ง, ์ฅ๊ธฐ์ ์ผ๋ก ๋ฒ๊ทธ์ ์ทจ์ฝ์ ์ ์ค์ผ ์ ์๋ ์ด์ ์ด ์์ฃ .
์ค์ฅ๊ธฐ์ ์ ๋ง (3-10๋ )
์ค์ฅ๊ธฐ์ ์ผ๋ก๋ ๋ฌ์คํธ์ ์ฑํ์ด ๊ณ์ ์ฆ๊ฐํ ๊ฒ์ผ๋ก ์์๋ผ์. ํนํ ๋ณด์์ด ์ค์ํ ๋ถ์ผ์์ ๋ฌ์คํธ์ ์ ์ง๊ฐ ๊ฐํ๋ ๊ฑฐ์์.
ํ์ง๋ง C++๋ ๊ณ์ํด์ ๋ฐ์ ํ๊ณ ์์ด, ์์ ํ ๋์ฒด๋์ง๋ ์์ ๊ฑฐ์์. ๋ ์ธ์ด๊ฐ ๊ณต์กดํ๋ฉด์, ๊ฐ์์ ๊ฐ์ ์ ์ด๋ฆฐ ์์ญ์์ ์ฌ์ฉ๋ ๊ฐ๋ฅ์ฑ์ด ๋์์.
์ฅ๊ธฐ์ ์ ๋ง (10๋ ์ด์)
์ฅ๊ธฐ์ ์ผ๋ก๋ ์์ ์ฑ๊ณผ ์์ฐ์ฑ์ ๋ชจ๋ ๊ฐ์ถ ์ธ์ด๊ฐ ์์คํ ํ๋ก๊ทธ๋๋ฐ ๋ถ์ผ๋ฅผ ์ฃผ๋ํ ๊ฑฐ์์. ๋ฌ์คํธ๊ฐ ์ด๋ฐ ๋ฐฉํฅ์ผ๋ก ๋ฐ์ ํ๊ณ ์์ง๋ง, C++๋ ์์ ์ฑ์ ๊ฐํํ๋ ๋ฐฉํฅ์ผ๋ก ์งํํ๊ณ ์์ด์.
๋ํ ์์ ํ ์๋ก์ด ์ธ์ด๊ฐ ๋ฑ์ฅํด ๋ ์ธ์ด๋ฅผ ๋ชจ๋ ๋์ฒดํ ๊ฐ๋ฅ์ฑ๋ ์์ด์. ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ์ญ์ฌ๋ฅผ ๋ณด๋ฉด, 10๋ ์ด์์ ์ฅ๊ธฐ์ ๊ด์ ์์๋ ์์์น ๋ชปํ ๋ณํ๊ฐ ์์ฃผ ์ผ์ด๋๊ฑฐ๋ ์!
๋ฏธ๋๋ ๋ถํ์คํ์ง๋ง, ์์ ์ฑ๊ณผ ์ฑ๋ฅ์ ๋ชจ๋ ์ค์์ํ๋ ์ถ์ธ๋ ๊ณ์๋ ๊ฒ์ผ๋ก ๋ณด์ฌ์. ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์๋ผ๋ฉด ๋ ์ธ์ด์ ๋ฐ์ ์ ์ฃผ์ํ๋ฉด์, ํ๋ก์ ํธ์ ์๊ตฌ์ฌํญ์ ๊ฐ์ฅ ์ ํฉํ ๋๊ตฌ๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์.
์ฌ๋ฅ๋ท์์ ์ํธํ ๊ด๋ จ ํ๋ก์ ํธ๋ฅผ ๊ณํํ๊ณ ๊ณ์ ๋ค๋ฉด, ๋จ์ํ ํ์ฌ์ ์ํฉ๋ฟ๋ง ์๋๋ผ ๋ฏธ๋์ ๋ฐ์ ๋ฐฉํฅ๋ ๊ณ ๋ คํด๋ณด์ธ์. ์ฅ๊ธฐ์ ์ผ๋ก ์ ์ง๋ณด์ํ ํ๋ก์ ํธ๋ผ๋ฉด ๋์ฑ ๊ทธ๋ ์ฃ ! ๐ฎ
9. ๊ฒฐ๋ก : ์ด๋ค ์ธ์ด๊ฐ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ๋ ์ ํฉํ๊ฐ? ๐
์ง๊ธ๊น์ง ๋ฌ์คํธ์ C++๋ฅผ ๋ค์ํ ์ธก๋ฉด์์ ๋น๊ตํด๋ดค์ด์. ์ด์ ํต์ฌ ์ง๋ฌธ์ ๋ตํด๋ณผ ์๊ฐ์ด์์: ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ์ด๋ค ์ธ์ด๊ฐ ๋ ์ ํฉํ ๊น์?
๊ฐ ์ธ์ด์ ์ฅ๋จ์ ์์ฝ
C++์ ์ฅ๋จ์
์ฅ์ ๐
- ์ฑ์ํ ์ํ๊ณ: ๋ค์ํ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋๊ตฌ๊ฐ ์ด๋ฏธ ์กด์ฌํด์.
- ๊ด๋ฒ์ํ ์ฑํ: ๋ง์ ๊ธฐ์ ๊ณผ ํ๋ก์ ํธ์์ ์ด๋ฏธ ์ฌ์ฉ ์ค์ด์์.
- ์ฑ๋ฅ ์ต์ ํ: ์ ์์ค ์ต์ ํ๊ฐ ๊ฐ๋ฅํ๊ณ , ์ฑ๋ฅ ํ๋์ ์ต์ ์ด ๋ง์์.
- ์ ์ฐ์ฑ: ๋ค์ํ ํ๋ก๊ทธ๋๋ฐ ํจ๋ฌ๋ค์๊ณผ ์คํ์ผ์ ์ง์ํด์.
- ์ธ๋ ฅ ๊ฐ์ฉ์ฑ: C++ ๊ฐ๋ฐ์๋ฅผ ์ฐพ๊ธฐ๊ฐ ์๋์ ์ผ๋ก ์ฌ์์.
๋จ์ ๐
- ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ ๋ถ์กฑ: ๋ฒํผ ์ค๋ฒํ๋ก์ฐ, ์ ์ฆ ์ ํํฐ ํ๋ฆฌ ๋ฑ์ ์ทจ์ฝ์ ์ํ์ด ๋์์.
- ๋ณต์ก์ฑ: ์ธ์ด๊ฐ ๋งค์ฐ ๋ณต์กํด ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๊ธฐ ์ด๋ ค์ธ ์ ์์ด์.
- ์ผ๊ด์ฑ ๋ถ์กฑ: ๋ค์ํ ์ฝ๋ฉ ์คํ์ผ๊ณผ ๊ดํ์ด ์กด์ฌํด ์ฝ๋ ํ์ง์ด ์ผ์ ํ์ง ์์ ์ ์์ด์.
- ๊ธด ์ปดํ์ผ ์๊ฐ: ํนํ ํ ํ๋ฆฟ์ ๋ง์ด ์ฌ์ฉํ๋ ์ฝ๋๋ ์ปดํ์ผ ์๊ฐ์ด ๋งค์ฐ ๊ธธ ์ ์์ด์.
- ํ๋์ ๋๊ตฌ์ ๋ถ์กฑ: ํจํค์ง ๊ด๋ฆฌ, ๋น๋ ์์คํ ๋ฑ์ด ๋ค์ ๊ตฌ์์ผ ์ ์์ด์.
๋ฌ์คํธ์ ์ฅ๋จ์
์ฅ์ ๐
- ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ: ์ปดํ์ผ ํ์์ ๋๋ถ๋ถ์ ๋ฉ๋ชจ๋ฆฌ ๊ด๋ จ ๋ฒ๊ทธ๋ฅผ ๋ฐฉ์งํด์.
- ํ๋์ ์ธ ๋๊ตฌ: Cargo, Rustfmt, Clippy ๋ฑ ๊ฐ๋ฐ์ ๊ฒฝํ์ ํฅ์์ํค๋ ๋๊ตฌ๊ฐ ๊ธฐ๋ณธ ์ ๊ณต๋ผ์.
- ๋์์ฑ ์์ ์ฑ: ๋ฐ์ดํฐ ๋ ์ด์ค๋ฅผ ์ปดํ์ผ ํ์์ ๋ฐฉ์งํด์.
- ํํ๋ ฅ ์๋ ํ์ ์์คํ : ๊ฐ๋ ฅํ ํ์ ์์คํ ์ผ๋ก ๋ง์ ๋ฒ๊ทธ๋ฅผ ์ฌ์ ์ ๋ฐฉ์งํด์.
- ํ๋ฐํ ์ปค๋ฎค๋ํฐ: ์น์ ํ๊ณ ๋์์ด ๋๋ ์ปค๋ฎค๋ํฐ๊ฐ ์์ด์.
๋จ์ ๐
- ๊ฐํ๋ฅธ ํ์ต ๊ณก์ : ์์ ๊ถ ์์คํ ๋ฑ ์๋ก์ด ๊ฐ๋ ์ ๋ฐฐ์์ผ ํด์.
- ์๋์ ์ผ๋ก ์์ ์ํ๊ณ: C++์ ๋นํด ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋๊ตฌ๊ฐ ์ ์ ์ ์์ด์.
- ์ธ๋ ฅ ๊ฐ์ฉ์ฑ: ์๋ จ๋ ๋ฌ์คํธ ๊ฐ๋ฐ์๋ฅผ ์ฐพ๊ธฐ๊ฐ ์๋์ ์ผ๋ก ์ด๋ ค์ธ ์ ์์ด์.
- ๋ ๊ฑฐ์ ์ฝ๋์์ ํตํฉ: ๊ธฐ์กด C/C++ ์ฝ๋์ ํตํฉํ ๋ ์ถ๊ฐ ์์ ์ด ํ์ํ ์ ์์ด์.
- ์ปดํ์ผ ์๊ฐ: ๋ฆด๋ฆฌ์ค ๋น๋์ ์ปดํ์ผ ์๊ฐ์ด ๊ธธ ์ ์์ด์.
์ํฉ๋ณ ๊ถ์ฅ ์ธ์ด
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ์ด๋ค ์ธ์ด๊ฐ ๋ ์ ํฉํ์ง๋ ํ๋ก์ ํธ์ ํน์ฑ๊ณผ ์๊ตฌ์ฌํญ์ ๋ฐ๋ผ ๋ฌ๋ผ์ง ์ ์์ด์. ๋ช ๊ฐ์ง ์ํฉ๋ณ๋ก ๊ถ์ฅ ์ธ์ด๋ฅผ ์ดํด๋ณผ๊ฒ์.
C++๊ฐ ๋ ์ ํฉํ ๊ฒฝ์ฐ
- ๊ธฐ์กด C++ ์ฝ๋๋ฒ ์ด์ค๊ฐ ์๋ ๊ฒฝ์ฐ: ์ด๋ฏธ ์๋นํ ์์ C++ ์ฝ๋๊ฐ ์๋ค๋ฉด, ํธํ์ฑ์ ์ํด C++๋ฅผ ์ ์งํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ผ ์ ์์ด์.
- ๊ทนํ์ ์ฑ๋ฅ ์ต์ ํ๊ฐ ํ์ํ ๊ฒฝ์ฐ: ๋ชจ๋ ๋นํธ์ ์ฌ์ดํด์ ์ ์ดํด์ผ ํ๋ ๊ฒฝ์ฐ, C++์ ์ ์์ค ์ ์ด๊ฐ ์ ๋ฆฌํ ์ ์์ด์.
- ๋ค์ํ ํ๋ซํผ ์ง์์ด ํ์ํ ๊ฒฝ์ฐ: ์์ง๊น์ง๋ C++๊ฐ ๋ ๋ง์ ํ๋ซํผ์ ์ง์ํด์.
- ํ์ด C++ ์ ๋ฌธ๊ฐ๋ก ๊ตฌ์ฑ๋ ๊ฒฝ์ฐ: ํ์ ์ ๋ฌธ์ฑ์ ํ์ฉํ๋ ๊ฒ์ด ๋จ๊ธฐ์ ์ผ๋ก ๋ ํจ์จ์ ์ผ ์ ์์ด์.
๋ฌ์คํธ๊ฐ ๋ ์ ํฉํ ๊ฒฝ์ฐ
- ์๋ก์ด ํ๋ก์ ํธ๋ฅผ ์์ํ๋ ๊ฒฝ์ฐ: ๋ ๊ฑฐ์ ์ฝ๋์ ์ ์ฝ ์์ด ์ฒ์๋ถํฐ ์์ํ๋ค๋ฉด, ๋ฌ์คํธ์ ์์ ์ฑ ์ด์ ์ ์ต๋ํ ํ์ฉํ ์ ์์ด์.
- ๋ณด์์ด ์ต์ฐ์ ์ธ ๊ฒฝ์ฐ: ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ์ด ์ ๋์ ์ผ๋ก ์ค์ํ ๊ฒฝ์ฐ, ๋ฌ์คํธ์ ์ปดํ์ผ ํ์ ๊ฒ์ฌ๊ฐ ํฐ ์ด์ ์ด ๋ผ์.
- ๋์์ฑ์ด ์ค์ํ ๊ฒฝ์ฐ: ๋ฉํฐ์ค๋ ๋ฉ ์ฝ๋๊ฐ ๋ง์ ๊ฒฝ์ฐ, ๋ฌ์คํธ์ ๋ฐ์ดํฐ ๋ ์ด์ค ๋ฐฉ์ง ๊ธฐ๋ฅ์ด ๋งค์ฐ ์ ์ฉํด์.
- ์ฅ๊ธฐ์ ์ธ ์ ์ง๋ณด์๊ฐ ์ค์ํ ๊ฒฝ์ฐ: ์ฝ๋๊ฐ ์ค๋ ๊ธฐ๊ฐ ์ ์ง๋ณด์๋ ์์ ์ด๋ผ๋ฉด, ๋ฌ์คํธ์ ์์ ์ฑ๊ณผ ๋ช ํํ ์ฝ๋ ์คํ์ผ์ด ๋์์ด ๋ผ์.
ํ์ด๋ธ๋ฆฌ๋ ์ ๊ทผ์ด ์ข์ ๊ฒฝ์ฐ
- ๊ธฐ์กด C++ ์ฝ๋๋ฅผ ์ ์ง์ ์ผ๋ก ๊ฐ์ ํ๋ ๊ฒฝ์ฐ: ๋ณด์์ ๋ฏผ๊ฐํ ๋ถ๋ถ๋ถํฐ ๋ฌ์คํธ๋ก ์ฌ์์ฑํ๋ ์ ๋ต์ด ํจ๊ณผ์ ์ผ ์ ์์ด์.
- ๋ค์ํ ์ ๋ฌธ์ฑ์ ๊ฐ์ง ํ์ธ ๊ฒฝ์ฐ: C++์ ๋ฌ์คํธ ์ ๋ฌธ๊ฐ๊ฐ ๋ชจ๋ ์๋ค๋ฉด, ๊ฐ์์ ๊ฐ์ ์ ์ด๋ ค ํ์ ํ ์ ์์ด์.
- ๋ค์ํ ์๊ตฌ์ฌํญ์ด ์๋ ๊ฒฝ์ฐ: ์ผ๋ถ๋ ๊ทนํ์ ์ฑ๋ฅ์ด, ์ผ๋ถ๋ ์์ ์ฑ์ด ์ค์ํ ๊ฒฝ์ฐ ๋ ์ธ์ด๋ฅผ ์ ์ ํ ์กฐํฉํ ์ ์์ด์.
์ต์ข ๊ฒฐ๋ก
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ์ ์์ด ๋ฌ์คํธ๋ ๋ฉ๋ชจ๋ฆฌ ์์ ์ฑ, ๋์์ฑ ์์ ์ฑ, ํ๋์ ์ธ ๋๊ตฌ ๋ฑ์ ์ธก๋ฉด์์ ๋ช ํํ ์ด์ ์ ์ ๊ณตํด์. ํนํ ๋ณด์์ด ์ต์ฐ์ ์ธ ์๋ก์ด ํ๋ก์ ํธ์์๋ ๋ฌ์คํธ๊ฐ ๋ ๋์ ์ ํ์ผ ์ ์์ด์.
ํ์ง๋ง C++๋ ์ฌ์ ํ ์ฑ์ํ ์ํ๊ณ, ๊ด๋ฒ์ํ ์ฑํ, ์ ์ฐ์ฑ ๋ฑ์ ๊ฐ์ ์ ๊ฐ์ง๊ณ ์์ด์. ๊ธฐ์กด C++ ์ฝ๋๋ฒ ์ด์ค๊ฐ ์๊ฑฐ๋ ๊ทนํ์ ์ฑ๋ฅ ์ต์ ํ๊ฐ ํ์ํ ๊ฒฝ์ฐ์๋ C++๊ฐ ์ฌ์ ํ ์ข์ ์ ํ์ผ ์ ์์ฃ .
๊ฒฐ๊ตญ ํ๋ก์ ํธ์ ๊ตฌ์ฒด์ ์ธ ์๊ตฌ์ฌํญ, ํ์ ์ ๋ฌธ์ฑ, ์ฅ๊ธฐ์ ์ธ ๋ชฉํ๋ฅผ ๊ณ ๋ คํด ์ ์ ํ ์ธ์ด๋ฅผ ์ ํํ๋ ๊ฒ์ด ์ค์ํด์. ๋๋ก๋ ๋ ์ธ์ด๋ฅผ ํจ๊ป ์ฌ์ฉํ๋ ํ์ด๋ธ๋ฆฌ๋ ์ ๊ทผ์ด ์ต์ ์ ํด๊ฒฐ์ฑ ์ผ ์๋ ์์ด์.
์ด๋ค ์ธ์ด๋ฅผ ์ ํํ๋ , ์ฝ๋ ํ์ง, ํ ์คํธ ์ปค๋ฒ๋ฆฌ์ง, ๋ณด์ ๊ฒํ ๋ฑ ์ข์ ์ํํธ์จ์ด ๊ฐ๋ฐ ๊ดํ์ ๋ฐ๋ฅด๋ ๊ฒ์ด ๋ฌด์๋ณด๋ค ์ค์ํด์. ์ธ์ด๋ ๋๊ตฌ์ผ ๋ฟ, ๊ทธ ๋๊ตฌ๋ฅผ ์ด๋ป๊ฒ ์ฌ์ฉํ๋๋๊ฐ ๋ ์ค์ํ๋๊น์!
์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์ ๋งค์ฐ ์ค์ํ๊ณ ์ฑ ์๊ฐ์ด ํ์ํ ์์ ์ด์์. ์ฌ๋ฅ๋ท์์ ์ด๋ฐ ํ๋ก์ ํธ๋ฅผ ์๋ขฐํ์ค ๋๋, ๋จ์ํ ์ธ์ด ์ ํ๋ฟ๋ง ์๋๋ผ ๊ฐ๋ฐ์์ ๋ณด์ ์์๊ณผ ๊ฒฝํ๋ ์ค์ํ๊ฒ ๊ณ ๋ คํด๋ณด์ธ์. ์์ ํ๊ณ ํจ์จ์ ์ธ ์ํธํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ฐ๋ฐ์ ์ํ ์ต์ ์ ์ ํ์ ํ์๊ธธ ๋ฐ๋๋๋ค! ๐
๊ด๋ จ ํค์๋
๋๊ธ ์์ฑ
์ด ๊ธ์ ๋ํ ์ฌ๋ฌ๋ถ์ ์๊ฐ์ ๋ค๋ ค์ฃผ์ธ์
๋ก๊ทธ์ธ์ด ํ์ํฉ๋๋ค
๋๊ธ์ ์์ฑํ๋ ค๋ฉด ๋จผ์ ๋ก๊ทธ์ธํด์ฃผ์ธ์.
๋๊ธ 0
์ง์์ธ์ ์ฒ - ์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
์ง์ ์ฌ์ฐ๊ถ ๋ณดํธ ๊ณ ์ง
- ์ ์๊ถ ๋ฐ ์์ ๊ถ: ๋ณธ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ๋ ์ AI ๊ธฐ์ ๋ก ์์ฑ๋์์ผ๋ฉฐ, ๋ํ๋ฏผ๊ตญ ์ ์๊ถ๋ฒ ๋ฐ ๊ตญ์ ์ ์๊ถ ํ์ฝ์ ์ํด ๋ณดํธ๋ฉ๋๋ค.
- AI ์์ฑ ์ปจํ ์ธ ์ ๋ฒ์ ์ง์: ๋ณธ AI ์์ฑ ์ปจํ ์ธ ๋ ์ฌ๋ฅ๋ท์ ์ง์ ์ฐฝ์๋ฌผ๋ก ์ธ์ ๋๋ฉฐ, ๊ด๋ จ ๋ฒ๊ท์ ๋ฐ๋ผ ์ ์๊ถ ๋ณดํธ๋ฅผ ๋ฐ์ต๋๋ค.
- ์ฌ์ฉ ์ ํ: ์ฌ๋ฅ๋ท์ ๋ช ์์ ์๋ฉด ๋์ ์์ด ๋ณธ ์ปจํ ์ธ ๋ฅผ ๋ณต์ , ์์ , ๋ฐฐํฌ, ๋๋ ์์ ์ ์ผ๋ก ํ์ฉํ๋ ํ์๋ ์๊ฒฉํ ๊ธ์ง๋ฉ๋๋ค.
- ๋ฐ์ดํฐ ์์ง ๊ธ์ง: ๋ณธ ์ปจํ ์ธ ์ ๋ํ ๋ฌด๋จ ์คํฌ๋ํ, ํฌ๋กค๋ง, ๋ฐ ์๋ํ๋ ๋ฐ์ดํฐ ์์ง์ ๋ฒ์ ์ ์ฌ์ ๋์์ด ๋ฉ๋๋ค.
- AI ํ์ต ์ ํ: ์ฌ๋ฅ๋ท์ AI ์์ฑ ์ปจํ ์ธ ๋ฅผ ํ AI ๋ชจ๋ธ ํ์ต์ ๋ฌด๋จ ์ฌ์ฉํ๋ ํ์๋ ๊ธ์ง๋๋ฉฐ, ์ด๋ ์ง์ ์ฌ์ฐ๊ถ ์นจํด๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
์์ง ๋๊ธ์ด ์์ต๋๋ค.