์ด๊ฒ์ RFC "์๋ก์ด MaybeUninit
์ ํ์ ์ํด uninitialized
์ค๋จ"(rust-lang / rfcs # 1892)์ ๋ํ ์ถ์ ๋ฌธ์ ์
๋๋ค.
๋จ๊ณ :
ํด๊ฒฐ๋์ง ์์ ์ง๋ฌธ :
&mut T
๋ฅผ ๋ฐํํ๋ ์์ ํ setter๊ฐ ์์ด์ผํฉ๋๊น?MaybeUninit
์ด๋ฆ์ ๋ฐ๊ฟ์ผํฉ๋๊น?into_inner
์ด๋ฆ์ ๋ฐ๊ฟ์ผํฉ๋๊น?MaybeUninit<T>
์ Copy
์ ๋ํด T: Copy
?get_ref
๋ฐ get_mut
(๋ฐํ ๋ ์ฐธ์กฐ์์ ์ฝ์ง ์์) ํธ์ถ์ ํ์ฉํด์ผํฉ๋๊น? (์ผ๋ช
: "์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ insta-UB์ ๋ํ ์ฐธ์กฐ์
๋๊น, ์๋๋ฉด ์ฝ์ ๋๋ง UB์
๋๊น?") into_inner
์ ๋น์ทํ๊ฒ ์ด๋ฆ์ ๋ฐ๊ฟ์ผํฉ๋๊น?T
mem::uninitialized
๊ฐ ํ์ฌ into_inner
(๋๋ ๊ทธ ์ด๋ฆ์ด ๋ฌด์์ด๋ ๊ฐ์) ๋นํฉํ๊ฒ ๋ง๋ค ์ ์์ต๋๊น?mem::zeroed
ํ๊ธฐํ์ง ์์ผ๋ ค๋ ๊ฒ ๊ฐ์ต๋๋ค.cc @RalfJung
[] RFC ๊ตฌํ
RFC ๊ตฌํ์ ๋์ธ ์ ์์ต๋๋ค.
๊ฐ์ฌํฉ๋๋ค. ๊ฒํ ๋ฅผ ๋์ ๋๋ฆด ์ ์์ต๋๋ค. :)
RFC์์ด ๋ถ๋ถ์ ๋ํ ์ค๋ช ์ด ํ์ํฉ๋๋ค.
๋น ์ ํ์์ ํธ์ถ์ด ์ด๊ธฐํ๋์ง ์๋๋ก ์ค์ ํ๋ฉด ์ฌ์ฉ ์ค๋จ ๋ฉ์์ง๋ ์ธ์ํ๋ ๋ฐํ์ ํจ๋์ด ํธ๋ฆฌ๊ฑฐ๋ฉ๋๋ค.
๋จ์งํด์ผ mem::uninitialized::<!>()
๋นํฉ? ์๋๋ฉด ๋น ์ ํ (์ : (!, u8)
)์ ํฌํจํ๋ ๊ตฌ์กฐ์ฒด (๊ทธ๋ฆฌ๊ณ ์๋ง๋ ์ด๊ฑฐ ํ?)๋ ํฌํจํด์ผํฉ๋๊น?
AFAIK ์ฐ๋ฆฌ๋ !
๋ํด์๋ง ์ ๋ง ์ ํดํ ์ฝ๋ ์์ฑ์ ์ํํฉ๋๋ค. mem::uninitialized
์ ๋๋ถ๋ถ์ ๋ค๋ฅธ ์ฉ๋๋ ๋๊ฐ์ด ์ฌ๋ฐ๋ฅด์ง ์์ง๋ง ์ปดํ์ผ๋ฌ๋์ด๋ฅผ ์
์ฉํ์ง ์์ต๋๋ค.
๊ทธ๋์ ์ ๋ !
๋ก๋งํ๊ณ mem::zeroed
๋ก๋ ํ ๊ฒ์
๋๋ค. (์ ๋ RFC์ zeroed
๋ฅผ ์ถ๊ฐํ์ ๋ ๊ทธ ๋ถ๋ถ์ ์์ ํ๋ ๊ฒ์ ์์์ต๋๋ค.)
๋จผ์ ๋ค์๊ณผ ๊ฐ์ด ๋ง๋ค ์ ์์ต๋๋ค.
https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc_codegen_llvm/intrinsic.rs#L184 -L198
fn_ty.ret.layout.abi
๊ฐ Abi::Uninhabited
ํ๊ณ ์ต์ํ ํธ๋ฉ์ ๋ด ๋ณด๋
๋๋ค. ์ : https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc_codegen_llvm/mir/ ํผ์ฐ์ฐ์ .rs # L400 -L403
์๋์ค์ธ ํจ์ (์ : intrinsics::abort
)์ ๋ณธ ํ์๋ ํจ๋์ ์ ๋ฐํ๋ ์ข์ ๋ฐฉ๋ฒ์ด ์๋์ง ํ์ธํ ์ ์์ต๋๋ค. ํ๊ธฐ ๋๋ฌธ์ ๊น๋ค๋กญ๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์์ ํน์ ์ผ์ด์ค๋ฅผ ์ฌ์ฉํด์ผํฉ๋๋ค : https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc_codegen_llvm/mir/block.rs#L445- L447
์ค์ ๋ก ๋นํฉํ๋ ค๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒ์ด ํ์ํฉ๋๋ค : https://github.com/rust-lang/rust/blob/8928de74394f320d1109da6731b12638a2167945/src/librustc_codegen_llvm/mir/block.rs#L360 -L407
( EvalErrorKind::BoundsCheck
ํ์ ๋ฌด์ํ ์ ์์ต๋๋ค)
@eddyb ํฌ์ธํฐ ์ฃผ์ ์ ๊ฐ์ฌํฉ๋๋ค.
์ด์ (์ฌ๋ฌ ๊ฐ์ง) ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ์์ ํ๊ณ ์์ผ๋ฉฐ sed -i s/mem::uninitialized()/mem::MaybeUninit::uninitialized().into_inner()/g
๋ง ์คํํ๊ณ ์ถ์ ์ ํน์ (๋งค์ฐ) ๋๋ผ์ง๋ง ์์ ์ ๋์น ๊ฒ ๊ฐ๋ค์ ... (๋ณต์ฌ) ์ ํ? ์ : let x: [u8; 1024] = mem::uninitialized();
.
์ ํํ ์์ ์ ๋์น ๊ฒ ๊ฐ๋ค์. ^^
์ ์ด๋ ์ง๊ธ์ ๋ชจ๋ ๋น ์กฐํฉ ์ ํ์ ๋ํด mem::MaybeUninit::uninitialized().into_inner()
UB๋ฅผ ๊ณ ๋ คํ๊ณ ์ถ์ต๋๋ค. Copy
๋ก๋ ํ์คํ ์ถฉ๋ถํ์ง ์์ต๋๋ค. bool
๋ฐ &'static i32
๋ ๋ชจ๋ Copy
์ด๋ฉฐ ์ค ๋ํซ์ ์ด๋ค์์ํ insta-UB ์ฉ์
๋๋ค. "๋ชจ๋ ๋นํธ ํจํด์ด ๊ด์ฐฎ์ ์ ํ"(์ ์ ์ ํ, ๋ณธ์ง์ ์ผ๋ก)์ ๋ํ ์์ธ๋ฅผ ์ํ ์ ์์ง๋ง undef
๋ ์ ์์ ์ธ ๋นํธ ํจํด์ด ์๋๊ธฐ ๋๋ฌธ์ ์ด๋ฌํ ์์ธ๋ฅผ ๋ง๋๋ ๊ฒ์ ๋ฐ๋ํฉ๋๋ค. ์ด๊ฒ์ด RFC์์ into_inner
๋ฅผ ํธ์ถํ๊ธฐ ์ ์ ์์ ํ ์ด๊ธฐํํด์ผํ๋ค๊ณ ๋งํ๋ ์ด์ ์
๋๋ค.
๋ํ get_mut
์ ๋ํด ์ธ๊ธํ์ง๋ง RFC ๋
ผ์๋ ์ฌ๊ธฐ์์ ์ ํ์ ์ํํ๊ธฐ๋ฅผ ์ํ๋ ์ผ๋ถ ์ฌ๋๋ค์ด ์ ๊ธฐํ์ต๋๋ค. ๊ทธ๊ฒ์ ๋ด๊ฐ ํจ๊ป ์ด ์์๋ ์ต์
์
๋๋ค. ๊ทธ๋ฌ๋ into_inner
์๋๋๋ค.
uninitialized
์ ์ด๋ฌํ ๋ชจ๋ ์ฌ์ฉ์ ๋ํด๋ณด๋ค ์ ์คํ๊ฒ ๊ฒํ ํด์ผ ํ ๊ฒ์ด ๋๋ ต์ต๋๋ค. ์ฌ์ค ์ด๊ฒ์ RFC์ ์๋ ์ค ํ๋์์ต๋๋ค. ๋ชจ๋ ์ฌ๋์ด ์ฆ์ into_inner
๋ง ์ฌ์ฉํ๋ค๋ฉด RFC๋ ์ธ๋ชจ๊ฐ ์์์ต๋๋ค.
๋ชจ๋ ์ฌ๋์ด ์ฆ์
into_inner
๋ง ์ฌ์ฉํ๋ค๋ฉด RFC๋ ์ธ๋ชจ๊ฐ ์์์ต๋๋ค.
์ด๊ฒ์ ๋์๊ฒ ์์ด๋์ด๋ฅผ ์ค๋ค. ์๋ง๋ ์ฐ๋ฆฌ๋ ์ด๋ฐ ์ข ๋ฅ์ ์ฝ๋๋ฅผ ๋ฆฐํธ (๊ทธ๋ฃน : "์ ํ์ฑ")ํด์ผ ํ ๊น? cc @ oli-obk
์ด์ (์ฌ๋ฌ) ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ์์ ํ๊ณ ์์ต๋๋ค.
๊ถ์ฅ ๊ต์ฒดํ์ด ์ ์ด๋ Stable์์ ์ฌ์ฉ ๊ฐ๋ฅํ ๊ฒฝ์ฐ์๋ง ์ด๋ฌํ ๊ฒฝ๊ณ ์ ํจ๊ป Nightly๋ฅผ ๋ฐฐ์กํด์ผํฉ๋๋ค. https://github.com/rust-lang/rust/pull/52994#issuecomment -411413493์์ ์ ์ฌํ ํ ๋ก ์
๋ฟก๋ฟก
"๋ชจ๋ ๋นํธ ํจํด์ด ๊ด์ฐฎ์ ์ ํ"(๊ธฐ๋ณธ์ ์ผ๋ก ์ ์ ์ ํ)์ ๋ํ ์์ธ๊ฐ ํ์ํ ์ ์์ต๋๋ค.
๋น์ ์ ์ด์ ์ ์ด๊ฒ์ ๋ํ ํ ๋ก ์ ์ฐธ์ฌํ์ง๋ง ๋ ๋๋ฆฌ ํผ ๋จ๋ฆฌ๊ธฐ ์ํด ์ฌ๊ธฐ์ ๊ฒ์ ํ ๊ฒ์
๋๋ค. ์ด๊ฒ์ ์ด๋ฏธ Fuchsia์์ ๋ง์ ๊ธฐ์กด ์ฌ์ฉ ์ฌ๋ก๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ ์ด์ ๋ํ ํน์ฑ์ด ์์ต๋๋ค ( FromBytes
) ๋ฐ ์ด๋ฌํ ์ ํ์ ๋ํ ํ์ ๋งคํฌ๋ก. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ (cc @gnzlbg @joshlf)์ ์ถ๊ฐํ๊ธฐ์ํ ๋ด๋ถ Pre-RFC ๋ ์์ต๋๋ค.
undef๋ ์ ์์ ์ธ ๋นํธ ํจํด์ด ์๋๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฌํ ์์ธ๋ฅผ ๋ง๋๋ ๊ฒ์ ๋ฐ๋ํฉ๋๋ค.
์, ์ด๊ฒ์ mem::zeroed()
๊ฐ mem::uninitialized()
ํฌ๊ฒ ๋ค๋ฅธ ์ธก๋ฉด์
๋๋ค.
๋ฟก ๋นต๋จ
๋น์ ์ ์ด์ ์ ์ด๊ฒ์ ๋ํ ํ ๋ก ์ ์ฐธ์ฌํ์ง๋ง ๋ ๋๋ฆฌ ํผ์ง๊ธฐ ์ํด ์ฌ๊ธฐ์ ๊ฒ์ ํ ๊ฒ์ ๋๋ค. ์ด๊ฒ์ ์ด๋ฏธ ์ฐ๋ฆฌ๊ฐ Fuchsia์์ ๋ง์ ๊ธฐ์กด ์ฌ์ฉ ์ฌ๋ก๋ฅผ ๊ฐ์ง๊ณ ์๊ณ ์ฐ๋ฆฌ๋ ์ด๊ฒ์ ๋ํ ํน์ฑ (FromBytes)๊ณผ ํ์ ๋งคํฌ๋ก๋ฅผ ๊ฐ์ง๊ณ ์์ต๋๋ค. ์ด๋ฌํ ์ ํ์ ๋ํด. ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ (cc @gnzlbg @joshlf)์ ์ถ๊ฐํ๊ธฐ์ํ ๋ด๋ถ Pre-RFC๋ ์์ต๋๋ค.
์ด๋ฌํ ๋
ผ์๋ ์ ํ๊ฐ์ ์์ ํ memcpy
๋ฅผ ํ์ฉํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๊ฒ์ด์์ง๋ง ๋ณต์ฌ์ค์ธ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ด๊ธฐํ๋์๋์ง ์ฌ๋ถ์ ๊ฑฐ์ ์ง๊ตํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฃ์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ๋น ์ ธ ๋๊ฐ๋๋ค.
๋ํ, ์์ ํ Rust์์ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ํ ํํ ์ธ ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ ์ฝ์ ์ ์๋๋ก ๋ ผ์ํ ๋ชจ๋ ์ ๊ทผ ๋ฐฉ์์ ๋ถ๊ฑด์ ํ๋ค๋ ์๊ฒฌ๋์์์ต๋๋ค. ์ฆ, ์ด๊ธฐํ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฃ์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค.
IIRC, ๊ฑฐ๊ธฐ์์ ์๋ฌด๋ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฃ๊ณ ์ด๊ธฐํ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ฌ ์์๋ ์ ๊ทผ ๋ฐฉ์์ ์ ์ํ๊ฑฐ๋ ๋ ผ์ํ์ง ์์๊ธฐ ๋๋ฌธ์์ด ํ ๋ก ์ด์ด ํ ๋ก ๊ณผ ๊ด๋ จ์ด์๋ ๊ฒ์ ๋ฐ๋ฅด์ง ์์ต๋๋ค. ๋์๊ฒ ๊ทธ๋ค์ ์์ ํ ์ง๊ฐ์ ๋๋ค.
ํฌ์ธํธ ํ์ ์กฐ๊ธ ๋ ์ ๋ํ๊ธฐ ์ํด LLVM์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ "์ผ๋ถ ์์์ ์ด์ง๋ง ์ ํจํ ๋นํธ ํจํด"๊ณผ ๊ตฌ๋ณ๋๋ Poison์ผ๋ก ์ ์ํฉ๋๋ค. Poison ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ๋ถ๊ธฐํ๊ฑฐ๋์ด๋ฅผ ์ญ ์ฐธ์กฐ ๋ ์ฃผ์๋ฅผ ๊ณ์ฐํ๋ ๋ฐ ์ฌ์ฉํ๋ ๊ฒ์ UB์ ๋๋ค. ๊ทธ๋์ ์ํ๊น๊ฒ๋ "๋ชจ๋ ๋นํธ ํจํด์ด ๊ด์ฐฎ์ ์ ํ"์ ๋ณ๋๋ก ์ด๊ธฐํํ์ง ์๊ณ ์ฌ์ฉํ๋ ๊ฒ์ด UB๊ฐ๋๊ธฐ ๋๋ฌธ์ ์ฌ์ ํ ๊ตฌ์ฑํ๊ธฐ์ ์์ ํ์ง ์์ต๋๋ค.
๋ง์, ๋ฏธ์ํด, ๋ด๊ฐ ๋ฌด์จ ๋ป์ธ์ง ๋ช ํํ ํ์ด์ผ ํ์ด. "๋ชจ๋ ๋นํธ ํจํด์ด ๊ด์ฐฎ์ ์ ํ"์ ์ด๋ฏธ ๋ค๋ฅธ ์ด์ ๋ก ์ ์ํ๊ณ ์ถ์ ๊ฒ์ ๋๋ค. @RalfJung์ด ์์์ ๋งํ๋ฏ์ด,
undef๋ ์ ์์ ์ธ ๋นํธ ํจํด์ด ์๋๊ธฐ ๋๋ฌธ์ ๊ทธ๋ฌํ ์์ธ๋ฅผ ๋ง๋๋ ๊ฒ์ ๋ฐ๋ํฉ๋๋ค.
๊ธ์ ์ฝ์ ์์๋ ๋ถ๋ค์ด ๊ณ์ ๋ ๋คํ์ ๋๋ค.
๋ง์ต๋๋ค, ๊ทธ๋์ ์ ๊ฐ ๋งํ๊ณ ์ํ๋ ๊ฒ์ : ์ฐ๋ฆฌ๋ ํ์คํ ๋ชจ๋ ์ด๊ธฐํ ๋ ๋นํธ ํจํด์ด ๊ด์ฐฎ์ ํ์
์ ๊ฐ์ง๊ณ ์์ต๋๋ค-๋ชจ๋ i*
๋ฐ u*
์ ํ, ์์ ํฌ์ธํฐ, ์ ์๊ฐ์๋ f*
๋ฟ๋ง ์๋๋ผ ๊ทธ๋ฐ ์ ํ์ผ๋ก ๋ง ๊ตฌ์ฑ๋ ํํ / ๊ตฌ์กฐ์ฒด.
๊ณต๊ฐ ๋ ์ง๋ฌธ์ ์ด๋ค ์ํฉ์์ ์ด๋ฌํ ์ ํ์ด ์ด๊ธฐํ๋์ง ์๋๋ก ํ์ฉ๋๋์ง, ์ฆ ๋ ์ด ํ์ฉ๋๋ ๊ฒ์ ๋๋ค. ๋ด๊ฐ ์ ํธํ๋ ๋๋ต์ "์ ๋"์ ๋๋ค.
๋ํ, ์์ ํ Rust์์ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ํ ํํ ์ธ ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ ์ฝ์ ์ ์๋๋ก ๋ ผ์ํ ๋ชจ๋ ์ ๊ทผ ๋ฐฉ์์ ๋ถ๊ฑด์ ํ๋ค๋ ์๊ฒฌ๋์์์ต๋๋ค. ์ฆ, ์ด๊ธฐํ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฃ์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค.
ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ MaybeUninit<u8>
๋ก ์ฝ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๋ํ, ์์ ํ Rust์์ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ํ ํํ ์ธ ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ ์ฝ์ ์ ์๋๋ก ๋ ผ์ํ ๋ชจ๋ ์ ๊ทผ ๋ฐฉ์์ ๋ถ๊ฑด์ ํ๋ค๋ ์๊ฒฌ๋์์์ต๋๋ค. ์ฆ, ์ด๊ธฐํ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฃ์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ์ ธ์ฌ ์ ์์ต๋๋ค.
ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ MaybeUninit๋ก ์ฝ๊ธฐ
๊ด์ฐฎ์๊ฑฐ์ผ.
์์ปจ๋ ๋
ผ์๋ ํน์ฑ์ ์ ๊ณต์ ์์๋ค Compatible<T>
์์ ํ ๋ฐฉ๋ฒ์ผ๋ก, fn safe_transmute(self) -> T
ํ๋ "์ฌ ํด์"/ "memcpys"์ ๋นํธ self
๋ก T
. ์ด ๋ฉ์๋์ ๋ณด์ฅ์ self
์ด ์ ๋๋ก ์ด๊ธฐํ๋๋ฉด ๊ฒฐ๊ณผ T
๋ง์ฐฌ๊ฐ์ง์
๋๋ค. ์ปดํ์ผ๋ฌ๊ฐ ์ ์ด ๊ตฌํ์ ์๋์ผ๋ก ์ฑ์ฐ๋๋ก ์ ์๋์์ต๋๋ค. ์๋ฅผ ๋ค์ด impl Compatible<V> for U
๋ฐ impl Compatible<W> for V
๊ฐ์๋ ๊ฒฝ์ฐ impl Compatible<W> for U
(์ ๊ณต ๋์๊ธฐ ๋๋ฌธ์ ์๋์ผ๋ก ๋๋ ์ปดํ์ผ๋ฌ๊ฐ ์๋์ผ๋ก ์์ฑํฉ๋๋ค. ๊ตฌํ ๋ฐฉ๋ฒ์ ์์ ํ ์๋์ผ๋ก ์ฒ๋ฆฌ๋์์ต๋๋ค.)
ํธ๋ ์ด ํธ๋ฅผ ๊ตฌํํ๋ ค๋ฉด unsafe
์ด์ด์ผํ๋ค๊ณ ์ ์๋์์ต๋๋ค. Self
์ ํ๋๊ฐ์๋ ํจ๋ฉ ๋ฐ์ดํธ๊ฐ์๋ T
๋ํด ๊ตฌํํ๋ฉด ๋ชจ๋ ๊ฒ์ด ์ ์์
๋๋ค. T
๋ฅผ ์ฌ์ฉํ๋ ค๊ณ ํ ๋๊น์ง ํ๋ก๊ทธ๋จ ๋์์ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ด์ฉ์ ๋ฐ๋ผ ๋๋ฉ๋๋ค.
๋๋ ์ด๊ฒ์ด MaybeUninit<u8>
๊ณผ ์ด๋ค ๊ด๋ จ์ด ์๋์ง ์ ํ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ์์ธํ ์ค๋ช
ํด ์ฃผ์๊ฒ ์ต๋๊น?
๋ด๊ฐ ์์ํ ์์๋ ์ ์ผํ ๊ฒ์ ๋ธ๋ญํท impl : unsafe impl<T> Compatible<[MaybeUninit<u8>; size_of::<T>()]> for T { ... }
์ถ๊ฐ ํ ์ ์๋ค๋ ๊ฒ์
๋๋ค. ๋ชจ๋ ์ ํ์ [MaybeUninit<u8>; N]
ํฌ๊ธฐ๋ก ๋ณํํ๋ ๊ฒ์ด ๋ชจ๋ ์ ํ์ ์์ ํ๊ธฐ ๋๋ฌธ์
๋๋ค. MaybeUninit
๊ฐ ๊ณต์ฉ์ฒด์ด๊ณ [MaybeUninit<u8>; N]
์ฌ์ฉํ๋ ์ฌ๋์ ๋ฐฐ์ด์ ํน์ ์์๊ฐ ์ด๊ธฐํ๋์๋์ง ์ฌ๋ถ๋ฅผ ์์ง ๋ชปํ๋ฏ๋ก ์ด๋ฌํ impl์ด ์ผ๋ง๋ ์ ์ฉํ ์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค
RustConf ์ @nikomatsakis์์ด ์ ์์ ๋ํด ๋ ผ์ํ๊ณ ๊ทธ๋ RFC๋ฅผ ์งํํ๋๋ก ๊ถ์ฅํ์ต๋๋ค. ๋ช ์ฃผ ์์ํ๋ ค๊ณ ํ๋๋ฐ ๊ด์ฌ์ด ์์ผ๋ฉด ์ด๋ฒ ์ฃผ๋ง์ํด๋ณผ ์ ์์ต๋๋ค. ์ด ํ ๋ก ์ ์ ์ฉํ ๊น์?
@joshlf ์ด๋ค ์ ์์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๊น?
๋ฟก๋ฟก
@gnzlbg ๊ทธ๋๋ FromBits์ ๋ํด ์ด์ผ๊ธฐํ์ต๋๋ค.
[u8]. ์ฌ๊ธฐ์ [MaybeUninit ] ๋์ .
Gotcha, ์ฌ๊ธฐ์ ์์ ํ ๋์ํฉ๋๋ค. ์ฐ๋ฆฌ๋ ๊ทธ๋ ๊ฒํ๊ณ ์ถ์๋ค๋ ์ฌ์ค์ ์์ ํ ์์์ต๋๋ค ๐
@joshlf ์ด๋ค ์ ์์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๊น?
FromBits
/ IntoBits
์ ์. TLDR : T: FromBits<U>
์๋จ ์ ํจํ ์์์ ๋นํธ ํจํด U
์ ํจํ์ ๋์ T
. U: IntoBits<T>
๋ ๊ฐ์ ์๋ฏธ์
๋๋ค. ์ปดํ์ผ๋ฌ๋ ํน์ ๊ท์น์ด ์ฃผ์ด์ง๋ฉด ๋ชจ๋ ์ ํ ์์ ๋ํด ์๋์ผ๋ก ๋ ๊ฐ์ง ์ ํ์ ๋ชจ๋ ์ถ๋ก ํ๋ฏ๋ก ํ์ฌ unsafe
ํ์๋กํ๋ ๋ง์ ์ฌ๋ฏธ์๋ ๊ธฐ๋ฅ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด RFC์ ์ด์์ด ์ฌ๊ธฐ ์ ์๋๋ฐ ์ผ๋ง ์ ์ ์์ฑํ ๊ฒ์ด์ง๋ง, ๊ทธ ๋ด์ฉ์ ์๋น ๋ถ๋ถ์ ๋ณ๊ฒฝํ๋ ค๊ณ ํ๋ฏ๋ก ํด๋น ํ
์คํธ๋ฅผ ๋๋ต์ ์ธ ๊ฐ์ด๋๋ก ๋ฐ์๋ค์ด์ง ๋ง์ญ์์ค.
@joshlf ๋๋ ๊ทธ๋ฌํ ํ ์์ ํน์ฑ์ด ํ ๋ก ์ ์ผ๋ถ๊ฐ๋๊ธฐ
MaybeUninit::get_mut
๋ฌธ์๋ฅผ ์กฐ์ ํด์ผํฉ๋๋ค (์ค์ ๋ก ์ด๊ธฐํ๋ฅผ ์๋ฃํ๊ธฐ ์ ์ ์ฌ์ฉํ๋ ๊ฒ์ UB๊ฐ ์๋์ง๋ง ์ด๊ธฐํ๋ฅผ ์๋ฃํ๊ธฐ ์ ์ ์ญ ์ฐธ์กฐ ํ๋ ๊ฒ์ UB์
๋๋ค). ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๋จผ์ ๊ทธ ๊ฒฐ์ ์ ํ๋น์ฑ์ ์ํด ๋ด๋ ค์ผํ๋๋ฐ, ๊ทธ ์ฅ์๊ฐ ๋ฌด์์ธ์ง ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ์๋ง๋ ์ ์ฉ RFC์ผ๊น์?u8
(๋ฐ ๊ธฐํ ์ ์ ์ ํ, ๋ถ๋ ์์์ , ์์ ํฌ์ธํฐ)๋ฅผ ์ด๊ธฐํํด์ผํฉ๋๊น? ์ฆ, MaybeUinit<u8>::uninitialized().into_inner()
insta-UB์
๋๊น? ๋๋ ๊ทธ๋ ๊ฒ ์๊ฐํ์ง๋ง, ๋๋ถ๋ถ ์ฐ๋ฆฌ๊ฐ poison
/ undef
๋ฅผ ํ์ฉํ๋ ์ฅ์๋ฅผ ์ต์ํ์ผ๋ก ์ ์งํ๊ณ ์ถ๋ค๋ ์ง๊ฐ์ ๊ทผ๊ฑฐํฉ๋๋ค. ๊ทธ๋ฌ๋์ด ํจํด์ ๋ง์ด ์ฌ์ฉํ๋ค๋ฉด ์ค๋ ํ ์ ์์ต๋๋ค (๋ฏธ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ์ด๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ๋์์ด๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค).์ฐธ์กฐ ์๋์์ ๋ฐ๋ณต๋ฉ๋๊น?
@RalfJung "์ฐธ์กฐ ์๋
u8 (๋ฐ ๊ธฐํ ์ ์ ์ ํ, ๋ถ๋ ์์์ , ์์ ํฌ์ธํฐ)์ ์ด๊ธฐํํด์ผํฉ๋๊น? ์ฆ, MaybeUinit์ ๋๋ค.
:: uninitialized (). into_inner () insta-UB?
์ธ์คํดํธ UB๊ฐ ์๋๋ฉด ์ด๋ป๊ฒ ๋๋์? ๊ทธ ๊ฐ์น๋ก ๋ฌด์์ ํ ์ ์์ต๋๊น? ์ผ์น์ํฌ ์ ์์ต๋๊น? ๊ทธ๋ ๋ค๋ฉด ํ๋ก๊ทธ๋จ ๋์์ด ๊ฒฐ์ ์ ์ ๋๊น?
UB๋ฅผ ๋์
ํ์ง ์๊ณ ๋ ๊ฐ์น๋ฅผ ๋ง์ถ ์ ์๋ค๋ฉด mem::uninitialized
๋ค์ ๋ฐ๋ช
ํ ๊ฒ ๊ฐ์ต๋๋ค. ๊ฐ์ ์ผ์น์ํฌ ์ ์๊ณ ๋์ผํ ๋ธ๋์น๊ฐ ํญ์ ๋ชจ๋ ์ํคํ
์ฒ, ์ตํธ ๋ ๋ฒจ ๋ฑ์์ ์ฌ์ฉ๋๋ค๋ฉด ์ฐ๋ฆฌ๋ mem::zeroed
๋ค์ ๋ฐ๋ช
ํ์ต๋๋ค (๊ทธ๋ฆฌ๊ณ MaybeUninit
์ฌ์ฉํ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค
u8
(๋ฐ ๊ธฐํ ์ ์ ์ ํ, ๋ถ๋ ์์์ , ์์ ํฌ์ธํฐ)๋ฅผ ์ด๊ธฐํํด์ผํฉ๋๊น? ์ฆ,MaybeUinit<u8>::uninitialized().into_inner()
insta-UB์ ๋๊น? ๋๋ ๊ทธ๋ ๊ฒ ์๊ฐํ์ง๋ง, ๋๋ถ๋ถ ์ฐ๋ฆฌ๊ฐpoison
/undef
๋ฅผ ํ์ฉํ๋ ์ฅ์๋ฅผ ์ต์ํ์ผ๋ก ์ ์งํ๊ณ ์ถ๋ค๋ ์ง๊ฐ์ ๊ทผ๊ฑฐํฉ๋๋ค. ๊ทธ๋ฌ๋์ด ํจํด์ ๋ง์ด ์ฌ์ฉํ๋ค๋ฉด ์ค๋ ํ ์ ์์ต๋๋ค (๋ฏธ๋ฆฌ๋ฅผ ์ฌ์ฉํ์ฌ์ด๋ฅผ ๊ฒฐ์ ํ๋ ๋ฐ ๋์์ด๋๊ธฐ๋ฅผ ๋ฐ๋๋๋ค).
FWIW, ์ด๊ฒ์ด UB๊ฐ ์๋ ๊ฒ์ ๋ ๊ฐ์ง ์ด์ ์ a) LLVM์ดํ๋ ์ผ๊ณผ ์ผ์นํ๊ณ , b) ๋ ๋ง์ ์ ์ฐ์ฑ wrt ์ต์ ํ๋ฅผ ํ์ฉํ๋ค๋ ๊ฒ์ ๋๋ค. ๋ํ ๊ฑด์ค ์๊ฐ์ด ์๋ ์ฌ์ฉ ์๊ฐ์ ์์ ์ ์ ์ํ๊ธฐ์ํ ์ต๊ทผ ์ ์๊ณผ ๋ ์ผ์นํ๋ ๊ฒ ๊ฐ์ต๋๋ค.
์ธ์คํดํธ UB๊ฐ ์๋๋ฉด ์ด๋ป๊ฒ ๋๋์? ๊ทธ ๊ฐ์น๋ก ๋ฌด์์ ํ ์ ์์ต๋๊น? ์ผ์น์ํฌ ์ ์์ต๋๊น? ๊ทธ๋ ๋ค๋ฉด ํ๋ก๊ทธ๋จ ๋์์ด ๊ฒฐ์ ์ ์ ๋๊น?
UB๋ฅผ ๋์ ํ์ง ์๊ณ ๋ ๊ฐ์น๋ฅผ ๋ง์ถ ์ ์๋ค๋ฉด
mem::uninitialized
๋ค์ ๋ฐ๋ช ํ ๊ฒ ๊ฐ์ต๋๋ค. ๊ฐ์ ์ผ์น์ํฌ ์ ์๊ณ ๋์ผํ ๋ธ๋์น๊ฐ ํญ์ ๋ชจ๋ ์ํคํ ์ฒ, ์ตํธ ๋ ๋ฒจ ๋ฑ์์ ์ฌ์ฉ๋๋ค๋ฉดmem::zeroed
๋ค์ ๋ฐ๋ช ํ์ต๋๋ค (๊ทธ๋ฆฌ๊ณMaybeUninit
์ฌ์ฉํ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค
์ด๊ธฐํ๋์ง ์์ ๊ฒ๊ณผ ์ผ์น์ํฌ ์์๋ ์ด์ ๋ ๋ฌด์์ ๋๊น? ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๊ธฐ๋ฐ์ผ๋ก ๋ธ๋์น ๋๋ ์ธ๋ฑ์ฑ ํ UB๋ก ์ ์ํ๋ฉด LLVM์ ์ต์ ํ ํ ์ฌ์ง๊ฐ ๋ ๋ง์ผ๋ฏ๋ก ํนํ ๊ฐ๋ ฅํ ์ฌ์ฉ ์ฌ๋ก๊ฐ์๋ ๊ฒฝ์ฐ ์์ ๋ ๋ฌถ๋ ๊ฒ์ด ์ข์ ์๊ฐ์ด๋ผ๊ณ ์๊ฐํ์ง ์์ต๋๋ค.
์ด๊ธฐํ๋์ง ์์ ๊ฒ๊ณผ ์ผ์น์ํฌ ์์๋ ์ด์ ๋ ๋ฌด์์ ๋๊น?
๋๋ ๋ด๊ฐํ๊ณ ์ถ๋ค๊ณ ๋งํ์ง ์์๊ณ , ์ด๊ฒ์ด ๋ถ๊ฐ๋ฅํ๋ค๋ฉด MaybeUinit<u8>::uninitialized().into_inner()
์ ๋จ์ง mem::uninitialized()
์ ์ฐจ์ด๋ฅผ ์ดํดํ์ง ๋ชปํ๋ค๊ณ ๋งํ์ต๋๋ค.
@RalfJung "์ฐธ์กฐ ์๋
๋ณธ์ง์ ์ผ๋ก ๋ฌธ์ ๋ ๋ค์์ ํ์ฉํ๋์ง ์ฌ๋ถ์ ๋๋ค.
let mut b = MaybeUninit::<bool>::uninitialized();
let bref = b.get_mut(); // insta-UB?
์ฐธ์กฐ๊ฐ ์ ํจํ ๊ฒ์ ๊ฐ๋ฆฌํค๋ ๊ฒฝ์ฐ์๋ง ์ ํจํ๋ค๊ณ ๊ฒฐ์ ํ๋ ๊ฒฝ์ฐ (์ฆ, "์ฐธ์กฐ ์๋ ๋ฐ๋ณต"์ด๋ผ๋ ์๋ฏธ)์ด ์ฝ๋๋ UB์ ๋๋ค.
์ธ์คํดํธ UB๊ฐ ์๋๋ฉด ์ด๋ป๊ฒ ๋๋์? ๊ทธ ๊ฐ์น๋ก ๋ฌด์์ ํ ์ ์์ต๋๊น? ์ผ์น์ํฌ ์ ์์ต๋๊น? ๊ทธ๋ ๋ค๋ฉด ํ๋ก๊ทธ๋จ ๋์์ด ๊ฒฐ์ ์ ์ ๋๊น?
์ด๊ธฐํ๋์ง ์์ u8
๋ ์ด๋ค ์ ์ผ๋ก๋ ๊ฒ์ฌ ํ ์ ์์ต๋๋ค. match
๋ ์ด๋ฆ์ ๋ฐ์ธ๋ฉํ๊ณ ์ค์ ๋ก ๋๋ฑ์ฑ์ ํ
์คํธํ๋ ๋ฑ ๋ง์ ์ผ์ ํ ์ ์์ต๋๋ค. ์ ์๋ ๊ด์ฐฎ์ง ๋ง ํ์๋ ๊ทธ๋ ์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ค์ ์ธ ์ ์์ต๋๋ค .
๋ณธ์ง์ ์ผ๋ก ์ด๊ฒ์ miri๊ฐ ํ์ฌ ๊ตฌํํ๋ ๊ฒ์ ๋๋ค.
UB๋ฅผ ๋์ ํ์ง ์๊ณ ๋ ๊ฐ์น๋ฅผ ๋ง์ถ ์ ์๋ค๋ฉด mem :: uninitialized๋ฅผ ๋ค์ ๋ฐ๋ช ํ ๊ฒ ๊ฐ์ต๋๋ค.
์ ๊ทธ๋ด๊น์? mem::uninitialized
์ ๊ฐ์ฅ ํฐ ๋ฌธ์ ๋ ์ ํจํ ๊ฐ์ด ๋ฌด์์ธ์ง์ ๋ํ ์ ํ์ด์๋ ์ ํ์ ๊ดํ ๊ฒ์
๋๋ค. u8
์ ๊ทธ๋ฌํ ์ ํ์ด ์๋ค๊ณ ๊ฒฐ์ ํ ์ ์์ผ๋ฏ๋ก mem::uninitialized()
๋ u8
๋ํด ๊ด์ฐฎ ์์ต๋๋ค. ์ ๋ค๋ฆญ ์ฝ๋์์ ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ ๊ฑฐ์ ๋ถ๊ฐ๋ฅํ๊ธฐ ๋๋ฌธ์ ์์ ํ ์ ๊ฑฐํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ด๋ ์ชฝ์ด๋ ์ด๊ธฐํ๋์ง ์์ u8
๋ฅผ ์์ ํ ์ฝ๋๋ก ์ ๋ฌํ๋ ๊ฒ์ ์ฌ์ ํ โโ์ณ์ง ์์ง๋ง ์์ ํ์ง ์์ ์ฝ๋์์ ์ ์คํ๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ ๊ด์ฐฎ์ ์ ์์ต๋๋ค.
์๋ชป๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฆฌํค๋ &mut
"์ผ์น"ํ ์ ์์ต๋๋ค. IOW, ์์์ ์ค๋ช
ํ bool
์์ ๋ ๊ด์ฐฎ๋ค๊ณ ์๊ฐํ์ง๋ง ๋ค์์ ํ์คํ ๊ทธ๋ ์ง ์์ต๋๋ค.
let mut b = MaybeUninit::<bool>::uninitialized();
let bref = b.get_mut();
match bref {
&b => // insta-UB! We have a bad bool in scope.
}
์ด๊ฒ์ match
๋ฅผ ์ฌ์ฉํ์ฌ ์ผ๋ฐ์ ์ธ ํฌ์ธํฐ ์ญ ์ฐธ์กฐ๋ฅผ ์ํํฉ๋๋ค.
FWIW, ์ด๊ฒ์ด UB๊ฐ ์๋ ๊ฒ์ ๋ ๊ฐ์ง ์ด์ ์ a) LLVM์ดํ๋ ์ผ๊ณผ ์ผ์นํ๊ณ , b) ๋ ๋ง์ ์ ์ฐ์ฑ wrt ์ต์ ํ๋ฅผ ํ์ฉํ๋ค๋ ๊ฒ์ ๋๋ค. ๋ํ ๊ฑด์ค ์๊ฐ์ด ์๋ ์ฌ์ฉ ์๊ฐ์ ์์ ์ ์ ์ํ๊ธฐ์ํ ์ต๊ทผ ์ ์๊ณผ ๋ ์ผ์นํ๋ ๊ฒ ๊ฐ์ต๋๋ค.
์ด๋ ๊ฒํ๋ฉด ์ด๋ค ์ต์ ํ๊ฐ ๊ฐ๋ฅํฉ๋๊น?
LLVM์ ๋ณธ์ง์ ์ผ๋ก ์ ํ์ด ์ง์ ๋์ง ์์ ์ฝ๋์ ๋ํด ์ต์ ํ๋ฅผ ์ํํ๋ฏ๋ก ์ฌ๊ธฐ์๋ ๋ฌธ์ ๊ฐ๋์ง ์์ต๋๋ค. ์ฌ๊ธฐ์๋ MIR ์ต์ ํ์ ๋ํด์๋ง ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค.
๋๋ ๋ณธ์ง์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ๋ช
ํํ๊ฒ ์ฌ์ฉํ ์์์ ๋๊น์ง ๊ฐ๋ฅํ ํ ์ ๊ฒ ํ์ฉํด์ผํ๋ค๋ ๊ด์ ์ ํ์ฑํ๊ณ ์์ต๋๋ค. ๋์ค์ ์ธ์ ๋ ์ง ๋ ๋ง์ ๊ฒ์ ํ์ฉ ํ ์ ์์ง๋ง ๋ฐ๋์ ๊ฒฝ์ฐ๋ ํ์ฉํ์ง ์์ต๋๋ค. ์ฆ, ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ค๋ u*
๋ฐ i*
๋ํด์ด ์์
์ ์ํํ๊ธฐ์ ์ถฉ๋ถํ ์ ์์ต๋๋ค.
์ฐธ์กฐ๊ฐ ์ ํจํ ๊ฒ์ ๊ฐ๋ฆฌํค๋ ๊ฒฝ์ฐ์๋ง ์ ํจํ๋ค๊ณ ๊ฒฐ์ ํ๋ ๊ฒฝ์ฐ (์ฆ, "์ฐธ์กฐ ์๋ ๋ฐ๋ณต"์ด๋ผ๋ ์๋ฏธ)์ด ์ฝ๋๋ UB์ ๋๋ค.
์์์ด.
mem :: uninitialized์ ๊ฐ์ฅ ํฐ ๋ฌธ์ ๋ ์ ํจํ ๊ฐ์ด ๋ฌด์์ธ์ง์ ๋ํ ์ ํ์ด์๋ ์ ํ์ ๊ดํ ๊ฒ์ ๋๋ค.
mem::uninitialized
์๋ ์์์ ์ง์ ํ ๋ฌธ์ ๋ ์์ต๋๋ค. ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๋ํ ์ฐธ์กฐ๋ฅผ ๋ง๋๋ ๊ฒ์ ์ ์๋์ง ์์ ๋์ ์ผ ์๋ ์๊ณ ๊ทธ๋ ์ง ์์ ์๋ ์๋ค๋ ๊ฒ์
๋๋ค. ๊ทธ๋์ ๋ค์ UB๋ ๋ฌด์์
๋๊น?
let mut b = MaybeUninit::<u8>::uninitialized().into_inner();
let bref = &mut b; // Insta UB ?
MaybeUninit
๋ฅผ ๋์
ํ ์ด์ ์ค ํ๋๋ ํญ์ ์ ๋์จ์ ์ด๊ธฐํ (์ : ๋จ์๋ก)ํ์ฌ์ด ๋ฌธ์ ๋ฅผ ํผํ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ์ต๋๋ค. ํ์ฑ ํ๋๋ฅผ u8
ํ๊ณ UB๋ฅผ ๋์
ํ์ง ์๊ณ ptr::write
๋ฅผ ํตํด ๊ฐ์ ์ ๊ณตํฉ๋๋ค.
๊ทธ๋์ ์ ๊ฐ ์ฝ๊ฐ ํท๊ฐ๋ฆฌ๋ ์ด์ ์
๋๋ค. into_inner
๊ฐ ๋ค์๋ณด๋ค ๋ ๋์์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
let mut b: u8 = uninitialized();
let bref = &mut b; // Insta UB ?
๋ ๋ค ๋์๊ฒ ์ ์๋์ง ์์ ํ๋ ์ํ ํญํ์ฒ๋ผ ๋ณด์ ๋๋ค.
์ด๋ ๊ฒํ๋ฉด ์ด๋ค ์ต์ ํ๊ฐ ๊ฐ๋ฅํฉ๋๊น?
LLVM์ ๋ณธ์ง์ ์ผ๋ก ์ ํ์ด ์ง์ ๋์ง ์์ ์ฝ๋์ ๋ํด ์ต์ ํ๋ฅผ ์ํํ๋ฏ๋ก ์ฌ๊ธฐ์๋ ๋ฌธ์ ๊ฐ๋์ง ์์ต๋๋ค. ์ฌ๊ธฐ์๋ MIR ์ต์ ํ์ ๋ํด์๋ง ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค.
์ ์๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ์ด๋ค ๊ฐ์น๊ฐ ์๋ค๊ณ ๋งํ๊ณ ๋ฐ๋ผ์ Rust ์๋ฏธ๋ก ์ ๋ฐ๋ผ ๋ถ๊ธฐ ํ ์ ์๋ค๊ณ ๋งํ๋ฉด LLVM์ undefined ๋ฒ์ ์ผ๋ก ๋ฎ์ถ ์ ์์ต๋๋ค.
๋๋ ๋ณธ์ง์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ๋ช ํํ๊ฒ ์ฌ์ฉํ ์์์ ๋๊น์ง ๊ฐ๋ฅํ ํ ์ ๊ฒ ํ์ฉํด์ผํ๋ค๋ ๊ด์ ์ ํ์ฑํ๊ณ ์์ต๋๋ค. ๋์ค์ ์ธ์ ๋ ์ง ๋ ๋ง์ ๊ฒ์ ํ์ฉ ํ ์ ์์ง๋ง ๋ฐ๋์ ๊ฒฝ์ฐ๋ ํ์ฉํ์ง ์์ต๋๋ค.
๊ณต์ ํด.
์ฆ, ๋ชจ๋ ๋ฐ์ดํฐ๋ฅผ ์ค๋ ์ฌ์ฉํ ์์๋ ๋ฐ์ดํธ ์ฌ๋ผ์ด์ค์ ์ข์ ์ฌ์ฉ์ด ์ต๊ทผ์ ๋ํ๋ฌ์ต๋๋ค. ์ด๋ ์ต์ํ
u*
๋ฐi*
๋ํด์ด ์์ ์ ์ํํ๊ธฐ์ ์ถฉ๋ถํ ์ธ์ ์ผ ์ ์์ต๋๋ค.
์ด๋ฌํ ์ฌ์ฉ ์ฌ๋ก ์ค ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๋ณด์ ํ๋ ๋ฐ์ดํธ ์ฌ๋ผ์ด์ค๋ฅผ ํฌํจํฉ๋๊น?
๊ฐ ์ด๊ธฐํ๋์ง ์์ -ํ์ง๋ง -ํ์ง - ๋
๊ฒ์ ํ ๊ณณ์์ &mut [u8]
์ํ ๋์์ด ๋ ์ Read::read
- ์ฐ๋ฆฌ๋ ๋ฒํผ๋ฅผ ์ ๋ก๋ก ํ์ ํผํ ์ ์๋๋กํ๊ณ ์ถ์ต๋๋ค ์ข ์ด์ํ ๋๋ฌธ์ Read
impl์ ๊ทธ๋ฅ ์ฐ๋ ๊ฒ์ด ์๋๋ผ ์ฝ์ ์ ์์ต๋๋ค.
๊ฐ ์ด๊ธฐํ๋์ง ์์ -ํ์ง๋ง -ํ์ง - ๋ ๊ฒ์ ํ ๊ณณ์์
&mut [u8]
์ํ ๋์์ด ๋ ์Read::read
- ์ฐ๋ฆฌ๋ ๋ฒํผ๋ฅผ ์ ๋ก๋ก ํ์ ํผํ ์ ์๋๋กํ๊ณ ์ถ์ต๋๋ค ์ข ์ด์ํ ๋๋ฌธ์Read
impl์ ๊ทธ๋ฅ ์ฐ๋ ๊ฒ์ด ์๋๋ผ ์ฝ์ ์ ์์ต๋๋ค.
๊ทธ๋์ ์์ด๋์ด๋ MaybeUninit
๊ฐ ์ด๊ธฐํ ๋ ์ ํ์ ๋ํ๋ด์ง ๋ง ์ ์๋์ง ์์ ๋ด์ฉ์ ๋ํ๋ด๋ ๋ฐ๋ฉด, ๋ค๋ฅธ ์ ํ์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ (์ : ํจ๋ฉ ํ๋)๋ LLVM ํฌ์ด์ฆ ๊ฐ๊ฐ์์ ์์ ํ ์ด๊ธฐํ๋์ง ์๋ ๊ฒ์
๋๊น?
์ผ๋ฐ์ ์ผ๋ก MaybeUninit์ ์ ์ฉ ํ ํ์๋ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๋ก ์ ์ผ๋ก๋ ๋ด์ฉ์ ์ ์๋์ง ์์ ์ํ์์ ์ ์๋์์ง๋ง ์์์ ์ธ ๊ฒ์ผ๋ก "๊ณ ์ "ํ๋ API๊ฐ์์ ์ ์์ต๋๋ค.
์ ์๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ์ด๋ค ๊ฐ์น๊ฐ ์๋ค๊ณ ๋งํ๊ณ ๋ฐ๋ผ์ Rust ์๋ฏธ๋ก ์ ๋ฐ๋ผ ๋ถ๊ธฐ ํ ์ ์๋ค๊ณ ๋งํ๋ฉด LLVM์ undefined ๋ฒ์ ์ผ๋ก ๋ฎ์ถ ์ ์์ต๋๋ค.
๊ทธ๊ฒ์ ์ ์์ด ์๋ ์์ต๋๋ค. poison
์ ๋ธ๋์น ํ๊ธฐ ์ํด UB ์ํ๋ก ์ ์ง๋ฉ๋๋ค.
๋ฌธ์ ๋ ๋ก์ปฌ u8
poison
๋ฅผ ๋จ์ํ "๊ฐ๋"๊ฒ์ด UB์ธ์ง ์ฌ๋ถ์
๋๋ค.
์ด๋ฌํ ์ฌ์ฉ ์ฌ๋ก ์ค ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๋ณด์ ํ๋ ๋ฐ์ดํธ ์ฌ๋ผ์ด์ค๋ฅผ ํฌํจํฉ๋๊น?
์ฌ๋ผ์ด์ค๋ ์ฐธ์กฐ์ ๊ฐ์ผ๋ฏ๋ก &mut [u8]
์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ ๊ธฐ๋ก ๋งํ๋ ํ ๊ด์ฐฎ์ต๋๋ค (์ฐธ์กฐ ์ ํจ์ฑ์ ์ํด ์ฌ์ฉํ๋ ์๋ฃจ์
์ด๋ผ๊ณ ๊ฐ์ ).
๋ฟก๋ฟก
์ด๊ธฐํ๋์ง ์์์ง๋ง ๋ ์ด ์๋ & mut [u8]์ด ์ ์ฉ ํ ์์๋ ํ ๊ณณ์ Read :: read์ ๋๋ค. ์ฐ๋ฆฌ๋ ์ด์ํ Read impl์ด ๊ทธ๊ฒ์ ์ฝ์ ์ ์๊ธฐ ๋๋ฌธ์ ๋ฒํผ๋ฅผ 0์ผ๋ก ๋ง๋ค ํ์๊ฐ ์๋๋กํ๊ณ ์ถ์ต๋๋ค. ์ฐ๊ธฐ๋ณด๋ค๋
์, &out
์์ด๋ ๋น์ ์ด impl์ ์๊ณ ์์ ๋๋ง ๊ทธ๋ ๊ฒ ํ ์์์ ๊ฒ์
๋๋ค. ๋ฌธ์ ๋ ์์ ์ฝ๋๋ฅผ ์ฒ๋ฆฌํ๋ ์ฌ๋ถ๋ฅผ poison
์์ u8
(์ด ์์ ํ ์ฝ๋์ ์ข์ ์ฌ์ฉ๋์ง ์๋๋ค๋ ๊ฒ์,ํ์ง ์์ต๋๋ค!) ๋ฌธ์ ๋ ์์ ํ์ง ์์ ์ฝ๋๊ฐ ์กฐ์ฌ์ค๋ฝ๊ฒ ์ฒ๋ฆฌ ํ ์ ์๋์ง ์ฌ๋ถ์
๋๋ค ์ด ๋ฐฉ๋ฒ. (์์ ๋ถ๋ณ๊ณผ ํ๋น ๋ถ๋ณ์ ์ฐจ์ด์ ์ ๋ํด ์ค๋ ์ฐ๊ณ ์ถ์๋ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ฐธ์กฐํ์ญ์์ค ...)
์ด์ฉ๋ฉด ๋ด๊ฐ ๋ฆ์ ์ด,ํ์ง๋ง ๋์ ์๋ช
์ ๋ณ๊ฒฝ ์ข์ ๊ฒ set()
๋ฐํํ๋ ๋ฐฉ๋ฒ์ &mut T
. ์ด๋ฐ ์์ผ๋ก MaybeUninit
์์
ํ๋ ์์ ํ ์์ ํ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ด ์์ ํฉ๋๋ค (์ ์ด๋ ์ผ๋ถ ์ํฉ์์๋).
fn init(dest: &mut MaybeUninit<u8>) -> &mut u8 {
dest.set(produce_value())
}
์ด๊ฒ์ init()
๊ฐ ๊ฐ์ ์ด๊ธฐํํ๊ฑฐ๋ ๋ฐ์ฐ ํ ๊ฒ์ด๋ผ๋ ์ค์ง์ ์ธ ์ ์ ์ธ ๋ณด์ฅ์
๋๋ค. (๋ค๋ฅธ ๊ฒ์ ๋ฐํํ๋ ค๊ณ ํ๋ฉด ์๋ช
์ด ์๋ชป๋์ด ์์ ํ ์ฝ๋์์ &'static mut u8
๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.) ํฅํ placer API์ ์ผ๋ถ๋ก ์ฌ์ฉ๋ ์ ์์ต๋๋ค.
@Kixunil ์์ ์๋ ๊ทธ๋ ๊ฒ set
ํผ๋ ์ค๋ฌ์์ ๋ฐ๊ฒฌํ์ต๋๋ค.
๋ฟก๋ฟก
์ด๊ฒ์
init()
๊ฐ ๊ฐ์ ์ด๊ธฐํํ๊ฑฐ๋ ๋ฐ์ฐ ํ ๊ฒ์ด๋ผ๋ ์ค์ง์ ์ธ ์ ์ ์ธ ๋ณด์ฅ์ ๋๋ค. (๋ค๋ฅธ ๊ฒ์ ๋ฐํํ๋ ค๊ณ ํ๋ฉด ์๋ช ์ด ์๋ชป๋๊ณ ์์ ํ ์ฝ๋์์&'static mut u8
๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค.)
์ข ๋น ์ง๋; Box::leak
ํ๋ ์ป์ ์ ์์ต๋๋ค.
์ต๊ทผ์ ์์ฑํ ์ฝ๋๋ฒ ์ด์ค์์ ๋น์ทํ ๊ณํ์ ์๊ฐํด ๋์ต๋๋ค. ์ข ๋ ๋ณต์กํ์ง๋ง ์ ๊ณต๋ ์ฐธ์กฐ๊ฐ ์ด๊ธฐํ๋์๋ค๋ ์ง์ ํ ์ ์ ๋ณด์ฆ์ ์ ๊ณตํฉ๋๋ค. ๋์ ์
fn init(dest: &mut MaybeUninit<u8>) -> &mut u8
๋๋ ๊ฐ์ง๊ณ ์๋ค
fn init<'a>(dest: Uninitialized<'a, u8>) -> DidInit<'a, u8>
ํธ๋ฆญ์ Uninitialized
๋ฐ DidInit
๋ชจ๋ ์๋ช
๋งค๊ฐ ๋ณ์์ ๋ํด ๋ถ๋ณ์ด๋ฏ๋ก DidInit
๋ฅผ ๋ค๋ฅธ ์๋ช
๋งค๊ฐ ๋ณ์ (์ : 'static
์ ํจ๊ป ์ฌ์ฌ์ฉ ํ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
DidInit
impls Deref
๋ฐ DerefMut
์ด๋ฏ๋ก ์์ ํ ์ฝ๋์์ ์์ ์ ๊ฐ์ด ์ฐธ์กฐ๋ก ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ค์ ๋ก ์ด๊ธฐํ ๋ ์๋ณธ์ด ์ ๋ฌ ๋ ์ฐธ์กฐ์ด๋ฉฐ ์์์ ๋ค๋ฅธ ์ฐธ์กฐ๊ฐ ์๋๋ผ๋ ๋ณด์ฅ์ ์์ ํ์ง ์์ ์ฝ๋์ ๋์์ด๋ฉ๋๋ค. ์ด๋์
๋ผ์ด์ ๋ฅผ ๊ตฌ์กฐ์ ์ผ๋ก ์ ์ ํ ์ ์์ต๋๋ค.
struct Foo {
a: i32,
b: u8,
}
fn init_foo<'a>(dest: Uninitialized<'a, Foo>,
init_a: impl for<'x> FnOnce(Uninitialized<'x, i32>) -> DidInit<'x, i32>,
init_b: impl for<'x> FnOnce(Uninitialized<'x, u8>) -> DidInit<'x, u8>)
-> &'a mut DidInit<'a, Foo> {
let ptr: *mut Foo = dest.ptr;
unsafe {
init_a(Uninitialized::new(&mut (*ptr).a));
init_b(Uninitialized::new(&mut (*ptr).b));
dest.did_init()
}
}
์ด ํจ์๋ ์ฌ์ฉ์๊ฐ ์ ๊ณต ํ ์ด๊ธฐํ ์ฝ๋ฐฑ์ ์ฌ์ฉํ์ฌ ๊ฐ ํ๋๋ฅผ ์ฐจ๋ก๋ก ์ด๊ธฐํํ์ฌ Foo
๊ตฌ์กฐ์ฒด์ ๋ํ ํฌ์ธํฐ๋ฅผ ์ด๊ธฐํํฉ๋๋ค. ์ฝ๋ฐฑ์ด DidInit
๋ฐํํด์ผํ์ง๋ง ๊ทธ ๊ฐ์ ์ ๊ฒฝ ์ฐ์ง ์์ต๋๋ค. ์กด์ฌํ๋ค๋ ์ฌ์ค๋ง์ผ๋ก๋ ์ถฉ๋ถํฉ๋๋ค. ๋ชจ๋ ํ๋๊ฐ ์ด๊ธฐํ ๋ ํ์๋ ์ ์ฒด ๊ฒ์ ์๊ณ Foo
์ ํจํฉ๋๋ค - ๊ทธ๊ฒ์ ํธ์ถ ๋๋ฌธ์ did_init()
์์ Uninitialized<'a, Foo>
๋จ์ง์ ์บ์คํ
ํ๋ ๊ฒ์ด ์์ ํ์ง ์์ ๋ฐฉ๋ฒ์
๋๋ค, ํด๋น DidInit
์ ํ, init_foo
๋ฐํ๋ฉ๋๋ค.
๋๋ ๋ํ ๊ทธ๋ฌํ ํจ์๋ฅผ ์์ฑํ๋ ๊ณผ์ ์ ์๋ํํ๋ ๋งคํฌ๋ก๋ฅผ ๊ฐ์ง๊ณ ์์ผ๋ฉฐ, ์ค์ ๋ฒ์ ์ ์๋ฉธ์์ ํจ๋์ ๋ํด ์กฐ๊ธ ๋์ฃผ์ํฉ๋๋ค (๊ฐ์ ์ด ํ์ํ์ง๋ง).
์ด์จ๋ , ์ด์ ๊ฐ์ ๊ฒ์ด ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์์ ๊ตฌํ ๋ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค.
(์ฐธ๊ณ : DidInit<'a, T>
์ฌ์ค์ ๋ํ ํ์ ๋ณ๋ช
์
๋๋ค &'a mut _DidInitMarker<'a, T>
์ ํผํ ์๋ช
๋ฌธ์ ๋ก DerefMut
.)
๊ทธ๊ฑด ๊ทธ๋ ๊ณ , ์์ ์ฐ๊ฒฐ๋ ์ ๊ทผ ๋ฐฉ์์ ์๋ฉธ์๋ฅผ ๋ฌด์ํ์ง๋ง ์ฝ๊ฐ ๋ค๋ฅธ ์ ๊ทผ ๋ฐฉ์์ T
์ ์๋ฉธ์๋ฅผ ์คํํ๋ ๋ฐ DidInit<โa, T>
์ฑ
์์ ๋ถ์ฌํ๋ ๊ฒ์
๋๋ค. ์ด ๊ฒฝ์ฐ ๋ณ์นญ์ด ์๋ ๊ตฌ์กฐ์ฒด ์ฌ์ผํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ๊ฒ์ ๋จ์ง์ ๋ํ ์ฐธ์กฐ ๋ฐฐ๋ถ ์ T
์ด์์๋๋งํผ ๊ฐ์ ๊ฒ์ DidInit
์์ฒด๊ฐ ์๋ ๋ชจ๋๋ฅผ ์ํด โa
(๊ทธ๋ ์ง ๋น์ ์ด ํ๊ดด ์ดํ์ ๊ณ์ ์ก์ธ์ค ํ ์ ์์ต๋๋ค).
์ด์ ์ set
์์ ์์ฒญํ ๋์์ ์ ๊ณตํ๋ ๋ฐฉ๋ฒ์ ํฌํจํ๋ +1์ด์ง๋ง ๋ค๋ฅธ ์ด๋ฆ์ ํตํด ์ฌ์ฉํ ์์๋ ๊ฒ์ ๊ด์ฐฎ์ต๋๋ค.
๊ทธ ์ด๋ฆ์ด ๋ฌด์์ธ์ง์ ๋ํ ์ข์ ์์ด๋์ด๊ฐ ์์ต๋๊น? set_and_as_mut
? ^^
set_and_borrow_mut
?
insert
/ insert_mut
? Entry
์ ํ์๋ or_insert
๋ฉ์๋๊ฐ ๋ค์ ์ ์ฌํฉ๋๋ค (ํ์ง๋ง OccupiedEntry
์๋ ์ด์ ๊ฐ์ ๋ฐํํ๋ insert
์์ผ๋ฏ๋ก ์ ํ ์ ์ฌํ์ง ์์ต๋๋ค).
๋ ๊ฐ์ง ๋ณ๋์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ๋ฐ ์ ๋ง ์ค๋๋ ฅ์๋ ์ด์ ๊ฐ ์์ต๋๊น? ๋ฐํ ๊ฐ์ ๋ฌด์ํ ์์์๋งํผ ๊ฐ๋จ ํด ๋ณด์ด๋ฉฐ ํจ์๊ฐ #[inline]
๋ก ํ์๋์ด ์ค์ ๋ฐํ์ ๋น์ฉ์ ๊ธฐ๋ํ์ง ์์ต๋๋ค.
๋ ๊ฐ์ง ๋ณ๋์ ๋ฐฉ๋ฒ์ ์ฌ์ฉํ๋ ๋ฐ ์ ๋ง ์ค๋๋ ฅ์๋ ์ด์ ๊ฐ ์์ต๋๊น? ๋ฐํ ๊ฐ์ ๋ฌด์ํ ์ ๋๋ก ๊ฐ๋จ ํด ๋ณด์ ๋๋ค.
์ ์ผํ ์ด์ ๋ set
๋ฌด์ธ๊ฐ๋ฅผ ๋ฐํํ๋ ๊ฒ์ ๋ณด๋ ๊ฒ์ด ๋ค์ ๋๋๋ค๋ ๊ฒ์
๋๋ค.
๋ด๊ฐ ๋ญ๊ฐ๋ฅผ ๋์น๊ณ ์์์ง๋ ๋ชจ๋ฅด์ง๋ง, ๋ฌด์์ด ์ฐ๋ฆฌ๊ฐ ์๋ชป๋ ๊ฐ์น๋ฅผ ๊ฐ์ง์ง ์๋๋ก ๊ตฌํ ์ ์์ต๋๊น? ์ฐ๋ฆฌ๊ฐ
let mut foo: MaybeUninit<T> = MaybeUninit {
uninit: (),
};
let mut foo_ref = &mut foo as *mut MaybeUninit<T>;
unsafe {
some_native_function(&mut (*foo_ref).value, val);
}
some_native_function
๊ฐ ์๋ํ์ง ์๊ณ ์ค์ ๋ก ๊ฐ์ ์ด๊ธฐํํ์ง ์์ผ๋ฉด ์ด๋ป๊ฒ๋ฉ๋๊น? ์ฌ์ ํ UB์
๋๊น? ์ด๋ป๊ฒ ์ฒ๋ฆฌ ํ ์ โโ์์ต๋๊น?
@Pzixel ์ด๊ฒ์ ๋ชจ๋ MaybeUninit
์ ๋ํ API ๋ฌธ์์ ํฌํจ๋์ด ์์ต๋๋ค.
some_native_function
์ด NOP์ด๋ฉด ์๋ฌด ์ผ๋ ์ผ์ด๋์ง ์์ต๋๋ค. ๋น์ ์ด ๋์ค์ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ foo_ref.value
(๋๋ ์คํ๋ ค ํ foo_ref.as_mut()
๋น์ ์ ๋จ์ง ๊ณต์ฉ API ์ฌ์ฉํ ์์๋) ๋ชจ๋ ๊ฒ์ด ์ด๊ธฐํ๋๋ฉด ํจ์ ๋ง ํธ์ถ ํ ์ ์๊ธฐ ๋๋ฌธ์ UB์
๋๋ค.
MaybeUninit
๋ ์ ํจํ์ง ์์ ๊ฐ์ ๊ฐ๋ ๊ฒ์ ๋ฐฉ์งํ์ง ์์ต๋๋ค. ๊ฐ๋ฅํ๋ค๋ฉด ์์ ํ์ง๋ง ๋ถ๊ฐ๋ฅํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ปดํ์ผ๋ฌ์ ํ๋ก๊ทธ๋๋จธ ๋ชจ๋ ๋ณผ ์ ์๋๋ก ๊ฐ์ด ์ ํจํ์ง ์์ ์ ์๋ค๋ ์ ๋ณด๊ฐ ์ ํ์ผ๋ก ์ธ์ฝ๋ฉ๋๊ธฐ ๋๋ฌธ์ ์ ํจํ์ง ์์ ๊ฐ์ผ๋ก ์์
ํ๋ ๊ฒ๋ณด๋ค ํ ๊ฑด์ด ์ ์ต๋๋ค.
๋ฏธ๋์ ๋ฐ์ํ ์์๋ ๊ฐ์์ ๋ฌธ์ ์ ๋ํด @sfackler ์
์ฃผ์ ์ง๋ฌธ์ mem::zeroed
์ด MaybeUninit<NonZeroU8>
์ ํ์ฌ ๊ตฌํ ์ ์์ ๋ํด ์ ํจํ ๋ฉ๋ชจ๋ฆฌ ๋ด ํํ์ธ์ง ์ฌ๋ถ์
๋๋ค. ๋ด ์๊ฐ์ "uninit"์ํ์์ ๊ฐ์ ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ค ์ฉ๋๋ก๋ ์ฌ์ฉํ ์์๋ ํจ๋ฉ ์ผ ๋ฟ์ด๋ฉฐ "๊ฐ"์ํ์์๋ mem::zeroed
์ ์ธํ ๋ชจ๋ ๊ฐ๋ฅํ ๊ฐ์ด ์ ํจํฉ๋๋ค ( NonZero
๋๋ฌธ์
๋ ์ง๋ณด ๋ ์ด๊ฑฐ ํ ํ๋ณ ํจํน (์ง๊ธ๋ณด๋ค)์ ๊ฐ์ง ๋ฏธ๋ํ ๋ ์ด์์ ์์คํ
์ ํ๋ณ์๋ฅผ "๊ฐ"์ํ์ "uninit"์ํ / ์ ๋ก ๋ฉ๋ชจ๋ฆฌ ํจ๋ฉ์ ์ ์ฅํ ์ ์์ต๋๋ค. ์ด ๊ฐ์ ์์คํ
์์ Option<MaybeUninit<NonZeroU8>>
์ ํฌ๊ธฐ๋ 1์ด์ง๋ง ํ์ฌ๋ 2์
๋๋ค. ๋ํ ํด๋น ๊ฐ์ ์์คํ
์์ Some(MaybeUninit::uninitialized())
๋ None
๊ตฌ๋ณ ํ ์ ์์ต๋๋ค. ์ด๋ฌํ ์์คํ
์ผ๋ก ์ด๋ํ๋ฉด MaybeUninit
(๊ณต์ฉ API๋ ์๋)์ ๊ตฌํ์ ๋ณ๊ฒฝํ์ฌ์ด ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ด ์ ์์ NonZeroU8
์ &'static i32
์ฌ์ด์๋ ์ฐจ์ด๊ฐ ์์ต๋๋ค. ๋ ๋ค "0"์ด ์ ํจ ํ์ง MaybeUninit<T>::zeroed().into_inner()
๋ insta-UB์
๋๋ค.
Option<Union>
๊ฐ ๋ ์ด์์ ์ต์ ํ๋ฅผ ์ํ ํ ์ ์๋์ง ์ฌ๋ถ๋ ๊ณต์ฉ์ฒด์ ์ ํจ์ฑ์ ๋ฐ๋ผ ๋ค๋ฆ
๋๋ค. ์ด๊ฒ์ ๋ชจ๋ ๊ฒฝ์ฐ์ ๋ํด ์์ง ๊ฒฐ์ ๋์ง ์์์ง๋ง ()
์ ํ์ ๋ณํ์ด์๋ ๊ณต์ฉ์ฒด์ ๊ฒฝ์ฐ ๋ชจ๋ ๋นํธ ํจํด์ด ์ ํจํ๋ฏ๋ก ๋ ์ด์์ ์ต์ ํ๊ฐ ๊ฐ๋ฅ ํ์ง ์๋ค๋ ์ผ๋ฐ์ ์ธ ํฉ์๊ฐ ์์ต๋๋ค. ์ฌ๊ธฐ์๋ MaybeUninit
๋ฉ๋๋ค. ๋ฐ๋ผ์ Option<MaybeUninit<NonZeroU8>>
ํฌ๊ธฐ๋ 1์ด ์๋๋๋ค.
() ์ ํ์ ๋ณํ์ด์๋ ๊ณต์ฉ์ฒด์ ๊ฒฝ์ฐ ๋ชจ๋ ๋นํธ ํจํด์ด ์ ํจํ๋ฏ๋ก ๋ ์ด์์ ์ต์ ํ๊ฐ ๋ถ๊ฐ๋ฅํ๋ค๋ ์ผ๋ฐ์ ์ธ ํฉ์๊ฐ ์์ต๋๋ค.
"() ์ ํ์ ๋ณํ์ด์๋ ์กฐํฉ"์ ํน๋ณํ ๊ฒฝ์ฐ์
๋๊น? ์ด ๊ธฐ๋ฅ์ ์์ ํ๋ Rust ABI์ ํด๋น ๋ถ๋ถ์ ์์ ์ ์ผ๋ก ์์ ํํฉ๋๊น? struct UnitType;
๋๋ struct NewType(());
ํฌํจ ๋ union
struct NewType(());
์ด๋ป์ต๋๊น? struct Padded
(์๋)๋ ์ด๋ป์ต๋๊น? union
ํฌํจ ๋ struct Padded
์ด๋ป์ต๋๊น?
#[repr(C, align(4))]
struct Padded {
a: NonZeroU8,
b: (),
c: NonZeroU16
}
๋ด ๋ง์ ๋ฌธ์ ๊ทธ๋๋ก ์ฐ๋ฆฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก ๋์ํ๋ ์ ์ผํ ๋ด์ฉ์ด๊ธฐ ๋๋ฌธ์ ๋งค์ฐ ๊ตฌ์ฒด์ ์ด์์ต๋๋ค. :) ์ฐ๋ฆฌ๋ ์ด๊ฒ์ ํฌ๊ธฐ์๋ง ์์กดํ๊ฒ ๋ง๋ค๊ณ ์ถ์ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค (์ฆ, ๋ชจ๋ ZST๊ฐ ์ด๊ฒ์ ์ป์ ๊ฒ์ ๋๋ค).ํ์ง๋ง ์ค์ ๋ก๋์ด ๋ณํ์ด ํ์ํ์ง๋ ์๊ณ ๊ณต์ฉ์ฒด๊ฐ ๊ธฐ๋ณธ์ ์ผ๋ก ๋ ์ด์์ ์ต์ ํ
์ฐ๋ฆฌ๋ ํ์ฌ์ ํฉ์๋ฅผ ์ธก์ ํ๊ธฐ ์ํด ์ ์ ํ ํ ๋ก ์ ํ ๊ฒ์ด๋ฉฐ UCG repo์ ๋ค์ ํ ๋ก
์ด ๊ธฐ๋ฅ์ ์์ ํ๋ Rust ABI์ ํด๋น ๋ถ๋ถ์ ์์ ์ ์ผ๋ก ์์ ํํฉ๋๊น?
์ฌ๊ธฐ์๋ ๋ฐ์ดํฐ ๋ ์ด์์์ด ์๋ ์ ํจ์ฑ ๋ถ๋ณ์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์์ต๋๋ค (ABI๋ฅผ ๋ถ๋ฌ์ฌ ๋ ์ฐธ์กฐํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค). ๋ฐ๋ผ์์ด ์ค ์ด๋ ๊ฒ๋ ABI๋ฅผ ์์ ํ ํ ์ ์์ต๋๋ค. ์ด๊ฒ๋ค์ ๊ด๋ จ์ด ์์ง๋ง ๊ตฌ๋ณ๋๋ฉฐ ์ค์ ๋ก ํ์ฌ ๋ ธ์กฐ์ ABI์ ๋ํ ๋ ผ์ ๊ฐ
์ด๋ค์ ์๋ก ๊ด๋ จ์ด ์์ง๋ง ๊ตฌ๋ณ๋๋ฉฐ ์ค์ ๋ก ํ์ฌ ๋ ธ์กฐ์ ABI์ ๋ํ ๋ ผ์๊ฐ ์งํ ์ค์ ๋๋ค.
AFAICT ๋ ผ์๋ ๊ณต์ฉ์ฒด์ ๋ฉ๋ชจ๋ฆฌ ํํ์ ๊ดํ ๊ฒ์ด๋ฉฐ, ๊ณต์ฉ์ฒด๊ฐ ํจ์ ๊ฒฝ๊ณ๋ฅผ ํต๊ณผํ๋ ๋ฐฉ๋ฒ ๋ฐ ABI์ ๊ด๋ จ์ด์์ ์์๋ ๊ธฐํ ์ฌํญ์ ํฌํจํ์ง ์์ต๋๋ค. UCG ์ ์ฅ์์ ๋ชฉ์ ์ด Rust ์ฉ ABI๋ฅผ ๋ง๋๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ์ง ์์ต๋๋ค.
์, ๋ชฉํ๋ C์์ ์ํธ ์ด์ฉ์ฑ์ ์ํด ์ถฉ๋ถํ ๊ฒ์ ์ ์ํ๋ ๊ฒ์
๋๋ค. "Rust bool
๋ฐ C bool
๋ ABI์ ํธํ๋ฉ๋๋ค."
๊ทธ๋ฌ๋ ์ค์ ๋ก repr(Rust)
๊ฒฝ์ฐ ํจ์ ํธ์ถ ABI๋ฅผ ์ ์ ํ ๊ณํ์ด ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ด๋ ๋จ์ํ ๋๋ฝ์ด ์๋ ๊ฒฐ๊ณผ ๋ฌธ์๊ฐ ์ทจํ๋ ํ์์ ๊ด๊ณ์์ด ๋ช
์์ ์ธ ์ง์ ์ด์ด์ผํฉ๋๋ค.
Foo
๊ฐ ๋ค์๊ณผ ๊ฐ์ด ์ ์ ๋ Option<Foo>
๋ ์ด์์ ์ต์ ํ์ ๋ํ ๋ช ๊ฐ์ง ๋
ผ์์ด ์๋์ง ์๊ณ ์ถ์ต๋๋ค.
union Foo {
bar: NonZeroUsize,
baz: &'static str,
}
@Kixunil ์ https://github.com/rust-rfcs/unsafe-code-guidelines/issues/13 ์์ ์ ๊ธฐ ํ ์ MaybeUninit
์ (๊ณผ) ๊ด๋ จ์ด ์์ต๋๋ค.
์ด๊ธฐํํ์ง ์๊ณ ์ ์ ๋ณ์๋ฅผ ํฌํจ ํ ์น์
์ ์๊ณ ์ถ์ต๋๋ค.
"C"์์๋ ๋์ ์์ค์ ํ์ผ์ uint8_t a[100];
๋ฅผ ์ธ ์ ์์ผ๋ฉฐ ๊ธฐํธ๊ฐ .bss ์น์
์ ๋ฐฐ์น๋๋ค๋ ๊ฒ์ ์๊ณ ์์ต๋๋ค. uint8_t a[100] = {};
์ฐ๋ฉด a ๊ธฐํธ๊ฐ .data ์น์
์ ๋ฐฐ์น๋ฉ๋๋ค (์ด๋ main ์ด์ ์ FLASH์์ RAM์ผ๋ก ๋ณต์ฌ ๋จ).
MaybeUninit๋ฅผ ์ฌ์ฉํ Rust์ ์์ ์์ ๋๋ค :
struct A {
data: MaybeUninit<[u8; 100]>,
len: usize,
}
impl A {
pub const fn new() -> Self {
Self {
data: MaybeUninit::uninitialized(),
len: 0,
}
}
}
static mut a: MaybeUninit<[u8; 100]> = MaybeUninit::uninitialized();
static mut b: A = A::new();
์ด๋ค ์น์ ์ a ๋ฐ b ๊ธฐํธ๊ฐ ํฌํจ๋ฉ๋๊น?
์ถ์ : ๊ธฐํธ ๋งน ๊ธ๋ง์ ๋ํด ์๊ณ ์์ง๋ง์ด ์ง๋ฌธ์ ์ค์ํ์ง ์์ต๋๋ค.
@ qwerty19106 ๊ทํ์ ์์์ a
๋ฐ b
๋ชจ๋ .bss
๋ฉ๋๋ค. LLVM์ ๋ณ์๊ฐ ๋ค์ด๊ฐ ์น์
์ ์ ํํ ๋ MaybeUninit::uninitialized()
์ ๊ฐ์ undef
๊ฐ์ 0์ผ๋ก ์ฒ๋ฆฌํฉ๋๋ค.
A::new()
len
๋ฅผ 1๋ก ์ด๊ธฐํํ๋ค๋ฉด b
๋ .data
์์ ๋๋ฌ์ ๊ฒ์
๋๋ค. static
์ 0์ด ์๋ ๊ฐ์ด ํฌํจ ๋ ๊ฒฝ์ฐ ๋ณ์๋ .data
ํฉ๋๋ค. ํจ๋ฉ์ 0 ๊ฐ์ผ๋ก ์ฒ๋ฆฌ๋ฉ๋๋ค.
์ด๊ฒ์ด LLVM์ดํ๋ ์ผ์
๋๋ค. Rust๋ static
๋ณ์๊ฐ ๋ค์ด๊ฐ ๋ง์ปค ์น์
์ ๋ํด ~ ๋ณด์ฅ ~ ์ฝ์ (*)ํ์ง ์์ต๋๋ค. ๋จ์ง LLVM์ ๋์์ ์์ํฉ๋๋ค.
(*) #[link_section]
๋ฅผ ์ฌ์ฉํ์ง ์๋ ํ
์ฌ๋ฏธ์๋ ์ฌ์ค : ๊ณ ๋ ค ๋ช ๊ฐ์ง ํฌ์ธํธ LLVM์์ undef
์๋ ๊ฐ ์ ๋๋ก ๋ณ์ a
์์ ๋๋ ๊ทํ์ ์์ ์์ .data
. # 41315๋ฅผ ์ฐธ์กฐํ์ญ์์ค.
๊ทํ์ ๋ต๋ณ์ ๋ํด @japaric ์๊ฒ ๊ฐ์ฌ๋๋ฆฝ๋๋ค. ์ ์๊ฒ ๋งค์ฐ ๋์์ด๋์์ต๋๋ค.
์๋ก์ด ์์ด๋์ด๊ฐ ์์ต๋๋ค.
.init_array ์น์
์ ์ฌ์ฉํ์ฌ main ์ ํธ์ถํ๊ธฐ ์ ์ ์ ์ mut ๋ณ์๋ฅผ ์ด๊ธฐํ ํ ์ ์์ต๋๋ค.
์ด๊ฒ์ ๊ฐ๋ ์ฆ๋ช ์ ๋๋ค.
#[macro_export]
macro_rules! static_singleton {
($name_var: ident, $ty:ty, $name_init_fn: ident, $name_init_var: ident, $init_block: block) => {
static mut $name_var: MaybeUninit<$ty> = unsafe {MaybeUninit::uninitialized()};
extern "C" fn $name_init_fn() {
unsafe {
$init_block
}
}
#[link_section = ".init_array"]
#[used]
static $name_init_var: [extern "C" fn(); 1] = [$name_init_fn];
};
}
ํ ์คํธ ์ฝ๋ :
static_singleton!(A, u8, a_init_fn, A_INIT_VAR, {
let ptr = A.get_mut();
*ptr = 5;
});
fn main() {
println!("A inited to {}", unsafe {&A.get_ref()});
}
๊ฒฐ๊ณผ : 5๋ก ์ด๊ธฐํ ๋จ
์ ์ฒด ์ : ๋์ดํฐ
ํด๊ฒฐ๋์ง ์์ ์ง๋ฌธ :
concat_idents ๋ฅผ ์ฌ์ฉํ์ฌ a_init_fn ๋ฐ A_INIT_VAR ์ ์์ฑ ํ ์ ์์ต๋๋ค. # 1628 ์ ์์ง ์ฌ์ฉํ ์ค๋น๊ฐ๋์ง ์์ ๊ฒ ๊ฐ์ต๋๋ค.
์ด ํ ์คํธ๋๋ณ๋ก ์ ์ฉํ์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๋ณต์กํ ๊ตฌ์กฐ์ฒด ๋ฅผ ์ด๊ธฐํํ๊ธฐ ์ํด ์๋ฒ ๋๋์ ์ ์ฉ ํ ์ ์์ต๋๋ค ( .bss์ ๋ฐฐ์น๋๋ฏ๋ก ๊ฒฝ์ ์ ์ธ FLASH๊ฐ ๊ฐ๋ฅํฉ๋๋ค ).
rustc ๊ฐ .init_array ์น์ ์ ์ฌ์ฉํ์ง ์๋ ์ด์ ๋ ๋ฌด์์ ๋๊น? ELF ํ์์ ํ์ค ์น์ ์ ๋๋ค ( ๋งํฌ ).
@ qwerty19106 main () ์ด์ ์ ์ถ์ ์๋ชป๋ ๊ธฐ๋ฅ ์ผ๋ก ๊ฐ์ฃผ๋๊ณ Rust์ ์๋ฏธ์์ ๋ช ์ ์ ์ผ๋ก ๋ถ๋ฆฌ ๋์๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ข์, ์ข์ ์ธ์ด ๋์์ธ์ ๋๋ค.
๊ทธ๋ฌ๋ # [no_std] ์๋ ํ์ฌ ์ข์ ๋์์ด ์์ต๋๋ค (์๋ง๋ ๊ฒ์์ด ๋์๊ฒ ๋ ๊ฒ ๊ฐ์ต๋๋ค).
spin :: Once๋ฅผ ์ฌ์ฉํ ์ ์์ง๋ง ๋งค์ฐ ๋น์๋๋ค (๋ชจ๋ ์ฐธ์กฐ ๊ฐ์ ธ ์ค๊ธฐ์์ Ordering :: SeqCst ).
์๋ฒ ๋๋ ์ ๋ํ ์ปดํ์ผ ํ์ ๊ฒ์ฌ๋ฅผ ๋ฐ๊ณ ์ถ์ต๋๋ค.
๋งค์ฐ ๋น์๋๋ค (๋ชจ๋ ์ฐธ์กฐ ๊ฐ์ ธ ์ค๊ธฐ์
Ordering::SeqCst
).
๊ทธ๊ฒ์ ๋์๊ฒ ์ณ์ง ์์ ๊ฒ ๊ฐ์ต๋๋ค. ๋ชจ๋ "ํ ๋ฒ"์ถ์ํ๊ฐ ์ก์ธ์ค์ ์ํ๋๊ณ ์ด๊ธฐํ์ ๋๊ธฐํ๋์ด์ผํ์ง ์์ต๋๊น? ์๋๋ฉด ๋ค๋ฅธ ์๊ฐ์ํ๊ณ ์์ต๋๊น?
cc @Amanieu @alexcrichton
@ qwerty19106 :
"์๋ฒ ๋๋"๋ผ๊ณ ํ ๋ ๋ฒ ์ด ๋ฉํ์ ์๋ฏธํฉ๋๊น? .init_array
๋ ์ฌ์ค ELF ํ์ ์์ฒด์ ์ผ๋ถ๊ฐ ์๋๋ผ๋ ์ ์ ์ ์ํ ๊ฐ์น๊ฐ System V ABI ยฒ์ ์ผ๋ถ๋ ์๋๋๋ค. .init
๋ง ์์ต๋๋ค. Linux ABI๊ฐ ์์ ํ๋ System V ABI ์ด์ ์
๋ฐ์ดํธ์ ๋๋ฌ ํ ๋๊น์ง .init_array
์ฐพ์ ์ ์์ต๋๋ค.
๊ฒฐ๊ณผ์ ์ผ๋ก ๋ฒ ์ด ๋ฉํ์์ ์คํ์ค์ธ ๊ฒฝ์ฐ .init_array
๋ ์ฌ์ฉ ์ฌ๋ก์ ๋ํด ์์ ์ ์ผ๋ก ์๋ํ์ง ์์ ์ ์์ต๋๋ค. ๊ฒฐ๊ตญ ๋์ ๋ก๋ ๋ฐ / ๋๋ libc์ ์ฝ๋์ ์ํด ๋ฒ ์ด ๋ฉํ์ด ์๋ ๊ฒฝ์ฐ ๊ตฌํ๋ฉ๋๋ค. ๋ถํธ ๋ก๋๊ฐ .init_array
์์ ์ฐธ์กฐ ๋ ์ฝ๋ ์คํ์ ๋ด๋นํ์ง ์๋ ํ ์๋ฌด๊ฒ๋ํ์ง ์์ต๋๋ค.
1 : 28 ํ์ด์ง, ๊ทธ๋ฆผ 1-13 "ํน์ ์น์
"์ฐธ์กฐ
2 : 63 ํ์ด์ง, ๊ทธ๋ฆผ 4-13 "ํน์ ์น์
(๊ณ์)"์ฐธ์กฐ
@eddyb Once
์ฝ์ ๋๋ ์ต์ํ Acquire
๋ก๋๊ฐ ํ์ํฉ๋๋ค. ์ด๊ฒ์ x86์์๋ ์ ์์ ์ธ๋ก๋์ด๊ณ ARM์์๋๋ก๋ + ํ์ค์
๋๋ค.
ํ์ฌ ๊ตฌํ์ load(SeqCst)
๋ฅผ ์ฌ์ฉํ์ง๋ง ์ค์ ๋ก๋ ๋ชจ๋ ์ํคํ
์ฒ์์ load(Acquire)
์ ๋์ผํ asm์ ์์ฑํฉ๋๋ค.
(์ด ํ ๋ก ์ ๋ค๋ฅธ ๊ณณ์ผ๋ก ์ฎ๊ธฐ์๊ฒ ์ต๋๊น? ๊ทธ๋ค์ ๋ ์ด์ MaybeUninit ๋ mem :: uninitialized์๋ ์๋ฌด ๊ด๋ จ์ด ์์ต๋๋ค. ๋ ๋ค LLVM์ดํ๋ ๊ฒ๊ณผ ๋์ผํ wrt ๋์-undef๋ฅผ ์์ฑํฉ๋๋ค. ๋์ค์ ๊ทธ undef๋ก ๋ฌด์จ ์ผ์ด ๋ฐ์ํ๋์ง๋ ์ฌ๊ธฐ์ ์ฃผ์ ๊ฐ ์๋๋๋ค. )
์ค์ 13 ์ผ 2018 ๋ 9 ์ 00:59:20 MESZ schrieb Amanieu [email protected] :
@eddyb ์ต์ํ
Acquire
๋ก๋๊ฐ ํ์ํฉ๋๋ค.
Once
์ด๊ฒ์ x86์์๋ ์ ์์ ์ธ๋ก๋์ด๊ณ ARM์์๋๋ก๋ + ํ์ค์ ๋๋ค.ํ์ฌ ๊ตฌํ์
load(SeqCst)
๋ฅผ ์ฌ์ฉํ์ง๋ง ์ค์ ๋ก๋
๋ชจ๋ ์ํคํ ์ฒ์์load(Acquire)
์ ๋์ผํ asm์ ์์ฑํฉ๋๋ค.-
๋น์ ์ด ์ธ๊ธ ๋์๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ฐ๊ณ ์์ต๋๋ค.
์ด ์ด๋ฉ์ผ์ ์ง์ ๋ต์ฅํ๊ฑฐ๋ GitHub์์ ํ์ธํ์ธ์.
https://github.com/rust-lang/rust/issues/53491#issuecomment -420825802
MaybeUninit
์ด (๊ฐ) ๋ง์คํฐ์ ๋์ฐฉํ์ผ๋ฉฐ ๋ค์ ๋ ๋ฐค์์์ ์์ ์
๋๋ค. :)
https://github.com/rust-lang/rust/issues/54470๋ ์ฌ์ฉ ์ ์ Box<[MaybeUninit<T>]>
์ RawVec<T>
. ๋ณํ์ด ๋ ์ ์ ์์์ ์ฌ๋ผ์ด์ค๋ฅผ ์ฌ์ฉํ์ฌ ๋ค๋ฅธ ํฅ๋ฏธ๋ก์ด ์กฐํฉ์ ๊ฐ๋ฅํ๊ฒํ๋ ค๋ฉด ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ API๋ฅผ ๋ ์ถ๊ฐ ํ ์ ์์๊น์?
ํนํ ์ด๊ธฐํํ์ง ์๊ณ ํ ๋นํ๋ ค๋ฉด ( Box::new(MaybeUninit::uninitialized())
์ฌ์ ํ size_of::<T>()
ํจ๋ฉ ๋ฐ์ดํธ๋ฅผ ๋ณต์ฌํ๋ค๊ณ ์๊ฐํฉ๋๊น?) :
impl<T> Box<MaybeUninit<T>> {
pub fn new_uninit() -> Self {โฆ}
pub unsafe fn assert_init(s: Self) -> Box<T> { transmute(s) }
}
impl<T> Box<[MaybeUninit<T>]> {
pub fn new_uninit_slice(len: usize) -> Self {โฆ}
pub unsafe fn assert_init(s: Self) -> Box<[T]> { transmute(s) }
}
core::slice
/ std::slice
์์ ํ์ ์ฌ๋ผ์ด์ค๋ฅผ ์ทจํ ํ ์ฌ์ฉํ ์ ์์ต๋๋ค.
pub unsafe fn assert_init<T>(s: &[MaybeUninit<T>]) -> &[T] { transmute(s) }
pub unsafe fn assert_init_mut<T>(s: &mut [MaybeUninit<T>]) -> &mut [T] { transmute(s) }
Box :: new (MaybeUninit :: uninitialized ())๋ ์ฌ์ ํ size_of ::
() ํจ๋ฉ ๋ฐ์ดํธ
๊ทธ๋ ๊ฒํด์๋ ์๋๋ฉฐ์ด๋ฅผ ํ ์คํธํ๊ธฐ์ํ codegen ํ ์คํธ๊ฐ ์์ต๋๋ค.
ํจ๋ฉ ๋ฐ์ดํธ๋ ๋นํธ ํํ์ด ์ค์ํ์ง ์์ผ๋ฏ๋ก ๋ณต์ฌ ํ ํ์๊ฐ ์์ต๋๋ค (๋นํธ ํํ์ ๊ด์ฐฐํ๋ ๊ฒ์ ์ด์จ๋ UB์ ๋๋ค).
์ข์ต๋๋ค. Box::new_uninit
๊ฐ ๋ถํ์ํ ๊น์? ํ์ง๋ง Box::new
์๋ T: Sized
ํ์ํ๊ธฐ ๋๋ฌธ์ ์ฌ๋ผ์ด์ค ๋ฒ์ ์ด ๋ค๋ฆ
๋๋ค.
MaybeUninit::zeroed
์ (๋ฅผ) const fn
์ผ๋ก ์นํธํ๊ณ ์ถ์ต๋๋ค. FFI์ ๊ด๋ จ๋ ๋ช ๊ฐ์ง ์ฉ๋ (์ : 0์ผ๋ก ์ด๊ธฐํํด์ผํ๋ ์ ์ )๊ฐ ์์ผ๋ฉฐ ๋ค๋ฅธ ์ฌ๋๋ค์ด ์ ์ฉํ๋ค๊ณ ์๊ฐํฉ๋๋ค. zeroed
ํจ์๋ฅผ ๊ตฌ์ฑํ๋ ๋ฐ ์๊ฐ์ ํ ์ ํ๊ฒ๋์ด ๊ธฐ์ฉ๋๋ค.
@mjbshaw ๋ zeroed
๊ฐ min_const_fn
๊ฒ์ฌ๋ฅผ ํต๊ณผํ์ง ๋ชปํ๋ ์์
์ ์ํํ๋ฏ๋ก #[rustc_const_unstable(feature = "const_maybe_uninit_zeroed")]
๋ฅผ ์ฌ์ฉํด์ผํฉ๋๋ค (https://github.com/rust-lang/ rust / issues / 53555) ์ด๋ ํจ์๊ฐ ์์ ์ ์ด๋๋ผ๋ MaybeUninit::zeroed
์ constness๊ฐ ๋ถ์์ ํ๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค.
๋ ๋์ ์ํ๊ณ์์ MaybeUninit ์ ํ์ ๋ ๋นจ๋ฆฌ ์ฌ์ฉํ ์ ์๋๋ก ๊ตฌํ / ์์ ํ๋ฅผ ๋ช ๋จ๊ณ๋ก ๋๋ ์ ์์ต๋๊น? ๋จ๊ณ๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
1) MaybeUninit ์ถ๊ฐ
2) mem :: uninitialized / zeroed์ ๋ชจ๋ ์ฌ์ฉ์ ๋ณํํ๊ณ deprecate
์๋ ํ์ธ์.
MaybeUninit ์ถ๊ฐ
https://doc.rust-lang.org/nightly/core/mem/union.MaybeUninit.html :)
์ข์! ๊ทธ๋ ๋ค๋ฉด MaybeUninit๋ฅผ ์ต๋ํ ๋นจ๋ฆฌ ์์ ํ์ํฌ ๊ณํ์ ๋๊น?
๋ค์ ๋จ๊ณ๋ https://github.com/rust-lang/rust/pull/54668์ด ์ฑ๋ฅ์ ๊ทธ๋ ๊ฒ ๋์๊ฒ ํ๊ท์ํค๋ ์ด์ ๋ฅผ
๋ํ ์๋๋ฅด๋ฉด ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ์๋ชป ์ฒ๋ฆฌํ๊ธฐ์ํ ๋ง์ง๋ง API๊ฐ ์์ต๋๋ค. ์๋๋ฅด์ง ๋ง๊ณ ๋ค์ ๋ง์ณ ๋ณด์. ;)
์ฆ, ํ์๋ ๋ถํ์ํ ์ง์ฐ์ ์ถ๊ฐํ์ง ์๊ธฐ๋ฅผ ์ํ๋ฏ๋ก ๋ง์นจ๋ด ์ด์ ํ๊ฑด์ ํ๊ธฐ ํ ์ ์์ต๋๋ค. :)
์, ๊ทธ๋ฆฌ๊ณ ๋ฐฉ๊ธ ๋์๊ฒ ๋ค๋ฅธ ์ผ์ด ์๊ฒผ์ต๋๋ค ... https : //github.com/rust-lang/rust/pull/54667์ด ์ฐฉ๋ฅํ๋ฉด ์ค๋๋ API๊ฐ ์ค์ ๋ก ์ต์
์ ํ๊ฑด์ผ๋ก๋ถํฐ ๋ณดํธํฉ๋๋ค. MaybeUninit
๋ก๋๋ฐ์ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค. ์์ ํ๋ฅผ ์ฐจ๋จํ๋ ๊ฒ์ ์๋์ง๋ง ๋ฌด์ธ ์ ํ์์ ํธ์ถ ๋ ๋ MaybeUninit::into_inner
ํจ๋์ ์ ๋ฐํ ์์๋ ๋ฐฉ๋ฒ์ ์ฐพ์ ์ ์์ต๋๋ค. ๋๋ฒ๊ทธ ๋น๋์์ T
๋ฌด์ธ ์ํ์์ x: &[mut] T
์ฌ์ฉํ๋ฉด *x
๊ฐ ๋นํฉ ํ ์๋ ์์ต๋๋ค.
์ํ ์ ๋ฐ์ดํธ : https://github.com/rust-lang/rust/pull/54668๋ก ์งํํ๋ ค๋ฉด ๊ณต์ฉ์ฒด์ ๋ํ ๋ ์ด์์ ๊ณ์ฐ์ ์กฐ์ ํ ๋๊ตฐ๊ฐ๊ฐ ํ์ํ ๊ฒ์ ๋๋ค. @eddyb ์ ๊ธฐ๊บผ์ด ๋ฉํ ๋ง ํ ์ ์์ง๋ง ๊ตฌํ์ ์ํ ํ ์ฌ๋์ด ํ์ํฉ๋๋ค. :)
๋ํผ์์ ๋ฒ์ด๋ ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ผ๋ก ๋์ฒดํ๋ ๋ฐฉ๋ฒ์ด ์ ์ฉ ํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
pub unsafe fn take(&mut self) -> T
์ ์ถํ ๊น์?
@shepmaster ์ด๊ฒ์ ๊ธฐ์กด into_inner
๋ฐฉ๋ฒ๊ณผ ๋งค์ฐ ์ ์ฌํฉ๋๋ค. ์ฌ๊ธฐ์ ์ค๋ณต์ ํผํ ์ ์์๊น์?
๋ํ "๋ฐ๊พธ๊ธฐ"๋ ์ฌ๊ธฐ์์ ์๋ชป๋ ๊ทธ๋ฆผ ์ผ ๊ฐ๋ฅ์ฑ์ด ๋์ต๋๋ค. ์ด๊ฒ์ self
์ ๋ด์ฉ์ ์ ํ ๋ณ๊ฒฝํด์๋ ์๋ฉ๋๋ค. ์์ ๊ถ ๋ง ์ด์ ๋๋ฏ๋ก ์ด์ ๋ ์ด๊ธฐํ๋์ง ์์ ์ํ๋ก ๊ตฌ์ถ ๋ ๊ฒ๊ณผ ๋์ผํ ์ํ๊ฐ๋ฉ๋๋ค.
self
์ ์ ํ ๋ณ๊ฒฝ
๋ฌผ๋ก ๊ตฌํ ์ ๊ธฐ๋ณธ์ ์ผ๋ก ptr::read
์ด์ง๋ง ์ฌ์ฉ ๊ด์ ์์ ์ ํจํ ๊ฐ์ ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ผ๋ก ๋์ฒดํ๋ ๊ฒ์ผ๋ก ํ๋ ์์ ๊ตฌ์ฑํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ค๋ณต ๋ฐฉ์ง
๋๋ ํ๋์ ๊ตฌํ์ด ๋ค๋ฅธ ํ๋๋ฅผ ํธ์ถํ๊ธฐ๋ฅผ ๊ธฐ๋ํ๊ธฐ ๋๋ฌธ์ ๊ฐํ ๋ฐ๋๊ฐ ์์ต๋๋ค. ์ต์ข ์ํ๊ฐ ๋ฌด์์ธ์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
into_inner
๊ฐ ๋๋ฌด ๊ฒฐ๋ฐฑ ํ ํจ์ ์ด๋ฆ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์ฌ๋๋ค์ ์๋ง๋ ๋ฌธ์๋ฅผ ๋๋ฌด์ฃผ์ ๊น๊ฒ ์ฝ์ง ์๊ณ MaybeUninit::uninitialized().into_inner()
ํฉ๋๋ค. ์ด๋ฆ์ was_initialized_unchecked
์ ๊ฐ์ด ๋ณ๊ฒฝํ๋ฉด ๋ฐ์ดํฐ๊ฐ ์ด๊ธฐํ ๋ ํ์ ๋ง โโํธ์ถํด์ผ ํจ์ ๋ํ๋ผ ์ ์์ต๋๊น?
๋๋ take
์๋ ๋์ผํ๊ฒ ์ ์ฉ๋ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
์กฐ๊ธ ์ด์ํ์ง๋ง unchecked_into_initialized
๊ฒ์ด ์๋ ํ ์ ์์ต๋๊น?
์๋๋ฉด ํด๋น ๋ฉ์๋๋ฅผ ์์ ํ ์ ๊ฑฐํ๊ณ ๋ฌธ์์์ x.as_ptr().read()
์์ ๋ฅผ ์ ๊ณตํด์ผํฉ๋๊น?
@SimonSapin into_inner
์ (๋) self
์๋นํฉ๋๋ค.
๊ทธ๋ฌ๋ @shepmaster ์ take
๊ฒฝ์ฐ as_mut_ptr().read()
๋ฅผ ์ํํ๋ฉด ๋์ผํ ์์
์ ์ํ ํ ์ ์์ต๋๋ค ... ๋ฌผ๋ก ๋ณ๊ฒฝ ๊ฐ๋ฅํ ํฌ์ธํฐ๋ก ๊ท์ฐฎ๊ฒํ๋ ์ด์ ๋ ๋ฌด์์
๋๊น?
take_unchecked
๋ฐ into_inner_unchecked
์ด๋ป์ต๋๊น?
๊ทธ๊ฒ์ ๋ด๊ฐ ์๊ฐํ๋ ๋ฐฑ์ ๊ณํ์ด์ง๋ง ์ด๊ธฐํํด์ผ ํจ์ ๋ํ๋ผ ์ ์๋ค๋ฉด ์ ํธํฉ๋๋ค.
์ด๊ธฐํํด์ผํ๋ค๋ ๊ฐ์กฐ์ ๊ทธ๊ฒ์ดํ๋ ์ผ (unwrap / into_inner / etc.)์ ๋ํ ์ค๋ช
์ ํ๋์ ์ด๋ฆ์ ๋ฃ๋ ๊ฒ์ ๋ค์ ๋ค๋ฃจ๊ธฐ ์ด๋ ต์ต๋๋ค. ๋ฐ๋ผ์ ์ ์๋ assert_initialized
ํ๊ณ ํ์๋ ๊ทธ๋๋ก ๋๋ ๊ฒ์ ์ด๋ป์ต๋๊น? ์๋ช
์ ์ํด ์์๋ฉ๋๊น? ๊ฐ๋ฅํ unchecked_assert_initialized
๊ฐ์ ๋ฐํ์ ๊ฒ์ฌ๋ฅผ ์์ ํผํ๊ธฐ ์ํด assert!()
์๋ค.
assert! ()์ ๊ฐ์ ๋ฐํ์ ๊ฒ์ฌ๋ฅผ ์์ํ์ง ์๋๋ก unchecked_assert_initialized ๊ฐ๋ฅํฉ๋๋ค.
์ฐ๋ฆฌ๋ ์ด๋ฏธ intrinsics::assume(foo)
๋ assert!(foo)
๋ฅผ ํตํด ๊ฐ์ ๊ณผ ์ฃผ์ฅ์ ๊ตฌ๋ถํ๋ฏ๋ก assume_initialized
?
assume
๋ ๋ถ์์ ํ API์ด๊ณ , ๊ฐ์ ๋ assert์ ์์ ์ ์ธ ์๋ unreachable_unchecked
๋ unreachable
๋ฐ get_unchecked
๋ get
์
๋๋ค. ๊ทธ๋์ ์ ๋ unchecked
๊ฐ ์ฌ๋ฐ๋ฅธ ์ฉ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
foo_unchecked
๋ ํด๋น foo
์ด์์ ๋๋ง ์๋ฏธ๊ฐ ์๋ค๊ณ ๋งํ๊ณ ์ถ์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด unsafe
๋ผ๋ ํจ์์ ์์ํ ํน์ฑ์ด "๋ค๋ฅธ"๋ฌด์ธ๊ฐ๊ฐ ์งํ๋๊ณ ์์์ ๋ํ๋
๋๋ค. ์ ์์.
์ด ์์ ๊ฑฐ ์ฐฝ๊ณ ๋ ๋ถ๋ช ํ ์๋ชป๋ ์์ ๋๋ค
์ด ํน์ API๋ฅผ ์ฌ์ฉํ์ฌ ์ฐ๋ฆฌ๋ ํ๋ก๊ทธ๋๋จธ๊ฐ "์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๊ฐ ์ฐ๋ ๊ธฐ์ด๋ฏ๋ก ๋ถ์ฃผ์ํ๊ฒ ์ฒ๋ฆฌํ๋ฉด UB๋ฅผ ์ ๋ฐํ ์ ์์ต๋๋ค"๋ผ๊ณ ์๊ฐํ๋ ํ๋ก๊ทธ๋๋จธ๊ฐ "์ด๋ฅผ ํธ์ถํ๋ ๊ฒ์ด UB์
๋๋ค"๋ผ๊ณ ์๊ฐํ๋ ๊ฒ์ ์ด๋ฏธ ๋ณด์๊ณ ๊ณ์ ๋ณผ ๊ฒ์
๋๋ค. ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ, ๊ธฐ๊ฐ ". unchecked
์ ๊ฐ์ ์ค๋ณต ๋ โ ๏ธ๊ฐ ๋์์ด ๋ ์ง๋ ํ์คํ์ง ์์ง๋ง, ์คํ๋ ค ๋ ๋นํฉ์ค๋ฌ์ํ๋ ํธ์์๋ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค (= ์ฌ๋๋ค์ด ์ฃผ๋ณ์ ๋ฌป๊ฑฐ๋ ๋ฌธ์๋ฅผ ์ฝ๊ฒ ํ ๊ฐ๋ฅ์ฑ์ด ๋ ๋์ต๋๋ค). ๋งค์ฐ ์ ์คํ๊ฒ).
๋ฟก๋ฟก
into_inner
๊ฐ ๋๋ฌด ๊ฒฐ๋ฐฑ ํ ํจ์ ์ด๋ฆ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์ฌ๋๋ค์ ์๋ง๋ ๋ฌธ์๋ฅผ ๋๋ฌด์ฃผ์ ๊น๊ฒ ์ฝ์ง ์๊ณMaybeUninit::uninitialized().into_inner()
ํฉ๋๋ค. ์ด๋ฆ์was_initialized_unchecked
์ ๊ฐ์ด ๋ณ๊ฒฝํ๋ฉด ๋ฐ์ดํฐ๊ฐ ์ด๊ธฐํ ๋ ํ์ ๋ง โโํธ์ถํด์ผ ํจ์ ๋ํ๋ผ ์ ์์ต๋๊น?
๋๋ _ ์ ๋ง _์ด ์์ด๋์ด๋ฅผ ์ข์ํฉ๋๋ค. ๋๋ ๊ทธ๊ฒ์ด ์๋ฏธ๋ก ์ ๋ํด ์ณ์ ์ผ์ ๋งํ๊ณ ์ด๊ฒ์ด ์ ์ฌ์ ์ผ๋ก ์ํํ๋ค๊ณ ๊ฐํ๊ฒ ๋๋๋๋ค.
๋ฟก๋ฟก
์ด๊ธฐํํด์ผํ๋ค๋ ๊ฐ์กฐ์ ๊ณผ ๊ทธ๊ฒ์ดํ๋ ์ผ (unwrap / into_inner / etc.)์ ๋ํ ์ค๋ช ์ ํ๋์ ์ด๋ฆ์ ๋ฃ๋ ๊ฒ์ ๋ค์ ๋ค๋ฃจ๊ธฐ ์ด๋ ต์ต๋๋ค. ๋ฐ๋ผ์ ์ ์๋
assert_initialized
ํ๊ณ ํ์๋ ๊ทธ๋๋ก ๋๋ ๊ฒ์ด ์ด๋ป์ต๋๊น? ์๋ช ์ ์ํด ์์๋ฉ๋๊น? ๊ฐ๋ฅํunchecked_assert_initialized
๊ฐ์ ๋ฐํ์ ๊ฒ์ฌ๋ฅผ ์์ ํผํ๊ธฐ ์ํดassert!()
์ด์๋ค.
๋๋ ์ํํ ๋ฌผ๊ฑด์ ๋ํ ๋ค๋ฃจ๊ธฐ ํ๋ ๊ธด ์ด๋ฆ์ ๋ํ ๋ถ๋ง์ด ์์ต๋๋ค. ๋ ๋ง์ ์ฌ๋๋ค์ด ๋ ๋ฒ ์๊ฐํ๊ฒํ๋ค๋ฉด was_initialized_into_inner_unchecked
๋ ์์ ํ ๊ด์ฐฎ์ต๋๋ค. ์์ ํ์ง ์์ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒ์ด (์ด์ ๋ด์์) ์ธ์ฒด ๊ณตํ์ ์ด์ง ์๊ฒ ๋ง๋๋ ๊ฒ์ ๋ฒ๊ทธ๊ฐ ์๋๋ผ ๊ธฐ๋ฅ์
๋๋ค.)
๋๋ค์์ ์ฌ๋๋ค์ด ์ด๋ค ํํ๋ก๋ ์๋ ์์ฑ ๊ธฐ๋ฅ์ด์๋ IDE๋ฅผ ์ฌ์ฉํ ๊ฐ๋ฅ์ฑ์ด ๋์ผ๋ฏ๋ก ๊ธด ์ด๋ฆ์ ์ฌ์ํ๋ก๋ ๋ฒํ์ ๋๋ค.
์ ๋์ด ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ ์ธ์ฒด ๊ณตํ์ ํน๋ณํ ์ ๊ฒฝ ์ฐ์ง ์์ง๋ง ํน์ ํฌ์ธํธ ์ด๋ฆ์ ์ง๋์ ์ฝ๋ ๊ฒ๋ณด๋ค ํ์ด ๋ณด๋ ๊ฒฝํฅ์ด ์์ผ๋ฉฐ์ด ์ด๋ฆ์ ์ค์ ๋ก ๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ์ดํดํ๊ธฐ ์ํด ์ฝ์ด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ํ์ด ํจ์๋ ์ค์ ๋ก ์ฌ์ฉ๋๋๋งํผ ์์ฃผ ๋ ผ์ / ์ค๋ช ๋ ๊ฒ์ผ๋ก ๊ธฐ๋ํฉ๋๋ค (๋น๊ต์ ํ์ ์์ฅ์ด๊ณ ๋งค์ฐ ๋ฏธ๋ฌํ๊ธฐ ๋๋ฌธ์). ์์ค ์ฝ๋์ ๊ธด ์๋ณ์๋ฅผ ์ ๋ ฅํ๋ ๊ฒ์ ๊ด์ฐฎ์ ์ ์์ง๋ง (์ : IDE ๋๋ถ์) ์ฑํ ์์คํ ์ ๋ฉ๋ชจ๋ฆฌ๋ ... ๋ ๋ฉ์ง๋ค (์ด ์ ์ ๋ํด ๋ฐ์ ๋๋ด์ด์ง๋ง โโ๋ฐ๋ง).
@shepmaster ๋ฌผ๋ก ์
๋๋ค. ์๋ ์์ฑ ๊ธฐ๋ฅ์ด์๋ IDE๋ ์ฌ์ฉํฉ๋๋ค. ๊ทธ๋ฌ๋ unsafe
๋ธ๋ก ๋ด๋ถ๋ฅผ ํฌํจํ์ฌ ๋ด๋ถ์ unchecked
๊ฐ ํฌํจ ๋ ๋ ๊ธด ์ด๋ฆ์ด ์ถ๊ฐ๋ก ์ผ์ ์ค์ง๋์ง ์๋๋กํฉ๋๋ค.
๋ฟก๋ฟก
์ฑํ ์์คํ ์ ๋ฉ๋ชจ๋ฆฌ์์ ์ ๋ ฅํ๋ ๊ฒ์ ... ๋ ๋ฉ์ง๋ค (์ด ์ ์ ๋ํด ์ ๋ฐ์ ๋๋ด์ด์ง๋ง โโ์ ๋ฐ ๋ง).
๋๋ ๊ทธ ์ ์ถฉ์์ ๋ง๋ค ๊ฒ์ ๋๋ค. ์ด๋ฆ์ด ์กฐ๊ธ ํน๋ณํด์ ๋ ๊ธฐ์ต์ ๋จ์ ์๋ ์์ต๋๋ค. ;)
๋ค์ ์ค ํ๋ (๋๋ โโ๋์ผํ ์๋ฏธ ์๋ฏธ๋ฅผ ํฌํจํ๋ ์ ์ฌํ ์ด๋ฆ) :
was_initialized_unchecked
was_initialized_into_inner_unchecked
is_initialized_unchecked
is_initialized_into_inner_unchecked
was_init_unchecked
was_init_into_inner_unchecked
is_init_unchecked
is_init_into_inner_unchecked
assume_initialized_unchecked
assume_init_unchecked
๋๋ ๊ด์ฐฎ๋ค.
initialized_into_inner
์ด๋ป์ต๋๊น? ๋๋ initialized_into_inner_unchecked
, unchecked
์ด ์ ๋ง๋ก ํ์ํ๋ค๊ณ ์๊ฐํ๋ ๊ฒฝ์ฐ, ์ ๋ unchecked
๊ฐ ๋์ผํ ๋ค๋ฅธ _checked_ ๋ณํ๊ณผ ๊ตฌ๋ณํ๋ ๋ฐ๋ง ํ์ํ๋ค๋ @shepmaster ์ ๋์ํ๋ ๊ฒฝํฅ์ด ์์ต๋๋ค. ๋ฐํ์ ๊ฒ์ฌ๊ฐ ๋ฐ์ํ์ง ์๋ ๊ธฐ๋ฅ.
์๊ฐ ์ฐจ์ฉ ์์ฑ๊ธฐ๋ฅผ ์๋์ผ๋ก ๊ตฌํํ ๋ ptr::drop_in_place(maybe_uninit.as_mut_ptr())
์ฌ๋ฌ ๋ฒ ์ฌ์ฉํ๊ฒ๋์์ง๋ง MaybeUninit
์ ๊ณ ์ ํ ๋ฐฉ๋ฒ ์ธ unsafe fn drop_in_place(&mut self)
๋ก ์ ์๋ํ๋ ๊ฒ ๊ฐ์ต๋๋ค.
ManuallyDrop::drop
์ ๋ก๊ฐ ์์ต๋๋ค.
foo_unchecked๋ ํด๋นํ๋ foo๊ฐ์์ ๋๋ง ์๋ฏธ๊ฐ ์๋ค๊ณ ๋งํ๊ณ ์ถ์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์์ ํ์ง ์์ ํจ์์ ์์ ํ ํน์ฑ์ด "๋ค๋ฅธ"์ผ์ด ์งํ๋๊ณ ์์์ ๋ํ๋ ๋๋ค.
์์ ํ์ง ์์ ๋ฒ์ ์ด์๋ ๊ฒ์ด ์์ ํ์ง ์์ ๋ฒ์ ์์ ๊ฒฝ๊ณ ํ์๋ฅผ ์ ๊ฑฐํ๋ ์ข์ ์ด์ ๋ผ๊ณ ์๊ฐํ์ง ์์ต๋๋ค.
์์ ํ์ง ์์ ๋ฒ์ ์์ ๊ฒฝ๊ณ ํ์ ์ ๊ฑฐ
์ฝ๊ฐ ์๊ณก์ ์ด๊ธฐ ๋๋ฌธ์ ์ธ์ unsafe
ํจ์๊ฐ _unchecked
๋์ ๋ถ์ด ์์ง ์์์ผ ํฉ๋๊น? ๊ฐ์ ๋ง์ํ๋ ๋ ๊ฐ์ ๊ฒฝ๊ณ ๊ฐ์๋ ์ด์ ๋ ๋ฌด์์
๋๊น?
๊ณต์ ํ ์ง๋ฌธ์
๋๋ค. :) ๊ทธ๋ฌ๋ ๋๋ ๋๋ต์ด "๊ฑฐ์ ๊ฒฐ์ฝ"๋ผ๊ณ ์๊ฐํ์ง ์๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋๋ ๊ทธ๊ฒ์ด ์์ ํ์ง ์๋ค๋ ๊ฒ์ ๊ฒฐ์ฝ ํํํ์ง ์๋ ํฌ์ธํฐ์ ๋ํด ์์ ํ์ง ์์ ํจ์๋ก offset
์ ๊ฐ์ง๊ณ ์๋ค๋ ์ฌ์ค์ ํํํ๋ค. ๋ฌธ์ ๊ทธ๋๋ก unchecked
์ผ ํ์๋ ์์ง๋ง IMO์๋ ๋ญ๊ฐ ๊ฐ ์์ด์ผํฉ๋๋ค. ์ด์จ๋ ์์ ํ์ง ์์ ๋ธ๋ก ์์ ์๊ณ ์ค์๋ก ์์ฑํ๋ ๊ฒฝ์ฐ .offset
๋์ .wrapping_offset
, ๋ด๊ฐ ๋ง๋ค ์๋ํ์ง ์์ ๊ฒ์ ์ปดํ์ผ๋ฌ์ ๋ํ ์ฝ์์ํ๋ค.
์์ ํ์ง ์๋ค๋ ๊ฒ์ ๊ฒฐ์ฝ ํํํ์ง ์๋ ํฌ์ธํฐ์ ๋ํ ์์ ํ์ง ์์ ํจ์
์ด๊ฒ์์ด ๋จ๊ณ์์ ๋์ ์ฆ๊ฑฐ์์ ์์ฝํฉ๋๋ค.
@shepmaster ๋ฐ๋ผ์ ๋๊ตฐ๊ฐ๊ฐ ๊ธฐ์กด unsafe
๋ธ๋ก (์์ ์ ์ผ๋ก unsafe
๊ฐ์๋ ํฐ unsafe fn
๋ด๋ถ์์์ ์ ์์) ๋ด๋ถ์์ ์ฝ๋๋ฅผ ํธ์งํ๋ ๊ฒ์ด ํ์ค์ ์ด๋ผ๊ณ ์๊ฐํ์ง ์์ต๋๋ค unsafe
unsafe
๋ธ๋ก), ์ถ๊ฐํ๋ ํธ์ถ์ด unsafe
๋ผ๋ ๊ฒ์ ์์ง ๋ชปํฉ๋๊น?
๋๊ตฐ๊ฐ๊ฐ ๊ธฐ์กด
unsafe
๋ธ๋ก [...] ๋ด์์ ์ฝ๋๋ฅผ ํธ์งํ๊ณ ์ถ๊ฐํ๋ ํธ์ถ์ดunsafe
์์ ์์ง ๋ชปํฉ๋๋ค.
์ฃ์กํฉ๋๋ค. ์ ๋์ด ๊ฐ๋ฅ์ฑ์ ๋ฌด์ํ ์๋๊ฐ ์์์ผ๋ฉฐ ์ค์ ์ฒ๋ผ ๋ณด์
๋๋ค. ๋ด ์๊ฒฌ์ ๊ธฐ์กด unsafe
ํ์ ์๊ฐ ๋ ๊น์ ์คํจ๋ฅผ ๋ํ๋ด๋
์ด์ ๋ฒ์ ๊ณผ ํธํ๋๋ ๋ฐฉ์์ผ๋ก ๊ณ ์น ์์๋ ์คํจ ์ผ ์๋ ์๊ณ ์ด๋ฆ์ ๋จ์ด๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ด ์ ์ผํ ํด๊ฒฐ์ฑ ์ด์ง๋ง, ๊ทธ๋ ์ง ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค .
์๋ง๋ ํฐ ๊ฒ, ์๋ง๋
unsafe
๋ธ๋ก์ด์๋ ํฐunsafe fn
๋ด๋ถ
์๋ฐฑ ์ค์ ํจ์๊ฐ์์ ๋ ์๋ ์์ ๋ถ๋ช ํ ๋์ ์๊ฐ์ด๊ธฐ ๋๋ฌธ์ Rust๊ฐ ๋ณ์๋ฅผ ์๋ ์ํ๋๋ก ํ์ฉํ๋ ์ด์ ์ ๋ํด ์ง๋ฌธ์ ๋ฐ์์ต๋๋ค. ๋๋ ๊ทธ๋ฌํ ์ฝ๋๊ฐ ์ผ๋ฐ์ ์ผ๋ก ์์ํ๊ธฐ์ ๋์ ํํ๋ก ๋ฐ์ ๋ค์ฌ ์ง๋ค๊ณ ๋ฏฟ๊ธฐ ๋๋ฌธ์ ๊ฐ์ธ์ ์ผ๋ก ๊ทธ๋ฌํ ๊ฒฝ์ฐ๋ฅผ ๋งค์ฐ ๋ฌด์ํฉ๋๋ค.
์ด์ Rust์ ์ด๋ค ์ธก๋ฉด ์ด ์์ ํ์ง ์์ ๋ธ๋ก์ด "ํ์ํ"๊ฒ๋ณด๋ค ๋ ์ปค์ง๋๋ก
์ ์ณ๋๊ณ , IDE + RLS๊ฐ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ํ์๋ ๊ธฐ๋ฅ์ ์๋ณํ๊ณ ํน๋ณํ ๊ฐ์กฐ ํ์ ํ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ด ํธ์ง์๋ ์ด๋ฏธ unsafe
ํค์๋๋ฅผ ๊ฐ์กฐ ํ์ํฉ๋๋ค.
์ด์ Rust์ ์ด๋ค ์ธก๋ฉด์ด ์์ ํ์ง ์์ ๋ธ๋ก์ด "ํ์ํ"๊ฒ๋ณด๋ค ๋ ์ปค์ง๋๋ก ๊ฐ์ํ๋ค๋ฉด, ๊ทธ๊ฒ์ ๋ํ ๋ ๊ทผ๋ณธ์ ์ธ ๋ฌธ์ ๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
๊ธ์์ https://github.com/rust-lang/rfcs/pull/2585;)
์ ์ณ๋๊ณ , IDE + RLS๊ฐ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ํ์๋ ๊ธฐ๋ฅ์ ์๋ณํ๊ณ ํน๋ณํ ๊ฐ์กฐ ํ์ ํ ์ ์๋์ง ๊ถ๊ธํฉ๋๋ค.
๊ทธ๊ฒ์ ์ข์ ๊ฒ์ ๋๋ค! ํ์ง๋ง ๋ชจ๋ ์ฌ๋์ด IDE์์ ์ฝ๋ ๋ง ์ฝ๋ ๊ฒ์ ์๋๋๋ค. ์ฆ, ์ผ๋ฐ์ ์ผ๋ก IDE์์ ๊ฒํ ๊ฐ ์ํ๋์ง ์์ต๋๋ค.
์ด์ Rust์ ์ด๋ค ์ธก๋ฉด์ด ์์ ํ์ง ์์ ๋ธ๋ก์ด "ํ์ํ"๊ฒ๋ณด๋ค ๋ ์ปค์ง๋๋ก ๊ฐ์ํ๋ค๋ฉด, ๊ทธ๊ฒ์ ๋ํ ๋ ๊ทผ๋ณธ์ ์ธ ๋ฌธ์ ๋ฅผ ๋ํ๋ผ ์ ์์ต๋๋ค.
์ฒด์ธ์ ์์ ํ์ง ์์ ๋ฉ์๋๊ฐ ๋ ํฐ ์ ์ค ํ๋๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์ค๊ฐ์์๋ ๋ฉ์๋๋ฅผ let
๋ฐ์ธ๋ฉ์ผ๋ก ๋ถํ ํ๋ ๊ฒ์ ๋งค์ฐ ๋น์ธ๊ฐ์ ์ผ ์ ์์ง๋ง ๊ทธ๋ ๊ฒํ์ง ์์ผ๋ฉด ์ ์ฒด ์ฒด์ธ์ด ์ปค๋ฒ๋ฉ๋๋ค.
'ํ'์ ์๋์ง๋ง ํ์คํ '๋๊ธฐ'์ ๋๋ค.
๋ค,ํ์ง๋ง ์ค์ ๋ก๋ ๊ทํ์ ์ฌ๊ฑด์ ๋์์ด๋์ง ์๊ธฐ ๋๋ฌธ์ ์ธ๊ธํ์ง ์์์ต๋๋ค. ์ฌ๋๋ค์ ํญ์ ์ ์ฒด ๋ณธ๋ฌธ ์ฃผ์์ unsafe
๋ธ๋ก์ ์ถ๊ฐ ํ ์ ์์ต๋๋ค (์ฃผ์์์ ์ธ๊ธํ๋ฏ์ด). ๊ทธ๋ฌ๋ฉด ๋์ผํ ๋ฌธ์ ๋ก ๋ฐ๋ก ๋์๊ฐ ์ ์์ต๋๋ค. ์์ ํ์ง ์์ ํจ์๋ "sneak in"์ ํธ์ถํฉ๋๋ค.
๋ชจ๋๊ฐ IDE์์ ์ฝ๋ ๋ง ์ฝ๋ ๊ฒ์ ์๋๋๋ค.
๋ค, ๊ทธ๋์ ๊ทธ๊ฒ์ ์ ์ณ ๋์์ต๋๋ค. ๋๋ ๊ทธ๊ฒ์ ๋ ๋ช ํํ๊ฒ ๋ง ํ์ด์ผํ๋ค๊ณ ์๊ฐํ๋ค.
๋ด ๋ฌธ์ ๋ ํจ๊ณผ์ ์ผ๋ก ๋น์ ์ด ์ด๊ฒ์ ์นํธํ๊ณ ์๋ค๋ ๊ฒ์ ๋๋ค.
unsafe fn unsafe_real_name_of_function() { ... }
^~~~~~ for humans
^~~~~~ for the compiler
์ด๋ฅผ ํตํด ์ฝ๋๋ฅผ ์ฝ์ ๋ ์์ ํ์ง ์์ ๋ชจ๋ ๊ธฐ๋ฅ์ ๋ช ํํ๊ฒ ๋ณผ ์ ์์ต๋๋ค. ๋ฐ๋ณต์ ๋๋ฅผ ํฌ๊ฒ ๊ดด๋กญ ํ๊ณ ๋ฌด์ธ๊ฐ ๊ฐ ์ฐจ์ ์ฑ ์์ ๋ํ๋ ๋๋ค.
์ด๋ฅผ ํตํด ์ฝ๋๋ฅผ ์ฝ์ ๋ ์์ ํ์ง ์์ ๋ชจ๋ ๊ธฐ๋ฅ์ ๋ช ํํ๊ฒ ๋ณผ ์ ์์ต๋๋ค. ๋ฐ๋ณต์ ๋๋ฅผ ํฌ๊ฒ ๊ดด๋กญ ํ๊ณ ๋ฌด์ธ๊ฐ๊ฐ ์ฐจ์ ์ฑ ์์ ๋ํ๋ ๋๋ค.
์ดํด ํ์ด์. ์ด ๋ฐ๋ณต์ ์ปดํ์ผ๋ฌ๊ฐ ๋ ๊ฐ์ ๋์ ์ ๊ณตํ๋ 4-eyes ์์น์ ๊ตฌํํ๋ ๊ฒ์ผ๋ก ๋ณผ ์๋ ์์ต๋๋ค. ;)
@shepmaster ๋๋์ด ์คํ ํธ๋ ์กฐ๊ธ์ ๋ฐ๊ณ ์๋ค ์๊ฐํ์ง๋ง, IMO ์๋ ์ ์์ด ๋ฐฉ๋ฒ์ ๋ถ๋ณ์ด ๋ฌด์์ธ์ง ๋ช
ํํ์ง ์๋ค ์๋ค๊ณ ํฉ๋๋ค - ๋, ์ฆ unsafe
์ฝ๋๋ฅผ ์ค์ ๋กํ์ง UB๋ ๊ฐ๋จํ ์ด๋ฆ์ผ๋ก.
"unchecked"๊ฐ ์ต์ ์ ์ ํ์ด ์๋๋ผ๋ ๋ฐ ๋์ํ์ง๋ง "์ฝ๊ฒ ๋ถ๋ณ์ ์๋ฐํ๋"์ ๋ก๊ฐ ์์ต๋๋ค.
์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ initialized_or_ub
์ค์ ๋ฐ๋ผ ๋ช
๋ช
๊ท์น์ ๊ฐ์ง๊ณ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
๋๋ ์ด๊ฒ์ด ์ฝ๊ฐ ๋ฒ์ด๋ ๊ฒ ๊ฐ์์
๋๋ ๊ทธ๋ ๊ฒ ๋งํ๋ ค๊ณ ํ๋ค. ๋๋ ๋ด ์ํ์ ๋งํ๊ณ (์๋ฌด๋ ๋์ํ์ง ์๋ ๊ฒ ๊ฐ๋ค) ๊ฑฐ์ง๋ง์ํ๊ฒ ๋ค. ๋น์ ์ด ์ํ๋ ๊ฒ์ ๋ชจ๋ ์ ํํ์ญ์์ค.
์ฐ๋ฆฌ๋
initialized_or_ub
์ค์ ๋ฐ๋ผ ๋ช ๋ช ๊ท์น์ ๊ฐ์ก์ต๋๋ค.
maybe_uninit(ialized)
๊ฑด๊ฐ์? ์ด๋ป๊ฒ ๋ ๊ด๋ จ ๋ฉ์๋ ์งํฉ์ ๊ด๋ฒ์ํ๊ฒ ์ ์ฉ๋ ์์๋ ๊ฒ์ด ์์ต๋๊น? ๐
์๋์, unwrap_or_else
- "unhappy case"์์ ์ผ์ด๋๋ ์ผ์ ๋ฉ์๋ ์ด๋ฆ์ ๋ฃ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค.
@eddyb ์ด๊ฑฐ ๋์์ง ์์๋ฐ ... .initialized_or_unsound
์๋ง๋?
์ผ๋ฐ์ ์ผ๋ก ์๋ณ์ ์ด๋ฆ์ ์ ํ ์ ๋ณด๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ์ํฐ ํจํด (์ : foo_i32
, bar_mutex
, baz_iterator
)์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
๊ทธ๋ฌ๋ ํจ์์ ๊ดํด์๋ unsafe
์ด fn
์ ํ์ ์ผ๋ถ์ด์ง๋ง _unchecked
, _unsafe
, _you_better_know_what_you_are_doing
๊ฐ ์ถ๊ฐ๋ฉ๋๋ค. ๊ฝค ํํฉ๋๋ค.
์ ์ด๋ด๊น์?
๋ํ ์ฐธ๊ณ ๋ก rust-analyzer
์ ํจ์๊ฐ unsafe
์ธ์ง ์ฌ๋ถ๋ฅผ ๋
ธ์ถํ๋ ๋ฌธ์ (https://github.com/rust-analyzer/rust-analyzer/issues/190)๊ฐ ์์ต๋๋ค. ํธ์ง์์ IDE๋ unsafe
๋ธ๋ก ๋ด์์ unsafe
๊ฐ ํ์ํ ์์
์ ๊ฐ์กฐ ํ ์ ์์ด์ผํฉ๋๋ค. ์ฌ๊ธฐ์๋ unsafe
ํจ์ ํธ์ถ๋ฟ ์๋๋ผ ๋ค์๊ณผ ๊ฐ์ ์๋ณ์๊ฐ ์ ๋ฏธ์ฌ๋ก ์ถ๊ฐ๋์๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด ์ : _unchecked
์ฌ๋ถ), ์์ ํฌ์ธํฐ ์ญ ์ฐธ์กฐ ๋ฑ
ํ๋ฆผ์์ด rust-analyzer
๋ ์์ง ์ด๊ฒ์ ํ ์ ์์ต๋๋ค (ํธ์ง : intellij-Rust ์ข
๋ฅ์ can : https://github.com/intellij-rust/intellij-rust/issues/3013#issuecomment-440442306). ์๋๋ unsafe
๋ธ๋ก ๋ด์์ ์ด๊ฒ์ ํธ์ถํ๋ ค๋ฉด unsafe
ํ์ํ๋ค๋ ๊ฒ์ ๋ถ๋ช
ํํ๋ ๊ฒ์
๋๋ค. ๊ตฌ๋ฌธ ๊ฐ์กฐ๋ ์ด๊ฒ์ ์ ๋ฏธ์ฌ์ ์ถ๊ฐํ๋ ๊ฒ์ ๊ฐ๋ฅํ ๋์์
๋๋ค. ๋ด ๋ง์, ์ ๋ง๋ก ์ง๊ธ ์ด๊ฒ์ ์ํ๋ค๋ฉด์ด ํจ์์ ์ด๋ฆ์ ๋ช ๋ถ ์์ ๊ตฌ๋ฌธ ํ์ด ๋ผ์ดํฐ์ "ํค์๋"๋ก ์ถ๊ฐํ๊ณ ํ๋ฃจ์ ํธ์ถ ํ ์ ์์ต๋๋ค.
๋ฟก๋ฟก
์ผ๋ฐ์ ์ผ๋ก ์๋ณ์ ์ด๋ฆ์ ์ ํ ์ ๋ณด๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ์ํฐ ํจํด (์ :
foo_i32
,bar_mutex
,baz_iterator
)์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
๋ฌผ๋ก , ํ๊ฐ๋ฆฌ ํ๊ธฐ๋ฒ ์ ์ผ๋ฐ์ ์ผ๋ก ๋ฐ ํจํด์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค. ๋์ํฉ๋๋ค. ๊ทธ๋ฌ๋ ์ผ๋ฐ์ ์ผ๋ก ์ด๋ฌํ ๋ ผ์์์๋ ์์ ์ ๊ณ ๋ คํ์ง ์์ผ๋ฉฐ UB๊ฐ ์ ์ํ๋ ์ํ์ ๊ฐ์ํ ๋ ์ฌ๊ธฐ์ ์์ธ๋ฅผ ๋์ด์ผ ํ ์ถฉ๋ถํ ์ด์ ๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
๊ทธ๋ฌ๋ ํจ์์ ๊ดํด์๋
unsafe
์ดfn
์ ํ์ ์ผ๋ถ์ด์ง๋ง_unchecked
,_unsafe
,_you_better_know_what_you_are_doing
๊ฐ ์ถ๊ฐ๋ฉ๋๋ค. ๊ฝค ํํฉ๋๋ค.์ ์ด๋ด๊น์?
๊ฐ๋จํ ๋งํด์ : ์์ ํ์ง ์์ต๋๋ค. ์์ ํ์ง ์์ ๊ฒฝ์ฐ ์ค๋ณต์ ๋น์ ์ ์น๊ตฌ์ ๋๋ค. ์ด๊ฒ์ ์ฝ๋์ ์์ ์ ์ค์ํ ํ๋์จ์ด ๋ฑ์ ๋ชจ๋ ์ ์ฉ๋ฉ๋๋ค.
๋ํ ์ฐธ๊ณ ๋ก
rust-analyzer
์ ํจ์๊ฐunsafe
์ธ์ง ์ฌ๋ถ๋ฅผ ๋ ธ์ถํ๋ ๋ฌธ์ ( rust-analyzer / rust-analyzer # 190 )๊ฐ ์์ต๋๋ค. ํธ์ง์์ IDE๋unsafe
๋ธ๋ก ๋ด์์unsafe
๊ฐ ํ์ํ ์์ ์ ๊ฐ์กฐ ํ ์ ์์ด์ผํฉ๋๋ค. ์ฌ๊ธฐ์๋unsafe
ํจ์ ํธ์ถ๋ฟ ์๋๋ผ ๋ค์๊ณผ ๊ฐ์ ์๋ณ์๊ฐ ์ ๋ฏธ์ฌ๋ก ์ถ๊ฐ๋์๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด ์ :_unchecked
์ฌ๋ถ), ์์ ํฌ์ธํฐ ์ญ ์ฐธ์กฐ ๋ฑ๋ ผ์์ ์ฌ์ง๊ฐ ์์ง๋ง
rust-analyzer
๋ ์์ง ์ด๊ฒ์ ํ ์ ์์ง๋งunsafe
๋ธ๋ก ๋ด์์ ์ด๊ฒ์ ํธ์ถํ๋ ค๋ฉดunsafe
๊ฐ ํ์ํ๋ค๋ ๊ฒ์ ๋ถ๋ช ํํ๋ ๊ฒ์ด ๋ชฉ์ ์ด๋ผ๋ฉด ๊ตฌ๋ฌธ ๊ฐ์กฐ๋ ์ ๋ฏธ์ฌ์ ๋ํ ๋์์ด ๋ ์ ์์ต๋๋ค. ์ด๊ฒ์ ๋ฌด์์ด๋ .
์ด ๋ชจ๋ ๊ฒ์ด ๊ฝค ๊ต์ฅํฉ๋๋ค. ๊ทธ๋ฌ๋ @RalfJung์ด ์ธ๊ธํ๋ฏ์ด "๋ชจ๋ ์ฌ๋์ด IDE์์๋ง ์ฝ๋๋ฅผ ์ฝ๋ ๊ฒ์ ์๋๋๋ค .
์ถ์
ํ ๊ฒ๊ณผ unsafe
๋ถ์ ํ ํ (๋ฐ๋ผ์ ๊ฑด์ ํ์ง ์์) ์ฌ์ฉ ์ฌ์ด์ ์ ์ถฉ์ ์ด๋ผ๋ฉด ํญ์ ์ ์๋ฅผ ์ ํธํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ํ๋ก๊ทธ๋๋จธ๊ฐ "์ ๊น, ๋ด๊ฐ์ด ์ผ์ ์ ๋๋กํ๊ณ ์๋๊ฐ?"๋ผ๊ณ ์๊ฐํ๊ณ ์ ์ ๋ฉ์ถ๋๋ก ๋ง๋๋ ๊ฒ์ ๋ํด ๋ง์ ๋ง์ ํ ์ ์์ต๋๋ค.
์๋ฅผ ๋ค์ด Mundane์์ ์์ ํ์ง ์์ ์ํธํ ์์ ์ ์ฌ์ฉํ๋ ค๋ฉด ๋ค์์ ์ํํด์ผํฉ๋๋ค.
insecure
๋ชจ๋์์ ๊ฐ์ ธ ์ค๊ธฐallow(deprecated)
ํ๊ฑฐ๋ ํด๋น ์์
์ ์ฌ์ฉํ ๋๋ง๋ค ๋ด ๋ณด๋ธ ์ปดํ์ผ๋ฌ ๊ฒฝ๊ณ ๋ฅผ ๊ทธ๋๋ก ์ ์งํฉ๋๋ค.let mut hash = InsecureSha1::default(); hash.insecure_write(bytes); ...
์ ๊ฐ์ ์ฝ๋ ์์ฑ์ฌ๊ธฐ ์ ๋ชจ๋ ์์ธํ ์ค๋ช ๋์ด ์์ต๋๋ค. ๋๋ ์ฐ๋ฆฌ๊ฐ ๋ชจ๋ ์ํฉ์์ ๊ณต๊ฒฉ์ ์ผ ํ์๋ ์๋ค๊ณ ์๊ฐํ์ง๋ง, ์ฌ๋ฐ๋ฅธ ์ฒ ํ์ ๋ง์ฝ ์์ ์ด ๊ฑฑ์ ํ ๋งํผ ์ํํ๋ค๋ฉด ํ๋ก๊ทธ๋๋จธ๊ฐ ์ค๋ ฅ์ ๋์น ์์๋ ๋ฐฉ๋ฒ์ด ์์ด์ผํ๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ค์ดํ๋ ์ผ์.
์ฌ๋๋ค์ด์ด ์ ํ์ ์ค์ฉํ๋ ๊ฒ์ ๋ํด 95 % ๊ฑฑ์ ํ๊ณ ๊ธด ์ด๋ฆ์ ๋ํด 5 % ๋ง ๊ฑฑ์ ํ๋ฏ๋ก ์ ํ์ ์ด๋ฆ์ MaybeUninitialized
๋ก ๋ณ๊ฒฝํ์ฌ ์์ํ๊ฒ ์ต๋๋ค. ์ฌ๋ถ์ 7์๋ ๊ทธ๋งํ ๊ฐ์น๊ฐ ์์ต๋๋ค.
MaybeUninitializedOrUndefinedBehavior
๋ก ์ด๋ฆ์ ๋ณ๊ฒฝํ์ฌ ์ต์ข
์ฌ์ฉ์๊ฐ ์ฝ๊ฒ ์ดํดํ ์ ์๋๋กํฉ๋๋ค.
์ด ์ ํ์ ๋ฉ์๋๊ฐ ์๊ณ ๋ชจ๋ ๊ฒ์ด ์ฐ๊ฒฐ๋ ํจ์๊ฐ๋๋๋ก ์ ํํ์ฌ ์ํ๋๋๋ก ๋ชจ๋ ํจ์ ํธ์ถ์ ์์ ์ ๊ฐํํฉ๋๋ค.
MaybeUninitializedOrUndefinedBehavior::into_inner(value)
MaybeUninitializedOrUndefinedBehaviorReadTheDocsAllOfThemYesThisMeansYou
๊ธ์ ... ์์งํ, ์ ํ ์ MaybeUninitializedOrUndefinedBehavior
์ ๊ฐ์ ๊ธด ์ด๋ฆ์ด์๋ ๊ฒ ๊ฐ์ต๋๋ค. ๊ทธ๊ฒ์ ์์
์ .into_inner()
๊ทธ ํน๋ณํ์ฃผ์๋ฅผ ํ์๋กํ๋ ์ ์ฌ์ ์ผ๋ก ๋ฌธ์ ๋นํธ์ด๊ธฐ ๋๋ฌธ์ ์ข์ ์ด๋ฆ์ ํ์๋กํ๋. ๋ฐฉ๋ฒ์ด ์๋ค๋ ๊ฒ์ ์ข์ ์๊ฐ์ด ๋ ์ ์์ต๋๋ค. MaybeUninit::initialized_or_undefined(foo)
์ ๋งค์ฐ ๋ช
ํ ํด ๋ณด์
๋๋ค.
IMO ์ฐ๋ฆฌ๋ ์์ ํ์ง ์์ ์์ ์ ์ด์ ๊ฐ์ด ์ธ์ฒด ๊ณตํ์ ์ผ๋ก ๋ง๋ค์ง ์์์ผํฉ๋๋ค. ์ธ์ฒด ๊ณตํ์ ์ธ ์ด๋ฆ๊ณผ ์์ ํ์ง ์์ ์ฌ๋ฐ๋ฅธ ์ฝ๋๋ฅผ ์์ฑํ๋ ๋ฐฉ๋ฒ์ด ํ์ํฉ๋๋ค. ์ง๋์น๊ฒ ๊ธด ์ด๋ฆ๊ณผ ๋ถ๋ช ํ ํ ์ ํธ๋ฆฌํฐ ๋ฐ ๋ณํ์ผ๋ก ๋ณต์กํ๊ฒ ๋ง๋ค๋ฉด ์ฌ์ฉ์๊ฐ ์ฌ๋ฐ๋ฅธ ์์ ํ์ง ์์ ์ฝ๋๋ฅผ ์์ฑํ์ง ๋ชปํ๊ฒํ๊ณ ์์ ํ์ง ์์ ์ฝ๋๋ฅผ ์ฝ๊ณ ์ ํจ์ฑ์ ๊ฒ์ฌํ๊ธฐ ์ด๋ ต๊ฒ ๋ง๋ญ๋๋ค.
๋๋ค์์ ์ฌ๋๋ค์ด ์ด๋ค ํํ๋ก๋ ์๋ ์์ฑ ๊ธฐ๋ฅ์ด์๋ IDE๋ฅผ ์ฌ์ฉํ ๊ฐ๋ฅ์ฑ์ด ๋์ผ๋ฏ๋ก ๊ธด ์ด๋ฆ์ ์ฌ์ํ๋ก๋ ๋ฒํ์ ๋๋ค.
RLS๊ฐ ๋ ๊ธฐ๋ฅ์ ์ผ ๋๊น์ง๋ ์ ์ด๋ ์ ์๊ฒ๋ ๊ทธ๋ ์ง ์์ต๋๋ค.
๋๋ ์ฐ๋ฆฌ ๋๋ถ๋ถ์ด ๋์ ํ๋ค๊ณ ์๊ฐ ํฉ๋๋ค
๋ ์ค๋ช ์ ์ธ ์ด๋ฆ์ด ์ข์ต๋๋ค.
๋ ์ธ์ฒด ๊ณตํ์ ์ธ ์ด๋ฆ์ ๋์๋ค
๋ฌธ์ ๋ ๊ธด์ฅ ์ํ ์ผ ๋ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ ๋ฐฉ๋ฒ์ ๊ดํ ๊ฒ์ ๋๋ค.
๊ทธ๋ผ์๋ ๋ถ๊ตฌํ๊ณ ๋๋ ํนํ into_inner
์ด์ด ๋ฐฉ๋ฒ์ ๋ํ ๋์ ์ด๋ฆ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค (๋ฉ์ง ์ฉ์ด๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ํ๋ ํ ๊ตญ๊ฒฝ์ ์์ง ์์ต๋๋ค). ์ผ๋ฐ์ ์ธ ๊ท์น์ ์ฐ๋ฆฌ๊ฐ ๊ฐ์ง๊ณ ์๋ into_inner
a๊ฐ ๋ ๋ Foo<T>
์ ํํ ํ๋์ ํฌํจ T
, ๊ทธ๋ฆฌ๊ณ ๋น์ ์ด ๊ทธ๊ฒ์ ์ถ์ด. ๊ทธ๋ฌ๋ ์ด๊ฒ์ MaybeUninit<T>
์๋ ํด๋น๋์ง ์์ต๋๋ค. 0 ๊ฐ ๋๋ 1 ๊ฐ์ T
ํฉ๋๋ค.
๋ฐ๋ผ์ ๋ ๋์ ์ต์
์ ์ ์ด๋ unwrap
๋๋ unwrap_unchecked
๋ผ๊ณ ๋ถ๋ฅด๋ ๊ฒ์
๋๋ค.
from_initialized
๋๋ from_initialized_unchecked
๊ด์ฐฎ๋ค๊ณ ์๊ฐํ์ง๋ง "from"์ ์ผ๋ฐ์ ์ผ๋ก ์ ์ ๋ฉ์๋ ์ด๋ฆ์ ๋ํ๋ฉ๋๋ค.
unwrap_initialized_unchecked
๊ฐ ๊ด์ฐฎ์๊น์?
take_initialized
๋ผ๊ณ ๋ถ๋ฅด๊ณ &mut self
๋์ self
ํฉ๋๋ค. ์ด๋ฆ์ ๋ด๋ถ ๊ฐ์ด ์ด๊ธฐํ ๋ ๊ฒ์ผ๋ก ์์ ํจ์ ๋ช
ํํ๊ฒํฉ๋๋ค. MaybeUninit
์ ์ปจํ
์คํธ์์ unsafe
๋ฐ Option
/ Result
๋ฐํํ์ง ์๋๋ค๋ ์ฌ์ค๋์ด ์์
์ด ์ ํ ์ทจ์๋์์์ ๋ถ๋ช
ํํฉ๋๋ค.
&mut self
๊ฐ์ ธ๊ฐ๋ ๊ฒ์ ์๋ฏธ ์ MaybeUninit
์์ ์ด๋ํ๋์ง ์ฌ๋ถ๋ฅผ ์ฝ๊ฒ ์ถ์ ํ ์์๊ฒ ํด์ฃผ๋ ํ๊ฑด์ฒ๋ผ ๋ณด์
๋๋ค.
๋์ฒด ์ด๋ฆ : into
๋ผ๋ ๋ฉ์๋๊ฐ ์์ํ๋ ๊ฒ์ฒ๋ผ ์ค์ ๋ก ์์ ๊ถ์ ์ด๋ํ๋ฏ๋ก into_initialized_unchecked
?
& mut self๋ฅผ ์ทจํ๋ ๊ฒ์ ๋น์ ์ด MaybeUninit์์ ์๋ฏธ ๋ก ์ ์ผ๋ก ์ด๋ํ๋์ง ์ฌ๋ถ๋ฅผ ์ฝ๊ฒ ์ถ์ ํ ์์๊ฒ ํด์ฃผ๋ ํ๊ฑด์ฒ๋ผ ๋ณด์ ๋๋ค.
๊ทธ๋๋ ์์ฒญ ๋ ๋ฐฉ๋ฒ์ด๊ณ , ๊ทธ๋ ์ง ์์ผ๋ฉด ์ด๊ฒ์ด ๋ ๋ฒ ๋ฐ์ํ์ง ์๋๋ค๋ ๊ฒ์ ์ถ์ ํ๋ ํ ๊ด์ฐฎ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋น๋ฆฐ ๊ฒ๊ณผ ์๋นํ๋ ๋ณ์ข ์ ๋ชจ๋ ๊ฐ์ง ๊ฐ์น๊ฐ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
๋๋ take_initialized
๋๋ ๋ ๋ช
์์ ์ธ ๋ณํ take_initialized_unchecked
์ข์ํฉ๋๋ค.
์ ํ ์ด๋ฆ์ MaybeUninitialized๋ก ๋ฐ๊พธ๋ ๊ฒ์ผ๋ก ์์ํ๊ฒ ์ต๋๋ค.
PR์ ์ค๋น ํ ์ฌ๋ ์๋์?
PR ์ค๋น๋ฅผ ์ํด?
๋๋ ๊ทธ๊ฒ์ ์ ์ํ๊ธฐ ๋๋ฌธ์ ๋ด ๋ฉ์ง sed
๊ธฐ์ ์ ์ฌ์ฉํ ์ ์์ต๋๋ค ;-)
into_inner
๋ฉ์๋๊ฐ ์ด๊ธฐํ๋์๋ค๊ณ ๊ฐ์ ํ๋ ๊ฒ์ ๊ฐ์กฐํ๋ ๋ฌด์ธ๊ฐ๋ฅผ ํธ์ถํ๋ ๊ฒ์ด ๊ฐ์ ์ด๋ผ๊ณ ์๊ฐํ์ง๋ง unchecked
๊ฒ์ ๋ถํ์ํ๊ณ ๋์์ด๋์ง ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค. ์์ ํ์ง ์์ ํจ์๋ ์์ ํ์ง ์๋ค๋ ๊ฒ์ ์ฌ์ฉ์์๊ฒ ์๋ฆฌ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค. ์์ ํ์ง ์์ ๋ธ๋ก์ผ๋ก ๋ํํ์ง ์์ผ๋ฉด ์ปดํ์ผ๋ฌ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค.
ํธ์ง : take_initialized
์ข์ ๋ณด์ธ๋ค
assume_initialized
์ด๋ป์ต๋๊น? ์ด:
assume
๋ด์ฅ ํจ์์ ๋งค์ฐ ์ ์ฌํ๊ฒ ์๋ชป ๊ฐ์ ํ๋ฉด UB์
๋๋ค.PR์ ์ค๋น ํ ์ฌ๋ ์๋์?
์ ๊ฒฝ ์ฐ์ง ๋ง. libs ํ์ ์ด๊ฒ์ด ๊ฐ์น๊ฐ ์๋ค๊ณ ๊ฒฐ์ ํ์ต๋๋ค.
Copy
๋ T: Copy
MaybeUninit<T>
๊ฐ Copy
๊ฐ ์๋ ์ด์ ๊ฐ ์์ต๋๊น?
@tommit ์๋ํ๋ฉด MaybeUninit<T>
๋ ManuallyDrop<T>
์ ์์กดํ๊ธฐ ๋๋ฌธ์ ํ๋ก๊ทธ๋๋จธ๋ ๊ตฌ์กฐ์ฒด๊ฐ ๋ฒ์๋ฅผ ๋ฒ์ด๋ ๋ ๋ด๋ถ ๊ฐ์ด ์ญ์ ๋๋๋ก ๋ณด์ฅํด์ผํฉ๋๋ค. Copy
๊ตฌํํ๋ฉด Rust ์ ๊ท ์ฌ์ฉ์๊ฐ ๊ตฌ์กฐ์ฒด ์์ฒด ๋๋ ๋ณต์ฌ๋ณธ์ ๋ด๋ถ ๊ฐ T
๋งค๋ฒ ์ญ์ ํ๋ ๊ฒ์ ๊ธฐ์ตํ๋ ๊ฒ์ด ๋ ์ด๋ ค์ธ ์ ์์ต๋๋ค. ์ด๋ฐ ์์ผ๋ก ์ฐ๋ฆฌ๊ฐ ์์ํ์ง ๋ชปํ ๋ ๋์ ๋์ง ์๋ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
@ luojia65 T
์์ฒด๊ฐ Copy
์ผ ๋ ManuallyDrop
๋ฐ MaybeUninit
์ด ๋ฌด์์ํ๋ ๊ด๊ณ์์ด ์ถ๋ก ๋ผ์ธ์ด ์ ์ฉ๋๋์ง ํ์คํ์ง ์์ต๋๋ค.
์ด์ ๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์๋ฌด๋ #[derive(Copy)]
์ถ๊ฐ๋ฅผ ์๊ฐํ์ง ์์์ต๋๋ค;)
์ด๊ฒ์ ๋ค์ ๋ฏธ๋ฌํ ์ธก๋ฉด์ ๋ํ ๊ด์ฐฐ :
๋๋ ๋น๋ก ์๋ค๊ณ ์๊ฐ MaybeUninit<T>
๋์ด์ผํฉ๋๋ค Copy
ํ๋ฉด T: Copy
, MaybeUninit<T>
ํ์ง ์์์ผ Clone
ํ๋ฉด T: Clone
์ T
๋ Copy
๊ฐ ์๋๋๋ค.
์, ์ฐ๋ฆฌ๋ clone
์ ํ ํ ์ ์์ต๋๋ค.
Copy: Clone
...
๊ด์ฐฎ์ต๋๋ค. *self
๋ฐํ์ ๊ธฐ๋ฐ์ผ๋ก Clone for MaybeUninit<T> where T: Copy
๊ตฌํํ ์ ์์ต๋๋ค.
์ฌ๊ธฐ์ ์ฌ๋ผ์จ ๋ชจ๋ ์ง๋ฌธ์ผ๋ก ๋ฌธ์ ์ค๋ช ์ ์ ๋ฐ์ดํธํ๊ธฐ ์ํด ์ต์ ์ ๋คํ์ต๋๋ค. ๋ด๊ฐ ๋์น ๊ฒ์ด ์์ผ๋ฉด ์๋ ค์ฃผ์ธ์!
ManuallyDrop::drop
๋ํ ๋ฌธ์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
์ด ํจ์๋ ํฌํจ ๋ ๊ฐ์ ์๋ฉธ์๋ฅผ ์คํํ๋ฏ๋ก ๋ํ ๋ ๊ฐ์ ์ด์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ๋ํ๋ ๋๋ค. ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๊ฐ ์ค์ ๋ก ์ฌ์ฉ๋์ง ์๋๋กํ๋ ๊ฒ์์ด ๋ฐฉ๋ฒ์ ์ฌ์ฉ์์๊ฒ ๋ฌ๋ ค ์์ต๋๋ค.
MaybeUninit
๊ฐ ์ฒ๋ฆฌํ๋ "์ด๊ธฐํ๋์ง ์์"๊ณผ ํผ๋ ๋ ์ ์๋๋ก ํด๋น ๋ฌธ๊ตฌ๋ฅผ ๊ฐ์ ํ๋ ๋ฐฉ๋ฒ์ ๋ํ ์ ์์ด ์์ต๋๊น?
๋ด ๊ด์ ์์, a๋ ๊ฐ์ํ์ง ManuallyDrop<T>
๋ ์ด์ ์์ T
,ํ์ง๋ง์ด ์ ํจ T
๋ ์ด์์ ์ต์ ํ ์ ๊ฒฝ๊น์ง๋ก ์ ์ด๋ ....
"๋ถ์ค"/ "์ ํจํ์ง ์์", ์๋ง๋? ์ด๊ธฐํ ๋ฉ๋๋ค.
FWIW ๋๋ ๋ฌธ๊ตฌ๊ฐ ๋ช
ํํ๋ค๊ณ ์๊ฐํฉ๋๋ค (์ ์ด๋ ๋์๊ฒ๋)
๊ฐ์ฒด๊ฐ ๋ ๋ฒ ๋จ์ด์ง์ง ์๋ ๊ฒ์ "์์ "๋ฌธ์ ์
๋๋ค. ์์ ๋ฌธ์๊ฐ ์๋ค๋ฉด
"์์ "์ ์ ์ํ๋ UCG์์ ํ์ดํผ ๋งํฌ๋ฅผ ์ฌ์ฉํด์ผํฉ๋๋ค. ๋น์ ์ ํ ์ ์์ต๋๋ค
T๋ "์ ํจ"ํ๊ณ ํ์ดํผ ๋งํฌ "์ ํจ"์ ์ ์ฌ์ผํ์ง๋ง
์์ง ์ด๋์๋ ์ด๋ฌํ ์ ์๊ฐ ์ ํ ์์ง ์์ต๋๋ค ... ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ๋๋
๋ฌธ์ ์ ์ฒด์์ ๊ทธ๊ฒ๋ค์ ์์ญํด์ผํ๋ค๊ณ ์๊ฐํ์ง ๋ง์ญ์์ค.
์ด๊ธฐํ๋์ง ์์ ๊ฒ์ ํ๊ธฐํ๊ธฐ ์ ์ MaybeUninit๋ฅผ ์์ ํ์ํฌ ์ ์์ต๋๊น?
@RalfJung ๋๋ ์ฅ์๊ฐ "์์ ์ด๋ํ๋ค"๊ณ ๋งํ ๊ฒ์
๋๋ค. FWIW ์ฐ๋ฆฌ๋ std::ptr::read
์์ ๊ฐ์ ์ข
๋ฅ์ ์ฉ์ด๋ฅผ ์ฌ์ฉํด์ผํ์ง๋ง ๊ฑฐ๊ธฐ์์๋ ๊ทธ๋ค์ง ๋ช
ํํ์ง ์์ต๋๋ค.
@bluss ์ฐ๋ฆฌ๋ "๋ ๋์
์๋ฃจ์
โ/โ๋ง์ด๊ทธ๋ ์ด์
๊ฒฝ๋กโ.
์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ 'X๋ ์ง์ ์ค๋จ๋์์ต๋๋ค. ๋์ Y๋ฅผ ์ฌ์ฉํ์ธ์'์ฌ์ผํฉ๋๋ค. ์ฐ๋ฆฌ๊ฐ
Y๊ฐ์๊ณ X๊ฐ ๋๋ฆฌ ์ฌ์ฉ๋ฉ๋๋ค.
Y๊ฐ ๋์ฌ ๋๊น์ง ์ฌ์ฉ ์ค๋จ ๊ฒฝ๊ณ .
๊ทธ๋ ์ง ์์ผ๋ฉด ์ฐ๋ฆฌ๋ ์ ๋ง ์ด์ํ ๋ฉ์์ง๋ฅผ ๋ณด๋ผ ๊ฒ์ ๋๋ค.
@cramertj "์ ํจํ์ง ์์"์ ์ฌ์ ํ โโํ๋น์ฑ ๋ถ๋ณ์ ๋ง์กฑ์ํค๊ธฐ ๋๋ฌธ์ ์ข์ ์ ํ์ด ์๋๋๋ค.
UCG์ "์์ "์ ์ ์ํ๋ ์์ ๋ฌธ์๊ฐ ์๋ค๋ฉด ํ์ดํผ ๋งํฌ๋ฅผ ์ฌ์ฉํด์ผ ํ ๊ฒ์ ๋๋ค. T๋ "์ ํจ"ํ๊ณ ํ์ดํผ ๋งํฌ "์ ํจ"์ ์ ์ฌ์ผํ๋ค๊ณ ์ถ๊ฐ ํ ์ ์์ง๋ง ์์ง ์ด๋ฌํ ์ ์๋ฅผ ์ด๋์๋ ๊ธฐ๋กํ์ง ์์๊ธฐ ๋๋ฌธ์ ...
์ฐ๋ฆฌ๋ ๋ฌด์ธ๊ฐ๋ฅผ ์ป์์ ๋ ํ์คํํด์ผํฉ๋๋ค : D
@RalfJung ์ ๋ "์ ํจ์ฑ ๋ถ๋ณ"์ด ๋๋ถ๋ถ์ (๊ฑฐ์ ์ด๋ค?) Rust ์ฌ์ฉ์์ ์ดํ์ง์ ์๋ค๊ณ ์๊ฐํ์ง ์์ต๋๋ค. "์ ํจํ์ง ์์ ๋ฐ์ดํฐ"๋ฅผ ๊ตฌ์ด์ฒด๋ก ์ธ๊ธํ๋ ๊ฒ์ ํ์ฉ๋ฉ๋๋ค ( ManuallyDrop<T>
๋ ๋ ์ด์ ์ฌ์ฉํ ์ ์์ต๋๋ค. a T
). ์ปดํ์ผ๋ฌ๊ฐ ์ต์ ํ๋ฅผ ์ํด ์ฌ์ฉํ๋ ํน์ ํํ ๋ถ๋ณ์ ์ ์งํด์ผํ๋ค๊ณ ํด์ ์๋ชป๋ ๋ฐ์ดํฐ๊ฐ ์ค์ด๋ค์ง๋ ์์ต๋๋ค.
๋๋ "์ ํจ์ฑ ๋ถ๋ณ"์ด ๋๋ถ๋ถ์ (๊ฑฐ์ ์ด๋ค?) Rust ์ฌ์ฉ์์ ์ดํ์ง์ ์๋ค๊ณ ์๊ฐํ์ง ์์ต๋๋ค.
์ถฉ๋ถํ ๊ณตํํ์ง๋ง,์ด ์ฉ์ด๋ ๊ณต์์ ์ด์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๊ฒฐ๊ตญ ์ด๊ฒ์ ๋ํ ๊ณต์์ ์ธ ์ฉ์ด๋ฅผ ์ ํํด์ผํ๋ฉฐ ๊ทธ๋ฐ ์ถฉ๋์ ํผํด์ผํฉ๋๋ค. ๊ฒ์๋ฌผ์์ "์ ํจํ"๋ฐ์ดํฐ๋ฅผ "์์ "์ด๋ผ๊ณ ํ ์ ์์ง๋ง "์ ํจ"๋ผ๊ณ ๋ถ๋ฅด๋ ๋ค๋ฅธ ๋จ์ด๊ฐ ํ์ํฉ๋๋ค.
@shepmaster ๊ฐ ์ผ๋ง ์ ์ ์ผ์ต๋๋ค.
๋ํผ์์ ๋ฒ์ด๋ ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ผ๋ก ๋์ฒดํ๋ ๋ฐฉ๋ฒ์ด ์ ์ฉ ํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
pub unsafe fn take(&mut self) -> T
๋ด ๊ฐ์ฅ ํฐ ๊ด์ฌ์ฌ๋ ์ด๋ฌํ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ฉด ๋ณต์ฌ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ์ค์๋ก ๋ณต์ฌํ๊ธฐ๊ฐ ๋งค์ฐ ์ฝ๋ค๋ ๊ฒ์
๋๋ค. ํ์ํ ๊ฒฝ์ฐ maybe_uninit.as_ptr().read()
๊ฒ์ด ์ ๋ง ๋์๊ฐ์?
๋๋ take
๊ฐ์ ๊ฒ์ into_inner
๊ฐ์ ๊ฒ์ ๋์ฒดํ๋๋ก ๊ฑฐ๊ธฐ ์ด๋๊ฐ์ ์ ์ํ์ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ ์ด์ ์ข์ ์๊ฐ์ด ์๋๋ผ๊ณ ์๊ฐํฉ๋๋ค. ๋๋ถ๋ถ์ ๊ฒฝ์ฐ into_inner
self
์๋นํ๋ ์ถ๊ฐ ์ ํ์ ์ค์ ๋ก ๋์์ด๋ฉ๋๋ค.
@RalfJung ๊ฒฐ๊ตญ MaybeUninit
์ ๋ชจ๋ ๋ฉ์๋๋ ์์ ํ์ง ์์ผ๋ฉฐ as_ptr
์ฃผ์์ ํธ๋ฆฌํ ๋ํผ ์ผ๋ฟ์
๋๋ค. ๊ทธ๋ฌ๋ ๋ด๊ฐ ๊ธฐ๋ take
์ดํ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์์
์ค ํ๋, ์ MaybeUninit
ํจ์จ์ ์
๋๋ค ๋จ์ง Option
ํ๊ทธ๊ฐ ์ธ๋ถ์์ ๊ด๋ฆฌ๋๋ค. ์ด๋ ๋ง์ ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค. ์๋ฅผ ๋ค์ด ๋ชจ๋ ์์๊ฐ ์ด๊ธฐํ๋์ง ์์ ๋ฐฐ์ด (์ : ํด์ ํ
์ด๋ธ)์ด ์์ต๋๋ค.
https://github.com/rust-lang/rust/pull/57045 ์์ MaybeUninit
์ ๋ ๊ฐ์ง ์๋ก์ด ์์
์ ์ถ๊ฐ ํ ๊ฒ์ ์ ์ํฉ๋๋ค.
/// Get a pointer to the first contained values.
pub fn first_ptr(this: &[MaybeUninit<T>]) -> *const T {
this as *const [MaybeUninit<T>] as *const T
}
/// Get a mutable pointer to the first contained values.
pub fn first_mut_ptr(this: &mut [MaybeUninit<T>]) -> *mut T {
this as *mut [MaybeUninit<T>] as *mut T
}
๋๊ธฐ ๋ถ์ฌ์ ํ ๋ก ์ ์ํด PR์ ์ฐธ์กฐํ์ญ์์ค.
์ ๊ฑฐ ํ ๋ zeroed
๋จ์ง๋ก ๋์ฒด์ฒ๋ผ ๋ณด์ธ๋ค MaybeUninit::zeroed().into_inner()
๊ฐ์ ์ผ์ ์์ฑํ๋ ๋๋ฑํ ๋ฐฉ๋ฒ์ด๋๊ณ ์๋ค. ์ค์ง์ ์ธ ๋ณํ๋ ์์ต๋๋ค. uninit ๊ฐ์ ์ฌ์ฉํ๋ฉด ๋์ MaybeUninit
์ ํ์ ๊ฐ ๋๋ ์ด์ ์์ํ๋ ๊ณต์ฉ์ฒด์ ๊ฐ์ ์ ์ฅ๋๋ ๋ชจ๋ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ์ ์ค์ง์ ์ธ ๋ณ๊ฒฝ์ด ์์ต๋๋ค.
๋ฐ๋ผ์ FFI์์ ๋๋ฆฌ ์ฌ์ฉ๋๋ ํจ์์ด๋ฏ๋ก std::mem::zeroed
๋ฅผ ๊ทธ๋๋ก ์ ์งํ๋ ๊ฒ์ด ์ข์ต๋๋ค. ์ง์ ์ค๋จ์ ์ ๊ฑฐ๋๋ ๊ฒ๊ณผ ๊ฑฐ์ ๋์ผํ ํฐ ๊ฒฝ๊ณ ๋ฅผ ๋ด๋๋ก ๋ง๋ค๋ฉฐ, ์ ์ด๋ ๋งค์ฐ ์ฑ๊ฐ ์๊ฒํฉ๋๋ค. ์ด๊ฒ์ ๋ํ ๋ค๋ฅธ ๋ ์ค์ํ ๋ฌธ์ ๋ฅผ ์จ๊ธธ ์์๋ #[allow(deprecated)]
์ ์ฆ๊ฐ๋ก ์ด์ด์ง ์ ์์ต๋๋ค.
unsafe
-marked ์ฝ๋์ ๋ํ Rust์ ๋ชจ๋ธ๊ณผ ๊ฐ์ด๋ ๋ผ์ธ์ ๋ช
ํํํ๋์ด ์ฐ์ต์ ๋งค์ฐ ์ ์ฉํ์ง๋ง, zeroed
์ ๊ฐ์ ๋ณ๊ฒฝ์ ํผํฉ์๋ค. .
@bluss ๋ด ์ดํด (์๋ชป ๋ ์ ์์)๋ std::mem:zeroed
๋ std::mem::uninitialized
๋งํผ์ด๋ ์ํํ๋ฉฐ UB๋ก ์ด์ด์ง ๊ฐ๋ฅ์ฑ๋ ์๋ค๋ ๊ฒ์
๋๋ค. ์๋ง๋ vec![0; N]
๋๋ [0; N]
๋ก ๋ ์ ์ด๊ธฐํ๋๋ ๋ฐ์ดํธ ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ ๋ฐ ์ฌ์ฉ ์ค์ผ ์ ์์ต๋๋ค.์ด ๊ฒฝ์ฐ rustfix
๊ท์น์ ์ถ๊ฐํ์ฌ ๋ณ๊ฒฝ์ ์๋ํ ํ ์ ์์ต๋๊น? ๊ทธ๋ฌ๋ ๋ฐ์ดํธ ๋๋ ์ ์ ๋ฐฐ์ด์ ์ด๊ธฐํํ๋ ๊ฒ ์ธ์ std::mem::zeroed
๋ฅผ ์ฌ์ฉํ๋ฉด UB๋ก ์ด์ด์ง ์์๋ ์ข์ ๊ธฐํ๊ฐ ์๋ค๋ ๊ฒ์ ์ดํดํฉ๋๋ค.
@scottjmaddox std::mem:zeroed
UB๋ฅผ ํธ์ถํ๋ ๊ฒ์ ๋งค์ฐ ์ฝ์ง๋ง std::mem::uninitialized
๊ณผ ๋ฌ๋ฆฌ std::mem:zeroed
์ด ์๋ฒฝํ๊ฒ ์ ํจํ ์ผ๋ถ ์ ํ์ด ์์ต๋๋ค (์ : ๋ค์ดํฐ๋ธ ์ ํ, ๋ง์ FFI ๊ด๋ จ struct
๋ฑ). ๋ง์ unsafe
ํจ์์ ๋ง์ฐฌ๊ฐ์ง๋ก zeroed()
๋ ๊ฐ๋ณ๊ฒ ์ฌ์ฉํด์๋ ์๋์ง๋ง uninitialized()
๋งํผ ๋ฌธ์ ๊ฐ๋์ง๋ ์์ต๋๋ค. ์์ ์ธก๋ฉด์์ ์ฐจ์ด๊ฐ์๊ณ MaybeUninit
๋ฒ์ ์ด ๋ ๋ค๋ฃจ๊ธฐ ์ด๋ ต ๊ธฐ ๋๋ฌธ์ std::mem:zeroed()
MaybeUninit::zeroed().into_inner()
๋์ std::mem:zeroed()
๊ฐ๋
์ฑ์ด ์ฝ๊ฐ ๋จ์ด์ง๋๋ค (์์ ํ์ง ์์ ์ฝ๋๋ฅผ ์ฌ์ฉํด์ผ ํ ๋ ๊ฐ๋
์ฑ์ ๋์ด ํ๊ฐํฉ๋๋ค).
๋ฟก๋ฟก
std :: mem :: uninitialized์ ๋ฌ๋ฆฌ std :: mem : zeroed ๊ฐ ์๋ฒฝํ๊ฒ ์ ํจํ ์ผ๋ถ ์ ํ์ด ์์ต๋๋ค (์ : ๊ธฐ๋ณธ ์ ํ,
mem::uninitialized
๊ฐ ์๋ฒฝํ๊ฒ ์์ ํ ์ผ๋ถ ์ ํ ( ์ : unit
)์ด ์๊ณ ์ผ๋ถ "๋ค์ดํฐ๋ธ"์ ํ (์ : bool
, &T
๋ฑ)์ด ์์ต๋๋ค. .) mem::zeroed
๋ ์ ์๋์ง ์์ ๋์์ ํธ์ถํฉ๋๋ค.
์ฌ๊ธฐ์๋ MaybeUninit
๊ฐ ์ด๋ป๊ฒ ๋ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ์คํด๊ฐ์๋ ๊ฒ ๊ฐ์ต๋๋ค (๊ทธ๋ฆฌ๊ณ ๊ทธ ์ด์ ๋ฅผ ์ ์ ์์ต๋๋ค : "Uninitialized"๊ฐ ์ด๋ฆ์ ์์).
์ฐ๋ฆฌ๊ฐ ๋ง์ผ๋ ค๋ ์ํ์ _invalid_ ๊ฐ์ด ๋ชจ๋ 0์ ํฌํจํ๋์ง, ์ด๊ธฐํ๋์ง ์์ ๋นํธ๋ฅผ ํฌํจํ๋์ง ์ฌ๋ถ์ ๊ด๊ณ์์ด _invalid_ ๊ฐ์ ์์ฑ์ผ๋ก ์ธํด ๋ฐ์ํ๋ ๊ฒ์
๋๋ค (์ : ๋นํธ ํจํด์์ bool
true
๋๋ false
)๊ฐ ์๋๊ณ ๋ณ๋ก ์ค์ํ์ง ์์ต๋๋ค. mem::zeroed
๋ฐ mem::uninitialized
๋ชจ๋ _invalid_ ๊ฐ์ ์์ฑํ๋ ๋ฐ ์ฌ์ฉํ ์ ์์ผ๋ฏ๋ก ๋ด ๊ด์ ์์ ๋๊ฐ์ด ์ํํฉ๋๋ค.
OTOH MaybeUninit::zeroed()
๋ฐ MaybeUninit::uninitialized()
๋ union
๋ฅผ ๋ฐํํ๊ธฐ ๋๋ฌธ์ _safe_ ๋ฉ์๋์
๋๋ค. MaybeUninit::into_inner
๋ unsafe
์ด๋ฉฐ MaybeUninit<T>
์ ํ์ฌ ๋นํธ๊ฐ T
์ _valid_ ๊ฐ์ ๋ํ๋ด๋ ์ ์ ์กฐ๊ฑด์ด ์ถฉ์กฑ๋๋ ๊ฒฝ์ฐ์๋ง _safe_ ํธ์ถํฉ๋๋ค. ๋นํธ ํจํด์ด _invalid_์ด๋ฉด ๋์์ด ์ ์๋์ง ์์ต๋๋ค. ๋นํธ ํจํด์ด ๋ชจ๋ 0, ์ด๊ธฐํ๋์ง ์์ ๋นํธ ๋๋ ๋ค๋ฅธ ๊ฒ์ ํฌํจํ๊ธฐ ๋๋ฌธ์ ์ ํจํ์ง ์์์ง ์ฌ๋ถ๋ ์ค์ ๋ก ์ค์ํ์ง ์์ต๋๋ค.
@RalfJung ์ ๋ MaybeUninit
๋ผ๋ ์ด๋ฆ์ด ์ฝ๊ฐ ์คํด์ ์์ง๊ฐ ์๋ค๋ ๋๋์ ๋ฐ๊ธฐ ์์ํ์ต๋๋ค. ํด๊ฒฐํ๋ ๋ฌธ์ ์ ํผํ๋ ์ํ์ ๋ ์ ์ ๋ฌํ๊ธฐ ์ํด ์ด๋ฆ์ MaybeInvalid
๋๋ ์ด์ ์ ์ฌํ ์ด๋ฆ์ผ๋ก ๋ฐ๊ฟ์ผ ํ ์๋ ์์ต๋๋ค. ํธ์ง : @Centril ์ ์ ์์ ๋ฐ๋ผ ์์ ๊ฑฐ ํตํ ๋ฌธ์ ์ ๊ฒ์ํ์ต๋๋ค.
ํธ์ง : FWIW, ์ ๋กํ ๋ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์์ ํ๊ฒ ์์ฑํ๊ธฐ ์ํด ์ธ์ฒด ๊ณตํ์ ๋ฐฉ๋ฒ (์ : MaybeUninit
๋ฅผ ์ง์ ์ฌ์ฉํ์ง ์๊ณ )์ด ์ ์ฉ ํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํ์ง๋ง mem::zeroed
๊ทธ๋ ์ง ์์ต๋๋ค. ๋ชจ๋ 0 ๋นํธ ํจํด์ด ์ ํจํ ์ ํ ๋๋ ์ด์ ์ ์ฌํ ์ ํ์ ๋ํด์๋ง ๊ตฌํ๋๋ Zeroed
ํน์ฑ์ Default
์ ์ ์ฌํ ํน์ฑ์ ์ถ๊ฐํ์ฌ ๋ค์๊ณผ ์ ์ฌํ ํจ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค. mem::zeroed
์ง๊ธ์ํ์ง๋ง ํจ์ ์ด ์์ต๋๋ค.
์ผ๋ฐ์ ์ผ๋ก ํ์ฌ ์ฌ์ฉ์๋ฅผ ๋ ๋์ ์๋ฃจ์
์ผ๋ก ๋ง์ด๊ทธ๋ ์ด์
ํ ์์๋ ๊ฒฝ๋ก๊ฐ ๋ง๋ จ ๋ ๋๊น์ง ๊ธฐ๋ฅ์ ๋ ์ด์ ์ฌ์ฉํ์ง ์์์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. MaybeUninit
๋ ๋ด ๋์ mem::zeroed
๋ณด๋ค ๋ ๋์ ์๋ฃจ์
์
๋๋ค. ๋น๋ก ์๋ฒฝํ์ง๋ ์์ง๋ง (๋ ์์ ํ์ง๋ง ์ธ์ฒด ๊ณตํ์ ์ด์ง ์์) mem::zeroed
๋ฅผ ์ฌ์ฉํ์ง ์์๋ ๊ด์ฐฎ์ต๋๋ค MaybeUninit
๋์ฐฉํ์๋ง์ mem::zeroed
๊ทธ ๋๊น์ง ์ธ์ฒด ๊ณตํ์ ์ธ ๋์ฒดํ์ด ์์ด๋๋ฉ๋๋ค.
ํด๊ฒฐํ๋ ๋ฌธ์ ์ ํผํ๋ ์ํ์ ๋ ์ ์ ๋ฌํ๊ธฐ ์ํด ์ด๋ฆ์ MaybeInvalid ๋๋ ์ด์ ๋น์ทํ ์ด๋ฆ์ผ๋ก ๋ฐ๊ฟ์ผ ํ ์๋ ์์ต๋๋ค.
https://github.com/rust-lang/rust/pull/56138 ์์ Bikeshed
๋ฟก๋ฟก
์ผ๋ถ "๋ค์ดํฐ๋ธ"์ ํ์ด ์์ต๋๋ค (์ :
bool
bool
๊ฐ FFI์ ์์ ํ ํ (์ผ๋ฐ์ ์ผ๋ก RFC 954๊ฐ ๊ฑฐ๋ถ๋๊ณ ๋น๊ณต์์ ์ผ๋ก ์น์ธ ๋์์์๋ ๋ถ๊ตฌํ๊ณ ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฃผ ๋จ) mem::zeroed
๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์์ ํด์ผํฉ๋๋ค.
,
&T
๋ฑ)์ ๋ํดmem::zeroed
๊ฐ ์ ์๋์ง ์์ ๋์์ ํธ์ถํฉ๋๋ค.
์,ํ์ง๋ง mem::zeroed
๋ํ UB๊ฐ์๋ ์ด๋ฌํ ์ ํ์๋ MaybeUninit::zeroed().into_inner()
๋ํ UB๋ ์์ต๋๋ค (์๋ ๋๊ธ์ .into_inner()
๋ฅผ ์๋์ ์ผ๋ก ํฌํจํ๋๋ก์ฃผ์ํ์ต๋๋ค). MaybeUninit
์ฌ์ฉ์๊ฐ ์ฆ์ .into_inner()
ํธ์ถํ๋ฉด ์๋ฌด๊ฒ๋ ์ถ๊ฐํ์ง ์์ต๋๋ค ( mem::zeroed
๋ง ์ฌ์ฉํ๊ณ ์๊ธฐ ๋๋ฌธ์ mem::zeroed
๊ฐ ๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ๊ฒฝ์ฐ ์ ์ ๋ค๋ฅธ ๋ง์ ์ฌ๋๋ค์ด ์ํํ๋ ์์
์
๋๋ค.) ์ ๋ก ์์ ์ ํ์ ๊ฒฝ์ฐ mem::zeroed
).
bool์ด FFI์ ์์ ํ ํ (์ผ๋ฐ์ ์ผ๋ก RFC 954๊ฐ ๊ฑฐ๋ถ๋๊ณ ๋น๊ณต์์ ์ผ๋ก ์น์ธ ๋์์์๋ ๋ถ๊ตฌํ๊ณ ์ผ๋ฐ์ ์ผ๋ก ๊ฐ์ฃผ ๋จ) mem :: zeroed๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด ์์ ํด์ผํฉ๋๋ค.
๋๋ ์ด๊ฒ์ ๋ํด ์์ธํ ๋ค๋ฃจ๊ณ ์ถ์ง ์์์ง๋ง bool
๋ C์ _Bool
๊ณผ ๋์ผํ๊ฒ ์ ์๋๋ค๋ ์๋ฏธ์์ FFI ์์ ํฉ๋๋ค. ๊ทธ๋ฌ๋ C์ _Bool
์ true
๋ฐ false
๊ฐ์ C ํ์ค์ ์ ์๋์ด ์์ง ์์ต๋๋ค (์ธ์ ๊ฐ๋ C20์์์ ์ ์์ง๋ง). ๋ฐ๋ผ์ mem::zeroed
๋ ์ ํจํ bool
ํ๊ฑฐ๋ ๊ธฐ์ ์ ์ผ๋ก ๊ตฌํ ์ ์๋์ง ์์ต๋๋ค.
์,ํ์ง๋ง mem :: zeroed์ ๋ํ UB๊ฐ์๋ ์ด๋ฌํ ์ ํ์๋ MaybeUninit :: zeroed (). into_inner ()์ ๋ํ UB๋ ์์ต๋๋ค (์๋ ์ฃผ์์ .into_inner ()๋ฅผ ์๋์ ์ผ๋ก ํฌํจํ๋๋ก์ฃผ์ํ์ต๋๋ค). ์ฌ์ฉ์๊ฐ .into_inner ()๋ฅผ ์ฆ์ ํธ์ถํ๋ฉด MaybeUninit๋ ์๋ฌด๊ฒ๋ ์ถ๊ฐํ์ง ์์ต๋๋ค (์ ๋ก ์์ ์ ํ์ ๋ํด์๋ง mem :: zeroed๋ฅผ ์ฌ์ฉํ๊ธฐ ๋๋ฌธ์ mem :: zeroed๊ฐ ๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ๊ฒฝ์ฐ ์ ์ ๋ค๋ฅธ ๋ง์ ์ฌ๋๋ค์ด ์ํ ํ ์์ ์ ๋๋ค). .
๋๋ ๋น์ ์ด ์ฌ๊ธฐ์ ์ด๋ค ์์ ์ ๋ง๋ค๊ณ ์ํ๋์ง ์ ๋ง๋ก ์ดํดํ์ง ๋ชปํ๋ค. MaybeUninit
๋ mem::zeroed
์๋์๋ into_inner
๋ฅผ ํธ์ถํ๊ฑฐ๋ ํธ์ถํ์ง ์๋ ์ต์
์ ์ถ๊ฐํ๊ณ , ์ ์๋์ง ์์ ๋์์ ๋์
ํ ์์๋ ์์
์ด๊ธฐ ๋๋ฌธ์ ๊ฐ์น๊ฐ ์์ต๋๋ค ( uninitialized ๋๋ zeroed๋ก ์ ๋์จ์ ๊ตฌ์ฑํ๋ ๊ฒ์ ์์ ํฉ๋๋ค).
์ ๋๊ตฐ๊ฐ๊ฐ mem::zeroed
๋ฅผ MayeUninit
+ into_inner
๋ฒ์ญํ ๊น์? ์ด๋ mem::zeroed
์ ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ "์์ "ํ๋ ์ ์ ํ ๋ฐฉ๋ฒ์ด ์๋๋ฉฐ, ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ๋ฌด์์ผ๋ก ์ค์ ํ๋ฉด ๋์ผํ ํจ๊ณผ์ ํจ์ฌ ๋ฎ์ ๋น์ฉ์ด ๋ฐ์ํฉ๋๋ค.
mem::zeroed
์์ MaybeUninit
๋ก ์ด๋ํ๋ ์ ์ ํ ๋ฐฉ๋ฒ์ into_inner
๋ฅผ ํธ์ถํ๋ ๊ฒ์ด ์์ ํ์ง ํ๊ฐํ๋ ๊ฒ์
๋๋ค.์ด ๊ฒฝ์ฐ์๋ ๊ทธ๋ ๊ฒ ํ ์ ์๊ณ ๊ทธ ์ด์ ๋ฅผ ์ค๋ช
ํ๋ ์ฃผ์์ ์์ฑํ ์ ์์ต๋๋ค. ์์ ํ๊ฑฐ๋ into_inner
ํธ์ถ์ด ์์ ํด์ง ๋๊น์ง MaybeUninit
์ union
๊ณ์ ์์
ํ์ญ์์ค (์ด ๊ฒฝ์ฐ๊น์ง ๋ง์ ์ฝ๋๋ฅผ ๋ณ๊ฒฝํด์ผ ํ ์๋ ์์ต๋๋ค. ๋ฐํ ๋ณ๊ฒฝ MaybeUninit
๋์ T
S ๋ฑ).
๋๋ ์ด๊ฒ์ ๋ํด ์์ธํ ๋ค๋ฃจ๊ณ ์ถ์ง ์์์ง๋ง
bool
๋ C์_Bool
๊ณผ ๋์ผํ๊ฒ ์ ์๋๋ค๋ ์๋ฏธ์์ FFI ์์ ํฉ๋๋ค. ๊ทธ๋ฌ๋C's
_Boolare not defined in the C standard (although they might be some day, maybe in C20), so whether
mem :: zeroedcreates a valid
bool`์true
๋ฐfalse
๊ฐ์ ๊ธฐ์ ์ ์ผ๋ก ๊ตฌํ ์ ์๋ฉ๋๋ค. .
ํ์ ํธ๋ฅผ ๊ณ์ํ๋ ๊ฒ์ ๋ํด ์ฌ๊ณผํ์ง๋ง C11์์๋ 0์ผ๋ก ์ค์ ๋๋ ๋ชจ๋ ๋นํธ๊ฐ ์ ์ ์ ํ์ ๊ฐ 0์ ๋ํ๋ด๋๋ก ์๊ตฌํฉ๋๋ค (์น์
6.2.6.2 "์ ์ ์ ํ", ๋จ๋ฝ 5 ์ฐธ์กฐ) ( _Bool
). . ๋ํ true
๋ฐ false
์ด ๋ช
์ ์ ์ผ๋ก ์ ์๋ฉ๋๋ค (์น์
7.18 "๋ถ์ธ ์ ํ ๋ฐ ๊ฐ <stdbool.h>
"์ฐธ์กฐ).
๋๋ ๋น์ ์ด ์ฌ๊ธฐ์ ์ด๋ค ์์ ์ ๋ง๋ค๊ณ ์ํ๋์ง ์ ๋ง๋ก ์ดํดํ์ง ๋ชปํ๋ค.
MaybeUninit
๋mem::zeroed
์๋์๋into_inner
๋ฅผ ํธ์ถํ๊ฑฐ๋ ํธ์ถํ์ง ์๋ ์ต์ ์ ์ถ๊ฐํ๋ฉฐ, ์ ์๋์ง ์์ ๋์์ ๋์ ํ ์์๋ ์์ ์ด๋ฏ๋ก ๊ทธ์ ๊ฐ์น๊ฐ ์์ต๋๋ค ( uninitialized ๋๋ zeroed๋ก ์ ๋์จ์ ๊ตฌ์ฑํ๋ ๊ฒ์ ์์ ํฉ๋๋ค).
MaybeUninit
๋ฐ MaybeUninit::zeroed
์์ต๋๋ค. ์ฐ๋ฆฌ ๋ ๋ค ๊ทธ๊ฒ์ ๋์ํฉ๋๋ค. ๋๋ MaybeUninit::zeroed
์ ๊ฑฐ๋ฅผ ์ฃผ์ฅํ๋ ๊ฒ์ด ์๋๋๋ค. ๋ด ์์ ์ std::mem::zeroed
์๋ ๊ฐ์น๊ฐ ์๋ค๋ ๊ฒ์
๋๋ค.
mem :: uninitialized๊ฐ ์๋ฒฝํ๊ฒ ์์ ํ ์ ํ (์ : ๋จ์)์ด์๋ ๋ฐ๋ฉด, mem :: zeroed๊ฐ ์ ์๋์ง ์์ ๋์์ ํธ์ถํ๋ ์ผ๋ถ "๋ค์ดํฐ๋ธ"์ ํ (์ : bool, & T ๋ฑ)์ด ์์ต๋๋ค.
์ด๊ฒ์ ๋ถ์ ์ฒญ์ด์
๋๋ค. zeroed
๋ฐ uninitialized
๋ชจ๋ ์ ํ์ ์ผ๋ถ ํ์ ์งํฉ์ ๋ํด ์ ํจํ๊ธฐ ๋๋ฌธ์ ์ค์ ์ฌ์ฉ์์ ๋น๊ตํ ์๋ ์์ต๋๋ค. ์ด๋ฌํ ํ์ ์งํฉ์ ํฌ๊ธฐ๋ฅผ ํ์ธํด์ผํฉ๋๋ค. mem::uninitialized
๊ฐ ์ ํจํ ์ ํ์ ์๋ ๋งค์ฐ ์ ์ผ๋ฉฐ (์ค์ ๋ก ํฌ๊ธฐ๊ฐ 0 ์ธ ์ ํ์ผ๊น์?) ์๋ฌด๋ ์ค์ ๋ก ๊ทธ๋ ๊ฒํ๋ ์ฝ๋๋ฅผ ์์ฑํ์ง ์์ต๋๋ค (์ : ZST์ ๊ฒฝ์ฐ ์ฌ์ฉํ๋ ์ ํ ์์ฑ์). ๋ฐ๋ฉด์ mem::zeroed
๊ฐ ์ ํจํ ๋ง์ ์ ํ์ด ์์ต๋๋ค. mem::zeroed
์ (๋) ์ต์ํ ๋ค์ ์ ํ์ ๋ํด ์ ํจํฉ๋๋ค.
bool
)Option<T>
์ฌ๊ธฐ์ T๋ ์ด๊ฑฐ ํ ๋ ์ด์์ ์ต์ ํ๋ฅผ ํธ๋ฆฌ๊ฑฐํฉ๋๋ค. T
์๋ ๋ค์์ด ํฌํจ๋ฉ๋๋ค.NonZeroXXX
(๋ชจ๋ ์ ์ ์ ํ)NonNull<U>
&U
&mut U
fn
ํฌ์ธํฐstruct
์ฌ๊ธฐ์ ๋ชจ๋ ํ๋๋์ด ๋ชฉ๋ก์ ์ ํ์
๋๋ค.struct
๋๋ union
.์, uninitialized
๋ฐ zeroed
์ ์ฌ์ ์ผ๋ก ์๋ชป๋ ๊ฐ์ ์ฒ๋ฆฌํฉ๋๋ค. ๊ทธ๋ฌ๋ ํ๋ก๊ทธ๋๋จธ๋ ์ด๋ฌํ ํ๋ฆฌ๋ฏธํฐ๋ธ๋ฅผ ๋งค์ฐ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ์ฌ์ฉํฉ๋๋ค.
mem::uninitialized
์ ์ผ๋ฐ์ ์ธ ํจํด์ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
let val = MaybeUninit::uninitialized();
initialize_value(val.as_mut_ptr()); // or val.set
val.into_inner()
์ด๋ฌํ ๋ฐฉ์์ผ๋ก ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ์ฌ์ฉํ์ง ์๋ ๊ฒฝ์ฐ ํฐ ์ค์๋ฅผ ํ ๊ฐ๋ฅ์ฑ์ด ํฝ๋๋ค.
์ค๋๋ mem::zeroed
์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์ฉ๋ ๋ ์์์ ์ค๋ช
ํ ์ ํ์ ๋ํ ๊ฒ์ด๋ฉฐ ์ด๊ฒ์ ์๋ฒฝํ๊ฒ ์ ํจํฉ๋๋ค. ๋๋ ๋ชจ๋ ๊ณณ์์ mem::zeroed()
๋ฅผ MaybeUninit::zeroed().into_inner()
๋ก ๋์ฒดํด๋ ํ๊ฑด ์๋ฐฉ ํจ๊ณผ๊ฐ ์ ํ ๋ณด์ด์ง ์๋๋ค๋ @bluss์ ์ ์ ์ผ๋ก ๋์ํฉ๋๋ค.
์์ฝํ๋ฉด uninitialized
์ ์ผ๋ฐ์ ์ธ ์ฌ์ฉ์ ์๋ชป๋ ๊ฐ์ ๊ฐ์ง ์์๋ ์ ํ์ ์ฌ์ฉ๋ฉ๋๋ค. zeroed
์ ์ผ๋ฐ์ ์ธ ์ฉ๋๋ 0์ผ๋ก ์ค์ ํ๋ฉด ์ ํจํ ์ ํ์ ์ฌ์ฉ๋ฉ๋๋ค.
์ ์ ๋ Zeroed
ํธ๋ ์ด ํธ ๋๋ ์ ์ฌ (์ : Pod
,ํ์ง๋ง T: Zeroed
๋ T: Pod
์๋ฏธํ์ง ์์) ์ถ๊ฐํ๋ ๊ฒ์ด ์ข์ ๊ฒ ๊ฐ์ต๋๋ค. ํ์ง๋ง ์ค์ ๋ก ์์ ์ ์ธ fn zeroed2<T: Zeroed>() -> T
ํ๋ณด ํ ๋๊น์ง fn zeroed<T>() -> T
ํ๊ธฐํ์ง ๋ง์ญ์์ค.
๋ฟก๋ฟก
ํ์ ํธ๋ฅผ ๊ณ์ํด์ ๋ฏธ์ํ์ง๋ง C11์
๊ณผ์ฐ! ์ ํจํ ๊ฐ์ ์ง์ ํ์ง ์์ ๊ฒ์ C ++์ bool
๋ฟ์
๋๋ค! ์์ ํด์ฃผ์
์ ๊ฐ์ฌํฉ๋๋ค.์ด ๋ณด์ฆ๊ณผ ํจ๊ป UCG์ PR์ ๋ณด๋ด๊ฒ ์ต๋๋ค.
๋ฟก๋ฟก
์ด๋ฌํ ํ์ ์งํฉ์ ํฌ๊ธฐ๋ฅผ ํ์ธํด์ผํฉ๋๋ค.
mem::uninitialized
์ด ์ ํจํ ์ ํ์ ์๋ ๋งค์ฐ ์ ์ผ๋ฉฐ (์ค์ ๋ก ํฌ๊ธฐ๊ฐ 0 ์ธ ์ ํ์ผ๊น์?) ์๋ฌด๋ ์ค์ ๋ก ๊ทธ๋ ๊ฒํ๋ ์ฝ๋๋ฅผ ์์ฑํ์ง ์์ต๋๋ค (์ : ZST์ ๊ฒฝ์ฐ ์ ํ ์์ฑ์).
ZST๋ฅผ ์ผ์ข ์ "์์ ์ฆ๋ช "๋๋ "์์ ํ ํฐ"๋๋ ์ผ๋ฐ์ ์ผ๋ก "์ฆ๊ฑฐ ์ฆ๋ช "์ผ๋ก ์ฌ์ฉํ ์์๋ ๊ฐ์ธ ์ ๋ณด ๋ณดํธ๋ฅผ ๊ณ ๋ คํ๋ค๋ฉด ๋ชจ๋ ZST์ ๋ํด ์ณ์ง ์์ต๋๋ค. ๊ฐ๋จํ ์ :
mod refl {
use core::marker::PhantomData;
use core::mem;
/// Having an object of type `Id<A, B>` is a proof witness that `A` and `B`
/// are nominally equal type according to Rust's type system.
pub struct Id<A, B> {
witness: PhantomData<(
// Make sure `A` is Id is invariant wrt. `A`.
fn(A) -> A,
// Make sure `B` is Id is invariant wrt. `B`.
fn(B) -> B,
)>
}
impl<A> Id<A, A> {
/// The type `A` is always equal to itself.
/// `REFL` provides a proof of this trivial fact.
pub const REFL: Self = Id { witness: PhantomData };
}
impl<A, B> Id<A, B> {
/// Casts a value of type `A` to `B`.
///
/// This is safe because the `Id` type is always guaranteed to
/// only be inhabited by `Id<A, B>` types by construction.
pub fn cast(self, value: A) -> B {
unsafe {
// Transmute the value;
// This is safe since we know by construction that
// A == B (including lifetime invariance) always holds.
let cast_value = mem::transmute_copy(&value);
// Forget the value;
// otherwise the destructor of A would be run.
mem::forget(value);
cast_value
}
}
}
}
fn main() {
use core::mem::uninitialized;
// `Id<?A, ?B>` is a ZST; let's make one out of thin air:
let prf: refl::Id<u8, String> = unsafe { uninitialized() };
// Segfault:
let _ = prf.cast(42u8);
}
@Centril ์ด๊ฒ์ ์ผ์ข
์ ํ์ ํธ์ด์ง๋ง ๊ทํ์ ์ฝ๋๊ฐ ์ค์ ๋ก uninitialized
๋ฅผ ํธ์ถํ๋ฉด ์๋ชป๋ ๊ฐ์ด ์์ฑ๋๋ ์ ํ์ ์์ธ์ง ํ์คํ์ง ์์ต๋๋ค. Id
์ด ์ ์งํด์ผํ๋ ๋ด๋ถ ๋ถ๋ณ์ฑ์ ์๋ฐํ๊ธฐ ์ํด ์์ ํ์ง ์์ ์ฝ๋๋ฅผ ์ฌ์ฉํ๊ณ ์์ต๋๋ค. ์ด๋ฅผ ์ํํ๋ ๋ฐฉ๋ฒ์๋ ์ฌ๋ฌ ๊ฐ์ง๊ฐ ์์ต๋๋ค (์ transmute(())
) ๋๋ ์ ํ ์บ์คํ
์์ ํฌ์ธํฐ.
@jethrogb ๋ด ์ ์ผํ ์์ ์ a) ๋ฌธ๊ตฌ์ ๋์ฃผ์๋ฅผ ๊ธฐ์ธ์ด์ญ์์ค. b) ์ ํจํ ๊ฐ์ด ๋ฌด์์ธ์ง์ ๋ํ ํ ๋ก ์์ ํ๋ผ์ด๋ฒ์๊ฐ ์ถฉ๋ถํ ํฉ๋ฆฌ์ ์ด์ง ์์ ๊ฒ ๊ฐ์ต๋๋ค. "๋ด๋ถ ๋ถ๋ณ์ฑ ์๋ฐ"๊ณผ "์ ํจํ์ง ์์ ๊ฐ"์ ๊ฐ์ ๊ฒ ๊ฐ์ต๋๋ค. ์ฌ๊ธฐ์ ๋ถ์์ ์ธ ์กฐ๊ฑด์ด ์์ต๋๋ค. " A != B
์ด๋ฉด Id<A, B>
๋ ๋ฌด์ธ์
๋๋ค."
"๋ด๋ถ ๋ถ๋ณ์ฑ ์๋ฐ"๊ณผ "์ ํจํ์ง ์์ ๊ฐ"์ ๊ฐ์ ๊ฒ ๊ฐ์ต๋๋ค. ์ฌ๊ธฐ์ ๋ถ์์ ์ธ ์กฐ๊ฑด์ด ์์ต๋๋ค. "
A != B
์ด๋ฉดId<A, B>
๋ ๋ฌด์ธ์ ๋๋ค."
"๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ฝ๋์ ์ํด ๋ถ๊ณผ ๋"๋ถ๋ณ์ ์ฌ๋ฌ๋ฉด์์ "์ปดํ์ผ๋ฌ์ ์ํด ๋ถ๊ณผ ๋"๋ถ๋ณ ๊ณผ ๋ค๋ฆ
๋๋ค. ์ฃผ์ ์ ๋ํ @RalfJung ์ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ฐธ์กฐํ์ญ์์ค. ์ด ์ฉ์ด์์ Id
์์ ์๋ ์์ ๋ถ๋ณ์ด ์์ผ๋ฉฐ mem::zeroed
๋๋ Id<A, B>
๋ฅผ ์ผ๋ฐ์ ์ผ๋ก ํฉ์ฑํ๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ์์ ํ ์ ์์ต๋๋ค.ํ์ง๋ง ์ฆ๊ฐ์ ์ธ UB๋ ์๋๋๋ค. Id
์๋ ์ ํจ ๋ถ๋ณ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ Id
mem::zeroed
๋๋ mem::uninitialized
๋ก ์๋ชป๋ Id
๊ฐ์ ๊ตฌ์ฑํฉ๋๋ค. ์์ ํ์ง ์์ ์ฝ๋ ์์ฑ์๋ ํ์คํ ๋ ๊ฐ์ง ์ ํ์ ๋ถ๋ณ์ฑ์ ์ผ๋์ ๋์ด์ผํ์ง๋ง์ด ๋
ผ์๊ฐ ๋๋ถ๋ถ ์ ํจ์ฑ์ ์ด์ ์ ๋ง์ถ๋ ๋ช ๊ฐ์ง ์ด์ ๊ฐ ์์ต๋๋ค.
T
์ ์์ ๋ถ๋ณ์ ๊ธฐ๋ฐ์ผ๋ก mem::zeroed::<T>()
๋ฅผ ๊ธฐ๊ณ์ ์ผ๋ก ๋ฐฐ์ ํ ์ ์๋ค๊ณ ํด๋ ์ฐ๋ฆฌ๋ ์ํ์ง ์์ ์ ์์ต๋๋ค.์ฝ์ ํ ์ฝ๋ฉํธ๋ฅผ @jethrogb , ๋๋ ๋์ mem::zeroed
์ ๋์
์ผ๋ก ์ฌ์ฉ๋์งํด์๋ ์ MaybeUninit
.
@jethrogb ์์ ๋ํธ :
์ด ๋ชฉ๋ก์์๋ ๋ชจ๋ ์ ํ์ ๋ฐฐ์ด
ํ๋๊ฐ์ด ๋ชฉ๋ก์ ์ ํ ์ธ ๋ชจ๋ ๊ตฌ์กฐ์ฒด.
์ด๊ฒ์ด ๋จ์ํ ์คํ์ธ์ง ์๋ฏธ ๋ก ์ ์ฐจ์ด์ธ์ง๋ ํ์คํ์ง ์์ง๋ง,์ด ๋ ๊ฐ์ ๊ธ ๋จธ๋ฆฌ ๊ธฐํธ๋ฅผ ๋นผ๋ด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. None
๊ฐ Option<[&u8; 2]>
๊ฒฝ์ฐ๊ฐ ๋ฐ๋์ ์๋ค๊ณ ์๊ฐํ์ง๋ ์์ต๋๋ค None
์ผ์ด์ค์ ํํ์ผ๋ก [0, 24601]
๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค-๋ด๋ถ ๊ฐ ์ค ํ๋๋ง ํ์ ํํ์ ์ทจํด์ผํฉ๋๋ค-cc @ ์ด๊ฒ ์ ๋ํด ๋๋ฅผ ํ์ธํ๋
๋ฟก๋ฟก
์ค๋๋ mem :: zeroed์ ๊ฐ์ฅ ์ผ๋ฐ์ ์ธ ์ฌ์ฉ์ ์์์ ์ค๋ช ํ ์ ํ์ ๋ํ ๊ฒ์ด๋ฉฐ ์ด๊ฒ์ ์๋ฒฝํ๊ฒ ์ ํจํฉ๋๋ค.
์ด๊ฒ์ ๋ํ ์ถ์ฒ๊ฐ ์์ต๋๊น?
๋ฐ๋ฉด์ mem :: zeroed๊ฐ ์ ํจํ ๋ง์ ์ ํ์ด ์์ต๋๋ค.
๋ํ ์๋ชป ์ฌ์ฉ๋ ์์๋ ๊ฒฝ์ฐ๋ ๋ฌดํํ ๋ง์ต๋๋ค.
๋๋ mem::zeroed
๋ง์ด ์ฌ์ฉํ๋ ์ฌ๋๋ค์๊ฒ ๋ ์ธ์ฒด ๊ณตํ์ ์ธ ์๋ฃจ์
์ ์ฌ์ฉํ ์์์ ๋๊น์ง ์ง์ ์ค๋จ์ ์ฐ๊ธฐํ๋ ๊ฒ์ด ๋งค์ฐ ๋งค๋ ฅ์ ์ธ ๋์์ด๋ผ๋ ๊ฒ์ ์ดํดํฉ๋๋ค.
์ผ์์ ์ธ ์ธ์ฒด ๊ณตํ์ ๋น์ฉ์ด ๋ฐ์ํ๋๋ผ๋ mem::zeroed
์ ์๋ชป๋ ์ฌ์ฉ ํ์๋ฅผ ์ค์ด๊ฑฐ ๋ ์ ๊ฑฐํ๋ ์ ์ถฉ์์ ์ ํธํฉ๋๋ค. ์ง์ ์ค๋จ์ ์ฌ์ฉ์๊ฐ ์ํํ๋ ์์
์ด ์ ์ฌ์ ์ผ๋ก ์ ์๋์ง ์์ ๋์ (ํนํ ์ฒ์ ์ฌ์ฉํ๋ ์ ๊ท ์ฌ์ฉ์)์ ์ ๋ฐํ ์ ์์์ ๊ฒฝ๊ณ ํ๋ฉฐ, ๋์ ์ํ ํ ์์
์ ๋ํ ๊ฑด์ ํ ์๋ฃจ์
์ ์ ๊ณตํ๋ฏ๋ก ๊ฒฝ๊ณ ๋ฅผ ์คํํ ์ ์์ต๋๋ค.
์ ๋ MaybeUninit
์์ฃผ ์ฌ์ฉํ๊ณ mem::zeroed
๋ฐ mem::uninitialized
๋ณด๋ค ์ฌ์ฉํ๋ ๊ฒ์ด ์ธ์ฒด ๊ณตํ์ ์ด์ง ์์ง๋ง ์ ์๊ฒ ๊ณ ํต์ค๋ฝ์ง ์๊ฒ ์ธ์ฒด ๊ณตํ์ ์ด์ง ์์์ต๋๋ค. MaybeUninit
์ด์ด ํ ๋ก ์ฃผ์ฅ์ ์ผ๋ถ ์๊ฒฌ๋งํผ ๊ณ ํต ์ค๋ฝ๋ค๋ฉด ์์ ํ mem::zeroed
๋์์์ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฐ / ๋๋ RFC๊ฐ ์ฆ์ ๋ํ๋ฉ๋๋ค (์๋ฌด๊ฒ๋ AFAICT๋ฅผ ์ฐจ๋จํ์ง ์์).
๋๋ ์ฌ์ฉ์๊ฐ ๊ฒฝ๊ณ ๋ฅผ ๋ฌด์ํ๊ณ mem::zeroed
๊ณ์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด๋ ์ฌ์ฉ์์ ์ ํ์ ๋ฌ๋ ค ์์ต๋๋ค. mem::zeroed
์์ libcore
mem::zeroed
๋ฅผ ์ ๊ฑฐ ํ ์๋ ์์ต๋๋ค.
๊ทธ๋ฌ๋ mem::zeroed
๋ง์ด ์ฌ์ฉํ๋ ์ฌ๋๋ค์ ๋ชจ๋ ์ฌ์ฉ๋ฒ์ด ์ด์จ๋ ์ฌ๋ฐ๋ฅธ์ง ์ ๊ทน์ ์ผ๋ก ์กฐ์ฌํด์ผํฉ๋๋ค. ํนํ mem::zeroed
๋ง์ด ์ฌ์ฉํ๋ ์ฌ์ฉ์, ์ผ๋ฐ ์ฝ๋์์ ์ฌ์ฉํ๋ ์ฌ์ฉ์, mem::uninitialized
๋์ "๋ ๋ฌด์์ด"๋์์ผ๋ก ์ฌ์ฉํ๋ ์ฌ์ฉ์ ๋ฑ์
๋๋ค. ์ ์๋์ง ์์ ๋์ ์ผ ์ ์์ต๋๋ค.
๋ธ๋ฃจ์ค
์ ๋กํ๋ฅผ ์ ๊ฑฐํ๋ฉด MaybeUninit :: zeroed (). into_inner ()๋ก๋ง ๋์ฒด๋๋ ๊ฒ์ฒ๋ผ ๋ณด์ ๋๋ค. ์ค์ง์ ์ธ ๋ณํ๋ ์์ต๋๋ค. uninit ๊ฐ์ ์ฌ์ฉํ๋ฉด MaybeUninit ๋๋ ๋๋ฑํ ์ ๋์จ ์ ํ์ ๊ฐ์ ์ ์ฅ๋๋ ๋ชจ๋ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ์ ์ค์ง์ ์ธ ๋ณ๊ฒฝ์ด ๋์ ์์ต๋๋ค.
์ด๊ฒ์ ์ ์์ ๋ํด ์ด์ผ๊ธฐ ํ ๋ ์ฌ์ค์ด์ง๋ง, ์๋ฅผ ๋ค์ด ์ฐธ์กฐ ์ ํ์ ์ดํด๋ณด๋ฉด mem::zeroed()
๋ฌธ์ ๊ฐ๋ฉ๋๋ค.
๊ทธ๋ฌ๋, ๋๋ ํจ์ฌ ๋ ๊ฐ๋ฅ์ฑ์ด ์ฌ๋๋ค์ด ์ค์ ๋ก ์คํํ๋ ๊ฒ์
๋๋ค ๋์ mem::zeroed::<&T>()
์คํ ์ฌ๋๋ค๋ณด๋ค ๋ฌธ์ ๊ฐ mem::uninitialized::<bool>()
๋ฌธ์ ์
๋๋ค. ๋ฐ๋ผ์ mem::zeroed()
๋ฅผ ์ ์งํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ผ ์ ์์ต๋๋ค.
๊ทธ๋ฌ๋ mem::uninitialized::<u32>()
๊ฐ ๊ด์ฐฎ๋ค๊ณ ๊ฒฐ์ ํ ์ ์์ต๋๋ค. ์ ์ ์ ํ์์ ์ด๊ธฐํ๋์ง ์์ ๋นํธ๋ฅผ ํ์ฉํ๋ฉด mem::uninitialized()
๋ ๊ฑฐ์ ๋ชจ๋ "POD ์ ํ"์ ๋ํด ์ ํจ ํด์ง๋๋ค. ๋๋ ์ฐ๋ฆฌ๊ฐ ์ด๊ฒ์ ํ์ฉํด์ผํ๋ค๊ณ ์๊ฐํ์ง ์์ง๋ง, ์ฐ๋ฆฌ๋ ์ฌ์ ํ์ด ๋
ผ์๋ฅผํด์ผํฉ๋๋ค.
mem :: uninitialized๊ฐ ์ ํจํ ์ ํ์ ์๋ ๋งค์ฐ ์ ์ผ๋ฉฐ (์ค์ ๋ก ํฌ๊ธฐ๊ฐ 0 ์ธ ์ ํ์ผ๊น์?) ์๋ฌด๋ ์ค์ ๋ก์ด๋ฅผ ์ํํ๋ ์ฝ๋๋ฅผ ์์ฑํ์ง ์์ต๋๋ค (์ : ZST์ ๊ฒฝ์ฐ ์ ํ์ ์ฌ์ฉํฉ๋๋ค. ๊ฑด์ค์).
FWIW, ์ผ๋ถ ์ฌ๋ผ์ด์ค ๋ฐ๋ณต๊ธฐ ์ฝ๋๋ ์ค์ ๋ก ํ์ ์์ฑ์๋ฅผ ์์ฑํ ์์๋ ์ ๋ค๋ฆญ ์ฝ๋์์ ZST๋ฅผ ๋ง๋ค์ด์ผํฉ๋๋ค. ์ด๋ฅผ ์ํด mem::zeroed()
/ MaybeUninit::zeroed().into_inner()
๋ฅผ ์ฌ์ฉํฉ๋๋ค.
mem::zeroed()
๋ C ํจ์๋ฅผ ํธ์ถํ๊ธฐ ์ ์ memset(&x, 0, sizeof(x))
๋ก ๊ฐ์ 0์ผ๋ก ์ค์ ํด์ผํ๋ ํน์ FFI ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค. ๋๋ ์ด๊ฒ์ด ๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ๊ฒ์ผ๋ก ์ ์งํ๊ธฐ์ ์ถฉ๋ถํ ์ด์ ๋ผ๊ณ ์๊ฐํฉ๋๋ค.
@Amanieu ๋ถํ์ํ ๊ฒ ๊ฐ์ต๋๋ค. memset
์ผ์นํ๋ Rust ๊ตฌ์กฐ๋ write_bytes
์
๋๋ค.
mem :: zeroed ()๋ ํน์ FFI ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค.
๋ํ ๋ง์ง๋ง์ผ๋ก ํ์ธํ์ ๋ mem::zeroed
๋ ๊ฐ์ธ ๋๋ ํ๋ซํผ ์ข
์ ํ๋๋ก libc
๊ตฌ์กฐ๋ฅผ ์ด๊ธฐํํ๋ ๊ด์ฉ์ ๋ฐฉ๋ฒ์ด์์ต๋๋ค.
@RalfJung ๋ฌธ์ ์ ์ ์ฒด ์ฝ๋๋ ์ผ๋ฐ์ ์ผ๋ก Type x; memset(&x, 0, sizeof(x));
์ด๊ณ ์ฒซ ๋ฒ์งธ ๋ถ๋ถ์๋ Rust์ ์์ํ๋ ํ๋ฅญํ ์ฝ๋๊ฐ ์์ต๋๋ค. ์ฌ์ฉ MaybeUninit
์ด ํจํด์ ๋ผ์ธ ๋
ธ์ด์ฆ๊ฐ ๋ง์ด์๊ฒ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ ๋ก ํ ๋ฌดํจ ๊ฒฐ์ฝ (์ต์ ํ์์ด ํจ์ฌ ๋ CODEGEN)์
๋๋ค memset
.
MaybeUninit
์ ๋์์ธ์ ๋ํ ์ง๋ฌธ์ด ์์ต๋๋ค. MaybeUninit<T>
์์ ํฌํจ ๋ T
์ ๋จ์ผ ํ๋์ ์ธ ์์๋ ๋ฐฉ๋ฒ์ด ์์ต๋๊น? ๋ชจ๋ ํ๋๊ฐ ์ ํจํ / ์ด๊ธฐํ ๋ ์ ํ์ผ๋ก ๋๋ ๊น์?
๋ค์๊ณผ ๊ฐ์ ๊ตฌ์กฐ์ฒด๊ฐ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค.
// Let us suppose that Foo can in principle be any struct containing arbitrary types
struct Foo {bar: bool, baz: String}
& mut Foo ์ฐธ์กฐ๋ฅผ ์์ฑ ํ ๋ค์ ์ฐ๊ธฐ๊ฐ UB๋ฅผ ํธ๋ฆฌ๊ฑฐํฉ๋๊น?
main () {
let uninit_foo = MaybeUninitilized::<Foo>::uninitialized();
unsafe { *uninit_foo.get_mut().bar = true; }
unsafe { *uninit_foo.get_mut().baz = "hello world".to_owned(); }
}
์ฐธ์กฐ ๋์ ์์ ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ๋ฉด์ด ๋ฌธ์ ๋ฅผ ํผํ ์ ์์ต๋๊น?
main () {
let uninit_foo = MaybeUninitilized::<Foo>::uninitialized();
unsafe { *uninit_foo.as_mut_pointer().bar = true; }
unsafe { *uninit_foo.as_mut_pointer().baz = "hello world".to_owned(); }
}
์๋๋ฉด UB๋ฅผ ํธ๋ฆฌ๊ฑฐํ์ง ์๊ณ ์ด ํจํด์ ๊ตฌํํ ์์๋ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ต๋๊น? ์ง๊ด์ ์ผ๋ก, ์ด๊ธฐํ๋์ง ์์ / ์ ํจํ์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์ง ์๋ ํ ๋ชจ๋ ๊ฒ์ด ๊ด์ฐฎ์ ๊ฒ ๊ฐ์ง๋ง์ด ์ค๋ ๋์ ์ฌ๋ฌ ์ฃผ์์ผ๋ก ์ธํด ์์ฌ์ด ์๊น๋๋ค.
์ด ๊ธฐ๋ฅ์ ๋ํ ๋ด ์ฌ์ฉ ์ฌ๋ก๋ ์ผ๋ถ ํ๋๊ฐ ์ฌ์ฉ์๊ฐ ์ง์ ํด์ผํ๊ณ ํฉ๋ฆฌ์ ์ธ ๊ธฐ๋ณธ๊ฐ์ด์๋ ์ ํ์ ๋ํ ์ธํ๋ ์ด์ค (in-place) ๋น๋ ํจํด์ด์ง๋ง ์ผ๋ถ ํ๋์๋ ๊ธฐ๋ณธ๊ฐ์ด ์์ต๋๋ค. ๊ฐ.
MaybeUninit ์์ ํฌํจ ๋ T์ ๋จ์ผ ํ๋์ ์ฐ๋ ๋ฐฉ๋ฒ์ด ์์ต๋๊น?
์๊ฐ์ด ์ง๋จ์ ๋ฐ๋ผ ๋ชจ๋ ํ๋์ ์ฐ๊ณ ์ ํจ / ์ด๊ธฐํ ๋ ์ ํ์ผ๋ก ๋๋ ์ ์๋๋ก?
์. ์ฌ์ฉํ๋ค
ptr::write(&mut *(uninit.as_mut_ptr()).bar, val1);
ptr::write(&mut *(uninit.as_mut_ptr()).baz, val2);
...
์ด๋ฅผ ์ํด get_mut()
๋ฅผ ์ฌ์ฉํด์๋ ์๋ฉ๋๋ค. ์ด๊ฒ์ด get_mut
์ ๋ฌธ์์์์ด ๋ฉ์๋๋ฅผ ํธ์ถํ๊ธฐ ์ ์ ๊ฐ์ ์ด๊ธฐํํด์ผํ๋ค๊ณ ๋งํ๋ ์ด์ ์
๋๋ค. https://github.com/rust-rfcs/unsafe-code-guidelines/ ์์ ๋
ผ์๋๋ ํฅํ ๊ท์น์ ์ํ ํ ์ ์์ต๋๋ค
@RalfJung *(uninit.as_mut_ptr()).bar = val1;
์ด (๊ฐ) ์ด๊ธฐํ๋์ง ์์ bar
์ด์ ๊ฐ์ ๋จ์ด ๋จ๋ฆด ์ํ์ด ์์ง ์์ต๋๊น? ํ ํ์๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค
ptr::write(&mut (*uninit.as_mut_ptr()).bar, val1);
@scottjmaddox ์, ๋ง์. Drop
์ ๋ํด ์์ด ๋ฒ๋ ธ์ต๋๋ค. ๊ฒ์๋ฌผ์ ์
๋ฐ์ดํธํ๊ฒ ์ต๋๋ค.
์ด๊ธฐํ๋์ง ์์ ํ๋์ ์ฐ๋์ด ๋ณํ์ get_mut()
๋ณด๋ค ์ ์๋์ง ์์ ๋์์ด ๋ํฉ๋๊น? ptr::write
๋ํ ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ํ๊ฐ๋๋ ์ฝ๋ ์ง์ ์์ ์ฝ๋๋ ๋ด๋ถ ํ๋์ &mut _
๋ฅผ ๋ง๋ค์์ต๋๋ค.์ด ํ๋๋ ๊ทธ๋ ์ง ์์ผ๋ฉด ์ ์ฒด ๊ตฌ์กฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋งํผ ์ ์๋์ง ์์์ผํฉ๋๋ค. ๋ง๋ค์ด์ง. ์ปดํ์ผ๋ฌ๋ ์ด๊ฒ์ด ์ด๋ฏธ ์ด๊ธฐํ ๋ ์ํ๋ผ๊ณ ๊ฐ์ ํ๋๋ก ํ์ฉ๋์ง ์์์ผํฉ๋๊น?
๋
ธ์ถ ๋ &mut _
์ค๊ฐ์ฒด๋ฅผ ํ์๋กํ์ง ์๋ ์๋ก์ด ํฌ์ธํฐ ํ๋ก์ ์
๋ฐฉ๋ฒ์ด ํ์ํ์ง ์์๊น์?
์ฝ๊ฐ ํฅ๋ฏธ๋ก์ด ์ :
pub struct A { inner: bool }
pub fn init(mut uninit: MaybeUninit<A>) -> A {
unsafe {
let mut previous: [u8; std::mem::size_of::<bool>()] = [0];
{
// Doesn't the temorary reference assert inner was in valid state before?
let inner_ptr: *mut _ = &mut (*uninit.as_mut_ptr()).inner;
ptr::copy(inner_ptr as *const [u8; 1], (&mut previous) as *mut _, 1);
// With the assert below, couldn't the compiler drop this?
std::ptr::write(inner_ptr, true);
}
// Assert Inner wasn't false before, so it must have been true already!
assert!(previous[0] != 0);
// initialized all fields, good to proceed.
uninit.into_inner()
}
}
๊ทธ๋ฌ๋ ์ปดํ์ผ๋ฌ๊ฐ &mut _
๋ฅผ ์ ํจํ ํํ์ด๋ผ๊ณ ๊ฐ์ ํ๋ฉด ptr::write
? ์ด์ค ์
์ ํต๊ณผํ๋ฉด ์ฝํ
์ธ ๋ 0
์๋์ง๋ง ๋ค๋ฅธ ์ ํจํ ๋ถ์ธ์ true/1
์
๋๋ค. ๋ฐ๋ผ์ ์ฐ๋ฆฌ๊ฐ ์ด์ค ์
์์ง๋ ์น๋ฉด ์ด๊ฒ์ด ์๋ํ์ง ์๋๋ค๊ณ ๊ฐ์ ํ ์ ์์ต๋๋ค. ์ด์ ์ ๊ฐ์ ์ก์ธ์คํ์ง ์์๊ธฐ ๋๋ฌธ์ ์ฌ์ ๋ ฌ ํ์์ด ๊ฐ์ผ๋ก ๋๋ ์ ์์ต๋๊น? llvm์ด ์ง๊ธ ์ด๊ฒ์ ์
์ฉํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ ์์ง๋ง ์ด๊ฒ์ด ๋ณด์ฅ ๋ ์ง ํ์ ํ ์ ์์ต๋๋ค.
๋์ ํจ์ ๋ด์์ ์์ฒด MaybeUninit
๋ฅผ ์์ฑํ๋ฉด ์ฝ๊ฐ ๋ค๋ฅธ ํ์ค์ ์ป๊ฒ๋ฉ๋๋ค. ๋์ ๋์ดํฐ ์์ ์ด์ค ์
์ด ํธ๋ฆฌ๊ฑฐ ๋ ์ ์๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ์๋ง๋ str::ptr::write
๊ฐ inner
๋ํ ์ ์ผํ ์ฐ๊ธฐ์ด๋ฏ๋ก previous
์์ ์ฝ๊ธฐ ์ ์ ์ด๋ฏธ ๋ฐ์ ํ์ด์ผํฉ๋๋ค. false
๋ณ๊ฒฝํ๋ฉด ์ด๋ป๊ฒ๋๋์ง ์ดํด๋ณด์ญ์์ค.
์ด ์ถ์ ๋ฌธ์ ๊ฐ์ด ์ง๋ฌธ์ ๊ฐ์ฅ ์ ํฉํ ์ฅ์๊ฐ ์๋ ์ ์์์ ์๊ณ ์์ต๋๋ค.
@RalfJung @scottjmaddox ๋ต๋ณ ๋ฐ๋ก ๋ด๊ฐ ์์ฒญํ ์ด์ ์
๋๋ค.
@HeroicKatora ๋ค, ๊ถ๊ธํฉ๋๋ค.
์๋ง๋ ์ฌ๋ฐ๋ฅธ ์ฃผ๋ฌธ์ผ๊น์?
struct Foo {bar: bool, baz: String}
fn main () {
let mut uninit_foo = MaybeUninit::<Foo>::uninitialized();
unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).bar) as *mut bool, true); }
unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).baz) as *mut String, "".to_string()); }
}
( ๋์ดํฐ )
ํฌ์ธํฐ ( &mut foo as *mut T
)์ ๋ํ ์ฐธ์กฐ๋ฅผ ์ฆ์ ์บ์คํ
ํ๋ฉด ์ค์ ๋ก ํฌ์ธํฐ๋ฅผ ๋ง๋๋ ๊ฒ์ผ๋ก ์ปดํ์ผ๋๋ค๋ Reddit (๋ถํํ๋ ๋ ์ด์ ์ฐพ์ ์ ์์)์ ๋ํ ์ฃผ์์ ์ฝ์์ต๋๋ค. ๊ทธ๋ฌ๋ *uninit_foo.as_mut_ptr()
๋นํธ๋ ๋๋ฅผ ๊ฑฑ์ ํฉ๋๋ค. ์ด์ ๊ฐ์ด ๋จ์ผํ ๋ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ํฌ์ธํฐ๋ฅผ ์ญ ์ฐธ์กฐํด๋ ๊ด์ฐฎ์ต๋๊น? ์ฐ๋ฆฌ๋ ์ค์ ๋ก ์๋ฌด๊ฒ๋ ์ฝ์ง ์์ง๋ง ์ปดํ์ผ๋ฌ๊ฐ ๊ทธ๊ฒ์ ์๊ณ ์๋์ง ์ฌ๋ถ๋ ๋ถ๋ช
ํ์ง ์์ต๋๋ค.
๋ด๊ฐ ์๊ฐ unaligned
์ ๋ณ์ข
ptr::write
์ด์ ์ผ๋ฐ์ ์ธ ์ฝ๋๊ฐ ํ์ํ ์ ์์ต๋๋ค MaybeUninit<T>
๋ชจ๋ ์ข
๋ฅ์ ํ๋๋ฅผ ์ ๋ ฌ ํ ๊ฒ ๊ฐ์?
write_unaligned
ํ์ ์์ต๋๋ค. ์ปดํ์ผ๋ฌ๋ ํ๋ ์ ๋ ฌ์ ์ฒ๋ฆฌํฉ๋๋ค. ์ปดํ์ผ๋ฌ๊ฐ &mut
๋ฅผ *mut
๋ก ๊ฐ์ ๋ณํํด์ผํ๋ค๊ณ ์ถ๋ก ํ ์ ์๊ธฐ ๋๋ฌธ์ as *mut bool
ํ์ํ์ง ์์ต๋๋ค. ์ด ์ ์ถ ๋ ๊ฐ์ ๊ฐ ์์ / ์ ํจํ ์ด์ ๋ผ๊ณ ์๊ฐํฉ๋๋ค. ๋ช
์์ ์ด๊ณ as *mut _
ํ๊ณ ์ถ๋ค๋ฉด ๊ทธ๊ฒ๋ ๊ด์ฐฎ์ ๊ฒ์
๋๋ค. ํฌ์ธํฐ๋ฅผ ๋ณ์์ ์ ์ฅํ๋ ค๋ฉด ํฌ์ธํฐ๋ก ๊ฐ์ ๋ณํํด์ผํฉ๋๋ค.
@scottjmaddox ๊ตฌ์กฐ์ฒด๊ฐ #[repr(packed)]
๊ฒฝ์ฐ์๋ ptr::write
์ฌ์ ํ ์์ ํฉ๋๊น? ptr::write
๋ ํฌ์ธํฐ๊ฐ ์ฌ๋ฐ๋ฅด๊ฒ ์ ๋ ฌ๋์ด์ผํ๋ค๊ณ ๋งํ๋ฏ๋ก ํจํน ๋ ํํ์ ์ฒ๋ฆฌํด์ผํ๋ ์ผ๋ฐ ์ฝ๋๋ฅผ ์์ฑํ๋ ๊ฒฝ์ฐ ptr::write_unaligned
๊ฐ ํ์ํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค (์์งํ ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ํ๋๊ฐ ์ ๋๋ก ์ ๋ ฌ๋์๋์ง ์ฌ๋ถ๋ฅผ ์ ์์๋ " MaybeUninit<T>
์ด์์ ์ผ๋ฐ ์ฝ๋"์ ์๋ฅผ ์๊ฐํ ์ ์์ต๋๋ค.
๋ฟก ๋นต๋จ
์ฆ, ํฌ์ธํฐ์ ๋ํ ์ฐธ์กฐ๋ฅผ ์ฆ์ ์บ์คํ (& mut foo as * mut T)ํ๋ฉด ์ค์ ๋ก ํฌ์ธํฐ๋ฅผ ๋ง๋๋ ๊ฒ์ผ๋ก ์ปดํ์ผ๋ฉ๋๋ค.
์ปดํ์ผ๋๋ ๋ด์ฉ์ ์ปดํ์ผ๋ฌ๊ฐ์ด ์ปดํ์ผ์ ์ํํ๋ ๋ฐ ์ฌ์ฉํ ์์๋ ์๋ฏธ ์ฒด๊ณ์ ๋ค๋ฆ
๋๋ค. IR์์ ์๋ํ์ง ์๋๋ผ๋ ์ปดํ์ผ๋ฌ์ ์ถ๊ฐ ๊ฐ์ ์ ์ฃผ์ฅํ๋ ๊ฒ๊ณผ ๊ฐ์ ์๋ฏธ ๋ก ์ ํจ๊ณผ๋ฅผ ๊ฐ์ง ์ ์์ต๋๋ค. @scottjmaddox ๋ ์ฌ๊ธฐ์ ์ด๋ค ์ฐ์ฐ์ด ์๋ํ๋์ง ์ ํํ์ง๋ง ์ง๋ฌธ์ ์ค์ํ ๋ถ๋ถ์ ref-to-ptr ๊ฐ์ ๋ณํ ์ด์ ๋ฐ ๋
๋ฆฝ์ ์ผ๋ก ๋ฐ์ํ๋ ๊ฐ๋ณ ์ฐธ์กฐ๋ฅผ ์์ฑํ๋ ๊ฒ์
๋๋ค. ๊ทธ๋ฐ ๋ค์ @mjbshaw ๋ ์ธ์๊ฐ ์ ์์๋ ์ผ๋ฐ ์ธ์ ์ธ ๊ฒฝ์ฐ ptr::write_unaligned
๊ฐ ํ์ํ ์ผ๋ฐ ์์ ์ ๋ํด ๊ธฐ์ ์ ์ผ๋ก ์ ํํฉ๋๋ค.
์ด ๊ธ์ ์ด๋์ ์ฝ์๋์ง ๊ธฐ์ต์ด ๋์ง ์์ง๋ง (nomicon? @RalfJung ์ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ ์ค ํ๋?) ์์ ํฌ์ธํฐ ์ญ ์ฐธ์กฐ, ์ฐธ์กฐ ๋ฐ ์ฐธ์กฐ๋ฅผ ํฌ์ธํฐ๋ก ์ฆ์ ๋ณํ ( ๊ฐ์ ๋๋ ์บ์คํ )์ ํน์ํ ๊ฒฝ์ฐ์ ๋๋ค.
์ด๊ธฐํ๋์ง ์์ ํ๋์ ์ฐ๋์ด ๋ณํ์ ์ด๋ค ๋ฐฉ์์ผ๋ก get_mut ()๋ณด๋ค ์ ์๋์ง ์์ ๋์์ ๋ ๋ํ๋ ๋๋ค. ptr :: write์ ๋ํ ์ฒซ ๋ฒ์งธ ์ธ์๊ฐ ํ๊ฐ๋๋ ์ฝ๋ ์ง์ ์์ ์ฝ๋๋ ๋ด๋ถ ํ๋์ & mut _์ ์์ฑํ์ผ๋ฉฐ, ๊ทธ๋ ์ง ์์ผ๋ฉด ์์ฑ ๋ ์ ์ฒด ๊ตฌ์กฐ์ฒด์ ๋ํ ์ฐธ์กฐ๋งํผ ์ ์๋์ง ์์์ผํฉ๋๋ค. ์ปดํ์ผ๋ฌ๋ ์ด๊ฒ์ด ์ด๋ฏธ ์ด๊ธฐํ ๋ ์ํ๋ผ๊ณ ๊ฐ์ ํ๋๋ก ํ์ฉ๋์ง ์์์ผํฉ๋๊น?
์์ฃผ ์ข์ ์ง๋ฌธ์
๋๋ค! ์ด๋ฌํ ์ฐ๋ ค๊ฐ ๋ด๊ฐ https://github.com/rust-lang/rfcs/pull/2582๋ฅผ ์ฐ ์ด์ ์ค ํ๋ &mut
์์ฑํ์ง ์๊ณ *mut
ํฉ๋๋ค.
@mjbshaw Touchรฉ. ์, ๊ตฌ์กฐ์ฒด๊ฐ ํจํน ๋ ๊ฐ๋ฅ์ฑ์ ๋ํด ์ณ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ๋ฐ๋ผ์ ptr::write_unaligned
ํฉ๋๋ค. ๋๋ ๋
น์ฌ์ง ์๋ ๊ตฌ์กฐ๋ฅผ ์์ง ์ฌ์ฉํ์ง ์์๊ธฐ ๋๋ฌธ์ ์ด์ ์๋ ๊ณ ๋ คํ์ง ์์์ต๋๋ค. ์์ง ๊ทธ๋ ์ง ์๋ค๋ฉด ์๋ง ์๋ ค์ง ๋ณดํ ์ผ ๊ฒ์
๋๋ค.
ํธ์ง : ๊ด๋ จ ์๋ฆฐ ๋ฆฐํธ๊ฐ ๋ณด์ด์ง ์์์ ๋ฌธ์ ๋ฅผ ์ ์ถํ์ต๋๋ค : https://github.com/rust-lang/rust-clippy/issues/3659
mem::zeroed
๋น์ถ์ฒ์ ํด์ ํ๊ธฐ ์ํด PR์ ์ด์์ต๋๋ค : https://github.com/rust-lang/rust/pull/57825
์์ ํ ๋ฉ๋ชจ๋ฆฌ ์ ๋กํ์ ๋ํ ๋
ผ์๋ฅผ ํฌํฌํ๊ธฐ ์ํด RFC repo์์ ๋ฌธ์ ๋ฅผ ์ด์์ต๋๋ค. ๋ฐ๋ผ์ ํด๋น ๋ฌธ์ ์ ๋ํ ๋ ๋์ ํด๊ฒฐ์ฑ
์ด ํ๋ณด๋๋ฉด ์ธ์ ๊ฐ mem::zeroed
๋ฅผ ํ๊ธฐ ํ ์ ์์ต๋๋ค : https://github.com / rust-lang / rfcs / issues / 2626
const uninitialized
, as_ptr
๋ฐ
๋๋จธ์ง API๋ณด๋ค as_mut_ptr
์์ ์์ต๋๊น? ๋์๊ฒ๋ ์ด๊ฒ๋ค์ด
์ง๊ธ์ฒ๋ผ ์์ ํ๋ฉ๋๋ค. ๋ํ ๋๋จธ์ง API๋
as_ptr
๋ฐ as_mut_ptr
์๋จ์ด๋ฏ๋ก ์ผ๋จ ์์ ํ๋๋ฉด
์์ ์ ์ธ API๋ฅผ ์ ๊ณตํ๋ crates.io์ MaybeUninitExt
ํน์ฑ์ด ์์ต๋๋ค.
๋ ๋ง์ ์ฌ๋ (์ : ์์ ์ ์ฉ ์ฌ์ฉ์)์ ํ์ฉํ๋๋ก ํ์ฌ ๋
ผ์๋๊ณ ์์ต๋๋ค.
๊ทธ๊ฒ์ ๋ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ์ญ์์ค.
์๋ฒ ๋๋์์๋ ์ ์ญ ํ ๋น ์ (๋ถ์์ ) ๋์ ์ ์ ๋ณ์๋ฅผ ์ฌ์ฉํฉ๋๋ค.
๋ง์ด . MaybeUninit
์์ด๋ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฅํ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
์์ ๋ ์ ์ ๋ณ์. ์ด๋ ๊ฒํ๋ฉด ๊ณ ์ ์ฉ๋์ ๋ฐฐ์น ํ ์ ์์ต๋๋ค.
์ ์ ๋ณ์์ ์ปฌ๋ ์
๋ฐ ๋ฐํ์์ ์ ์ ๋ณ์ ์ด๊ธฐํ
์ ๋ก ๋น์ฉ. ์ด API ํ์ ์งํฉ์ ์์ ํํ๋ฉด ์ด๋ฌํ ์ฌ์ฉ ์ฌ๋ก๊ฐ ์ฐจ๋จ ํด์ ๋ฉ๋๋ค.
์ด๊ฒ์ด ์๋ฒ ๋๋ ์ปค๋ฎค๋ํฐ์ ์ผ๋ง๋ ์ค์ํ์ง ์ดํดํ๊ธฐ ์ํด
[์ค๋ฌธ ์กฐ์ฌ] ์ง์ญ ์ฌํ์ ๊ทธ๋ค์ ๊ณ ์ถฉ๊ณผ ํ์์ ๋ํด ์ง๋ฌธํฉ๋๋ค. ์์ ํ
MaybeUninit
๋ ์์ ์ ์ํด ๋ ๋ฒ์งธ๋ก ๋ง์ ์์ฒญ์ ๋ฐ์์ต๋๋ค.
const fn
with trait bounds) ๊ทธ๋ฆฌ๊ณ ์ ๋ฐ์ ์ผ๋ก ์์ญ ๊ฐ ์ค 7 ์๋ฅผ ์ฐจ์งํ์ต๋๋ค.
rust-lang / * ๊ด๋ จ ์์ฒญ. WG ๋ด๋ถ ์ฌ์ ๋์ ์ฐ๋ฆฌ๋
์ํ๊ณ์ ๋ํ ์์๋๋ ์ํฅ์ผ๋ก ์ธํด ์ ์ฒด์ ์ผ๋ก 3 ์์ ์ฐ์ ์์๋ฅผ๋๊ณ ์์ต๋๋ค.
(๋ ๊ฐ์ธ์ ์ธ ๋ฉ๋ชจ์์ ์ ๋ ์๋ฒ ๋๋ ๋์์ฑ ํ๋ ์ ์ํฌ์ ์์ฑ์์
๋๋ค.
๋ด๋ถ์ ์ผ๋ก MaybeUninit
(๋ฉ๋ชจ๋ฆฌ ์ฌ์ฉ๋
์ฌ์ฉ์ ์ฝ๋๋ฅผ ์ ํ ๋ณ๊ฒฝํ์ง ์์ผ๋ฉด ์ ํ๋ฆฌ์ผ์ด์
์ 10-50 %๊น์ง ์ค์ผ ์ ์์ต๋๋ค. ๋๋
์ด๋ฅผ ์ํด ์ผ๊ฐ ์ ์ฉํ๋ฌผ ๊ธฐ๋ฅ์ ์ ๊ณต
์ผ๊ฐ ์ ์ฉ ์๋ฒ ๋๋ ๋ฐ ์ต๊ทผ์์ผ ์์ ์ ์ผ๋ก ๋ง๋ค์์ต๋๋ค.
์ผ๊ฐ ์ ์ฉ ๊ธฐ๋ฅ์ ์ ๊ณตํ๋ ๊ฒ์ ๋ด ์ฌ์ฉ์์๊ฒ ๋ณด๋ด๋ ์๋ชป๋ ๋ฉ์์ง์
๋๋ค.
๊ทธ๋์์ด API๊ฐ ์์ ํ๋๊ธฐ๋ฅผ ๊ฐ์ ํ ๊ธฐ๋ค๋ฆฌ๊ณ ์์ต๋๋ค.)
@japaric ๊ทธ๊ฒ์ ํ์คํ into_inner
๋ฐ ์น๊ตฌ๋ค ์ฃผ์์ ๋ช
๋ช
ํ ๋ก ์ ํผํ ๊ฒ์
๋๋ค. ๊ทธ๋ฌ๋ ๋๋ ์ฌ์ ํ ์๋ฏธ ๋ก ์ ๋
ผ์์ ๋ํด ์ฐ๋ คํ๊ณ ์๋ค. ์๋ฅผ ๋ค์ด ์ฌ๋๋ค์ด let r = &mut *foo.as_mut_ptr();
ํ๊ณ ๋ฐ๋ผ์ ๊ทธ๋ค์ด ์ ํจํ ์ฐธ์กฐ๋ฅผ ๊ฐ์ง๊ณ ์๋ค๊ณ ์ฃผ์ฅํ์ง๋ง ์ฐธ์กฐ์ ๋ํ ํ๋น์ฑ ์๊ตฌ ์ฌํญ์ด ๋ฌด์์ธ์ง ์์ง ํ์คํ์ง ์๋ค. ์ฆ, ์ฐ๋ฆฌ๋ ์ ํจํ์ง ์์ ๋ฐ์ดํฐ์ ๋ํ ์ฐธ์กฐ๊ฐ ์๋์ง ์ฌ๋ถ๋ ์์ง ํ์คํ์ง ์์ต๋๋ค. ๊ตฌ์ฒด์ ์ธ ์ :
let x: MaybeUninit<!> = MaybeUninit::uninitialized();
let r: &! = &*x.as_ptr() // is this UB?
์ด ํ ๋ก ์ ์ต๊ทผ UCG WG์์
์ ํฌ๋ง์ ํ๋์ ์ผ๊ด๋ "ํจํค์ง"์์ MaybeUninit
๋ฅผ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ์ ๋ํ ์ ์ ํ ์คํ ๋ฆฌ์ ํจ๊ป ์์ ํํ์ฌ ์ฌ๋๋ค์ด ์ด๋ฌํ ์ ๋ณด๋ฅผ ํ๋์ฉ ๊ณต๊ฐํ๋ ๋์ ํ ๋ฒ๋ง ๋ค์ ๋ฐฐ์ฐ๋ฉด๋๋ ๊ฒ์ด ์์ต๋๋ค. ์ผ๋ถ ๊ท์น์ ๋ณ๊ฒฝํด์ผ ํ ์๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ ์ข์ ์๊ฐ์ด ์๋ ์๋ ์๊ณ ํ์ ์ ์ง๋ฅผ ๊ฐ์ ํ๊ธฐ ์ํด ๋ฌด์ธ๊ฐ ๋ฅผ ์ป๋
๊ทธ๋ฌ๋ ์ด๋ ์ชฝ์ด๋ ์ฐ๋ฆฌ๊ฐ https://github.com/rust-lang/rfcs/pull/2582 ๋ฅผ ์๋ฝํ๊ธฐ ์ ์๋ ์๋ฌด๊ฒ๋ ์์ ํํด์๋ ์๋๋ค๊ณ ์๊ฐํ๋ฏ๋ก ์ ์ด๋ ๋ค์์ UB๊ฐ ์๋๋ผ๋ ๊ฒ์ ์ฌ๋๋ค์๊ฒ ํ์คํ๊ฒ ๋งํ ์ ์์ต๋๋ค.
let x: MaybeUninit<(!, u32)> = MaybeUninit::uninitialized();
let r1: *const ! = &(*x.as_ptr()).1; // immediately coerced to raw ptr, no UB
let r2 = &(*x.as_ptr()).1 as *const !; // immediately cast to raw ptr, no UB
(ํ์์ ๊ฐ์ด !
๋ ์ฌ๊ธฐ์์ ๋ถ์ ์ฒญ์ด์ด๊ณ ,์ด ๊ฒ์๋ฌผ์ ๋ชจ๋ ์์ ๋ bool
๋์ ์ฌ์ฉํ๋ค๋ฉด UB-wise์ ๋์ผํฉ๋๋ค.)
๋ด ํฌ๋ง์ MaybeUninit๋ฅผ ํ๋์ ์ผ๊ด๋ "ํจํค์ง"๋ก ์์ ํ์์ผ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ์ ๋ํ ์ ์ ํ ์คํ ๋ฆฌ๋ฅผ ์ ๊ณตํ์ฌ ์ฌ๋๋ค์ด ์ด๋ฌํ ๊ฒ๋ค์ ํ๋์ฉ ๊ณต๊ฐํ์ง ์๊ณ ํ ๋ฒ๋ง ๋ค์ ๋ฐฐ์ฐ๋ฉด๋๋ ๊ฒ์ด ์์ต๋๋ค. ๊ธธ์ ๋ฐ๋ผ ๋ช ๊ฐ์ง ๊ท์น์ ๋ณ๊ฒฝํฉ๋๋ค.
๋๋์ด ์ฃผ์ฅ์ด ๋งค์ฐ ๋งค๋ ฅ์ ์ด๋ผ๊ณ โโ์๊ฐํฉ๋๋ค.
๊ฐ์ฅ ์ฆ๊ฐ์ ์ธ ํ์๋ UB์์ด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฒ๋ฆฌํ๋ ๋ฐฉ๋ฒ์ ๋ํ ๋ช
ํํ ๋ฉ์์ง๋ฅผ ๊ฐ๋ ๊ฒ์
๋๋ค. ํ์ฌ ๋จ์ํ "์์ ํฌ์ธํฐ ์ฌ์ฉ ๋ฐ ptr::read_unaligned
๋ฐ ptr::write_unaligned
"์ธ ๊ฒฝ์ฐ ๊ด์ฐฎ์ต๋๋ค. ๊ทธ๋ฌ๋ ์ด๊ธฐํ๋์ง ์์ ์คํ ๊ฐ์ ๋ํ ์์ ํฌ์ธํฐ๋ฅผ ๊ฐ์ ธ์ค๊ณ ํ๋๋ฅผ ๊ตฌ์กฐํํ๋ ค๋ฉด ์ ์ ์ ๋ ๋ฐฉ๋ฒ์ด ํ์ํฉ๋๋ค. . rust-lang / rfcs # 2582 (์ผ๋ถ ๋ฌธ์ ํฌํจ)๋ ์ฆ๊ฐ์ ์ธ ์๊ตฌ๋ฅผ ์ถฉ์กฑํ๋ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ง MaybeUninit
๋ ๊ทธ๋ ์ง ์์ต๋๋ค.
@scottjmaddox ๊ทธ RFC๋ ์ด๋ป์ต๋๊น?ํ์ง๋ง MaybeUninit
์์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ (์คํ) ๋ฉ๋ชจ๋ฆฌ์ ์ ์ฉํฉ๋๊น?
@RalfJung ๋๋ ๋ค์์ด UB์ธ์ง ์ฌ๋ถ์ ๋ฌ๋ ค ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
let x: bool = mem::uninitialized();
ptr::write(&x as *mut bool, false);
assert_eq!(x, false);
๋ด ๋ฌต์์ ์ธ ๊ฐ์ ์ rust-lang / rfcs # 2582 ๊ฐ ์์ ์๋ฅผ ์ ํจํ๊ณ ์ ์ ์ ํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค. ๊ทธ๋ ์ง ์์ต๋๊น?
์๋ ํ์ธ์.
let x: bool = mem::uninitialized();
UB์ ๋๋ค. ์ฐธ์กฐ์๋ ๊ด๋ จ์ด ์์ต๋๋ค.
๋ด ๋ฌต์์ ์ธ ๊ฐ์ ์ rust-lang / rfcs # 2582๊ฐ ์์ ์๋ฅผ ์ ํจํ๊ณ ์ ์ ์ ํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค.
๋๋ ์ด๊ฒ์ ์์ ํ ๋๋๋ค. RFC๋ ์ฐธ์กฐ์ ๊ดํ ๊ฒ์ ๋๋ค. ์ ๊ทธ๊ฒ์ด ๋ถ์ธ์ ๋ํด ๋ญ๊ฐ ๋ณ๊ฒฝ๋์๋ค๊ณ ๊ฐ์ ํฉ๋๊น?
๋ฟก๋ฟก
UB์ ๋๋ค. ์ฐธ์กฐ์๋ ๊ด๋ จ์ด ์์ต๋๋ค.
mem :: uninitialized () ๋ฌธ์๋ ๋ค์๊ณผ ๊ฐ์ด ๋งํฉ๋๋ค.
Rust์ ์ ์์ ์ธ ๋ฉ๋ชจ๋ฆฌ ์ด๊ธฐํ ๊ฒ์ฌ๋ฅผ ์ฐํํ๋ฉด์ T ์ ํ์ ๊ฐ์ ์์ฑํ๋ ์ฒํ๋ฉด์ ์๋ฌด๊ฒ๋ํ์ง ์์ต๋๋ค.
๋ฌธ์์๋ T*
์ ๋ํ ๋ด์ฉ์ด ์์ต๋๋ค.
@kpp ๋ฌด์จ ๋ง์ํ๋ ค๋ ๊ฑด๊ฐ์? ํ ์ค์ ์ฝ๋์๋ *
๋ฐ &
๊ฐ ์์ต๋๋ค.
let x: bool = mem::uninitialized();
์ด ๋ผ์ธ์ UB๋ผ๊ณ ์ฃผ์ฅํ๋ ์ด์ ๋ ๋ฌด์์ ๋๊น?
bool
๋ ํญ์ true
๋๋ false
์ฌ์ผํ์ง๋ง ์ด๊ฒ์ ๊ทธ๋ ์ง ์์ต๋๋ค. https://github.com/rust-rfcs/unsafe-code-guidelines/blob/master/reference/src/glossary.md#validity -and-safety-invariant๋ ์ฐธ์กฐ
๊ทธ ์ง์ ์ ๋ํ @kpp๊ฐ ์ ์ํ๋ ํ๋ mem::uninitialized
๊ตฌ์ฒดํ _valid_์ ํ์ bool
.
ํ์ฌ ์ง์๋๋ ๋ชจ๋ ํ๋ซํผ์์ bool
์๋ true
(๋นํธ ํจํด : 0x1
) ๋ฐ false
(๋นํธ ํจํด : 0x0
)์ ๋ ๊ฐ์ _valid_ ๊ฐ๋ง ์์ต๋๋ค
mem::uninitialized
๋ ๋ชจ๋ ๋นํธ๊ฐ uninitialized
๊ฐ์ ๊ฐ๋ ๋นํธ ํจํด์ ์์ฑํฉ๋๋ค. ์ด ๋นํธ ํจํด์ 0x0
๋ 0x1
๊ฐ ์๋๋ฏ๋ก ๊ฒฐ๊ณผ bool
๋ _invalid_์ด๊ณ ๋์์ ์ ์๋์ง ์์ต๋๋ค.
๋์์ ์ ์ํ๋ ค๋ฉด true
, false
๋๋ uninitialized
์ธ ๊ฐ์ง ์ ํจํ ๊ฐ์ ์ง์ํ๋๋ก bool
์ ์ ์๋ฅผ ๋ณ๊ฒฝํด์ผํฉ๋๋ค. ํ์ง๋ง T-lang๊ณผ T- ์ปดํ์ผ๋ฌ๊ฐ ์ด๋ฏธ bool
๊ฐ C์ _Bool
์ ๋์ผํ๋ค๊ณ RFC๋ฅผํ๊ธฐ ๋๋ฌธ์ ๊ทธ๋ ๊ฒ ํ ์ ์์ต๋๋ค. bool
๋ C FFI์์ ์ด์ ๊ฐ๋ฅํ๊ฒ ์ฌ์ฉ).
ํ๋ฆผ์์ด C๋ Rust์ ๋๊ฐ์ ์ ํจ์ฑ ์ ์๋ฅผ ๊ฐ์ง๊ณ ์์ง ์์ง๋ง C "ํธ๋ฉ ํํ"์ ๋งค์ฐ ๊ฐ๊น์ต๋๋ค. ๊ฐ๋จํ ๋งํด์, ์ ์๋์ง ์์ ๋์์ ํธ์ถํ์ง ์๊ณ ๊ฐ์ด true
๋๋ false
์ ๋ํ๋ด์ง ์๋ _Bool
๋ก C์์ ํ ์์๋ ์์
์ ๋ง์ง ์์ต๋๋ค.
์ ํํ๋ค๋ฉด ๋ค์ ์์ ์ฝ๋๋ UB ์ฌ์ผํฉ๋๋ค.
let x: bool;
x = true;
๋ถ๋ช ํ ๊ทธ๋ ์ง ์์ต๋๋ค.
์ฌ๋ฐ๋ฅธ ๊ฒฝ์ฐ ๋ค์ ์์ ์ฝ๋๋ UB ์ฌ์ผํฉ๋๋ค.
let x: bool;
๋ x
์ uninitialized
๋นํธ ํจํด์ผ๋ก ์ด๊ธฐํํ์ง ์์ผ๋ฉฐ x
๋ฅผ ์ ํ ์ด๊ธฐํํ์ง ์์ต๋๋ค. x = true;
x
์ด๊ธฐํํฉ๋๋ค (์ฐธ๊ณ : x
๋ฅผ ์ฌ์ฉํ๊ธฐ ์ ์ ์ด๊ธฐํํ์ง ์์ผ๋ฉด ์ปดํ์ผ ์ค๋ฅ๊ฐ ๋ฐ์ํฉ๋๋ค).
์ด๋ ์ปจํ
์คํธ์ ๋ฐ๋ผ _Bool x;
x
๋ฅผ _indeterminate_ ๊ฐ์ผ๋ก ์ด๊ธฐํํ๋ C์ ๋์๊ณผ ๋ค๋ฆ
๋๋ค.
์๋์, ์ปดํ์ผ๋ฌ๋ x
๊ฐ ์ด๊ธฐํ๋์ง ์์ ์์ ์๊ณ ์์ต๋๋ค.
mem::uninitialized
์ ๋ฌธ์ ๋ ์ปดํ์ผ๋ฌ์ ์ด๊ธฐํ ์ถ์ ์ ๊ดํ ํ ๋ณ์๋ฅผ ์ด๊ธฐํํ๋ค๋ ๊ฒ ์
๋๋ค .
let x: bool;
๋ ์์ฒด์ ์ผ๋ก x
๋ฅผ ์ ์ฅํ ๊ณต๊ฐ์ ์์ฝํ์ง ์๊ณ ์ด๋ฆ ๋ง ์์ฝํฉ๋๋ค. let x = foo;
์ฝ๊ฐ์ ๊ณต๊ฐ์ ์์ฝํ๊ณ foo
์ฌ์ฉํ์ฌ ์ด๊ธฐํํฉ๋๋ค. let x: bool = mem::uninitialized();
๋งค์ฅ๋ 1 ๊ณต๊ฐ์ ๋ฐ์ดํธ x
ํ์ง๋ง์ด ์ด๊ธฐํ๋์ง ์์ ์, ๊ทธ๋ฆฌ๊ณ ๋ฌธ์ ์
๋๋ค.
์ด๊ฒ์ mem :: uninitialized์ ๋ํ ์ ๋ฌธํ์ ํจ๊ป mem :: uninitialized ๋ฐ intrinsics :: uninit ๋ชจ๋์ ๋ฌธ์ํ๋์ด์ผํ๋ ๋ค๋ฆฌ ๋์์ธ API๋ฅผ ์ดฌ์ํ๋ ๋งค์ฐ ์ฌ์ด ๋ฐฉ๋ฒ์
๋๋ค.
๋ํ mem :: uninitialized๋ฅผ ์ฌ์ฉํ์ฌ bool์ด ํฌํจ ๋ ๊ตฌ์กฐ์ฒด๋ฅผ ์ด๊ธฐํํ๋ ๊ฒ๋ UB์์ ์๋ฏธํฉ๋๊น?
@kpp
๋ํ mem :: uninitialized๋ฅผ ์ฌ์ฉํ์ฌ bool์ด ํฌํจ ๋ ๊ตฌ์กฐ์ฒด๋ฅผ ์ด๊ธฐํํ๋ ๊ฒ๋ UB์์ ์๋ฏธํฉ๋๊น?
์-๋น์ ์ด ์๋ง ์๊ณ ๊ณ์ ๊ฒ ์ง๋ง, mem::uninitialized
์ (๋) ๋ฐ์ ์ด์ ์๋ ๊ฒ์ด ์ฌ์ํ ์ผ์
๋๋ค. ์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ๋ ๊ฒ์ด ๊ฑฐ์ ๋ถ๊ฐ๋ฅํ๋ค๊ณ ๋งํ ์ ์์ต๋๋ค. ๊ทธ๋ ๊ธฐ ๋๋ฌธ์ ์ฐ๋ฆฌ๋ MaybeUninit
๋์ ์ฌ์ฉ์ ์ค๋จํ๋ ค๊ณ ํฉ๋๋ค. ์ด๊ฒ์ ์ฌ์ฉํ๊ธฐ์ ์ข ๋ ์ฅํฉํ์ง๋ง ์ ๋์จ์ด๊ธฐ ๋๋ฌธ์ ์ค์ ๋ก ๊ตฌ์ฒดํํ์ง ์๊ณ ๋ ๊ฐ์ "๋ถ๋ถ์ ์ผ๋ก"์ด๊ธฐํ ํ ์ ์๋ค๋ ์ด์ ์ด ์์ต๋๋ค. _invalid_ ์ํ์ ๊ฐ ์์ฒด. ๊ฐ์ into_inner()
ํธ์ถ ํ ๋๊น์ง๋ง ์์ ํ _valid_๋์ด์ผํฉ๋๋ค.
์ ํ ๋ฐ ์ ํ ์ทจ์ (๋น) ์ด๊ธฐํ์ ๋ํ nomicon ์น์
์ ์ฝ๋ ๋ฐ ๊ด์ฌ์ด์์ ์ ์์ต๋๋ค. https://doc.rust-lang.org/nomicon/checked-uninit.html let x: bool;
์ด๊ธฐํ ๋ฐฉ๋ฒ์ ๋ค๋ฃน๋๋ค. ์์ ํ Rust์์ ์๋ํฉ๋๋ค. ์ค๋ช
์ด ๋ช
ํํ์ง ์๊ฑฐ๋ ์ดํดํ ์์๋ ๊ฒ์ด ์์ผ๋ฉด ๋ฌธ์ ๋ฅผ ์์ฑํ์ญ์์ค. ๋ํ ๋๋ถ๋ถ์ ์ค๋ช
์ ์์ง RFC ํ๋ก์ธ์ค๋ฅผ ๊ฑฐ์น์ง ์์๊ธฐ ๋๋ฌธ์ "๋น ๊ท๋ฒ ์ "์ด๋ผ๋ ๊ฒ์ ๋ช
์ฌํ์ญ์์ค. ์์ ํ์ง ์์ ์ฝ๋ ์ง์นจ WG๋ ์ฌํด ์ธ์ ๊ฐ ํ์ฌ ํ๋์ ๋ฌธ์ํํ๊ณ ๋ณด์ฅํ๋ RFC๋ฅผ ์ ์ถํ๋ ค๊ณ ์๋ ํ ๊ฒ์
๋๋ค.
์ด๊ฒ์ mem :: uninitialized ๋ฐ intrinsics :: uninit๋ก ๋ฌธ์ํ๋์ด์ผํ๋ ๋ค๋ฆฌ ์ค๊ณ API๋ฅผ ์ดฌ์ํ๋ ๋งค์ฐ ์ฌ์ด ๋ฐฉ๋ฒ์ ๋๋ค.
๋ฌธ์ ๋ ํ์ฌ์ด ์์
์ ์ํํ๋ ์ฌ๋ฐ๋ฅธ ๋ฐฉ๋ฒ์ด ์๋ค๋ ๊ฒ์
๋๋ค. ์ด๊ฒ์ด ๋ฐ๋ก ์ด๋ฌํ ํจ์๊ฐ ๋ฌธ์๋ฅผ "์ฌ์ฉํ์ง ๋ง์ญ์์ค"๋ก ๋์ฒด ํ ์ ์๋๋ก MaybeUninit
์์ ํํ๊ธฐ ์ํด ๋
ธ๋ ฅํ๋ ์ด์ ์
๋๋ค.
๊ฐ์ ์ด๋ฐ ํ ๋ก ๋ฐ ๋ฌธ์ ์ด ๋๋ฅผ ๋์ฑ ๋์ @japaric ์ฐ๋ฆฌ๊ฐ ์ต๋ํ ๋นจ๋ฆฌ ๋ฌธ ๋ฐ์ผ๋ก ๋ฌด์ธ๊ฐ๋ฅผ ์ป์ด์ผํ๋ค ๋์ ๋ฉ์ดํฌ์ . ๊ธฐ๋ณธ์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ํ์๋กํ๋ ์ด ์ ์ด ์ฒดํฌ ๋ฐ์ค์ ๋ชฉ๋ก์ ์ณค๋ค ์ป์, ๋ด๊ฐ ๋งํ ๊ฒ์ ๋๋ค. ๊ทธ๋ฐ ๋ค์ ๋ช ๊ฐ์ง ๊ธฐ๋ณธ ํจํด์ ์ ๊ณตํ๊ธฐ์ ์ถฉ๋ถํฉ๋๋ค.
const uninitialized, as_ptr ๋ฐ
๋๋จธ์ง API๋ณด๋ค ์์ as_mut_ptr? ๋์๊ฒ๋ ์ด๊ฒ๋ค์ด
์ง๊ธ์ฒ๋ผ ์์ ํ๋ฉ๋๋ค.
์ด๊ฒ์ ๋ํด +1. ์ด ๊ธฐ๋ฅ์ ์์ ์ ์ผ๋ก ์ฌ์ฉํ ์ ์์ผ๋ฉด ์ข์ ๊ฒ์ ๋๋ค. ์ด๋ฅผ ํตํด ์ฌ๋๋ค์์ด ๊ธฐ๋ณธ ํ์ ์์ค API๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ค์ํ ์์ ์์ค (์ ์ฌ์ ์ผ๋ก ์์ ํ) API๋ฅผ ์คํ ํ ์ ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ API์ ์ด๋ฌํ ์ธก๋ฉด์ ๋ ผ๋์ ์ฌ์ง๊ฐ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
๋ํ get_ref
๋ฐ get_mut
์ (๋) ์์ ํ๋์ง ์๊ณ ์์ ํ ์ ๊ฑฐ ๋ ๊ฒ์ ์ ์ํ๊ณ ์ถ์ต๋๋ค. ์ผ๋ฐ์ ์ผ๋ก ์ฐธ์กฐ๋ก ์์
ํ๋ ๊ฒ์ด ์์ ํฌ์ธํฐ๋ก ์์
ํ๋ ๊ฒ๋ณด๋ค ์์ ํฉ๋๋ค (๋ฐ๋ผ์ ์ฌ๋๋ค์ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ํ์๋์ด ์์ด๋ as_ptr
๋ฐ as_mut_ptr
๋ณด๋ค ์ด๋ฌํ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ค๋ ์ ํน์๋ฐ์ ์ ์์ต๋๋ค),์ด ๊ฒฝ์ฐ์๋ UB๋ฅผ ์ ๋ฐํ ์์๋ ๋ฐ๋ฉด ํฌ์ธํฐ ๋ฉ์๋๋ ํ ์ ์๊ธฐ ๋๋ฌธ์ ์์ ํฌ์ธํฐ ๋ฉ์๋๋ณด๋ค ์๊ฒฉํ๊ฒ ์ํํฉ๋๋ค.
๊ท์น์ด "์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ์ฐธ์กฐ๋ฅผ ์์ฑํ์ง ์์"์ด๋ฉด ๋ด๋ถ์ ์ผ๋ก ์ํํ๋ ๋์ฐ๋ฏธ ๋ฉ์๋๋ฅผ ์ฌ์ฉํ๋ ๊ฒ๋ณด๋ค ๋ช ์ ์ ์ผ๋ก ๊ทธ๋ ๊ฒํด์ผ๋ง ๊ทธ๋ฌํ ์ฐธ์กฐ๋ฅผ ์์ฑ ํ ์ ์๋๋กํจ์ผ๋ก์จ ์ฌ๋๋ค์ด์ด ๊ท์น์ ์ค์ํ๋๋ก ๋์์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. .
https://github.com/rust-lang/rfcs/pull/2582 ๊ฐ์ ํ๋ฉด (1) (2)๊ฐ UB๋ ์๋๊ณ (1) ํฌ์ธํฐ์ ์ญ ์ฐธ์กฐ๋ ํฌํจ๋์ด ์์์ ์์ ํ ํ์ ํฉ๋๊น? ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํค๋?
(1) unsafe { ptr::write_unaligned(&mut ((*uninit_foo.as_mut_ptr()).bar) as *mut bool, true); }
(2) let x: bool = mem::uninitialized();
๊ทธ๋ ๋ค๋ฉด ๊ทธ ๋ ผ๋ฆฌ๋ ๋ฌด์์ ๋๊น (์ด ๋ฌธ์ ์ ๋ํ ํ ๋ก ์ ์ผ๋ถ๋ฅผ MaybeUninit์ ๋ํ ๋ฌธ์์ ๋ฃ์ ์ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค)? ๋๋ (1)์์ ์ญ ์ฐธ์กฐ ๋ ๊ฐ์ด ํญ์ "rvalue"๋ก ์ ์ง๋๊ณ "lvalue"๊ฐ๋์ง ์๊ณ "lvalue"๊ฐ๋์ง ์๋ ๋ฐ๋ฉด, (2)์์๋ ์ ํจํ์ง ์์ bool์ด "lvalue"๊ฐ๋์ด ์ค์ ๋ก ๋ฉ๋ชจ๋ฆฌ์์ ๊ตฌ์ฒดํ๋์ด์ผํ๊ธฐ ๋๋ฌธ์ ๊ฐ์ ๊ฒ์ ์ถ์ธกํ๊ณ ์์ต๋๋ค. (๋๋ ์ด๊ฒ์ด Rust์์ ์ ํํ ์ฉ์ด๊ฐ ๋ฌด์์ธ์ง ์ ๋ชจ๋ฅด๊ฒ ์ง๋ง C ++์ ์ฌ์ฉ๋๋ ์ฉ์ด๋ฅผ ๋ณด์์ต๋๋ค).
๊ทธ๋ฆฌ๊ณ ๋ค๋ฅธ ์ฌ๋๋ค์ ์ฒ์์ ์ด๋ฌํ ํผ๋์ ํผํ๊ธฐ ์ํด ํ๋์ ๋ํ ์์ ํฌ์ธํฐ๋ก ์ง์ ํ๊ฐ๋๋ ์์ ํฌ์ธํฐ์ ๋ํ ํ๋ ์ก์ธ์ค ๊ตฌ๋ฌธ์ ๋ํ RFC๋ฅผ ๋ง๋๋ ๊ฒ์ด ๊ฐ์น๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๊น?
๊ท์น์ด "์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ์ฐธ์กฐ๋ฅผ ์์ฑํ์ง ์์"์ธ ๊ฒฝ์ฐ
๋๋ ๊ทธ๊ฒ์ด ๊ท์น์ด๋์ด์ผํ๋ค๊ณ ์๊ฐํ์ง ์์ง๋ง, ๊ทธ๋ด ์๋ ์์ต๋๋ค. ์ง๊ธ UCG์์ ๋ ผ์๋๊ณ ์์ต๋๋ค.
์ฐ๋ฆฌ๋ (2)๊ฐ UB์ธ๋ฐ๋ (1)์ด UB๊ฐ ์๋๋ฉฐ (1)์ด ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํค๋ ํฌ์ธํฐ์ ์ญ ์ฐธ์กฐ๋ฅผ ํฌํจํ๋ค๋ ๊ฒ์ ์์ ํ ํ์ ํฉ๋๊น?
์ข์ ์ง๋ฌธ! ๊ทธ๋ฌ๋ ์, ์ฐ๋ฆฌ๋ ๊ธฐ๋ณธ์ ์ผ๋ก ํ์ํ์ง ์์ต๋๋ค. &mut foo as *mut bool
๋ฅผ &raw mut foo
์ ํ์ ์์ ์์ธ *mut bool
. ์ฌ๊ธฐ์๋ ์ฐธ์กฐ๊ฐ์๊ณ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๋ํ ์์ ptr ๋ง ์์ต๋๋ค. ํ์คํ ๊ด์ฐฎ์ต๋๋ค.
let x: bool = mem::uninitialized();
UB์ ๋๋ค. ์ฐธ์กฐ์๋ ๊ด๋ จ์ด ์์ต๋๋ค.
๋ด ๋ฌต์์ ์ธ ๊ฐ์ ์ rust-lang / rfcs # 2582 ๊ฐ ์์ ์๋ฅผ ์ ํจํ๊ณ ์ ์ ์ ํ ์ ์๋ค๋ ๊ฒ์ ๋๋ค.
๋๋ ์ด๊ฒ์ ์์ ํ ๋๋๋ค. RFC๋ ์ฐธ์กฐ์ ๊ดํ ๊ฒ์ ๋๋ค. ์ ๊ทธ๊ฒ์ด ๋ถ์ธ์ ๋ํด ๋ญ๊ฐ ๋ณ๊ฒฝ๋์๋ค๊ณ ๊ฐ์ ํฉ๋๊น?
@RalfJung ๋๋ ๊ทธ๊ฒ์ด ์ ํจํ bool ๊ฐ์ผ๋ก ์ฆ์ ๋ฎ์ด ์จ ์ก๊ธฐ ๋๋ฌธ์ ์ ์๋์ง ์์ ๊ฐ์ด ๊ด์ฐฐ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๊ทธ๊ฒ์ด UB๊ฐ ์๋๋ผ๊ณ ์๊ฐํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ํ์ง๋ง ๊ทธ๋ ์ง ์์ ๊ฒ ๊ฐ์์?
x์ ๊ฐ์ด Drop์ ๊ตฌํํ๋ ๋ ๋ณต์กํ ์์ ์ ๊ฒฝ์ฐ ๊ฐ์ ๋ฎ์ด ์ฐ๋ ค๋ฉด ์์ ํฌ์ธํฐ๊ฐ ํ์ํ๋ฏ๋ก UB๋ฅผ ํผํ๋ ค๋ฉด rfc 2582๊ฐ ํ์ํ๋ค๊ณ ์๊ฐํ์ต๋๋ค.
์ ์๋์ง ์์ ๊ฐ์ ์ ํจํ bool ๊ฐ์ผ๋ก ์ฆ์ ๋ฎ์ด ์จ์ ๊ด์ฐฐ ํ ์ ์๊ธฐ ๋๋ฌธ์ UB๊ฐ ์๋๋ผ๊ณ ์๊ฐํฉ๋๋ค. ํ์ง๋ง ๊ทธ๋ ์ง ์์ ๊ฒ ๊ฐ์์?
์๋ฏธ๋ก ์ ๋ฌธ๋ณ๋ก ๋ฌธ์ ์งํํฉ๋๋ค (MIR๋ณด๊ธฐ). ๋ชจ๋ ๋จ์ผ ์ง์ ์ ์๋ฏธ๊ฐ ์์ด์ผํฉ๋๋ค. let x: bool = mem::uninitialized();
๋ ์๋ชป๋ ๋ถ์ธ์ ๊ตฌ์ฒดํํ๊ณ ๋์ค์ ์ด๋ค ์ผ์ด ๋ฐ์ํ๋์ง๋ ์ค์ํ์ง ์์ต๋๋ค. ์๋ชป๋ ๋ถ์ธ์ ๊ตฌ์ฒดํํด์๋ ์๋ฉ๋๋ค.
x์ ๊ฐ์ด ์ ํจํ์ง ์๋ค๋ ๊ฒ์ ์ดํดํ์ง๋ง ์ ์๋์ง ์์ ๋์ ์ด ํ์ํฉ๋๊น? ์ผ๋ฐ์ ์ผ๋ก ์ด๋ป๊ฒ ๋ฌธ๋งฅ์์ ๋ฒ์ด๋ ์ ์๋์ง ์ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ํน์ ์์ ๋งฅ๋ฝ์์ ํ๋์ด ์ ์ ์๋์ง ์์์ต๋๊น? ๋๋ "์ ์๋์ง ์์ ํ๋"์ ์๋ฏธ๋ฅผ ์์ ํ ์ดํดํ์ง ๋ชปํ๋ค๊ณ ์๊ฐํ๋ค.
์ปดํ์ผ๋ฌ๊ฐ ํน์ ๋ถ๋ณ์ ์์กด ํ ์ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ์ด๋ค์ ํญ์ ์ ์ง๋๋ ๊ฒฝ์ฐ์๋ง ๋ถ๋ณ ์ ๋๋ค. ์์ธ๋ฅผ ์ถ๊ฐํ๊ธฐ ์์ํ๋ฉด ์๋ง์ด๋ฉ๋๋ค.
์๋ง๋ ๋น์ ์ "๊ฐ์ ๊ฒ์ฌ ํ๋ ๋ฐ๋ ํ๋น์ฑ ๋ถ๋ณ์ด ํ์ํ๋ค"๋ผ๋ ํ์์ ๊ธฐ๋ํ๊ณ ์์ ๊ฒ์
๋๋ค. ์ฌ๊ธฐ์์, "๊ฒ์ฌ"๋ bool
์์ ๊ทธ๊ฒ์ ์ฌ์ฉํ๋ ๊ฒ์
๋๋ค if
. ์ด๊ฒ์ ํฉ๋ฆฌ์ ์ธ ์ฌ์์ด์ง๋ง ๋ ์ ์ฉํฉ๋๋ค. ์ด์ ์ปดํ์ผ๋ฌ๋ ๊ฐ์ด ๋ถ๋ณ์ ๊ฐ์ ํ๊ธฐ ์ ์ ์ค์ ๋ก "๊ฒ์ฌ"๋์์์ ์ฆ๋ช
ํด์ผํฉ๋๋ค.
์ ์๋์ง ์์ ๋์์ด ํ์ํฉ๋๊น?
์ฐ๋ฆฌ๋ํ๊ณ ์ ์๋์ง ์์ ๋์์ด์๋ ๊ฒ์ ํ์ํ๋ค. ๋ฐ๋ผ์ ์ฌ๊ธฐ์ ๊ธฐ์ ์ ์ํ๋ ์ต์ ํ๋ฅผ ๊ฐ๋ฅํ๊ฒํ๊ณ (์์ ํ์ง ์์) ํ๋ก๊ทธ๋๋จธ์ ๊ธฐ๋์ ๋ถํฉํ๋ ์ ์๋์ง ์์ ๋์์ ์ ์๋ฅผ ์ฐพ๋ ๊ฒ์ ๋๋ค.
"์ ์๋์ง ์์ ํ๋"์ ์๋ฏธ๋ฅผ ์์ ํ ์ดํดํ์ง ๋ชปํฉ๋๋ค.
์ด์ ๋ํ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ผ์ง ๋ง ์งง์ ๋๋ต์ ์ ์๋์ง ์์ ๋์์ด ์ฌ์ฉ์์ ์ปดํ์ผ๋ฌ ๊ฐ์ ๊ณ์ฝ์ด๋ผ๋ ๊ฒ์ ๋๋ค. ๊ณ์ฝ์๋ ์ ์๋์ง ์์ ๋์์ด ๋ฐ์ํ์ง ์๋๋กํ๋ ๊ฒ์ด ์ฌ์ฉ์์ ์๋ฌด๋ผ๊ณ ๋งํฉ๋๋ค. ์ฆ๋ช ์๋ฌด์ ๋๋ค. "NULL ํฌ์ธํฐ๋ฅผ deeferencing a NULL pointer is UB"๋ "ํฌ์ธํฐ๊ฐ ์ญ ์ฐธ์กฐ ๋ ๋๋ง๋ค ํ๋ก๊ทธ๋๋จธ๋์ด ํฌ์ธํฐ๊ฐ NULL ์ผ ์ ์์์ ์ฆ๋ช ํด์ผํฉ๋๋ค"๋ผ๊ณ ๋งํ๋ ๊ฒ๊ณผ ๊ฐ์ต๋๋ค. ์ด๊ฒ์ ์ปดํ์ผ๋ฌ๊ฐ ์ฝ๋๋ฅผ ์ดํดํ๋ ๋ฐ ๋์์ด๋ฉ๋๋ค. ์๋ํ๋ฉด ํฌ์ธํฐ๊ฐ ์ญ ์ฐธ์กฐ ๋ ๋๋ง๋ค ์ปดํ์ผ๋ฌ๋ "์ํ! ์ฌ๊ธฐ์์ ํ๋ก๊ทธ๋๋จธ๋ ํฌ์ธํฐ๊ฐ NULL์ด ์๋๋ผ๋ ๊ฒ์ ์ฆ๋ช ํ์ผ๋ฏ๋ก ์ต์ ํ ๋ฐ ์ฝ๋ ์์ฑ์์ด ์ ๋ณด๋ฅผ ์ฌ์ฉํ ์ ์์ต๋๋ค. ๊ฐ์ฌํฉ๋๋ค. , ํ๋ก๊ทธ๋๋จธ! "
๊ณ์ฝ์ด ์ ํํ ๋งํ๋ ๊ฒ์ ํ๋ก๊ทธ๋๋ฐ ์ธ์ด์ ๋ฌ๋ ค ์์ต๋๋ค. ๋ฌผ๋ก ์ ์ฝ์ด ์์ต๋๋ค (์ : LLVM์ ์ํด ์ ์ฝ ๋จ). ์ฐ๋ฆฌ์ ๊ฒฝ์ฐ UCG๋ (์ธ์ด ๋ฐ ์ปดํ์ผ๋ฌ ํ์์๋ค์ ๋ฐ์ ๋ฐ๋ผ) ๊ณ์ฝ์ ๋ค์ ์ ์ด ํฌํจ๋๊ธฐ๋ฅผ ์ํ๋ค๊ณ ๋ฏฟ์ต๋๋ค. "rvalue๊ฐ ์์ฑ ๋ ๋๋ง๋ค ํ๋ก๊ทธ๋๋จธ๋์ด rvalue๊ฐ ํญ์ ํ๋น์ฑ ๋ถ๋ณ์ ๋ง์กฑ ์ํค์ญ์์ค. " ๊ณ์ฝ์์์ด ์กฐํญ์ ํฌํจํ๋๋ก ๊ฐ์ํ๋ ๋ฌผ๋ฆฌ ๋ฒ์น์ด๋ ์ปดํจํฐ๋ ์์ง๋ง ๋ค์ํ ์ ํ ์ฌ์ด์์ ํฉ๋ฆฌ์ ์ธ ํํ์ผ๋ก ๊ฐ์ฃผ๋ฉ๋๋ค.
ํนํ, ์ฐ๋ฆฌ๋ ์ฝํ ๊ณ์ฝ์ผ๋ก ์ ๋นํ๊ฒ ๋ฐฉ์ถ ํ ์์๋ LLVM์ ๋ํ ์ ๋ณด๋ฅผ ์ด๋ฏธ ๋ฐฉ์ถํฉ๋๋ค. ๋ฌผ๋ก LLVM์ ์๋ ค์ฃผ๋ ๋ด์ฉ์ ๋ณ๊ฒฝํ ์๋ ์์ต๋๋ค. ๊ทธ๋ฌ๋ "์์ ํ์ง ์์ ์ฝ๋๋ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ค๋ฃฐ ๋๋ง๋ค MaybeUninit
์ฌ์ฉํด์ผํฉ๋๋ค"์ " ๋ชจ๋ ์ฝ๋๋ฅผ ๋ ์ต์ ํ ํ ์ ์์ต๋๋ค"์ค์์ ์ ํํ๋ฉด ์ ์๊ฐ ๋ณด์
๋๋ค. ๋ ๋์ ์ ํ์ฒ๋ผ.
์๋ฅผ ๋ค์ด :
let x: bool = mem::uninitialized();
์ด ์ฝ๋๋ ์ค๋๋ rustc์ UB์
๋๋ค. mem::uninitialized::<bool>()
์ ๋ํ (์ต์ ํ๋์ง ์์) LLVM IR์ ๋ณด๋ฉด ๋ค์๊ณผ ๊ฐ์ ๊ฒฐ๊ณผ๋ฅผ ์ป์ ์ ์์ต๋๋ค.
; core::mem::uninitialized
; Function Attrs: inlinehint nonlazybind uwtable
define zeroext i1 @_ZN4core3mem13uninitialized17h6c99c480737239c2E() unnamed_addr #0 !dbg !5 {
start:
%tmp_ret = alloca i8, align 1
%0 = load i8, i8* %tmp_ret, align 1, !dbg !14, !range !15
%1 = trunc i8 %0 to i1, !dbg !14
br label %bb1, !dbg !14
bb1: ; preds = %start
ret i1 %1, !dbg !16
}
; snip
!15 = !{i8 0, i8 2}
๊ธฐ๋ณธ์ ์ผ๋ก์ด ํจ์๋ ์คํ์ 1 ๋ฐ์ดํธ๋ฅผ ํ ๋น ํ ๋ค์ ํด๋น ๋ฐ์ดํธ๋ฅผ๋ก๋ํฉ๋๋ค. ๊ทธ๋ฌ๋๋ก๋๋ !range
๋ก ํ์๋์ด LLVM์ ๋ฐ์ดํธ๊ฐ 0 <= x <2 ์ฌ์ด ์ฌ์ผํฉ๋๋ค. ์ฆ, 0 ๋๋ 1 ๋ง ๊ฐ๋ฅํจ์ ์๋ ค์ค๋๋ค. LLVM์ ์ด๊ฒ์ด ์ฐธ์ด๋ผ๊ณ ๊ฐ์ ํ๊ณ ๋์์ ์ ์๋์ง ์์ต๋๋ค. ์ด ์ ์ฝ ์กฐ๊ฑด์ ์๋ฐํ๋ ๊ฒฝ์ฐ.
์์ฝํ๋ฉด ๋ฌธ์ ๋ ์ด๊ธฐํ๋์ง ์์ ๋ณ์ ์์ฒด๊ฐ ์๋๋ผ ์ ํ ์ ์ฝ ์กฐ๊ฑด์ ์๋ฐํ๋ ๊ฐ์ ๋ณต์ฌํ๊ณ ์ด๋ํ๋ค๋ ์ฌ์ค์ ๋๋ค.
๋ฐ๋ํ์ ๊ฐ์ฌ๋๋ฆฝ๋๋ค! ์ด์ ํจ์ฌ ๋ ๋ช ํ ํด์ก์ต๋๋ค!
๋๋ "์ ์๋์ง ์์ ํ๋"์ ์๋ฏธ๋ฅผ ์์ ํ ์ดํดํ์ง ๋ชปํ๋ค๊ณ ์๊ฐํ๋ค.
์ด ์ผ๋ จ์ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ (๋ ๋ฒ์งธ ๊ฒ์๋ฌผ์ ๋ค์ ํฅ๋ฏธ๋กญ๊ณ ๋ฌด์์ด ์์ ๊ฐ ์์)์ ๋งค์ฐ ์ ์ฉํ๋ค๊ณ ์๊ฐํฉ๋๋ค. http://blog.llvm.org/2011/05/what-every-c-programmer-should-know .html
์ ๋ง ์ข์ ๋ฌธ์๊ฐ ํ์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ฌ๊ธฐ์์ ๋ณ๊ฒฝ ํ ์ฌํญ์ ๋ด๊ฐ ๋์ด ํ ์์๋ ์ฌ๋ฌ ๊ฐ์ง ์ด์ ์ ๋ด๊ฐ ํ ์์๋ ๋ค๋ฅธ ์ด์ ๋๋ฌธ์ ์ข์ ๊ฒ์ผ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ์ฌ๋ฐ๋ฅธ ์ฌ์ฉ (๋ฐ ๊ธฐํ ์์ ํ์ง ์์ ์ฌ์ฉ)์ ๋งค์ฐ ์ง๊ด์ ์ด์ง ์์ ์ ์์ต๋๋ค. Nomicon์๋ uninitialized
์ ๋ํ ์น์
์ด ์์ง๋ง (์๋ง๋์ด โโ์ ํ์ ๋ํด ์ค๋ช
ํ๊ธฐ ์ํด ์
๋ฐ์ดํธ ๋ ๊ฒ์) ๋ฌธ์ ์ ์ ์ฒด์ ์ธ ๋ณต์ก์ฑ์ ํํํ์ง ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
(์ ๋ ๊ทธ๋ฌํ ๋ฌธ์๋ฅผ ์์ฑํ๋ ๋ฐ ์์ํ๋ ๊ฒ์ด ์๋๋๋ค. ์ ๋ณด๋ค ์ด๊ฒ์ ๋ํด ๋ ๋ง์ด ์๋ ์ฌ๋์ ์ง๋ช ํฉ๋๋ค.)
https://github.com/rust-lang/rust/issues/55422#issuecomment -433943803์ ํฅ๋ฏธ๋ก์ด ์์ด๋์ด : into_inner
์ ๊ฐ์ ๋ฉ์๋๋ฅผ ํจ์๋ก ๋ณํ ํ ์ ์์ผ๋ฏ๋ก MaybeUninit::into_inner(foo)
๋ฅผ ์์ฑํด์ผํฉ๋๋ค. foo.into_inner()
MaybeUninit::into_inner(foo)
๋์ foo.into_inner()
-๋ฌด์จ ์ผ์ด ์ผ์ด๋๊ณ ์๋์ง ํจ์ฌ ๋ ๋ช
ํํ๊ฒ ๋ฌธ์ํํฉ๋๋ค.
https://github.com/rust-lang/rust/pull/58129์์ ์ผ๋ถ ๋ฌธ์๋ฅผ ์ถ๊ฐํ๊ณ &mut T
์์ set
&mut T
๋ฅผ ๋ฐํํ๊ณ into_inner
์ด๋ฆ์ into_initialized
๊ทธ ํ์ https://github.com/rust-lang/rust/pull/56138 ์ด ํด๊ฒฐ๋๋ฉด API์ ์ผ๋ถ ์์ ํ ์์
์ ์งํํ ์ ์์ต๋๋ค (์์ฑ์, as_ptr
, as_mut_ptr
, set
, into_initialized
).
MaybeUninit::zeroed()
๊ฐ const fn
๊ฐ ์๋ ์ด์ ๋ ๋ฌด์์
๋๊น? ( MaybeUninit::uninitialized()
์ const fn
)
ํธ์ง : ์ค์ ๋ก ์ผ๊ฐ Rust๋ฅผ ์ฌ์ฉํ์ฌ const fn
๋ง๋ค ์ ์์ต๋๊น?
MaybeUninit::zeroed()
๊ฐconst fn
๊ฐ ์๋ ์ด์ ๋ ๋ฌด์์ ๋๊น? (MaybeUninit::uninitialized()
์const fn
)
@gnzlbg ์๋ ํ์ง๋ง ๋ค์ ์ค ํ๋๊ฐ ํ์ํฉ๋๋ค.
init
๋ด์ฅ ํจ์๋ฅผ const fn
๋ง๋ญ๋๋ค. ์ด๊ฒ์ ๊ฐ๋ฅํ์ง๋ง Ralf๋ ๊ทธ๋ ๊ฒํ๋ ค๋ ๋ชจ๋ ์๋๋ฅผ ํ ๊ฒ์
๋๋ค . ๋๋std::ptr::write_bytes
๋ฅผ const fn
๋ง๋์ญ์์ค. ํ์ฌ ๋ ํ์ฉ๋์ง ์๋ const
์์ &mut
๋ฅผ ๋ฐ์์ผํฉ๋๋ค.๊ณง ์์ ํ๋ก ์ ํํ๋ ๊ฒ์ ๋ํด ๊ฐ์ฅ ๊ฑฑ์ ๋๋ ํ ๊ฐ์ง๋ ์ค์ ๋ก์ด ์ ํ์ ์ฌ์ฉํ๋ ์ฌ๋๋ค์ ํผ๋๋ฐฑ์ด ์ ํ ์๋ค๋ ๊ฒ์ ๋๋ค. ๋ชจ๋ ์ฌ๋๋ค์ด ์ฌ์ฉ์ ์์ํ๊ธฐ ์ ์ ์ด๊ฒ์ด ์์ ํ๋๊ธฐ๋ฅผ ๊ธฐ๋ค๋ฆฌ๋ ๊ฒ ๊ฐ์ต๋๋ค. ๊ทธ๊ฒ์ ์ฐ๋ฆฌ๊ฐ API ๋ฌธ์ ๋ฅผ ๋๋ฌด ๋ฆ๊ฒ ์๊ฒ ๋ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๋ฌธ์ ์ ๋๋ค.
@ rust-lang / libs ๋ฉ์๋ ๋์ ํจ์๋ฅผ ์ฌ์ฉํ๋ ์ผ๋ฐ์ ์ธ ์กฐ๊ฑด์ ๋ฌด์์
๋๊น? ์ฌ๋๋ค์ด MaybeUninit::as_ptr(...)
์ ๊ฐ์ด ์์ฑํด์ผ ํ ์ ์๋๋ก ์ฌ๊ธฐ์์๋ ์ผ๋ถ ์์
์ด ํจ์ ์ฌ์ผํ๋์ง ๊ถ๊ธํฉ๋๋ค. ๋๋ ์ด๊ฒ์ด ์ฝ์ ์ ์๊ฒ ๋ ์ฝ๋๋ฅผ ๋ ๋ ค ๋ฒ๋ฆด๊น ๊ฑฑ์ ๋๋ค.ํ์ง๋ง OTOH, ManuallyDrop
์ผ๋ถ ํจ์๋ ์ ํํ ์ด๊ฒ์ํ๋ค.
@RalfJung ๋ด ์ดํด๋ ์ฌ์ฉ์ ์ ํ์์ ๋ฉ์๋๋ฅผ ์จ๊ธฐ๋ ๊ฒ์ ํผํ๊ธฐ ์ํด ์ผ๋ฐ ๋งค๊ฐ ๋ณ์๋ฅผ ์ญ ์ฐธ์กฐํ๋ ํญ๋ชฉ์์ ๋ฉ์๋๋ฅผ ํผํ๋ค๋ ๊ฒ์
๋๋ค. ๋ฐ๋ผ์ ManuallyDrop::take
.
MaybeUninit<T>
๋ ๊ฒฐ์ฝ Deref<Target = T>
๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์ ์ฌ๊ธฐ์ ๋ฉ์๋๊ฐ ์ ์ ํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
ํผ๋๋ฐฑ์ ์์ฒญํ๋ฉด๋ฐ์ ๊ฒ์
๋๋ค. ์ต๊ทผ MaybeUninit
๋ฅผ ์ฌ์ฉํ์ฌ std
์์ ์๋ก์ด ๊ธฐ๋ฅ์ ๊ตฌํํ์ต๋๋ค.
get_mut
์๋ชป ์ฌ์ฉํ์ฌ ์ฐธ์กฐ์ ์์ ํฌ์ธํฐ๊ฐ ๋๋ฑํ๋ค๊ณ ์๊ฐํ์ต๋๋ค (928efca1์์ ์์ ๋จ). ๋๋ ์ด๋ฏธ ์์ ํ์ง ์์ ๋ธ๋ก์ ์์๊ธฐ ๋๋ฌธ์ ์ฒ์์๋ ๊ทธ ์ฐจ์ด๋ฅผ ์ค์ ๋ก ์์ ์ฐจ๋ฆฌ์ง ๋ชปํ์ต๋๋ค.const fn new()
์ ๋นํธ ํจํด์ด C ํค๋ ํ์ผ์ ๋ฐฐ์ด ์ด๋์
๋ผ์ด์ ์ ๋์ผํ ์ง ํ์ธํ๋ ๋ฐ ์ฌ์ฉํ๊ณ ์์ต๋๋ค. ๋๋ zeroed
๋ค์์ set
๋ฅผ ์ฌ์ฉํ์ฌ "do n't care"๋นํธ๊ฐ 0์ธ์ง ํ์ธํ๋ ค๊ณ ํฉ๋๋ค. ์ด๊ฒ์ด ์ฌ๋ฐ๋ฅธ ์ฌ์ฉ๋ฒ์ธ์ง ๋ชจ๋ฅด๊ฒ ์ง๋ง ์ ์๋ํ๋ ๊ฒ ๊ฐ์ต๋๋ค. .out.get_mut() as *mut _
! = out.as_mut_ptr()
์ด๋ฉด ๋งค์ฐ ํผ๋ ์ค๋ฌ์ธ ๊ฒ์
๋๋ค. ์ ๋ง C ++์ฒ๋ผ ๋ณด์
๋๋ค. ์ด๋ป๊ฒ ๋ ๊ณ ์ณ ์ก์ผ๋ฉด ์ข๊ฒ ์ด์.get_mut()
์ ์์ ์ ๋ฌด์์
๋๊น?
์ต๊ทผ์ ๋ด๊ฐ ๊ถ๊ธํ๋ ํ ๊ฐ์ง๋ MaybeUninit<T>
์ด T
์ ๋์ผํ ๋ ์ด์์์ ๊ฐ์ง๋๋ก ๋ณด์ฅ๋๋์ง ์ฌ๋ถ์ ์ด์ ์ ์ฌํ ๊ฒ์ ์ฌ์ฉํ์ฌ ํ์ ๊ฐ์ ๋ถ๋ถ์ ์ผ๋ก ์ด๊ธฐํ ํ ๋ค์์ด๋ฅผ ์์ ํ ์ด๊ธฐํ ๋ ๊ฐ, ์ : ( ์ ์ฒด ๋์ดํฐ )
struct Foo {
x: i32,
}
let mut partial: Box<MaybeUninit<Foo>> = Box::new(MaybeUninit::uninitialized());
let complete: Box<Foo> = unsafe {
ptr::write(&mut (*partial.as_mut_ptr()).x, 5);
mem::transmute(partial)
};
Miri์ ๋ฐ๋ฅด๋ฉด์ด ์์ ๊ฐ ์๋ํฉ๋๋ค (ํ์ง๋ง ๋์ผํ ๋ ์ด์์์ ๊ฐ์ง ์ ํ์ ์์๋ฅผ ๋ณํํ๋ ๊ฒ์ด ๊ทธ ์์ฒด๋ก ์ฌ์ด๋์ธ์ง ์ ์๋ ์์ง๋ง ์ง๊ธ์ ์๊ณ ์์ต๋๋ค).
@ Nemo157 into_inner
๊ฐ ์๋๋ฐ ์ ๋์ผํ ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์์ด ํ์ํฉ๋๊น?
@Pzixel ์ ์ด๊ธฐํ ํ ๊ฐ์ ๋ณต์ฌํ์ง ์์ผ๋ ค๋ฉด ์คํ์ ํ ๋น ๋ ๊ฒฝ์ฐ ์คํ ์ค๋ฒํ๋ก๋ฅผ ์ ๋ฐํ๋ 100MB ๋ฒํผ๋ฅผ ํฌํจํ๋ค๊ณ ๊ฐ์ ํฉ๋๋ค. ํ
์คํธ ์ผ์ด์ค๋ฅผ ์์ฑ ํ๋ ค๋ฉด ์คํ์ ๊ฑด๋๋ฆฌ์ง ์๊ณ ์ด๊ธฐํ๋์ง ์์ ์์๋ฅผ ํ ๋น ํ ์ ์๋๋ก ์ถ๊ฐ API fn uninit_boxed<T>() -> Box<MaybeUninit<T>>
๊ฐ ํ์ํฉ๋๋ค.
์ฌ์ฉ box
์ฌ์ฉํ๋ ๋์,์ด ์ํ์ฒ๋ผ ๊ทธ ๋ณํ์๋ฅผ ๋ณผ ์์๋ ์ด๊ธฐํ๋์ง ์์ ํ ๊ณต๊ฐ์ ํ ๋น ํ ์ ์๋๋ก ๊ตฌ๋ฌธ์ into_initialized
์คํ ์ค๋ฒ ํ๋ก์ฐ๊ฐ ๋ฐ์ํฉ๋๋ค ๋์ดํฐ
@ Nemo157 ๋ณต์ฌ๋ฅผ ์ต์ ํํ๊ธฐ ์ํด ์ปดํ์ผ๋ฌ๋ฅผ ๊ฐ์ ํ๋ ๊ฒ์ด ๋ ๋ซ์ต๋๊น? ์ด์จ๋ ๊ทธ๊ฒ์ํด์ผํ๋ค๊ณ ์๊ฐํ์ง๋ง, ์ปดํ์ผ์ด ๊ทธ๊ฒ์ ๋ณด์ฅํ๋ ์์ฑ์ด์์ ์ ์์ต๋๋ค.
ํํ
์ต๊ทผ์ ๋ด๊ฐ ๊ถ๊ธํ๋ ํ ๊ฐ์ง๋
MaybeUninit<T>
์ดT
์ ๋์ผํ ๋ ์ด์์์ ๊ฐ์ง๋๋ก ๋ณด์ฅ๋๋์ง ์ฌ๋ถ์ ์ด์ ์ ์ฌํ ๊ฒ์ ์ฌ์ฉํ์ฌ ํ์ ๊ฐ์ ๋ถ๋ถ์ ์ผ๋ก ์ด๊ธฐํ ํ ๋ค์์ด๋ฅผ ์์ ํ ์ด๊ธฐํ ๋ ๊ฐ,
๋๋์ด ๋ณด์ฅ๋์ด ์๋ค๊ณ ์๊ฐํ๊ณ ์์์ ์ฝ๋์ฃผ์์ ๋ถ๋ถ์ ํจ๊ป, ์ ํจํฉ๋๋ค :
ptr::write_unaligned
๊ฐ ํ์ํ ์ ์์ต๋๋ค.์ด๊ฒ์ ์์ ํ ๋ด๋ถ ๋น๋ ์ถ์ํ๋ฅผ ์ ๊ณตํ๊ธฐ ์ํด proc-macro์ ๊ฒฐํฉ ๋ ์ ์๋ค๊ณ ๋ฏฟ๊ธฐ ๋๋ฌธ์ ์ ๊ฐ ๊ด์ฌ์ ๊ฐ์ง๊ณ ์๋ ์ฌ์ฉ ์ฌ๋ก์ด๊ธฐ๋ํฉ๋๋ค.
@Pzixel ๋ฉ๋ชจ๋ฆฌ ๋ ์ด์์์ด ๊ฐ์ผ๋ฉด ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๊ตฌ์ฑํ ํ ์ ์ฒด ๋ฐ์ดํฐ ๊ตฌ์กฐ๋ฅผ ๋ณต์ฌํ๋ ๊ฒ์ ํผํ ์ ์์ต๋๋ค. ๋ฌผ๋ก ์ปดํ์ผ๋ฌ ๋ ๋ณต์ฌ๋ณธ์ ์ ๊ฑฐ ํ ์ ์์ผ๋ฉฐ ์์ ๊ตฌ์กฐ์์๋ ์ค์ํ์ง ์์ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ ํ์คํ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ด ์ข์ต๋๋ค.
@nicoburns ์, ์ง๊ธ ๋ณผ ์ ์์ต๋๋ค. #[same_layout]
๋๋ #[elide_copying]
๋๋ ๋ ๋ค ๋๋ transmute
์ ๋์ผํ ๋ฐฉ์์ผ๋ก ์๋ํ๋์ง ํ์ธํ๊ธฐ ์ํด ๋ ๋ค ๋๋ ๋ค๋ฅธ ์์ฑ๊ณผ ๊ฐ์ ์์ฑ์ด์์ ์ ์๋ค๊ณ ๋งํ๊ณ ์์ต๋๋ค #[elide_copying]
. ๋๋ ์ถ๊ฐ ๋ณต์ฌ๋ฅผ ํผํ๊ธฐ ์ํด into_constructed
๊ตฌํ์ ๋ณ๊ฒฝํ์ญ์์ค. ๋๋ ์ด๊ฒ์ด ๋ ์ด์์์ ๊ดํ ๋ฌธ์๋ฅผ ์ฝ๋ ํ๋ช
ํ ์ฌ๋๋ค๋ฟ๋ง ์๋๋ผ ๊ธฐ๋ณธ ๋์์ด ๋ ๊ฒ์ผ๋ก ๊ธฐ๋ํฉ๋๋ค. into_constructed
๋ฅผ ํธ์ถํ๋ ์ฝ๋๊ฐ ์๊ณ ์ถ๊ฐ ๋ณต์ฌ๋ณธ์ด ์์ง๋ง @ Nemo157 ์ transmute
๋ง ํธ์ถํ๋ฉด ๊ด์ฐฎ์ต๋๋ค. into_constructed
๊ฐ ๊ฐ์ ์ผ์ ํ ์์๋ ์ด์ ๊ฐ ์์ต๋๋ค.
out.get_mut() as *mut _
! =out.as_mut_ptr()
์ด๋ฉด ๋งค์ฐ ํผ๋ ์ค๋ฌ์ธ ๊ฒ์ ๋๋ค. ์ ๋ง C ++์ฒ๋ผ ๋ณด์ ๋๋ค. ์ด๋ป๊ฒ ๋ ๊ณ ์ณ ์ก์ผ๋ฉด ์ข๊ฒ ์ด์.
get_mut()
์ ์์ ์ ๋ฌด์์ ๋๊น?
๋๋ get_mut()
์ get_ref()
๊ฐ ์ ์ฌ์ ์ผ๋ก ํผ๋ ์ค๋ฝ๊ฑฐ๋ ์ ์๋์ง ์์ ๋์์ ์ค์๋ก ์ฝ๊ฒ ํธ์ถ ํ ์ ์๋๋ก ์์ ๋น์ทํ ์ ์ ๋ง๋ค์์ต๋๋ค ( as_ptr()
์ ๋ํ ๋ ์์ ํ ๋์์ด๋๋ ํ์์์ฃผ๊ธฐ ๋๋ฌธ์
๋๋ค. as_mut_ptr()
์ด์ง๋ง ์ค์ ๋ก๋ ์ด๋ฌํ ๋ฐฉ๋ฒ๋ณด๋ค ๋ ์์ ํฉ๋๋ค.)
@RalfJung์ด ์์ ํ๋ฅผ ์ ์ํ API์ ํ์ ์งํฉ์ ์ํ์ง ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค (https://www.ralfj.de/blog/2019/02/12/all-hands-recap.html ์ฐธ์กฐ).
@RalfJung ptr::freeze()
๋ฐฉ๋ฒ์ ๋ํ ๊ทํ์ ์ ์์ ๋ํด (https://www.ralfj.de/blog/2019/02/12/all-hands-recap.html) :
MaybeUninit
? ( MaybeUninit::frozen()
, MaybeUninit::abitrary()
๋๋ ์ ์ฌ)๋ฅผ ๊ตฌ์ฑํ๋ ์ ์ฌํ ๋ฐฉ๋ฒ์ ๊ฐ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ผ๊น์? ์ง๊ด์ ์ผ๋ก, ์ด๋ฌํ ๋ฉ๋ชจ๋ฆฌ๋ zeroed
์ ๊ฐ์ ๋ฉ๋ชจ๋ฆฌ์ ์ฐ๋ ๋น์ฉ์์ด ๋ง์ ์ฌ์ฉ ์ฌ๋ก์์ ์ง์ ์ผ๋ก ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋งํผ ์ฑ๋ฅ์ด ๋ฐ์ด๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ฌ๋๋ค์ด ์ค์ ๋ก ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํ์ํ๋ค๊ณ ํ์ ํ์ง ์๋ ํ uninitialized
์์ฑ์๋ณด๋ค ๊ถ์ฅ ๋ ์๋ ์์ต๋๋ค.
๊ทธ ์ ์์ "๊ณ ์ ๋"๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ "์ด๊ธฐํ๋์ง ์์"๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ ๋ก ํ์ํ ์ฌ์ฉ ์ฌ๋ก๋ ๋ฌด์์ ๋๊น?
ํ
1. I'd be very confused if `out.get_mut() as *mut _` != `out.as_mut_ptr()`. Looks really C++ish. I hope it would be fixed somehow.
์ ๋ช
ํ. ์ด๋ค ์ฌ๋๋ค์ด ์ด๊ฒ์ ์ ์ํ๋ ์ด์ ๋ &mut !
๋ฌด์ธ ์ ์ธํ๋ ๊ฒ์ด ์ ์ฉ ํ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค. ๊ทธ๋ฌ๋ MaybeUninit::<!>::uninitiailized().get_mut()
ํ์ฌ ์ด๋ฌํ ๊ฐ์ ๋ง๋ค์์ต๋๋ค. ์ด๊ฒ์ด as_mut_ptr
๊ฐ ๋ ์ํํ ์ด์ ์
๋๋ค. ์ฐธ์กฐ ์์ฑ์ ๋ฐฉ์งํฉ๋๋ค.
@nicoburns ( freeze
๋ ๋ด ์๊ฐ์ด ์๋๋ผ ๋จ์ง ํ ๋ก ์ ์ผ๋ถ ์๊ณ ์ ์์ ๋ง์ด ์ข์ํฉ๋๋ค.)
@RalfJung์ด ์์ ํ๋ฅผ ์ ์ํ API์ ํ์ ์งํฉ์
์ณ์. ๊ทธ๋ฆฌ๊ณ ์ค์ ๋ก ์ฐ๋ฆฌ๋ ๊ทธ๊ฒ๋ค์ ์ ํ ๊ฐ์ ธ์๋ ์๋ฉ๋๋ค.
MaybeUninit
? (MaybeUninit::frozen()
,MaybeUninit::abitrary()
๋๋ ์ ์ฌ)๋ฅผ ๊ตฌ์ฑํ๋ ์ ์ฌํ ๋ฐฉ๋ฒ์ ๊ฐ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ผ๊น์?
์! ๊ธฐ๋ณธ MaybeUninit
๊ฐ ์์ ๋๊ณ ptr::freeze
๊ฐ ๋์ฐฉํ๋ฉด ์ด๊ฒ์ ์ถ๊ฐ ํ ๊ฒ์ ์ ์ํ๋ ค๊ณ ํ์ต๋๋ค.
๊ทธ ์ ์์ "๊ณ ์ ๋"๋ฉ๋ชจ๋ฆฌ๊ฐ ์๋ "์ด๊ธฐํ๋์ง ์์"๋ฉ๋ชจ๋ฆฌ๊ฐ ์ค์ ๋ก ํ์ํ ์ฌ์ฉ ์ฌ๋ก๋ ๋ฌด์์ ๋๊น?
์ด๋ฅผ ์ํด์๋ ๋ ๋ง์ ์ฐ๊ตฌ์ ๋ฒค์น๋งํน์ด ํ์ํฉ๋๋ค. LLVM์ ๊ทธ๋ ์ง ์์ผ๋ฉด ํ ์์๋ ์ต์ ํ๋ฅผ ์ํํ์ง ์๊ธฐ ๋๋ฌธ์ ์ฑ๋ฅ์ด ์ ํ ๋ ์ ์์ต๋๋ค.
(์๊ฐ์ด ์๊ธฐ๋ฉด ๋ค๋ฅธ ๋๊ธ๋ก ๋ค์ ๋์์ค๊ฒ ์ต๋๋ค.)
@Pzixel ์ด ์ฌ์ ํ ๋น ๋ ๋ฉ๋ชจ๋ฆฌ์ ์ง์ ๊ฐ์ฒด๋ฅผ ๊ตฌ์ฑ ํ ์ ์๋ค๋ ๊ฒ์ ์ฌ์ํ ์ผ์ด ์๋๋๋ค. Rust๋ ์ด๋ฌํ ์์
์ ๊ตฌํํ๊ธฐ ์ํด ๋ ๊ฐ์ RFC๋ฅผ ํ์ฉํ์ง๋ง (4 ๋
์ !) ์ดํ ํ์ฉ๋์ง ์๊ณ ๋๋ถ๋ถ์ ๊ตฌํ์ด ์ ๊ฑฐ๋์์ต๋๋ค. (์์์ ์ฌ์ฉํ box
๊ตฌ๋ฌธ ์ ์ธ). ๋ ์์ธํ ์ ๋ณด๋ฅผ ์ํ๋ฉด ์ ๊ฑฐ์ ๋ํ i.rl.o ์ค๋ ๋ ๋ฅผ ์์ํ๋ ๊ฒ์ด ๊ฐ์ฅ ์ข์ต๋๋ค.
@nicoburns๊ฐ ์ธ๊ธํ๋ฏ์ด MaybeUninit
๋ ์ ์ฌ์ ์ผ๋ก ๋์ผํ ๋ฌธ์ ์ ๋ํ ๋ ์ธ์ฒด ๊ณตํ์ ์ธ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ธฐ๋ฐ ์๋ฃจ์
์ ๋น๋ฉ ๋ธ๋ก์ผ๋ก ์ฌ์ฉ๋ ์ ์์ผ๋ฉฐ, ๊ฐ๋
์ ์คํํ๊ณ ์ด๋ค ์ข
๋ฅ์ API๋ฅผ ํ์ธํ๋ ๋ฐฉ๋ฒ์ผ๋ก ๋งค์ฐ ์ ์ฉํฉ๋๋ค. ๊ฑด๋ฌผ์ ํ์ฉํฉ๋๋ค. ์ด๋ MaybeUninit
๊ฐ ๊ทธ๋ฌํ ์๋ฃจ์
์ ๊ตฌ์ถํ๋ ๋ฐ ํ์ํ ๋ณด์ฆ์ ์ ๊ณต ํ ์ ์๋์ง ์ฌ๋ถ์ ๋ฌ๋ ค ์์ต๋๋ค.
@ Nemo157 ํ๊ณณ ์์๋ง ์ฌ์ฉํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
@jethrogb ๊ฐ์ฌํฉ๋๋ค! ์ง๊ธ API๊ฐ ์ ์๋ํ๋ ๊ฒ ๊ฐ์ต๋๊น?
2. sys / sgx / rwlock.rs ์์
const fn new()
์ ๋นํธ ํจํด์ด C ํค๋ ํ์ผ์ ๋ฐฐ์ด ์ด๋์ ๋ผ์ด์ ์ ๋์ผํ ์ง ํ์ธํ๊ธฐ ์ํด ์ฌ์ฉํ๊ณ ์์ต๋๋ค.
์, ๊ทธ๊ฑด ๋ฏธ์ณค ๋ค์ ^^ํ์ง๋ง ์๋ํด์ผ ํ ๊ฒ ๊ฐ์์. ๊ฒฐ๊ตญ ์ธ์๊ฐ์๋ const fn
์ด๋ฏ๋ก ํญ์ ๊ฐ์ ๊ฒ์ ๋ฐํํด์ผํฉ๋๋ค ...
์ต๊ทผ์ ๋ด๊ฐ ๊ถ๊ธํ๋ ํ ๊ฐ์ง๋
MaybeUninit<T>
๊ฐT
์ ๋์ผํ ๋ ์ด์์์ ๊ฐ์ง๋๋ก ๋ณด์ฅ๋๋์ง ์ฌ๋ถ์ ์ด์ ์ ์ฌํ ๊ฒ์ ์ฌ์ฉํ์ฌ ํ์ ๊ฐ์ ๋ถ๋ถ์ ์ผ๋ก ์ด๊ธฐํ ํ ๋ค์์ด๋ฅผ ์์ ํ ์ด๊ธฐํ ๋ ๊ฐ
์ฐ๋ฆฌ๊ฐ ๊ฒฐ๊ตญ ์ถ๊ฐํด์ผ ํ ๋ชฉ๋ก์๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
fn into_initialized_box(Box<MaybeUninit<T>>) -> Box<T>
Box
๋ณํํฉ๋๋ค.
ํ์ง๋ง ๊ทธ๋ ์ต๋๋ค. ๊ทธ๋ฌํ ๋ณํ์ ํ์ฉํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ฌธ์์์ "๋น์ ์ ์ด๊ฒ์ ๋ค์๊ณผ ๊ฐ์ด ๋ณํ ํ ์ ์์ต๋๋ค"๋ผ๊ณ ๋งํ๋ ์ ๋ก๊ฐ ์์ต๋๊น? ์ผ๋ฐ์ ์ผ๋ก ์ฌ๋๋ค์ด ์์ ์ ๋ณํ์ ์ํํ๋ ๋์ ๋์ฐ๋ฏธ ๋ฉ์๋๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ์ ํธํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
- ์ฌ์ฉ์ค์ธ ์ ํ (ํนํ ์ผ๋ฐ ์ฝ๋)์ ๋ฐ๋ผ
ptr::write_unaligned
๊ฐ ํ์ํ ์ ์์ต๋๋ค.
์ผ๋ฐ ์ฝ๋์์๋ ํ๋์ ์ก์ธ์ค ํ ์ ์์ต๋๋ค. ํ๋์ ์ก์ธ์ค ํ ์ ์๋ค๋ฉด ์ผ๋ฐ์ ์ผ๋ก ๊ตฌ์กฐ์ฒด๊ฐ ํจํน๋์๋์ง, ๊ทธ๋ ์ง ์์ ๊ฒฝ์ฐ ptr::write
์ด๋ฉด ์ถฉ๋ถํฉ๋๋ค. (๊ทธ๊ฒ์ด ๋จ์ด์ง ์ ์๊ธฐ ๋๋ฌธ์ ํ ๋น์ ์ฌ์ฉํ์ง ๋ง์ญ์์ค! ์๊พธ ์์ด ๋ฒ๋ฆฝ๋๋ค ...)
ํ ์คํธ ์ผ์ด์ค๋ฅผ ์์ฑ ํ๋ ค๋ฉด ์คํ์ ๊ฑด๋๋ฆฌ์ง ์๊ณ ์ด๊ธฐํ๋์ง ์์ ์์๋ฅผ ํ ๋น ํ ์ ์๋๋ก ์ถ๊ฐ API
fn uninit_boxed<T>() -> Box<MaybeUninit<T>>
๊ฐ ํ์ํฉ๋๋ค.
๊ทธ๊ฒ์ ๋ฒ๊ทธ ์ด์ง๋ง, ๊ทธ ๋ฒ๊ทธ๋ ๊ณ ์น๊ธฐ ์ด๋ ค์ธ ์ ์๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ํ ๋ณ๋์ ์์ฑ์๋ฅผ ์ ๊ณตํ๋ ๊ฒ๋ ์ข์ ์๊ฐ ์ผ ์ ์์ต๋๋ค. ๊ทธ๋๋ ๊ตฌํ ๋ฐฉ๋ฒ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ ์๋ง๋ ์คํ ์ฌ๋กฏ์ ์ ๋กํ ํ ๋ค์ memcpying ๋ฑ์ ํผํ๋ zeroed_box
์ ๊ฐ์ ๊ฒ์ ์ํ ๊ฒ์
๋๋ค.์ด ๋ชจ๋ ๋ณต์ ๊ฐ ๋ง์์ ๋ค์ง ์์ต๋๋ค. : /
๊ทธ๋์ ์ ๋ ์ด๊ธฐ ์์ ํ ์ดํ / ๋ณ๋ ฌ๋ก ํ์ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ (๊ธฐ๋ณธ์ ์ผ๋ก Box
๋ฐ MaybeUninit
ํผํฉ)์ ๋ํ ์ฌ์ฉ ์ฌ๋ก๋ฅผ ๊ฐ์ง ์ผ๋ถ ์ฌ๋๋ค์ด ํจ๊ป ๋ชจ์ฌ ์ต์ ํฌ๊ธฐ๋ฅผ ๋์์ธ ํ ๊ฒ์ ์ ์ํฉ๋๋ค. ๊ฐ๋ฅํ API ํ์ฅ์
๋๋ค. @eddyb ๋ ์ด๊ฒ์ ๊ด์ฌ์ ํ๋ช
ํ์ต๋๋ค. ๊ทธ๊ฒ์ ๋ ์ด์ mem::uninitialized
๋ ์ด์ ์ฌ์ฉํ์ง ์๋ ๊ฒ๊ณผ ๊ด๋ จ์ด ์์ผ๋ฏ๋ก์ด (์ด๋ฏธ ๋๋ฌด ํฐ) ์ถ์ ๋ฌธ์ ๋ฅผ ์ ์ธํ๊ณ ๋ ์์ฒด ํ ๋ก ์ฅ์๋ฅผ ๊ฐ์ ธ์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋ด ์๊ฒฌ : ์ผ๋ฐ์ ์ผ๋ก MaybeUninit<T>
ํฉ๋๋ค. ๋๋ ํฐ ๋ถ๋ง์ด ์์ต๋๋ค. mem::uninitialized
๋ณด๋ค ํ ๊ฑด์ด ์ ์ต๋๋ค. const
new
๋ฐ uninitialized
๋ฉ์๋๊ฐ ์ข์ต๋๋ค. ๋๋ ๋ ๋ง์ ๋ฐฉ๋ฒ ์ค ์ํ๋ const๋ฅผํ์ง๋ง, ๋๋ ๊ทธ๊ฒ์ด ๋ง์ ์ด๋ค์ ์ดํด๊ฐ ํ์ ์ด์์ ๋ง๋ค์ด ์ง ์งํ const fn
๊ฐ ๋ ์ ์๊ธฐ ์ ์ ์ผ๋ฐ์ ์ผ๋ก const
.
T
๋ฐ MaybeUninit<T>
๋ํด "๋์ผํ ๋ ์ด์์"๋ณด๋ค ๋ ๊ฐ๋ ฅํ ๋ณด์ฆ์ ์ํฉ๋๋ค. ABI์ ํธํ๋๊ณ (ํจ๊ณผ์ ์ผ๋ก #[repr(transparent)]
์์ฑ์ด ๊ณต์ฉ์ฒด์ ์ ์ฉ๋ ์ ์์์ ์๊ณ ์์ง๋ง) FFI ์์ (์ฆ, T
์ด FFI ์์ ์ธ ๊ฒฝ์ฐ) ์ด๋ฉด MaybeUninit<T>
๋ FFI์ ์์ ํด์ผํฉ๋๋ค). (์ ์ ์ ์ผ๋ก, ์์ ํฌ๊ธฐ ํ๋๊ฐ ํ๋๋ง์๋ ๊ณต์ฉ์ฒด์ #[repr(transparent)]
๋ฅผ ์ฌ์ฉํ ์ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค (๊ตฌ์กฐ์ฒด์ ๋ํด ํ ์์๋ ๊ฒ์ฒ๋ผ))
์ ๋ ์ค์ ๋ก ํ๋ก์ ํธ์์ MaybeUninit<T>
์ ABI๋ฅผ ์ฌ์ฉํ์ฌ ์ต์ ํ๋ฅผ ์ง์ํฉ๋๋ค (์์ ํ์ง ์์ ๋ฐฉ์์ด ์๋๋ฏ๋ก ๋นํฉํ์ง ๋ง์ญ์์ค). ๊ด์ฌ์ด ์์ผ์๋ฉด ์์ธํ ์ค๋ช
ํด ์ฃผ์๋ฉด ๊ฐ์ฌํ๊ฒ ์ต๋๋ค.ํ์ง๋ง ์ง๊ธ์์ด ์ค๋ช
์ ๊ฐ๋ตํ๊ฒ ์ ์งํ๊ณ ์ธ๋ถ ์ฌํญ์ ์๋ตํ๊ฒ ์ต๋๋ค.
@mjbshaw ๊ฐ์ฌํฉ๋๋ค!
๋๋ ์ฐ๋ฆฌ๊ฐ ๊ตฌ์กฐ์ฒด์ ๋ํด ํ ์์๋ ๊ฒ์ฒ๋ผ ์์ ํฌ๊ธฐ์ ํ๋๊ฐ ํ๋๋ง์๋ ๊ณต์ฉ์ฒด์
#[repr(transparent)]
๋ฅผ ์ฌ์ฉํ ์ ์๊ธฐ๋ฅผ ๋ฐ๋๋๋ค.
ํด๋น ์์ฑ์ด ์กด์ฌํ๋ฉด MaybeUninit
์ถ๊ฐํ๋ ๊ฒ์ ์ฌ์ด ์ผ์ด ์๋๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ์ค์ด์ ๋ํ ๋
ผ๋ฆฌ๋ ์ด๋ฏธ rustc์ ๊ตฌํ๋์์ต๋๋ค ( MaybeUninit<T>
์ฌ์ค์์ด์ ABI - ํธํ T
,ํ์ง๋ง ์ฐ๋ฆฌ๊ฐ ๊ทธ๊ฒ์ ๋ณด์ฅํ์ง ์์ต๋๋ค.)
๋๊ตฐ๊ฐ๊ฐ RFC๋ฅผ ์์ฑํ๊ณ ์ดํด๋ณด๊ณ repr(transparent)
๊ณต์ฉ์ฒด์ ZST๊ฐ ์๋ ํ๋๊ฐ ํ๋๋ง ์๋์ง ํ์ธํ๋ ๋ช ๊ฐ์ง ๊ฒ์ฌ๋ฅผ ์ถ๊ฐํ๊ธฐ ๋งํ๋ฉด๋ฉ๋๋ค. ์๋ํด ๋ณด์๊ฒ ์ต๋๊น? :๋
๋๊ตฐ๊ฐ๊ฐ RFC๋ฅผ ์์ฑํ๊ณ ์ด๋ฅผ ํตํด ํ์ธํ๊ณ
repr(transparent)
๊ณต์ฉ์ฒด์ ZST๊ฐ ์๋ ํ๋๊ฐ ํ๋๋ง ์๋์ง ํ์ธํ๋ ๋ช ๊ฐ์ง ๊ฒ์ฌ๋ฅผ ์ถ๊ฐํ๊ธฐ ๋งํ๋ฉด๋ฉ๋๋ค. ์๋ํด ๋ณด์๊ฒ ์ต๋๊น? :๋
@RalfJung ๋ฌผ์ด ๋ณด๋ฉด๋ฐ์ ๊ฒ์ด๋ค!
์ฐธ์กฐ https://github.com/rust-lang/rust/pull/58468
์ด๋ ๊ฒํ๋ฉด maybe_uninit
์์ ํฉ๋ฆฌ์ ์ผ๋ก ์์ ํ ํ ์์๋ API ๋ง ๋จ๊ณ ๋๋จธ์ง๋ ๋ณ๋์ ๊ธฐ๋ฅ ๊ฒ์ดํธ๋ก ์ด๋ํฉ๋๋ค.
์ข์์, ์ค๋น PR์ด ๋ชจ๋ ๋์ฐฉํ๊ณ into_inner
๋ ์ฌ๋ผ์ก์ต๋๋ค.
๊ทธ๋ฌ๋ ์์ ํํ๊ธฐ ์ ์ https://github.com/rust-lang/rfcs/pull/2582 ๋ฅผ ์๋ฝํ๊ณ ์ถ์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ํ๋๋ณ๋ก ๊ตฌ์กฐ์ฒด๋ฅผ ์ด๊ธฐํํ๋ ๋ฐฉ๋ฒ์กฐ์ฐจ ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ทธ๊ฒ์ MaybeUninit
์ ์ฃผ์ ์ฌ์ฉ ์ฌ๋ก์ฒ๋ผ ๋ณด์
๋๋ค. FCP๋ฅผ ์์ํ๋ ๋ฐ ํ์ํ ๋ชจ๋ ์์๊ฐ ๊ฑฐ์ ์ค๋น ๋์์ต๋๋ค.
๋ฐฉ๊ธ MaybeUninit
๋ฅผ) ์ฌ์ฉํ๋๋ก ์ฝ๋๋ฅผ ๋ณํํ์ต๋๋ค. ๋ด๊ฐ ์ฌ์ฉํ ์๋ ๊ฝค ๋ช ๊ตฐ๋ฐ ์์ต๋๋ค take
์๋ ๋ฐฉ๋ฒ &mut self
๋ณด๋ค๋ self
. ํ์ฌ x.as_ptr().read()
์์ง๋ง x.take()
๋๋ x.take_initialized()
๊ฐ ํจ์ฌ ๋ ๋ช
ํ ํ ๊ฒ ๊ฐ์ต๋๋ค.
@Amanieu ์ด๊ฒ์ ๊ธฐ์กด์ into_inner
๋ฐฉ๋ฒ๊ณผ ๋งค์ฐ ์ ์ฌํฉ๋๋ค. ์ฌ๊ธฐ์ ์ค๋ณต์ ํผํ ์ ์์๊น์?
๋ฐฉ๋ฒ take
์ Option
๋ค๋ฅธ ์๋ฏธ๋ฅผ ๊ฐ์ง๊ณ ์๋ค. x.as_ptr().read()
x์ ๋ด๋ถ ๊ฐ์ ๋ณ๊ฒฝํ์ง ์๊ณ Option::take
๊ฐ์ ๋ฐ๊พธ์ญ์์ค. ์คํด์ ์์ง๊ฐ ์์ต๋๋ค.
@ qwerty19106 x.as_ptr().read()
on a MaybeUninit
_semantically_ ๊ฐ์ ๊บผ๋ด๊ณ ๋ํผ๋ฅผ ๋ค์ ์ด๊ธฐํํ์ง ์์ ์ํ๋ก ๋ก๋๋ค. ๋จ๊ฒจ์ง ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๊ฐ์ ธ์จ ๊ฐ๊ณผ ๋์ผํ ๋นํธ ํจํด์ ๊ฐ์ต๋๋ค. .
ํ์ฌ
x.as_ptr().read()
์์ง๋งx.take()
๋๋x.take_initialized()
๊ฐ ํจ์ฌ ๋ ๋ช ํ ํ ๊ฒ ๊ฐ์ต๋๋ค.
๊ถ๊ธํฉ๋๋ค. ์ด์ ๋ฅผ ์ค๋ช ํด ์ฃผ์๊ฒ ์ต๋๊น?
๋ด ์๊ฐ์ take
-like ๋ฉ์๋๋ take
๋ฐ into_initialized
๋ ๋ค์ ๋ฌ๋ฆฌ ๋ ๋ฒ๋ฐ๋ ๊ฒ์ ๋ฐฉ์งํ์ง ์๊ธฐ ๋๋ฌธ์ ๋ค์ ์คํด์ ์์ง๊ฐ ์์ต๋๋ค. ์ฌ์ค์ ๋ํ Copy
์ ํ (๋ฐ ๋ํ ์ฌ์ค Copy
๊ฐ์ ๊ฐ None as Option<Box<T>>
), ํ
์ดํฌ ๋ณด๋ด๊ณ ๋ ๋ฒ ์์ ํ ๊ด์ฐฎ์ต๋๋ค! ๋ฐ๋ผ์ take
์์ ๋น์ ๋ ์ ๊ด์ ์์ ์ค์ ๋ก ์ ์ง๋์ง ์์ต๋๋ค.
์ฐ๋ฆฌ๋ ๊ทธ๊ฒ์ read_initialized()
๋ผ๊ณ ๋ถ๋ฅผ ์ ์์ง๋ง, ๊ทธ ์์ ์์ ๊ทธ๊ฒ์ด ์ค์ ๋ก as_ptr().read()
๋ณด๋ค ๋ ๋ช
ํํ ์ง ์ง์งํ๊ฒ ๊ถ๊ธํฉ๋๋ค.
x.as_ptr().read()
on aMaybeUninit
_semantically_ _semantically_ ๋ฒ ์ผ์ ๊บผ๋ด๊ณ ๋ํผ๋ฅผ ๋ค์ ์ด๊ธฐํํ์ง ์์ ์ฑ๋ก ๋ก๋๋ค. ๋จ๊ฒจ์ง ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ๊ฐ์ ธ์จ ๊ฐ๊ณผ ๋์ผํ ๋นํธ ํจํด์ ๊ฐ์ต๋๋ค.
MaybeUninit
์๋ ์ค์ ๋ก ์ ์ฉํ ์๋ฏธ ๋ถ๋ณ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ ๊ทธ ์ง์ ์ ์์ ํ ๋์ํ๋์ง ํ์ ํ ์ ์์ต๋๋ค. TBH MaybeUninit
์ ๋ํ ์์
์ ์์ ์์
ํจ๊ณผ ์ด์ธ์ ๋ค๋ฅธ ๋ฐฉ์์ผ๋ก ๊ณ ๋ คํ๋ ๊ฒ์ด ์ ์ฉํ๋ค๊ณ ํ์ ํ์ง ์์ต๋๋ค.
@RalfJung ํ , ์๋ง๋ "์๋ฏธ ์"์ด ์๋ชป๋ ๋จ์ด ์ผ ์ ์์ต๋๋ค. ์ฌ์ฉ์๊ฐ ์ ํ์ ์ฌ์ฉํ๋ ๋ฐฉ๋ฒ๊ณผ ๊ด๋ จํ์ฌ ๊ฐ์ ์ฝ์ ํ ๊ฐ์ด ๋ค์ ์ด๊ธฐํ๋์ง ์๋๋ค๊ณ ๊ฐ์ ํด์ผํฉ๋๋ค (์ ํ์ด Copy
๋ผ๋ ๊ฒ์ ๊ตฌ์ฒด์ ์ผ๋ก ์๊ณ ์์ง ์๋ ํ).
์์ ์ด์ ํจ๊ณผ ๋ง ์ดํด๋ณด๋ฉด ๊ธฐ์ ์ ์ผ๋ก ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์ง ์๊ณ ๋ ๋ค๋ฅธ ์์ ํ์ง ์์ API์ ์์ ๋ถ๋ณ์ ์๋ฐํ ์์๋ ์ด์ ๊ฐ์ ์ด์ํ ์ํธ ์์ฉ ์ด ๋ฐ์ํฉ๋๋ค. (๋๋ Miri๊ฐ ์ฌ์ ํ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๊ธธ์ด๊ฐ 0 ์ธ ์ฝ๊ธฐ๋ฅผ ์ถ์ ํ๊ธฐ๋ฅผ ๋ฐ๋ผ๊ณ ์์์ง๋ง ๊ทธ๋ ๊ฒ ๋ณด์ด์ง๋ ์์์ต๋๋ค).
@RalfJung ๋ด ๋ชจ๋ ๊ฒฝ์ฐ์ ์ด๊ฒ์ static mut
์ ๊ฐ์ ๋ฃ์ ๋ค์ ๋์ค์ ๊บผ๋ด๋ ๊ฒ๊ณผ ๊ด๋ จ์ด ์์ต๋๋ค. ์ ์ ์ ์๋น ํ ์ ์๊ธฐ ๋๋ฌธ์ into_uninitialized
์ฌ์ฉํ ์ ์์ต๋๋ค.
@Amanieu ๋ด๊ฐ x.take_initialized()
๊ฐ x.as_ptr().read()
๋ณด๋ค ๋ ๋ช
ํํ๋ค๊ณ ์๊ฐํฉ๋๊น?
ํํ
๋๋ Miri๊ฐ ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๊ธธ์ด๊ฐ 0 ์ธ ์ฝ๊ธฐ๋ฅผ ๊ณ์ ์ถ์ ํ๊ธฐ๋ฅผ ๋ฐ๋ผ๊ณ ์์์ง๋ง ๊ทธ๋ ๊ฒ ๋ณด์ด์ง๋ ์์ต๋๋ค.
์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ์ ๊ธธ์ด๊ฐ 0 ์ธ ์ฝ๊ธฐ๋ ๊ฒฐ์ฝ UB๊ฐ ์๋๋๋ค. ๊ทธ๋ ๋ค๋ฉด Miri๊ฐ ์ ๊ทธ๊ฒ๋ค์ ๊ด์ฌ์ ๊ฐ์ง๊น์?
์์ ์ด์ ํจ๊ณผ ๋ง ์ดํด๋ณด๋ฉด ๊ธฐ์ ์ ์ผ๋ก ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์ง ์๊ณ ๋ ๋ค๋ฅธ ์์ ํ์ง ์์ API์ ์์ ๋ถ๋ณ์ ์๋ฐํ ์์๋ ์ด์ ๊ฐ์ ์ด์ํ ์ํธ ์์ฉ ์ด ๋ฐ์ํฉ๋๋ค.
๋ฌผ๋ก , ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฝ์ง ์๊ณ ๋ ์์ ๋ถ๋ณ์ ์๋ฐํ ์ ์์ต๋๋ค . ์ด๋ฅผ ์ํด MaybeUninit::zeroed().into_initialized()
๋ฅผ ์ฌ์ฉํ ์๋ ์์ต๋๋ค. ๋ฌธ์ ๊ฐ ๋ณด์ด์ง ์์ต๋๋ค.
์ฌ๊ธฐ์ "์ด์ํ ์ํธ ์์ฉ"์ ์์ฑ ํ ๊ถํ์ด์๋ ์ ํ์ ๋ ๊ฐ์ ์์ฑํ๋ค๋ ๊ฒ์
๋๋ค. ์ด๊ฒ์ ๋ชจ๋ Spartacus
์ ์์ ๋ถ๋ณ์ ๊ดํ ๊ฒ์ด๋ฉฐ ์ ํจ์ฑ ๋ถ๋ณ๊ณผ ๊ด๋ จ์ด ์์ต๋๋ค.
์ด๊ฒ์ด ์ ๊ฐ read_initialized()
๊ฐ ๋ ๋์ ์ผ์ ์ ๋ฌํ๋ค๊ณ ์๊ฐํ๋ ์ด์ ์
๋๋ค. ์ฐ๋ฆฌ๋ ๋ฐ์ดํฐ๋ฅผ ์ฝ๊ณ ์ ์ ํ๊ฒ ์ด๊ธฐํ๋์๋ค๊ณ ์ฃผ์ฅํฉ๋๋ค. ์ด๊ฒ์ MaybeUninit
์ฌ์ ํ ์ ์ฅ๋ ๋นํธ ํจํด์๋ ์ํฅ์ ๋ฏธ์น์ง ์์ต๋๋ค.
@RalfJung ์ ๋ ๋ณธ์ง์ ์ผ๋ก MaybeUninit
์ Option
ํ๊ณ ์์ง๋ง ํ๊ทธ๋ ์์ต๋๋ค. ์ฌ์ค, ์ ๋ ์ด์ ์ ์ ํํ์ด ๋ชฉ์ ์ ์ํด ํ๊ทธ์๋ ์ต์
์์๋ฅผ ์ฌ์ฉํ๊ณ ์์์ผ๋ฉฐ, ์ ๋์จ์์ ๊ฐ์ ์ถ์ถํ๋ take
๋ฉ์๋๊ฐ ์์ต๋๋ค.
@Amanieu @shepmaster https://github.com/rust-lang/rust/pull/58660์ read_initialized
์ ์ถ๊ฐํ์ต๋๋ค . ๋๋ ๊ทธ๊ฒ์ด take_initialized
๋ณด๋ค ๋ ๋์ ์ด๋ฆ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์ด๊ฒ์ด ๊ทํ์ ์๊ตฌ๋ฅผ ์ถฉ์กฑํฉ๋๊น?
๊ทธ PR์ ๋ํ ๋ค๋ฅธ ๋ฐฉ๋ฒ ์ค ์ผ๋ถ์ ์์ ๋ฅผ ์ถ๊ฐํฉ๋๋ค. ํผ๋๋ฐฑ ํ์ํฉ๋๋ค!
read_initialized
ํฉ๋๋ค.
๋ด๊ฐ ๊ทธ ์๋ฆฌ์์๋ ๋์ MaybeUninit<T>: Copy
์ด๋ฉด T: Copy
MaybeUninit<T>: Copy
T: Copy
. ๊ทธ๋ ๊ฒํ์ง ์์ ์ด์ ๊ฐ์๋ ๊ฒ ๊ฐ์ต๋๋ค.
ํ , get_initialized
๊ฐ ๋ ๋์ ์ด๋ฆ์ผ๊น์? ๊ฒฐ๊ตญ set
๋ณด์ํฉ๋๋ค.
์๋๋ฉด set
์ด๋ฆ์ write
๋ก ๋ฐ๊ฟ์ผํฉ๋๊น? ๊ทธ๊ฒ์ ๋ํ ์ผ๊ด์ฑ์ ์ป์ ๊ฒ์
๋๋ค.
MaybeUninit
๋ฅผ ์ฌ์ฉํ๋๋ก ์ฝ๋๋ฅผ ๋ณํํ๊ณ ์๋๋ฐ ์ด๊ธฐํ๋์ง ์์ ์ฌ๋ผ์ด์ค๋ก ์์
ํ๋ ๊ฒ์ด ๋งค์ฐ ๋น์ธ๊ฐ์ ์ด๋ผ๋ ์ฌ์ค์ ๋ฐ๊ฒฌํ์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ๊ธฐ๋ฅ์ด ์์ผ๋ฉด ๊ฐ์ ๋ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
&mut [T]
๋ฅผ &mut [MaybeUninit<T>]
์์ ํ๊ฒ ๋ณํํฉ๋๋ค. ์ด๋ ๊ฒํ๋ฉด &out
๋งค๊ฐ ๋ณ์๊ฐ &mut [MaybeUninit<T>]
์ฌ์ฉํ์ฌ ์๋ฎฌ๋ ์ด์
๋ ์ ์์ต๋๋ค. ์๋ฅผ ๋ค์ด read
์ ์ฉํฉ๋๋ค.&mut [MaybeUninit<T>]
์์ &mut [T]
๋ก์ ์์ ํ์ง ์์ ๋ณํ (๊ทธ๋ฆฌ๊ณ &[T]
), ์ฌ๋ผ์ด์ค์ ๋ชจ๋ ์์์์ .set
๋ฅผ ํธ์ถํ๋ฉด ์ฌ์ฉ๋ฉ๋๋ค.๋ด๊ฐ ๊ฐ์ง API๋ ๋ค์๊ณผ ๊ฐ์ต๋๋ค.
// The returned slice is truncated to the number of elements actually read.
fn read<T>(out: &mut [MaybeUninit<T>]) -> Result<&mut [T]>;
์ฌ๋ผ์ด์ค ์์
์ด ํ์ฌ ์ธ์ฒด ๊ณตํ์ ์ด์ง ์๋ค๋ ๋ฐ ๋์ํฉ๋๋ค. ๊ทธ๋์ first_ptr
๋ฐ first_ptr_mut
. ๊ทธ๋ฌ๋ ๊ทธ๊ฒ์ ์๋ง๋ ์ต๊ณ ์ API์๋ ๊ฑฐ๋ฆฌ๊ฐ ๋ฉ๋ค.
๊ทธ๋ฌ๋ ๋จผ์ "ํต์ฌ API"๋ฅผ ์ ๊ณตํ๋ ๋ฐ ์ง์ค ํ ๋ค์ ์ฌ๋ผ์ด์ค (๋ฐ Box
)์์ ์ํธ ์์ฉ์ ์ดํด๋ณผ ์ ์์ผ๋ฉด ์ข์ต๋๋ค.
๋๋ ์ด๋ฆ ๋ณ๊ฒฝ์ ์๊ฐ์ฒ๋ผ set
์ write
, ์ผ๊ด์ฑ์ ์ ๊ณตํ๋ ptr::write
.
๊ฐ์ ๋งฅ๋ฝ์์ read_initialized
read
๋ณด๋ค ์ ๋ง ๋ซ์ต๋๊น? ์จ๊ฒจ์ง๋ ์ฐ๋ฐ์ ์ธ ์ฌ์ฉ์ ๋ํ ์ฐ๋ ค๊ฐ ์๋ค๋ฉด ์๋ง๋ ๋ฉ์๋ ๋์ ํจ์๋ก ๋ง๋์ญ์์ค. ์ : MaybeUninit::read(&mut v)
? write
, ์ฆ ์ผ๊ด์ฑ์ ์ํด MaybeUninit::write(&mut v)
์ ๋ํด์๋ ๋์ผํ๊ฒ ์ํ ํ ์ ์์ต๋๋ค. ๋ ๊ฒฝ์ฐ ๋ชจ๋ ์ฌ์ฉ ์ฑ๊ณผ ๋ช
์ ์ฑ ์ฌ์ด์ ์์ถฉ ๊ด๊ณ์ด๋ฉฐ, ํ ๊ฒฝ์ฐ์์ ๋ช
์ ์ฑ์ด ๋ ๋์ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋๋ฉด ๋ค๋ฅธ ๊ฒฝ์ฐ์๋ ์ ๋ค๋ฅธ์ง ์ ์ ์์ต๋๋ค.
๊ทธ๋ผ์๋ ๋ถ๊ตฌํ๊ณ ์ด๋ฌํ API๊ฐ ํด๊ฒฐ ๋ ๋๊น์ง ์ต์ํ์ API (์ : new
, uninitialized
, zeroed
, as_ptr
, as_mut_ptr
์ฌ์ฉํ์ฌ ์์ ํ๋ฅผ ๊ฐ๋ ฅํ๊ฒ ์ง์ํฉ๋๋ค get_ref
๋ฐ get_mut
.
get_ref
๋ฐget_mut
์์ต๋๋ค.
https://github.com/rust-rfcs/unsafe-code-guidelines/issues/77 ์ ํด๊ฒฐ ํ ํ์ ๋ง โโ์์ ํ๋์ด์ผํ๋ฉฐ ์๊ฐ์ด ๊ฑธ๋ฆด ์์๋ ๊ฒ ๊ฐ์ต๋๋ค ...
์ต์ํ์ API๋ก ์์ ํ, ์ฆ
new
,uninitialized
,zeroed
,as_ptr
,as_mut_ptr
๋ด ๊ณํ์ into_initialized
, set
/ write
, ๊ทธ๋ฆฌ๊ณ read_initialized
์ด ์ต์ ์ธํธ์ ์ผ๋ถ๊ฐ๋์์ต๋๋ค. ํ์ง๋ง ์ ๋ ๊น์? set
/ write
๋ฐ read_initialized
๋ ๋๋จธ์ง๋ก ์ฝ๊ฒ ๊ตฌํํ ์ ์์ผ๋ฏ๋ก ์ด์ ์ฒซ ๋ฒ์งธ ๋ฐฐ์น์์ ์์ ํํ์ง ์๋์ชฝ์ผ๋ก ๊ธฐ์ธ๊ณ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ฒ์๋ถํฐ into_initialized
์ ๊ฐ์ ๊ฒ์ ๊ฐ๋ ๊ฒ์ด ๋ฐ๋์งํฉ๋๋ค, IMO.
๋ฉ์๋ ๋์ ํจ์๋ก ๋ง๋ค ์ ์์ต๋๋ค. ์ :
MaybeUninit::read(&mut v)
?write
, ์ฆ ์ผ๊ด์ฑ์ ์ํดMaybeUninit::write(&mut v)
์ ๋ํด์๋ ๋์ผํ๊ฒ ์ํ ํ ์ ์์ต๋๋ค.
์ด์ ์ ์ฌ๊ธฐ์์ ๋
ผ์ํ ๋ด์ฉ์์ Deref
์ธ์คํด์ค ๋ฌธ์ ๋ฅผ ๋ฐฉ์งํ๊ธฐ ์ํด ๋ช
์ ์ ํจ์ ์ ๊ทผ ๋ฐฉ์ ๋ง ์ฌ์ฉํฉ๋๋ค. ๋ฉ์๋ ๋์ ํจ์๋ฅผ ์ฌ์ฉํ๋ ๋ ๋ค๋ฅธ ์ด์ ๋๋ฌธ์ ์ฐ์ ์์๋ฅผ ๋์
ํด์๋ ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค.
read_initialized
read
๋ณด๋ค ์ ๋ง ๋ซ์ต๋๊น?
์ข์ ์ง๋ฌธ! ๋ชจ๋ฅด๊ฒ ์ด์. ์ด๊ฒ์ into_initialized
์์ ๋์นญ์์ํ ๊ฒ์
๋๋ค. ๊ทธ๋ฌ๋ into_inner
๋ ํธ์ถ ๋ ์ ํ์ ๊ฐ์๋ฅผ ์์ ์์๋ ์ผ๋ฐ์ ์ธ ๋ฐฉ๋ฒ์ด๋ฉฐ read
๋ ํจ์ฌ ๋ ์ผ๋ฐ์ ์
๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ด์ฉ๋ฉด ๊ทธ๊ฒ์ ๋จ์งํด์ผ initialized
๋์ into_initialized
? ๋๋ฌด ๋ง์ ์ต์
...
์ด์ ์ ๋ ผ์ ๋ ๋ด์ฉ์์
Deref
์ธ์คํด์ค ๋ฌธ์ ๋ฅผ ํผํ๊ธฐ ์ํด ๋ช ์ ์ ํจ์ ์ ๊ทผ ๋ฐฉ์ ๋ง ์ฌ์ฉํฉ๋๋ค. ๋ฉ์๋ ๋์ ํจ์๋ฅผ ์ฌ์ฉํ๋ ๋ ๋ค๋ฅธ ์ด์ ๋๋ฌธ์ ์ฐ์ ์์๋ฅผ ๋์ ํด์๋ ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค.
ptr::read
๋ฐ ptr::write
๋ ๋ฉ์๋๊ฐ ์๋๋ผ ํจ์์
๋๋ค. ๋ฐ๋ผ์ ์ฐ์ ์์๋ ์ด๋ฏธ MaybeUninit::read
๋ฐ MaybeUninit::write
์์ต๋๋ค.
ํธ์ง : ์ข์, ๋ถ๋ช
ํ ๊ฑฐ๊ธฐ์ read
๋ฐ write
๋๋ฌด ํฌ์ธํฐ์ ๋ํ ๋ฐฉ๋ฒ์ ... ๊ฒฐ์ฝ ์ ์ ... ์ฌ๋๋ค์ ๋ฐ๊ฒฌํ์ง๋ง ๊ทธ๋ค์ ์ง์ง๋ก ์ดํด๊ฐ๋์ง ์์ต๋๋ค ํฌ์ธํฐ, ์๋น MaybeUninit
.
๋๋ฌด ๋ง์ ์ต์ ...
๋์ํฉ๋๋ค. ๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋ํด ๋ ๋ง์ ์์ ๊ฑฐ ํ๋ฆผ์ด์์ ๋๊น์ง new
, uninitialized
, zeroed
, as_ptr
, as_mut_ptr
์์ ํ ํ ์ค๋น๊ฐ๋์์ต๋๋ค.
ptr::read
๋ฐptr::write
๋ ๋ฉ์๋๊ฐ ์๋๋ผ ํจ์์ ๋๋ค. ๋ฐ๋ผ์ ์ฐ์ ์์๊ฐ ์ด๋ฏธ ์ค์ ๋์ด ์์ต๋๋ค.
๊ทธ๋ค์ ๋ฐ์ดํฐ ๊ตฌ์กฐ์ ์ผ๋ถ๊ฐ ์๋๋ฉฐ ๋ฌผ๋ก ๋ ๋ฆฝ ํจ์์ ๋๋ค. ๊ทธ๋ฆฌ๊ณ ๋น์ ์ด ๋งํ๋ฏ์ด ๊ทธ๊ฒ๋ค์ ์ค๋๋ ์๋ ๋ฐฉ๋ฒ์ผ๋ก ์กด์ฌํฉ๋๋ค.
๊ทธ๋ฌ๋ ๊ทธ๋ค์ ํฌ์ธํฐ๋ฅผ ์๋นํฉ๋๋ค.
์์ ํฌ์ธํฐ๋ Copy
์ด๋ฏ๋ก ์ค์ ๋ก ์๋น๋๋ ๊ฒ์ ์์ต๋๋ค.
์์ ํฌ์ธํฐ๋
Copy
์ด๋ฏ๋ก ์ค์ ๋ก ์๋น๋๋ ๊ฒ์ ์์ต๋๋ค.
์ข์ ์ง์ ...
์, v.as_ptr().read()
๋ ์ด๋ฏธ ๊ฝค ๊ฐ๊ฒฐํ๊ณ ๋ช
ํํฉ๋๋ค. as_ptr
๋ค์์ read
๊ฐ ์ค๋ฉด into_initialized
๋ณด๋ค ํจ์ฌ ๋ ์ ์คํ๊ฒ ์๊ฐํ ์ ์์ต๋๋ค. ๊ฐ์ธ์ ์ผ๋ก ์ ์ด๋ ์ง๊ธ์ as_ptr
๋ฐ as_mut_ptr
๋ง ๋
ธ์ถํ๋ ๊ฒ์ ์ ํธํฉ๋๋ค. ๋ฌผ๋ก new
, uninitialized
๋ฐ zeroed
.
@Amanieu &mut MaybeUninit<[T]>
์ &mut [MaybeUninit<T>]
์์ ํ ๋ณํ์ด์๋ Cell
๊ฒฝ์ฐ๋ ์ด๋ป์ต๋๊น?
๊ทธ๊ฒ์ ๋ค์์ ํ์ฉ ํ ๊ฒ์ ๋๋ค.
fn read<T>(out: &mut MaybeUninit<[T]>) -> Result<&mut [T]> {
let split = out.as_mut_slice_of_uninit();
// ... operate on split ...
return Some(unsafe { split[0..n].as_uninit_mut_slice().get_mut() })
}
๋ํ ํธ์ถ์์๊ฒ ์๋ฏธ๋ฅผ ๋ ์ ํํ๊ฒ ๋ํ๋ด๋ ๊ฒ์ฒ๋ผ ๋๊ปด์ง๋๋ค. &mut [MaybeUninit<T>]
์ทจํ๋ ํจ์๋ ์ด๋ค ๊ฒ์ด ๊ด์ฐฎ๊ณ ์ด๋ค ๊ฒ์ด ๊ทธ๋ ์ง ์์์ง์ ๋ํ ๋ช ๊ฐ์ง ๊ตฌ๋ณ๋๋ ๋
ผ๋ฆฌ๋ฅผ ๊ฐ์ง๊ณ ์๋ ๊ฒ์ฒ๋ผ ๋๊ปด์ง ๊ฒ์
๋๋ค. ๋ฐ๋ฉด์ &mut MaybeUninit<[T]>
์ทจํ๋ฉด ์ด๋ฏธ ์ด๋ค ๋ฐ์ดํฐ๊ฐ ์๋์ง์ ๊ดํด์๋ ์
์ ๊ตฌ๋ณํ์ง ์์ ๊ฒ์์ ๋ํ๋
๋๋ค.
(๋ฌผ๋ก ๋ฐฉ๋ฒ์ ์ด๋ฆ์ ๋ฐ์ดํฌ ์๋ฉ์ ๋์์ด๋ฉ๋๋ค. ์ ๋ Cell
๊ฐํ๋ ์ผ์ ๋ชจ๋ฐฉํ์ต๋๋ค.)
@eternaleye MaybeUninit<[T]>
์ (๋) ๊ณต์ฉ์ฒด๊ฐ DST๊ฐ ๋ ์ ์๊ธฐ ๋๋ฌธ์ ์ ํจํ ์ ํ์ด ์๋๋๋ค.
์, ๋ง์
๋ค๋ฅธ ๋ฐฉ๋ฒ์ ๋ํด ๋ ๋ง์ ์์ ๊ฑฐ ํ๋ฆผ์ด์์ ๋๊น์ง
new
,uninitialized
,zeroed
,as_ptr
,as_mut_ptr
์์ ํ ํ ์ค๋น๊ฐ๋์์ต๋๋ค.
๊ธ์, ๋๋ ์ฐ๋ฆฌ๊ฐ ๋ฌด์์ด๋ ์์ ํํ๊ธฐ ์ ์์ด RFC ๋ฅผ
๋ฐ๋ผ์ ์คํ ์ ๊ธฐ๋ค๋ฆฌ๋ ๋์ ํ์ฌ set
, read_initialized
๋ฐ into_initialized
๋ผ๋ ์ด๋ฆ์ ๋ํด ์ฝ๊ฐ์ ์์ ๊ฑฐ๋ฅผ ํ ์ ์์ต๋๋ค. ๋ค์๊ณผ ๊ฐ์ ์ด๋ฆ ๋ณ๊ฒฝ์ด ์ ์๋์์ต๋๋ค.
set
-> write
.as_ptr().read()
๋ํ ๊ฐ์ฅ ์ข์ ์์ ๋ "get"์ด ์๋๋ผ "read"์ธ ๊ฒ์ฒ๋ผ ๋ณด์ด์ง๋ง ๋ณด์ ( .as_ptr_mut().write()
)์ "set"์ด ์๋๋ผ "write"์ฌ์ผํฉ๋๋ค.read_initialized
-> read
write
์ ์ ์ผ์นํ์ง๋ง ์์ ํ์ง ์์ต๋๋ค. (๋ฌธ์์ ํจ๊ป) ๋ฐ์ดํฐ๊ฐ ์ด๋ฏธ ์ด๊ธฐํ๋์๋์ง ์๋์ผ๋ก ํ์ธํด์ผํ๋ ์ถฉ๋ถํ ๊ฒฝ๊ณ ์
๋๊น? ์์ ํ์ง ์์ into_inner
๋ก๋ ์ถฉ๋ถ ํ์ง ์๋ค๋ ๋ง์ ๋์๊ฐ ์์๊ธฐ ๋๋ฌธ์ ์ด๋ฆ์ into_initialized
๋ก ๋ฐ๊ฟจ์ต๋๋ค.into_initialized
-> initialized
read_initialized
๋ฐ into_initialized
์์ผ๋ฉด IMO์ ์ผ๊ด์ฑ์ด ์ข์ง๋ง read
์ด๋ฉด into_initialized
์ด ์ฝ๊ฐ ํ์ด ๋์ต๋๋ค. ๋ฉ์๋ ์ด๋ฆ์ด ์๋นํ ๊น๋๋ค. ๊ทธ๋๋ ๋๋ถ๋ถ์ ์๋น ์์
์ ๋ด๊ฐ ์๋ ๋ฐ์์ into_*
๋ผ๊ณ ํฉ๋๋ค.(1)์ ๋ํ ์ด์๊ฐ ์์ต๋๊น? ๊ทธ๋ฆฌ๊ณ ๋๋ ์ฃผ๋ก (3)์ ๊ธฐ๋์ด ์์ต๋๋ค. (2) ๋๋ ๋ฏธ์ ์ด๋ค : read
๋ ์
๋ ฅํ๊ธฐ ์ฝ์ง๋ง read_initialized
IMO๋ ๊ทธ๋ฌํ ์ฝ๋๋ฅผ ์ฝ์ ๋ ๋ ์ ์๋ํ๋ฉฐ ์ฝ๋๋ ์ฐ์ฌ์ง ๊ฒ๋ณด๋ค ๋ ์์ฃผ ์ฝ๊ณ ๊ฒํ ๋ฉ๋๋ค. ์ค์ ๋ก ์ด๊ธฐํํด์ผํ๋ค๊ณ ๊ฐ์ ํ๋ ๊ณณ์ ๋ถ๋ฅด๋ ๊ฒ์ด ์ข์ต๋๋ค.
์๊ฐ, ์๊ฒฌ?
๊ธ์, ๋๋ ์ฐ๋ฆฌ๊ฐ ๋ฌด์์ด๋ ์์ ํํ๊ธฐ ์ ์์ด RFC ๋ฅผ
offset_of!
ํ๋ฌ๊ทธ๋ฅผ ๊ฝ์ ๊ณณ์
๋๊น? :)
์ฐธ๊ณ read_initialized
์๊ฒฉํ ์์ ์ธ into_initialized
(์์ &self
๋์ self
). ๋ ๋ค ์ง์ํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์
๋๊น?
offset_of!
ํ๋ฌ๊ทธ๋ฅผ ๊ฝ์ ๊ณณ์ ๋๊น? :)
๋ด RFC๊ฐ ์๋ฝ๋๊ธฐ ์ ์ ์์ ํ ๋ ์ ์๋ค๋ฉด ํ์คํฉ๋๋ค. ;)
๋ ๋ค ์ง์ํ๋ ๊ฒ์ด ํฉ๋ฆฌ์ ์ ๋๊น?
IMO ์. into_initialized
๋ ๋์ผํ ๊ฐ์ ๋ ๋ฒ ์ฌ์ฉํ๋ ๊ฒ์ ๋ฐฉ์งํ๋ฏ๋ก ๋ ์์ ํ๋ฏ๋ก ๊ฐ๋ฅํ๋ฉด read_initialized
๋ณด๋ค ์ ํธํด์ผํฉ๋๋ค.
๊ทธ๋์ @nikomatsakis ๋ ์ด์ ์์ด ์ ์ ์ง์ ํ์ง๋ง ์ด๋ ค์ด ์ฐจ๋จ์ ๋ก ๋ง๋ค์ง๋ ์์์ต๋๋ค.
MaybeUninit<T>
๋ฐ into_initialized
๋ฅผ ์ฌ์ฉํ๊ธฐ ์ํด ๋ง์ ์ฝ๋๋ฅผ ์ด์ํ๋๋ฐ ๋ถํ์ํ๊ฒ ์ฅํฉํฉ๋๋ค. ์ฝ๋๋ mem::uninitialized
์ฌ์ฉํ์ฌ "์๋ชป"๋์๋ ์ด์ ๋ณด๋ค ํจ์ฌ ๋ ์ฅํฉํฉ๋๋ค.
MaybeUninit<T>
๋ ๊ทธ๋ฅ Uninit<T>
๋ผ๊ณ ํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์๋ํ๋ฉด ๋ชจ๋ ์ค์ฉ์ ์ธ ๋ชฉ์ ์ ์ํด ์๋ ค์ง์ง ์์ MaybeUninit<T>
๋ฅผ ์ป์ผ๋ฉด ์ด๊ธฐํ๋์ง ์์ ๊ฒ์ผ๋ก ๊ฐ์ฃผํด์ผํ๋ฏ๋ก Uninit<T>
์์ด๋ฅผ ์ฌ๋ฐ๋ฅด๊ฒ ์์ฝํฉ๋๋ค. ๋ํ ์ผ๊ด์ฑ์ ์ํด into_uninitialized
๋ into_init()
๋๋ ์ ์ฌํด์ผํฉ๋๋ค.
Uninitialized<T>
๊ณผ into_initialized
๋ฉ์๋๋ฅผ ํธ์ถ ํ ์๋ ์์ง๋ง ํ์์ ๋ํ ์ฝ์ด๋ฅผ ์ฌ์ฉํ๊ณ ๋ฉ์๋์ ๋ํด ๊ธด ํ์์ ์ฌ์ฉํ๊ฑฐ๋ ๊ทธ ๋ฐ๋์ ๊ฒฝ์ฐ๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค. ์ด์์ ์ผ๋ก๋ "Rust API๋ ์ฝ์ด / ๊ธด ํ์์ ์ฌ์ฉํฉ๋๋ค"๋ผ๋ ์ฌ์ค ๋ง ๊ธฐ์ตํ๋ฉด๋ฉ๋๋ค.
์ฝ์ด๋ ๋ค๋ฅธ ์ฌ๋๋ค์๊ฒ ๋ชจํธ ํ ์ ์๊ธฐ ๋๋ฌธ์ ๋๋ ์ด๋์์๋ ๊ธด ํ์์ ์ฌ์ฉํ๊ณ ํ๋ฃจ๋ผ๊ณ ๋ถ๋ฅด๋ ๊ฒ์ ์ ํธํฉ๋๋ค. ๊ทธ๋ฌ๋ ํผํฉ์ ์ฌ์ฉํ๋ ๊ฒ์ IMO๊ฐ ๋ ์ธ๊ณ ๋ชจ๋์์ ์ต์
์
๋๋ค. Rust๋ ๊ธด ํ์๋ณด๋ค ์ฝ์ด๋ฅผ ๋ ์์ฃผ ์ฌ์ฉํ๋ ๊ฒฝํฅ์ด ์์ผ๋ฏ๋ก ์ฝ์ด๋ก Uninit<T>
๋ฅผ, ๋ฉ์๋์ ๋ ๋ค๋ฅธ ์ฝ์ด๋ก .into_init()
๋ฅผ ์ฌ์ฉํ์ง ์์ต๋๋ค.
๊ฐ์ ์ด๊ธฐํํ๋ ๋ณํ์ด ์งํ๋๋ ๊ฒ์ฒ๋ผ ๋ค๋ฆฌ๊ธฐ ๋๋ฌธ์ into_initialized()
์ข์ํ์ง ์์ต๋๋ค. ๋๋ take_initialized()
ํจ์ฌ ์ ํธํฉ๋๋ค. ํ์
์๊ทธ๋์ฒ๊ฐ ๋ค๋ฅธ take
๋ฉ์๋์์ ๋ฒ์ด๋๋ค๋ ๊ฒ์ ์๊ณ ์์ง๋ง ์๋ฏธ ๋ก ์ ์ผ๋ก ํจ์ฌ ๋ ๋ช
ํํ๊ณ ์๋ฏธ ๋ก ์ ๋ช
ํ์ฑ์ด ์ฐจ์ฉ / ์ด๋ ์ผ๊ด์ฑ์ ๋์ฒดํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ณ๊ฒฝ ๊ฐ๋ฅํ ์ฐจ์
์ ์ฐ์ ์์๊ฐ ์์ง์๋ ๋ค๋ฅธ ๋์์ move_initialized
๋๋ consume_initialized
์์ต๋๋ค.
set()
๋ write()
, ๋ณ์นญ์ด ๋ as_ptr().write()
์ ์ ์ฌ์ฑ์ ํธ์ถํ๊ธฐ ์ํด write()
๋ฅผ ๊ฐ๋ ฅํ ์ ํธํฉ๋๋ค.
๋ง์ง๋ง์ผ๋ก take_initialized()
๋๋ ์ด์ ์ ์ฌํ ๊ฒ์ด์์ ๊ฒฝ์ฐ ์ ์์ ๋ช
์ ์ฑ์ผ๋ก ์ธํด read()
๋ณด๋ค read_initialized()
๋ฅผ ์ ํธํฉ๋๋ค.
ํธ์ง : ๊ทธ๋ฌ๋ ๋ช
ํํํ๊ธฐ ์ํด as_ptr().write()
๋ฐ as_ptr().read()
๊ณ ์ํ๋ ๊ฒ์ด ํจ์ฌ ๋ ๋ช
ํํ๊ณ DANGER DANGER ์ ์ ํ๋ก๋ฅผ ์ ๋ฐํ ๊ฐ๋ฅ์ฑ์ด ๋ ๋๋ค๊ณ ์๊ฐํฉ๋๋ค.
@gnzlbg ์ฐ๋ฆฌ๋ ์ ํ์ ์ด๋ฆ์ ๋ํ FCP๋ฅผ ๊ฐ์ง๊ณ ์์๋๋ฐ, ๊ทธ ํ ๋ก ์ ๋ค์ ์ด์ด์ผํ ์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
๊ทธ๋ฌ๋ MaybeUninit::uninit()
๋ฐ x.into_init()
์์์ฒ๋ผ "init"๋ฅผ ์ง์์ ์ผ๋ก ์ฌ์ฉํ๋ ์ ์์ด ๋ง์์ ๋ญ๋๋ค.
๊ฐ์ ์ด๊ธฐํํ๋ ๋ณํ์ด ์งํ๋๋ ๊ฒ์ฒ๋ผ ๋ค๋ฆฌ๊ธฐ ๋๋ฌธ์
into_initialized()
์ข์ํ์ง ์์ต๋๋ค.
into
๋ฉ์๋๋ ํน์ ์ ํ์์ ๋์ผํ (์์ ํ) ๋ฐ์ดํฐ๋ฅผ ๋ณด๋ ๊ฒ ์ธ์ ์ค์ ๋ก ๋ณํ์ ์ํํ์ง ์๋ ๊ฒฝ์ฐ๊ฐ ๋ง์ต๋๋ค. ์๋ฅผ ๋ค์ด ๋ค์ํ into_vec
๋ฉ์๋๋ฅผ ์ฐธ์กฐํ์ธ์.
๋๋ take_initialized(&mut self)
(into_init ์ธ์) ๊ด์ฐฎ์ง ๋ง ๋ด๋ถ ์ํ๋ฅผ ๋ค์ undef
๋๋๋ ค ์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋ด๋ถ ์ํ๋ฅผ ๋ ๋๋ฆฌ๋ค
https://github.com/rust-lang/rust/issues/53491#issuecomment -437811282
์ด๊ฒ์
self
์ ๋ด์ฉ์ ์ ํ ๋ณ๊ฒฝํ์ง ์์์ผํฉ๋๋ค. ์์ ๊ถ ๋ง ์ด์ ๋๋ฏ๋ก ์ด์ ๋ ์ด๊ธฐํ๋์ง ์์ ์ํ๋ก ๊ตฌ์ถ ๋ ๊ฒ๊ณผ ๋์ผํ ์ํ๊ฐ๋ฉ๋๋ค.
์ด๋ฌํ ๋ง์ ๊ฒ๋ค์ ์ด๋ฏธ 200 ๊ฐ ์ด์์ ์จ๊ฒจ์ง ๋๊ธ์์ ๋ ผ์๋์์ต๋๋ค.
์ด๋ฌํ ๋ง์ ๊ฒ๋ค์ ์ด๋ฏธ 200 ๊ฐ ์ด์์ ์จ๊ฒจ์ง ๋๊ธ์์ ๋ ผ์๋์์ต๋๋ค.
๋๋ ํ๋์ ํ ๋ก ์ ๋ฐ๋ผ ์๊ณ ๋ด๊ฐ ์ฐฉ๊ฐ ํ ์๋ ์์ง๋ง์ด ์ ์ด ์ด์ ์ ์ ๊ธฐ ๋ ์ ์ด ์๋ค๊ณ ์๊ฐํ๋ค. ํนํ, ์ธ์ฉ ํ ์ฃผ์์ "๋ด๋ถ ์ํ๋ฅผ ๋ค์ undef
๋๋ ๋ฆฌ๋๋ก ์ ์ ํ์ง ์์ง๋ง ptr::read
(๋ด๋ถ ์ํ๋ฅผ ๋ณ๊ฒฝํ์ง ์์ ์ํ๋ก ๋๋ ๊ฒ)์ ๋์ผํ๊ฒ ๋ง๋ญ๋๋ค. ๋ด๊ฐ ์ ์ํ๋ ๊ฒ์ mem::replace(self, MaybeUninit::uninitialized())
์ ๊ฐ๋
์ ๋๋ฑ ๋ฌผ์
๋๋ค.
mem::replace(self, MaybeUninit::uninitialized())
์ ๊ฐ๋ ์ ๋๋ฑ ๋ฌผ.
undef
์ ์๋ฏธ ๋๋ฌธ์ read
: https://rust.godbolt.org/z/e0-Gyu ์ ๋์ผํฉ๋๋ค.
@scottmcm ์๋์์. read
๋ฅผ ์ฌ์ฉํ๋ฉด ๋ค์์ด ํฉ๋ฒ์ ์
๋๋ค.
let mut x = MaybeUninit::<u32>::uninitialized();
x.set(13);
let x1 = unsafe { x.read_initialized() };
// `u32` is `Copy`, so we may read multiple times.
let x2 = unsafe { x.read_initialized() };
assert_eq!(x1, x2);
์ ์ ๋ take
์์๋ x2
์ด undef
์ด๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ถ๋ฒ์
๋๋ค.
๋ ํจ์๊ฐ ๋์ผํ ์ด์ ๋ธ๋ฆฌ๋ฅผ ์์ฑํ๋ค๊ณ ํด์ ์ด๋ค์ด ๋๋ฑํ๋ค๋ ์๋ฏธ๋ ์๋๋๋ค.
๊ทธ๋ฌ๋ ๋ด์ฉ์ undef
๋ฎ์ด ์จ๋ ์๋ฌด๋ฐ ์ด์ ์ด ์์ต๋๋ค. ์ฌ๋๋ค์ด ์์ ์ ๋ฐ์ ์๋ ๋ ๋ง์ ๋ฐฉ๋ฒ์ ์๊ฐํฉ๋๋ค. @jethrogb ๋น์ ์ ์ด๋ค ๋๊ธฐ๋ ๋ถ์ฌํ์ง ์์์ต๋๋ค. ์ ์ด๊ฒ์ด ์ข์ ์๊ฐ์ด๋ผ๊ณ ์๊ฐํ๋์ง ์ค๋ช
ํด ์ฃผ์๊ฒ ์ต๋๊น?
๋๋
take_initialized(&mut self)
(into_init ์ธ์) ๊ด์ฐฎ์ง ๋ง ๋ด๋ถ ์ํ๋ฅผ ๋ค์undef
๋๋๋ ค ์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋๋ ์ด์ ์ด๋ฆ์ด ์์
์ ๋ ์ ํํ๊ฒ ์ค๋ช
ํ๋ค๊ณ ๋ฏฟ๊ธฐ ๋๋ฌธ์ into_initialized(self)
take_initialized(self)
๋์ take
์ผ๋ฐ์ ์ผ๋ก &mut self
, into
์ผ๋ฐ์ ์ผ๋ก self
์ด ํ์ํ์ง๋ง ์๋ฏธ ์ ์ ํํ ์ด๋ฆ ์ง์ ์ด ์ผ๊ด๋๊ฒ ์
๋ ฅํ๋ ๊ฒ๋ณด๋ค ๋ ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ช
๋ช
. ํ์ง๋ง move_initialized
๋๋ transmute_initialized
์ ๊ฐ์ด ๋ค๋ฅธ ์ด๋ฆ์ ์ฌ์ฉํด์ผ ํ ์๋ ์์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ค์ v.write()
๋ฐ v.read_initialized()
๊ฒฝ์ฐ v.as_ptr().write()
๋ฐ v.as_ptr().read()
๋ณด๋ค ๊ธ์ ์ ์ธ ๊ฐ์ด ํ์๋์ง ์์ต๋๋ค. ํ์์ ๋ ๊ฐ์ง๋ ์ค์ฉ ๋ ๊ฐ๋ฅ์ฑ์ด ์ ์ต๋๋ค.
๊ทธ๋ฆฌ๊ณ ๋ค์
v.write()
๋ฐv.read_initialized()
๊ฒฝ์ฐv.as_ptr().write()
๋ฐv.as_ptr().read()
๋ณด๋ค ์์ ๊ฐ์ด ํ์๋์ง ์์ต๋๋ค. ํ์์ ๋ ๊ฐ์ง๋ ์ค์ฉ ๋ ๊ฐ๋ฅ์ฑ์ด ์ ์ต๋๋ค.
v.write()
(๋๋ v.set()
๋๋ ์์ฆ ์ฐ๋ฆฌ๊ฐ ๋ถ๋ฅด๋ ๋ชจ๋ ๊ฒ)๋ ์์ ํฉ๋๋ค. v.as_ptr().write()
์๋ unsafe
๋ธ๋ก์ด ํ์ํฉ๋๋ค. v.read_init()
๋ v.as_ptr().read()
์ ๋ํด ๋์ํ์ง๋ง. v.read_init()
์ (๋) ๋ถํ์ํ ๊ฒ ๊ฐ์ต๋๋ค.
์ ๋ into_initialized (self) ๋์ take_initialized (self)๋ฅผ ์ ์ํ์ต๋๋ค. ์ด์ ์ด๋ฆ์ด ์์ ์ ๋ ์ ํํ๊ฒ ์ค๋ช ํ๋ค๊ณ ๋ฏฟ๊ธฐ ๋๋ฌธ์ ๋๋ค. ๋ค์ ๋งํ์ง๋ง, ๋๋ ํ ์ดํฌ๊ฐ ์ผ๋ฐ์ ์ผ๋ก & mut self๋ฅผ ์ทจํ๊ณ ์ผ๋ฐ์ ์ผ๋ก self๋ฅผ ์ทจํ๋ค๋ ๊ฒ์ ์ดํดํ์ง๋ง, ์๋ฏธ ์ ์ ํํ ์ด๋ฆ ์ง์ ์ด ์ผ๊ด๋ ํ์์ ์ด๋ฆ ์ง์ ๋ณด๋ค ๋ ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋๋ into_init(ialized)
๋ํ ์๋ฏธ ์ ์ผ๋ก ๋ ์ ํํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๊ฒฐ๊ตญ MaybeUninit
์๋นํฉ๋๋ค.
@mjbshaw ์, ๋ค, ๊ทธ๋ ์ต๋๋ค. ์์ ์ฐจ๋ฆฌ์ง ๋ชปํ์ต๋๋ค ... ์ข์์,์ด ๊ฒฝ์ฐ set
/ write
๋ํ ์ด์ ์๊ฒฌ์ ๋ชจ๋ ์ทจ์ํฉ๋๋ค. set
๊ฐ ๋ ์๋ฏธ๊ฐ์์ ์ ์์ต๋๋ค. Cell
๋ฐ Pin
์ด๋ฏธ set
๋ฉ์๋๋ฅผ ์ ์ํฉ๋๋ค. ์ฃผ์ ์ฐจ์ด์ ์ MaybeUninit::set
๊ฐ ์ด์ ์ ์ ์ฅ๋ ๊ฐ์ ์ญ์ ํ์ง ์๋๋ค๋ ๊ฒ์
๋๋ค. ์๋ง๋ ๊ทธ๊ฒ์ write
๋ ๊ฐ๊น์ต๋๋ค ... ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. ์ด๋ ์ชฝ์ด๋ ๋ฌธ์๋ ๋งค์ฐ ๋ช
ํํฉ๋๋ค.
@RalfJung ์ข์, take...
์์ด ๋ฒ๋ ค. move...
, consume...
, transmute...
๋ฑ๊ณผ ๊ฐ์ ์ ์ด๋ฆ์ ์ด๋ป์ต๋๊น? into_init(ialized)
์ด ๋๋ฌด ํท๊ฐ๋ฆฌ๋ค์. ๋๋, ๊ทธ๊ฒ์ ๊ฐ์ด ์ด๊ธฐํ๋๊ณ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ค์ ๋ก ์ฐ๋ฆฌ๋ ๊ทธ๊ฒ์ด ์ด๋ฏธ ์ด๊ธฐํ๋์๋ค๊ณ ์์ ์ ์ผ๋ก ์ฃผ์ฅ ํ ๋์
๋๋ค.
์ค์ ๋ก ์ฐ๋ฆฌ๊ฐ ์ด๋ฏธ ์ด๊ธฐํ๋์๋ค๊ณ ์์ ์ ์ผ๋ก ์ฃผ์ฅ ํ ๋.
into_init
์ฃผ์ฅํ๋ ์ ์ผํ ๊ฒ์ ๊ทธ ๊ฐ์ด T
์ _ ์ ํจ ๋ถ๋ณ _์ ๋ง์กฑํ๋ค๋ ๊ฒ์
๋๋ค. ์ด๋ T
์ ํผ๋ํด์๋ ์๋ฉ๋๋ค
์๋ฅผ ๋ค๋ฉด :
pub mod foo {
pub struct AlwaysTrue(bool);
impl AlwaysTrue {
pub fn new() -> Self { Self(true) }
/// It is impossible to initialize `AlwaysTrue` to false
/// and unsafe code can rely on `is_true` working properly:
pub fn is_true(x: bool) -> bool { x == self.0 }
}
}
pub unsafe fn improperly_initialized() -> foo::AlwaysTrue {
let mut v: MaybeUninit<foo::AlwaysTrue> = MaybeUninit::uninitialized();
// let v = v.into_init(); // UB: v is invalid
*(v.as_mut_ptr() as *mut u8) = 3; // OK
// let v = v.inti_init(); // UB v is invalid
*(v.as_mut_ptr() as *mut bool) = false; // OK
let v = v.into_init(); // OK: v is valid, even though AlwaysTrue is false
v
}
์ฌ๊ธฐ์ ๋ฐํ ๊ฐ improperly_initialized
์๋ฏธ์์ "์ด๊ธฐํ"๋์ด ๊ทธ ๊ทธ๊ฒ์ ๋ง์กฑ _validity์ invariant_ T
์๋ ์ ์์ ๊ทธ๊ฒ์ด ๋ง์กฑ์ _safety์ invariant_ T
, ๊ทธ๋ฆฌ๊ณ ๊ตฌ๋ณ์ ๋ฏธ๋ฌํ์ง๋ง ์ค์ํฉ๋๋ค.์ด ๊ฒฝ์ฐ์ด ๊ตฌ๋ณ์ improperly_initialized
๋ฅผ unsafe fn
๋ก ์ ์ธํด์ผํ๊ธฐ ๋๋ฌธ์
๋๋ค.
๋๋ถ๋ถ์ ์ฌ์ฉ์๊ฐ "์ด๊ธฐํ"๋ ๊ฒ์ ๋ํด ์ด์ผ๊ธฐ ํ ๋ ์ผ๋ฐ์ ์ผ๋ก MaybeUninit::into_init
์ "์ ํจํ์ง๋ง MaybeUnsafe"์๋ฏธ๋ฅผ ๊ฐ์ง ์์ต๋๋ค.
์ด์ ๋ํด ๊ทน๋๋ก ์์ธํ ์๊ณ ์ถ๋ค๋ฉด Invalid<T>
๋ฐ Unsafe<T>
, Invalid<T>::into_valid() -> Unsafe<T>
, ์ฌ์ฉ์์๊ฒ uninit.into_valid().into_safe()
๋ฅผ ์์ฑํ๋๋ก ์๊ตฌํ ์ ์์ต๋๋ค. ๊ทธ๋ฐ ๋ค์ ์์ improperly_initialized
๋ฐํ Unsafe<T>
, ์ฌ์ฉ์๊ฐ ์ ์ ์ ๊ฐ์ผ๋ก ์ค์ ํ ํ์ ๋ง AlwaysTrue
์ true
์ค์ ๋ก ์์ T๋ฅผ ์ป์ ์ ์์ต๋๋ค :
// note: this is now a safe fn
fn improperly_uninitialized() -> Unsafe<foo::AlwaysTrue>;
fn initialized() -> foo::AlwaysTrue {
let mut v: Unsafe<foo::AlwaysTrue> = improperly_uninitialized();
unsafe { v.as_mut_ptr() as *mut bool } = true;
unsafe { v.into_safe() }
}
์ด๋ ๊ฒํ๋ฉด improperly_uninitialized
์ด ์์ ํ fn
๊ฐ ๋ ์ ์์ต๋๋ค. ์ด์ AlwaysTrue
๊ฐ ์์ ํ์ง ์๋ค๋ ๋ถ๋ณ์ด ํจ์ ์ฃผ๋ณ์ "์ฃผ์"์ผ๋ก ์ธ์ฝ๋ฉ๋์ง ์๊ณ ์ ํ.
๊ณ ํต์ค๋ฝ๊ฒ ๊ทน์ฌํ ์ ๊ทผ ๋ฐฉ์์ด ์ถ๊ตฌ ํ ๊ฐ์น๊ฐ ์๋์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค. MaybeUninit
๋ชฉํ๋ ์ฌ์ฉ์๊ฐ ์ด๊ธฐํ๋์ง ์์ ์ ํจํ์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฒ๋ฆฌ ํ ์ โโ์๋๋ก ํํํ๋ ๊ฒ์
๋๋ค. ๋๋ ๊ฐ์ธ์ ์ผ๋ก ์ฐ๋ฆฌ๊ฐ ๊ทธ๋ค์ ์ผ๊ตด์ ๋ช
์ ์ ์ผ๋ก ์ธ๊ธํ์ง ์๋ ํ ์ฌ์ฉ์๊ฐ ์ด๋ฌํ ๊ตฌ๋ณ์ ์๊ธฐ๋ฅผ ๊ธฐ๋ํ ์ ์๋ค๊ณ ์๊ฐํ๋ฉฐ, MaybeUninit
์ฌ๋ฐ๋ฅด๊ฒ ์ฌ์ฉํ ์ ์์ผ๋ ค๋ฉด์ด ๊ตฌ๋ณ์ ์์์ผํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฌ๋๋ค์ fn improperly_uninitialized() -> AlwaysTrue
๋ฅผ ์์ ํ fn
๋ก ์์ฑํ๊ณ ์์ ํ์ง ์์ AlwaysTrue
๋ฐํ ํ ์ ์์ต๋๋ค. ์๋ํ๋ฉด ๊ทธ๋ค์ด "์ด๊ธฐํ"ํ๊ธฐ ๋๋ฌธ์
๋๋ค.
Invalid<T>
๋ฐ Unsafe<T>
๋ก๋ ํ ์์๋ ํ ๊ฐ์ง๋ ValidityCheckeable
๋ฐ UnsafeCheckeable
๋ฐ ๋ ๊ฐ์ง ๋ฉ์๋, ValidityCheckeable::is_valid(Invalid<Self>)
๋ฐ UnsafeCheckeable::is_safe(Unsafe<Self>)
, Invalid::into_valid
๋ฐ Unsafe::into_safe
๋ฉ์๋ assert_validity!
๋ฐ assert_safety!
๊ฐ ์์ต๋๋ค.
์ฃผ์์ ์์ ๋ถ๋ณ์ ์์ฑํ๋ ๋์ ํ์ธ์์ํ ์ฝ๋๋ฅผ ์์ฑํ ์ ์์ต๋๋ค.
๋๋ into_init๊ฐ ์ฃผ์ฅํ๋ ์ ์ผํ ๊ฒ์ ๊ทธ ๊ฐ์ด T์ ํ๋น์ฑ ๋ถ๋ณ์ ๋ง์กฑํ๋ค๋ ๊ฒ์์ ๋ค์ ์ธ๊ธ ํ ๊ฐ์น๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๊ฒ์ ์ด๋ค ์ผ๋ฐ์ ์ธ ์๋ฏธ์์ T๊ฐ "์ด๊ธฐํ"๋๋ ๊ฒ๊ณผ ํผ๋ํด์๋ ์๋ฉ๋๋ค.
๋ง์ต๋๋ค. OTOH, ์ฒซ ๋ฒ์งธ ์ค๋ช ์์ "์ด๊ธฐํ"๊ฐ ์ด์ ๋ํ ํฉ๋ฆฌ์ ์ธ ๋๋ฆฌ๋ผ๊ณ ์๊ฐํฉ๋๋ค.
๊ทธ๋ ์ง ์์ผ๋ฉด ์ฌ๋๋ค์ fn improperly_uninitialized ()-> AlwaysTrue๋ฅผ ์์ ํ fn์ผ๋ก ์์ฑํ๊ณ ์์ ํ์ง ์์ AlwaysTrue๋ฅผ ๋ฐํ ํ ์ ์์ต๋๋ค. ์๋ํ๋ฉด ๊ทธ๋ค์ด "์ด๊ธฐํ"ํ๊ธฐ ๋๋ฌธ์ ๋๋ค.
์ด๊ฒ์ด ์ ์ ํ๊ฒ "์ด๊ธฐํ"๋์ง ์์๋ค๋ ํฉ๋ฆฌ์ ์ธ ์ง์ ์ ํ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋๋์ด ๋ ๊ฐ์ง ๋ถ๋ณ์ฑ์ด ์ด๋๊ฐ์์ ์ด๋ป๊ฒ ์ํธ ์์ฉํ๋์ง์ ๋ํ ์ ์ ํ ๋ฌธ์๊ฐ ํ์ํ๋ค๋ ๋ฐ ๋์ํฉ๋๋ค (๊ทธ๋ฆฌ๊ณ ๊ฐ์ฅ ์ข์ ๊ณณ์ด ๋ฌด์์ธ์ง ์ ๋ชจ๋ฅด๊ฒ ์ต๋๋ค).ํ์ง๋ง ๋๋ถ๋ถ์ ์ฌ๋๋ค์ ์ง๊ฐ์ improperly_uninitialized
๊ฐ ๊ด์ฐฎ์ง ์๋ค๊ณ ๋งํ ๊ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ๋ด๋ณด๋ผ ๊ธฐ๋ฅ. "๋ค๋ฅธ ์ฌ๋์ ๋ถ๋ณ์ ๊นจ๋จ๋ฆฌ๋ ๊ฒ"์ "๋ด๊ฐ ๋ด๋ณด๋ด๋ ๋ชจ๋ ์์ ํ ๊ธฐ๋ฅ์ ์์ ํ ์ฝ๋๊ฐ ๊ทธ๋ค์ ํ๊ดดํ๋ ๋ฐ ์ฌ์ฉํ ์ ์๋๋กํด์ผํ๋ค"๋ ์๊ฐ์ ํ ๋ ์์ฐ์ค๋ฝ๊ฒ ๋ฐ์ํ๋ ๊ฐ๋
์
๋๋ค.
Invalid๋ก๋ ํ ์์๋ ํ ๊ฐ์ง
์์ ํ์ง ์์ ValidityCheckeable :: is_valid (Invalid) ๋ ๊ฐ์ง ํน์ฑ ์ธ ValidityCheckeable ๋ฐ UnsafeCheckeable์ด ์์ผ๋ฉฐ ๋ ๊ฐ์ง ๋ฉ์๋๊ฐ ์์ต๋๋ค. ) ๋ฐ UnsafeCheckeable :: is_safe (Unsafe ), Invalid :: into_valid ๋ฐ Unsafe :: into_safe ๋ฉ์๋ assert_validity! ๊ทธ๋ฆฌ๊ณ assert_safety! ๊ทธ๋ค์.
๋๋ถ๋ถ์ ๊ฒฝ์ฐ ์์ ๋ถ๋ณ์ ํ์ธํ ์ ์์ต๋๋ค. ํ๋น์ฑ ๋ถ๋ณ๋ ์ฐธ์กฐ์ ๋ํด ํ์ธํ ์ ์์ต๋๋ค. (์ ์ด๊ฒ์ ์ฐ๋ฆฌ๊ฐ ์ฌ๋ฌผ์ ์ด๋ป๊ฒ ๊ณ ๋ ค ํ๋๋์ ๋ฌ๋ ค ์์ต๋๋ค.)
์๋ ํ์ธ์.
์ด๋ ..., ์๋น ..., ๋ณํ ... ๋ฑ๊ณผ ๊ฐ์ ์๋ก์ด ์ด๋ฆ์ ์ด๋ป์ต๋๊น? ๋๋ into_init (ialized)๊ฐ ๋๋ฌด ํผ๋ ์ค๋ฝ๋ค๊ณ ์๊ฐํฉ๋๋ค; ๋๋, ๊ทธ๊ฒ์ ๊ฐ์ด ์ด๊ธฐํ๋๊ณ ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๋ค. ์ค์ ๋ก ์ฐ๋ฆฌ๋ ๊ทธ๊ฒ์ด ์ด๋ฏธ ์ด๊ธฐํ๋์๋ค๊ณ ์์ ์ ์ผ๋ก ์ฃผ์ฅ ํ ๋์ ๋๋ค.
move_init
๋ into_init
๋ณด๋ค "์ด์ค ์
"์ ์ด๋ป๊ฒ ์ ๋ฌํฉ๋๊น?
assert_init(italized)
์ด (๊ฐ) ์ด์ ์ ์ ์๋์์ต๋๋ค.
๊ทธ๋ฌ๋ read
๋๋ read_initialized
๋๋ as_ptr().read
๋ ์ค์ ๋ก ์๋ฌด๊ฒ๋ ์ฃผ์ฅํ๋ ๊ฒ์ ๋ํด ์๋ฌด ๋ง๋ํ์ง ์์ต๋๋ค.
์ด๊ฒ์ ๋ํด ๊ทน๋๋ก ์์ธํ ์๊ณ ์ถ๋ค๋ฉด
Invalid<T>
๋ฐUnsafe<T>
,Invalid<T>::into_valid() -> Unsafe<T>
, ์ฌ์ฉ์๊ฐuninit.into_valid().into_safe()
๋ฅผ ์์ฑํ๋๋ก ์๊ตฌํ ์ ์์ต๋๋ค. ๊ทธ๋ฐ ๋ค์ ์์improperly_initialized
๋ฐํUnsafe<T>
์ฌ์ฉ์๊ฐ ์ ์ ํ๊ฒ ๊ฐ ์ค์ ํ๊ณ , ํ์ ๋งAlwaysTrue
์true
์ค์ ๋ก ์์ T๋ฅผ ์ป์ ์ ์์ต๋๋ค :
@gnzlbg ์๋
ํ์ธ์, ๊ฝค uninit.into_valid().into_safe()
์ uninit.assume_initialized()
๋๋ ๊ทธ ๋ฐ์ ๊ฒ๋ค์ ๋นํด ์ฅํฉํ์ง ์์ต๋๋ค. ๋ฌผ๋ก ์ด๋ฌํ ๊ตฌ๋ถ์ํ๊ธฐ ์ํด์๋ ์ฐ์ ๋ชจ๋ธ์ ๋ํ ํฉ์๋ฅผ ์ฐพ์์ผํฉ๋๋ค. ๐
์ด ๋ชจ๋ธ์ ์ข ๋ ์กฐ์ฌํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
assert_init(italized)
์ด (๊ฐ) ์ด์ ์ ์ ์๋์์ต๋๋ค.
@RalfJung ์ฐ๋ฆฌ๋ ๋ํ์ด assume_initialized
@eternaleye์ (๋ด๊ฐ ์๊ฐํ๋) ๋๋ฌธ์. ๊ฝค ์ค๋๋ ฅ์๋ ๊ทผ๊ฑฐ ๋ชฉ๋ก์ https://github.com/rust-lang/rust/issues/53491#issuecomment -440730699๋ฅผ ์ฐธ์กฐ
TBH ๋ ๊ฐ์ง ์ ํ์ ๊ฐ๋ ๊ฒ์ ๋๋ฌด ์ฅํฉํ ๊ฒ ๊ฐ์ต๋๋ค.
@RalfJung ๋ ๊น์ด ํ๊ณ ๋ค ์ ์์๊น์? ์๋ง๋ ๋์ ์์ค์ ์์ธํ ๋ด์ฉ์ ๋ณด์ฌ์ค ๊ฒ์ผ๋ก ์๊ฐ๋๋ ๋ช ๊ฐ์ง ์๋ฅผ ๋น๊ตํ ์ ์์ต๋๊น?
์ ... ๋ ์์ธํ API๋ฅผ ๊ณ ๋ คํ๊ณ ์๋ค๋ฉด
uninit.into_inner(uninit.assert_initialized());
์๋ฏธ ์ ๊ฝค ์ ์๋ ํ ์ ์์ต๋๋ค. ์ฒซ ๋ฒ์งธ ๋ฉ์๋๋ ์ด์ค ์ ์ ๊ธฐ๋กํ๋ ํ ํฐ์ ๋ฐํํฉ๋๋ค. ๋ ๋ฒ์งธ ๋ฉ์๋๋ ๋ด๋ถ ์ ํ์ ๋ฐํํ์ง๋ง ์ ํจํ๋ค๊ณ ์ฃผ์ฅํด์ผํฉ๋๋ค.
์ถ์ํ๊ฐ ์ฌ๋๋ค์ ๋ ํผ๋์ค๋ฝ๊ฒ ๋ง๋ค์ด ์ค์๋ฅผ ํ ๊ฐ๋ฅ์ฑ์ด ์๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ด ์ถ๊ฐ ๋ ธ๋ ฅ์ ๊ฐ์น๊ฐ ์๋ค๊ณ ํ์ ํ์ง๋ ์์ต๋๋ค.
์ฐ๋ฆฌ๋ ๋ํ @eternaleye (๋ด ์๊ฐ์)๋ก ์ธํด assume_initialized๋์์ต๋๋ค. ๊ฝค ์ค๋๋ ฅ์๋ ๊ทผ๊ฑฐ ๋ชฉ๋ก๊ณผ ํจ๊ป # 53491 (์ฃผ์)์ ์ฐธ์กฐํ์ญ์์ค.
๊ณต์ ํ. assume_initialized
์ข์ ๊ฒ ๊ฐ์ต๋๋ค.
์๋๋ฉด assume_init
์ผ๊น์? ์ด๋ ์์ฑ์, MaybeUninit::uninit()
vs MaybeUninit::uninitialized()
์ ์ผ์น ํด์ผํ๋ฉฐ ์ฒซ ๋ฒ์งธ ๋ฐฐ์น๋ก ์์ ํ ๋ ์์ ์ด๋ฏ๋ก ๊ณง ํธ์ถํด์ผํฉ๋๋ค.
@nicoburns ์ฌ๊ธฐ์ ํ ํฐ์ ํตํด ๊ฐ์ ์ถ๊ฐ๋ฅผ ์ถ๊ฐํจ์ผ๋ก์จ ์ป์ ์์๋ ์ด์ ์ด ์์ต๋๋ค.
๊ทธ๊ฒ์ ๋ํด ๋ ๊น์ด ํ๊ณ ๋ค ์ ์์ต๋๊น? ์๋ง๋ ๋์ ์์ค์ ์์ธํ ๋ด์ฉ์ ๋ณด์ฌ์ค ๊ฒ์ผ๋ก ์๊ฐ๋๋ ๋ช ๊ฐ์ง ์๋ฅผ ๋น๊ตํ ์ ์์ต๋๊น?
์, "๋จ์ง" MaybeUninit
๋ณด๋ค ๋ ์ฅํฉํ๋ค๋ ๊ฒ์ด ๋ถ๋ช
ํฉ๋๋ค. ๋ง์ฃ ? ์ถ๊ฐ์ ์ธ ์ ์ ์ ๋ถ๋ด (๋ ๊ฐ์ง ์ ํ์ ์ดํดํด์ผ ํจ)์ด ๋ง๊ณ ์ด์ค ํ๋ฆผ์ด ์์ผ๋ฉฐ ์ฌ์ฉํ ์ ํ์ ์ ํํด์ผํ๋ค๋ ์๋ฏธ์
๋๋ค. ๋ฐ๋ผ์ ์ฌ๊ธฐ์ ์ ๋นํํด์ผ ํ ์ถ๊ฐ ๋น์ฉ์ด ์์ต๋๋ค.
๋๋ ์ค์ ๋ก Unsafe
์ ์ ์ฉ์ฑ์ ์ผ๋ฐ์ ์ผ๋ก ์์ฌํฉ๋๋ค. ์ปดํ์ผ๋ฌ ๊ด์ ์์ ๋ณผ ๋ ๊ทธ๊ฒ์ ์์ ํ NOP ์ผ ๊ฒ์
๋๋ค. ์ปดํ์ผ๋ฌ๋ ๋ฐ์ดํฐ๊ฐ ์์ ๋ถ๋ณ์ ์ถฉ์กฑํ๋ค๊ณ ๊ฐ์ ํ์ง ์์ต๋๋ค. ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๊ตฌํ ๊ด์ ์์ ๋ณผ ๋ Vec
๊ตฌํ์์ ์ผ์์ ์ผ๋ก ์์ ๋ถ๋ณ์ ์๋ฐํ ๋๋ง๋ค Unsafe<Vec<T>>
๋ณํํ๋ฉด ์ฝ๋ ๊ฐ๋
์ฑ์ด ํฅ์ ๋ ๊ฒ ๊ฐ์ง ์์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ๊ต์ก์ ๊ด์ ์์ ๋ณผ ๋, ์ ํจํ์ง๋ง ์์ ํ์ง ์์ Vec<T>
๋ฅผ ๋ง๋ค์ด์ ์์ ํ ์ฝ๋์ ๋ถ์ฌํ๋ฉด ๋ชจ๋ ๊ฒ์ด ํญ๋ฐ ํ ๋ ๋๋ผ์ง ์์ ๊ฒ์
๋๋ค.
์ด๊ฒ์ ์ปดํ์ผ๋ฌ ๊ด์ ์์ ํ์๋กํ๋ MaybeUninit
์ ๋์กฐํ๊ณ , ์์ ์ ๊ฐ์ธ ์ฝ๋์์ "๋์" bool
์ ๋ํด์ฃผ์ํด์ผํ๋ค๋ ์ฌ์ค์ด ์ผ๋ถ ์ฌ๋๋ค์๊ฒ๋ ๋๋ผ ์ธ ์ ์์ต๋๋ค. .
์๋นํ ๋น์ฉ์ ๊ฐ์ํ ๋ Unsafe
ํจ์ฌ ๋ ๊ฐ๋ ฅํ ๋๊ธฐ ๋ถ์ฌ๊ฐ ํ์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ค์ ๋ก ๋ฒ๊ทธ๋ฅผ ๋ฐฉ์งํ๊ฑฐ๋ ์ฝ๋ ๊ฐ๋
์ฑ์ ๋์ด๋ ๋ฐ ์ด๋ป๊ฒ ๋์์ด๋๋์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
MaybeUninit
์ MaybeInvalid
๋ก ๋ฐ๊พธ๋ ์ธ์๋ฅผ ๋ณผ ์ ์์ต๋๋ค . ๊ทธ๋ฌ๋ "์ ํจํ์ง ์์"์ ๋งค์ฐ ๋ชจํธํฉ๋๋ค ( ๋ฌด์ ์ Vec
"๊ฐ ์ ํจํ๋ค๊ณ ๊ฐ์ ํ ์๋ ์์ต๋๋ค. ๋ชจ๋ ์ข
๋ฅ์ ์ฌ์ฉ. "์ด๊ธฐํ๋์ง ์์"์ ์ต์ํ ๊ธฐ๋ณธ์ ์ผ๋ก ๋๋ถ๋ถ์ ์ฌ๋๋ค์๊ฒ ์ฌ๋ฐ๋ฅธ ์ฐ๊ด์ฑ์ ์ ๋ฐํฉ๋๋ค. "์ ํจ ๋ถ๋ณ"์ ์ด๋ฆ์ "์ด๊ธฐํ ๋ถ๋ณ"์ผ๋ก ๋ฐ๊ฟ์ผํ ๊น์?
๋ํ, Unsafe<T>
์กด์ฌ๋ง์ผ๋ก๋์ด ๋ํผ ์ธ๋ถ์ ์์ ํ์ง ์์ ๊ฐ์ ๊ฐ๋ ๊ฒ์ ๋ํด ๊ฐ๋ ฅํ ๊ด๋ฒ์ํ ๊ท์น์ ์ฑํํ์ง ์๋ ํ (๊ทธ ์์ ๋ํ ๋์ง ์์ ๋ชจ๋ ๊ฐ์ด ์์ ํ๋ค๊ณ ์๋ชป ์์ํ์ฌ) ์คํด์ ์์ง๊ฐ์์ ์ ์์ต๋๋ค. ์ด๊ฒ์ ๋ ๋ค๋ฅธ RFC์ ๋ ๊ด๋ฒ์ํ ์ปค๋ฎค๋ํฐ ํฉ์๊ฐ ํ์ํ ๋๊ท๋ชจ ํ๋ก์ ํธ๊ฐ ๋ ๊ฒ์
๋๋ค. ๋๋ ๊ทธ๊ฒ์ด ๋ค์ ๋
ผ๋์ ์ฌ์ง๊ฐ์์ ๊ฒ์ผ๋ก ์์ํ๊ณ ( @RalfJung ์ ์์์ ๊ทธ๊ฒ์ ๋ํด ๋ช ๊ฐ์ง ์ข์ ์ด์ ๋ฅผ ์ ์ํ๋ค), UB๊ฐ ๊ด๋ จ๋์ด ์์ง ์๊ธฐ ๋๋ฌธ์ MaybeUninit
๋ณด๋ค ๋ ์ฝํ ์ฃผ์ฅ์ด ์์ต๋๋ค. ๋ณธ์ง์ ์ผ๋ก ์คํ์ผ ์ง๋ฌธ์
๋๋ค. ๋ฐ๋ผ์ RFC๊ฐ ์น์ธ๋๊ณ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฌธ์๊ฐ ์
๋ฐ์ดํธ ๋๋๋ผ๋ ๊ทธ๋ฌํ ๊ท์น์ด Rust ์ปค๋ฎค๋ํฐ์์ ๋ณดํธ์ ์ผ์ง์ ๋ํด์๋ ํ์์ ์
๋๋ค.
๊ทธ๋์ IMO์์ ๊ทธ ๋ํ๊ฐ ์ผ์ด๋๋ ๊ฒ์๋ณด๊ณ ์ถ์ ์ฌ๋์ MaybeUninit
API๋ฅผ ์์ ๊ฑฐ๋ฅผ ํ๋ ๊ฒ๋ณด๋ค ๋ ํฐ ๋ฌผ๊ณ ๊ธฐ๋ฅผ ํ๊ธธ ์ ์์ผ๋ฉฐ, ๊ทธ ๊ณผ์ ์ ํด๊ฒฐ์ ๊ธฐ๋ค๋ฆฌ๊ธฐ ์ํด ์์ ํ๋ฅผ ๋ ์ง์ฐํ์ง ์๋ ๊ฒ์ด ์ข์ต๋๋ค. MaybeUninit<T> -> T
๋ณํ์ ์์ ํํ๋ฉด ํฅํ Rust ์ธ๋๋ ์ฒ์์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ๋ํ ๋ด๊ธฐ ์ํด MaybeUninit<Unsafe<T>>
๋ฅผ ์ธ ์ ์์ผ๋ฉฐ ์ด๊ธฐํ ๋ ํ์๋ ์ฌ์ ํ ์์ ํ์ง ์์ ์ ์์ต๋๋ค.
๋ฟก๋ฟก
์๋๋ฉด
assume_init
์ผ๊น์? ์์ฑ์์ ์ผ์นํด์ผํฉ๋๋ค.MaybeUninit::uninit()
vsMaybeUninit::uninitialized()
-๊ทธ๋ฆฌ๊ณ _that_ one์ ์ฒซ ๋ฒ์งธ ๋ฐฐ์น๋ก ์์ ํ ๋ ์์ ์ด๋ฏ๋ก ๊ณง ํธ์ถํด์ผํฉ๋๋ค.
์ ํ, ์์ฑ์ ๋ฐ -> T
ํจ์์ 3 ๋ฐฉํฅ ์ผ๊ด์ฑ์ ๊ฐ์ง ์ ์๋ค๋ฉด ๋ ์ข์ ๊ฒ์
๋๋ค. ์ ํ์ -ialized
์ ๋ฏธ์ฌ๊ฐ ์๊ธฐ ๋๋ฌธ์ ::uninit()
๋ฐ .assume_init()
์ด (๊ฐ) ์๋ง๋ ๊ฐ ๊ธธ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
์, "๋จ์ง"
MaybeUninit
๋ณด๋ค ๋ ์ฅํฉํ ๊ฒ์ด ๋ถ๋ช ํฉ๋๋ค. ๋ง์ฃ ?
๋ฌ๋ ค ... ์ ์๊ฐ์๋ foo.assume_init().assume_safe()
(๋๋ foo.init().safe()
ํ๋ ๊ฐ๋จํ ๋ ํ๋ ๊ฒฝํฅ ๊ฒฝ์ฐ) ๋ชจ๋ ์ด์์ด๋ค. ํ์ํ ๊ฒฝ์ฐ ์กฐํฉ์ foo.assume_init_safe()
๋ก ์ ๊ณต ํ ์๋ ์์ต๋๋ค. ์ด ์กฐํฉ์ ์ฌ์ ํ โโ๋ ๊ฐ์ง ๊ฐ์ ์ ์ค๋ช
ํ๋ค๋ ์ฅ์ ์ด ์์ต๋๋ค.
์ถ๊ฐ์ ์ธ ์ ์ ์ ๋ถ๋ด (๋ ๊ฐ์ง ์ ํ์ ์ดํดํด์ผ ํจ)์ด ๋ง๊ณ ์ด์ค ํ๋ฆผ์ด ์์ผ๋ฉฐ ์ฌ์ฉํ ์ ํ์ ์ ํํด์ผํ๋ค๋ ์๋ฏธ์ ๋๋ค. ๋ฐ๋ผ์ ์ฌ๊ธฐ์ ์ ๋นํํด์ผ ํ ์ถ๊ฐ ๋น์ฉ์ด ์์ต๋๋ค.
ํ๋น์ฑ๊ณผ ์์ ์ฑ์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์ดํดํด์ผ ๋ณต์ก์ฑ์ด ๋ฐ์ํ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ์ผ๋จ ๊ทธ๋ ๊ฒ๋๋ฉด ์ ์ ์ ์ผ๋ก ๋ ๋ณต์กํด์ง์ง ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋๋ ๊ธฐ๋ณธ ๊ฐ๋ ์ด tho๋ฅผ ์ ๋ฌํ๋ ๋ฐ ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋๋ ์ค์ ๋ก ์ผ๋ฐ์ ์ผ๋ก
Unsafe
์ ์ ์ฉ์ฑ์ ์์ฌํฉ๋๋ค. ์ปดํ์ผ๋ฌ ๊ด์ ์์ ๋ณผ ๋ ๊ทธ๊ฒ์ ์์ ํ NOP ์ผ ๊ฒ์ ๋๋ค. ์ปดํ์ผ๋ฌ๋ ๋ฐ์ดํฐ๊ฐ ์์ ๋ถ๋ณ์ ์ถฉ์กฑํ๋ค๊ณ ๊ฐ์ ํ์ง ์์ต๋๋ค.
ํ์คํ; ๋๋ ์ปดํ์ผ๋ฌ POV์์ ์ธ๋ชจ๊ฐ ์๋ค๋ ๊ฒ์ ๋์ํฉ๋๋ค. ๊ตฌ๋ณ์ ์ ์ฉ์ฑ์ ์ผ์ข ์ "์ธ์ ์ ํ"์ธํฐํ์ด์ค์ ๋๋ค.
์๋นํ ๋น์ฉ์ ๊ฐ์ํ ๋
Unsafe
ํจ์ฌ ๋ ๊ฐ๋ ฅํ ๋๊ธฐ๊ฐ ํ์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ค์ ๋ก ๋ฒ๊ทธ๋ฅผ ๋ฐฉ์งํ๊ฑฐ๋ ์ฝ๋ ๊ฐ๋ ์ฑ์ ๋์ด๋ ๋ฐ ์ด๋ป๊ฒ ๋์์ด๋๋์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
์ ๋์ ์ฌ๋ก ์ก์ ๋ถ๋ถ์ ๊ฐ๋ฅด์น๋ ๋ฅ๋ ฅ์ด์์ต๋๋ค. ์ฌ๋๋ค์ด .assume_init()
์ด "OK; ์ ํจ์ฑ ๋ถ๋ณ์ฑ์ ํ์ธํ๊ณ ์ด์ ์ข์ T
"๋ฅผ ์๋ฏธํ๋ค๊ณ ์๊ฐํ ๋ ์ค์๊ฐ ๋ฐ์ํ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. MaybeUninit<T>
์ ํ์ฌ ์ฒด๊ณ๋ ์ด๋ฐ ์์ผ๋ก ๋์์ด๋์ง ์์ต๋๋ค. ๊ทธ๋ฌ๋ ์ ๋ Unsafe<T>
๋ฐ Invalid<T>
์ด๋ฆ๊ณผ ๊ฒฐํผํ์ง ์์์ต๋๋ค. ์ด๋ฆ์ ๊ด๊ณ์์ด ๋ ๊ฐ์ง ์ ํ์ผ๋ก ๋ถ๋ฆฌํ๋ ๊ฒ์ด ๊ต์ก์ ์ผ๋ก ๋์์ด ๋ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์๋ง๋ ํ์ฌ ํ๋ ์ ์ํฌ ๋ด์์์ด๋ฅผ ๋ณด์ ํ ์์๋ ๋ฌธ์๋ฅผ ๊ฐํํ๋ ๊ฒ๊ณผ ๊ฐ์ ๋ค๋ฅธ ๋ฐฉ๋ฒ์ด ์์ต๋๊น?
MaybeUninit
์MaybeInvalid
๋ก ๋ฐ๊พธ๋ ์ธ์๋ฅผ ๋ณผ ์ ์์ต๋๋ค _. ๊ทธ๋ฌ๋ "์ ํจํ์ง ์์"์ ๋งค์ฐ ๋ชจํธํฉ๋๋ค (_what_?์ ์ ํจํ์ง ์์). ์ฌ๋๋ค์ด "์ ํจ ํจ"๊ณผ "์์ ํจ"์ ๊ตฌ๋ถํ์ฌ ํผ๋์ค๋ฌ์ํ๋ ๊ฒ์ ๋ณด์์ต๋๋ค. "์ ํจํVec
"๊ฐ ์ ํจํ๋ค๊ณ ๊ฐ์ ํ ์๋ ์์ต๋๋ค. ๋ชจ๋ ์ข ๋ฅ์ ์ฌ์ฉ. "์ด๊ธฐํ๋์ง ์์"์ ์ต์ํ ๊ธฐ๋ณธ์ ์ผ๋ก ๋๋ถ๋ถ์ ์ฌ๋๋ค์๊ฒ ์ฌ๋ฐ๋ฅธ ์ฐ๊ด์ฑ์ ์ ๋ฐํฉ๋๋ค. "์ ํจ ๋ถ๋ณ"์ ์ด๋ฆ์ "์ด๊ธฐํ ๋ถ๋ณ"์ผ๋ก ๋ฐ๊ฟ์ผํ ๊น์?
๋๋ "์ ํจ์ฑ"๊ณผ "์์ ์ฑ"์ด "์ ํจ"ํ๊ฒ ๋ค๋ฆฌ๋ ๋ฐฉ์์ผ๋ก ์ธํด ํผ๋๋๋ ๊ฒ์ ๋์ํฉ๋๋ค. ๋๋ "์ ํจ์ฑ"์ ๋์ฒดํ๋ "๊ธฐ๊ณ ๋ถ๋ณ"๊ณผ "์์ "์์ํ "์ ํ ์์คํ ๋ถ๋ณ"์ ๋ถ๋ถ์ ์ด์๋ค.
๋ฟก๋ฟก
๊ทธ๋์ IMO๋ ๊ทธ ๋ํ๊ฐ ์ผ์ด๋๋ ๊ฒ์๋ณด๊ณ ์ํ๋ ์ฌ๋์ด๋ผ๋ฉด
MaybeUninit
API๋ฅผ ์์ ๊ฑฐ๋ฅผ ํ๋ ๊ฒ๋ณด๋ค ๋ ํฐ ๋ฌผ๊ณ ๊ธฐ๋ฅผ ํ๊ธธ ์ ์์ผ๋ฉฐ, ๊ทธ ๊ณผ์ ์ ํด๊ฒฐ์ ๊ธฐ๋ค๋ฆฌ๊ธฐ ์ํด ์์ ํ๋ฅผ ๋ ์ง์ฐํ์ง ์๋ ๊ฒ์ด ์ข์ต๋๋ค.MaybeUninit<T> -> T
๋ณํ์ ์์ ํํ๋ฉด ๋ฏธ๋์ Rust ์ธ๋๋ ์ฒ์์ ์ด๊ธฐํ๋์ง ์์ ๋ฐ์ดํฐ๋ฅผ ๋ํ ๋ด๊ธฐ ์ํดMaybeUninit<Unsafe<T>>
๋ฅผ ์ธ ์ ์์ผ๋ฉฐ ์ด๊ธฐํ ๋ ํ์๋ ์ฌ์ ํ ์์ ํ์ง ์์ ์ ์์ต๋๋ค.
ํนํ ๋ค์ ์ข์ ์ . MaybeUninit<Unsafe<T>>
; ์ ํ ์ด๋ฆ์ ๋ ์ฅํฉํ๊ฒ ๋ง๋ค๊ธฐ ์ํด ์ ํ ๋ณ์นญ์ ์ถ๊ฐ ํ ์๋ ์์ต๋๋ค.
์ ํ, ์์ฑ์ ๋ฐ-> T ํจ์์ 3 ๋ฐฉํฅ ์ผ๊ด์ฑ์ ๊ฐ์ง ์ ์๋ค๋ฉด ๋ ์ข์ ๊ฒ์ ๋๋ค. ์ ํ์ -ialized ์ ๋ฏธ์ฌ๊ฐ ์์ผ๋ฏ๋ก :: uninit () ๋ฐ .assume_init ()๊ฐ ์๋ง๋ ๊ฐ ๊ธธ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
๋์ํฉ๋๋ค. into
์ ๋์ฌ๋ฅผ ์์ด๋ฒ๋ฆฐ ๊ฒ์ ๋ํด ์กฐ๊ธ ์ฌํ์ง๋ง ๊ทธ๊ฒ์ ์ ์งํ๋ ์ข์ ๋ฐฉ๋ฒ์ ์์ต๋๋ค.
๊ทธ๋ ๋ค๋ฉด read
/ read_init
๋ ์ด๋ป์ต๋๊น? ptr::read
์์ ์ ์ฌ์ฑ์ด "์ค์ ๋ก ์ด๊ธฐํ๋์๋์ง ํ์ธํ๋ ๊ฒ์ด ์ข์ต๋๋ค"๋ฅผ ํธ๋ฆฌ๊ฑฐํ๊ธฐ์ ์ถฉ๋ถํฉ๋๊น? ์์ต๋๋ค read_init
์ ์ ์ฌํ ๋ฌธ์ ๊ฐ into_init
๊ฐ ๊ทธ๊ฒ์ ์ด๊ธฐํํ๋ ๋์ ํ์ํฉ๋๋ค ๊ฐ์ ์๋ฆฌ, ๊ทธ ๊ฐ์ ์ผ๋ก? assume_init
์ด read
) ์ง๊ธ ๊ฐ์์ผํฉ๋๊น?
ํ๋น์ฑ๊ณผ ์์ ์ฑ์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์ดํดํด์ผ ๋ณต์ก์ฑ์ด ๋ฐ์ํ๊ธฐ๋ฅผ ๋ฐ๋๋๋ค. ์ผ๋จ ๊ทธ๋ ๊ฒ๋๋ฉด ์ ์ ์ ์ผ๋ก ๋ ๋ณต์กํด์ง์ง ์๋๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋๋ ๊ธฐ๋ณธ ๊ฐ๋ ์ด tho๋ฅผ ์ ๋ฌํ๋ ๋ฐ ์ค์ํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
Vec
์ ๋ถ๋ณ์ด ์๋ฐ๋์์ ๋์ด๋ฅผ ๋ฐ์ํ๊ธฐ ์ํด ์ด๊ฒ์ ์ ์ ํ ์ฌ์ฉํ์ฌ Vec
์์๋ ๊ฒ์ด ์๋ค๋ฉด ์ฝ๋ ์์ ๋ฅผ ์ค ์ ์์ต๋๊น? ๋๋ ๊ทธ๊ฒ์ด ์ค์ ๋ก ์ผ์ด๋๋ ์ผ์ด ๋งค์ฐ ์ฅํฉํ๊ณ ์์ ํ ๋ชจํธํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
์ด์ ๊ฐ์ ์ ํ์ ์ถ๊ฐํ๋ ๊ฒ์ ๊ธฐ๋ณธ ๊ฐ๋ ์ ์ ๋ฌํ๋ ์๋ชป๋ ๋ฐฉ๋ฒ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค.
๋๋ ์ฌ๋๋ค์ด .assume_init ()๊ฐ "OK; ๋๋ ๋ถ๋ณ์ ์ ํจ์ฑ์ ํ์ธํ๊ณ ์ด์ ์ข์ T๋ฅผ ๊ฐ์ง๊ณ ์๋ค"๋ ์๋ฏธ๋ผ๊ณ ์๊ฐํ ๋ ์ค์๊ฐ ์ผ์ด๋ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค.
๋๋ ๋๊ตฐ๊ฐ๊ฐ " 0xFF
๊ฐ๋ ์ฐจ์์ด Vec<i32>
๋ฅผ ์ด๊ธฐํํ์ต๋๋ค. ์ด์ ์ด๊ธฐํ๋์์ต๋๋ค. ์ฆ, ํธ์ ํ ์ ์์์ ์๋ฏธํฉ๋๋ค." ๋๋ ์ด๊ฒ์ด ์ค์ ๋ก ์ฌ๋๋ค์ด ์ ์ง๋ฅด๋ ์ค์๋ผ๋ ํ์, ๋ ํ์คํ ๋ฐ์ดํฐ๋ฅผ๋ณด๊ณ ์ถ์ต๋๋ค.
๋ด ๊ฒฝํ์ ์ฌ๋๋ค์ ์ ์์๋ ์ฝ๋์ ๋ฐ์ดํฐ๋ฅผ ์ ๋ฌํ๊ฑฐ๋ ์ผ๋ถ ๋ฐ์ดํฐ์ ๋ํ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์์
์ ํธ์ถ ํ ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ถ๋ณ์ฑ์ ์ ์งํด์ผํ๋ค๋ ๋งค์ฐ ํ์คํ ์ง๊ฐ์ ๊ฐ์ง๊ณ ์์ต๋๋ค.
์ฌ๊ธฐ์ ์ํฉ์ด ์กฐ๊ธ ์ง์ ๋์์ต๋๋ค. ๋ฐ๋ผ์ ๋ค์ ๊ณํ์ ์ด๋ป์ต๋๊น?
MaybeUninit::uninitialized
๋ฅผ ์ฌ์ฉํ์ง ์๋๋ก PR์ ์ค๋นํ๊ณ ์ด๋ฆ์ MaybeUninit::uninit
๋ฐ๊ฟ๋๋ค.MaybeUninit::{new, uninit, zeroed, as_ptr, as_mut_ptr}
์์ ํ๋ฅผ์ํ PR์ ์ค๋นํฉ๋๋ค.๊ทธ๋ฌ๋ฉด set
/ write
, into_init[ialized]
/ assume_init[ialized]
๋ฐ read[_init[italized]]
๋ํ ์ง๋ฌธ์ด ์ด๋ฆฝ๋๋ค. ํ์ฌ๋ assume_init
, write
๋ฐ read
์์งํ๊ณ ์์ง๋ง ์ด์ ์ ์ด์ ๋ํด ๋ง์์ ๋ฐ๊ฟจ์ต๋๋ค. ๋ถํํ๋ ์ ๋ ์ฌ๊ธฐ์ ๊ฒฐ์ ์ ๋ด๋ฆฌ๋ ๋ฐฉ๋ฒ์ ์ ๋ชจ๋ฆ
๋๋ค.
- ์ผ๋จ ์ฐฉ๋ฅํ๋ฉด
์ด๋ (a) ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋๋ (b) ๋ถ์์ ํ ๊ธฐ๋ฅ์ ์ฌ์ฉํ์ง ์๊ณ ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ์์ฑ ํ ๋ฐฉ๋ฒ์ด ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๊น? ๊ทธ๊ฒ์ ์ง์ ๊ฐ๋ฅํ ๊ดํ์ด ์๋๋๋ค.
ํจ๊ณผ์ ์ผ๋ก ์ ๊ฑฐ ํ ๊ณํ์ด์๋ ํญ๋ชฉ์ ํ๊ธฐ ํ ๋๋ ํ๊ธฐ ๊ฒฝ๊ณ ๊ฐ ์ถ๊ฐ ๋ ๋๋ง๋ค ์์ ์ ์ธ ๊ต์ฒด๋ฅผ ์ฌ์ฉํ ์ ์์ด์ผํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฌ๋๋ค์ ๊ฒฝ๊ณ ๋ฅผ ๋ฌด์ํ๊ณ ์ถ์ ๊ณ์ํ๊ธฐ ์ํด ์ฃผ์์ ์ถ๊ฐ ํ ๊ฒ์ ๋๋ค.
์ด๋ (a) ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋๋ (b) ๋ถ์์ ํ ๊ธฐ๋ฅ์ ์ฌ์ฉํ์ง ์๊ณ ์ด๊ธฐํ๋์ง ์์ ๊ฐ์ ์์ฑ ํ ๋ฐฉ๋ฒ์ด ์๋ค๋ ๊ฒ์ ์๋ฏธํฉ๋๊น?
ํผ๋ ์ค๋ฝ์ต๋๋ค. ๋๋ ๋ถ์์ ํ ๋ฐฉ๋ฒ์ ๋น๋ํ๊ณ ๋์ ๋ค๋ฅธ ๋ถ์์ ํ ๋ฐฉ๋ฒ์ ๋์ ํ ๊ฒ์ ์ ์ํ๊ณ ์์ต๋๋ค.
๋ด๊ฐ mem::uninitialized
์๋๋ผ MaybeUninit::uninitialized
์ ๋ํด ์ด์ผ๊ธฐํ๊ณ ์๋ ๊ฒ์ ์ฃผ๋ชฉํ์ญ์์ค.
๋ถํํ๋ ์ ๋ ์ฌ๊ธฐ์ ๊ฒฐ์ ์ ๋ด๋ฆฌ๋ ๋ฐฉ๋ฒ์ ์ ๋ชจ๋ฆ ๋๋ค.
@RalfJung ๋ค๋ฅธ ์ด๋ฆ ๋ณ๊ฒฝ PR๊ณผ ํจ๊ป ์ด์ ์ํ๋ ๊ฒ์ฒ๋ผ (๊ทธ๋ฆฌ๊ณ ์ํ๋ ๊ฒฝ์ฐ r? ์ ๋ฅผ) ์ํํ๊ณ ๋๊ตฐ๊ฐ๊ฐ ๋ฐ๋ํ๋ ๊ฒฝ์ฐ FCP์์ ์ฒ๋ฆฌ ํ ์ โโ์์ต๋๋ค. :)
๋ค๋ฅธ ์ด๋ฆ ๋ณ๊ฒฝ PR์ ๋ํด ์ด์ ์ํ๋ ๊ฒ์ฒ๋ผ (๊ทธ๋ฆฌ๊ณ ์ํ๋ ๊ฒฝ์ฐ r? me) ์ํํ๊ณ ๋๊ตฐ๊ฐ๊ฐ ๋ฐ๋ํ๋ ๊ฒฝ์ฐ FCP์์ ์ฒ๋ฆฌ ํ ์ โโ์์ต๋๋ค. :)
๊ธ์, ๋๋ ์ด๊ฒ๋ค์ด ์ด๊ธฐ ์์ ํ์ ์ผ๋ถ๊ฐ ๋ ํ์๊ฐ ์๊ธฐ ๋๋ฌธ์ ์กฐ๊ธ ๊ธฐ๋ค๋ฆด ๊ฒ์ ๋๋ค.
๋ถ์์ ํ ๋ฉ์๋๋ฅผ ํ๊ธฐํ๊ณ ๋์ ๋ค๋ฅธ ๋ถ์์ ํ ๋ฉ์๋๋ฅผ ๋์ ํ์ญ์์ค.
์, ์ก์๋ค. ๊ทธ๋ผ ๊ณ์ํด.
์ข์ต๋๋ค. https://github.com/rust-lang/rust/pull/59284 ์์ ์ด๋ฆ์ ๋ณ๊ฒฝํฉ๋๋ค.
์ด๊ธฐํ๋์ง ์์-> ์ด๊ธฐํ ํด์
into_initialized-> ๊ฐ์ _ ์ด๊ธฐํ
read_initialized-> ์ฝ๊ธฐ
์ค์ -> ์ฐ๊ธฐ
์๋ก ์ ์ ๋ ์ด๋ฆ์ด ๋ง์์ ๋ญ๋๋ค. read
์ด ์ค์ฉ๋๋ ๊ฒ์ ๋ํด ์ฝ๊ฐ ๊ฑฑ์ ๋์ง๋ง, ์ฃผ๋ก ptr::read
์์ ์ฐ๊ด์ฑ ๋๋ฌธ์ into_initialized
๊ฐ ์ค์ฉ๋๋ ๊ฒ๋ณด๋ค ํจ์ฌ ๋ ์ฌ์ฉ๋๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ ๋ฐ์ ์ผ๋ก ์๋ก์ด ์ด๋ฆ์ ์์ ํ๋ฅผ ์ํด ์์ ํ ์์ฉ ๊ฐ๋ฅํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
MaybeUninit :: {new, uninit, zeroed, as_ptr, as_mut_ptr}๋ฅผ ์์ ํํ๊ธฐ ์ํด PR์ ์ค๋นํฉ๋๋ค.
์ด๊ฒ์ด 1.35- ๋ฒ ํ (์ฝ 2 ์ฃผ ํ)๊ฐ ๋ ๊ฐ๋ฅ์ฑ์ด ์์ต๋๊น?
๋๋ https://github.com/rust-lang/rfcs/pull/2582๊ฐ ์ฌ์ ํ ์ผ๋ง๋ ๊ณต์ค์ ์๋์ง๋ฅผ ๊ฐ์ํ ๋ ์ด๊ฒ์ ๋ฐ์ด๋ด๋ ๊ฒ์ ๋ํด ์ฝ๊ฐ ์ถฉ๋ํฉ๋๋ค. : / RFC ์์ด๋ ๊ตฌ์กฐ์ฒด์ ์ ์ง์ ์ธ ์ด๊ธฐํ๋ ์ฌ์ ํ ๋ถ๊ฐ๋ฅํ์ง๋ง ์ฌ๋๋ค์ ์ด์จ๋ ๊ทธ๋ ๊ฒ ํ ๊ฒ์
๋๋ค.
OTOH, MaybeUninit
์ (๋) ์ถฉ๋ถํ ์ค๋ ๊ธฐ๋ค๋ ธ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๋๋ค์ด ํ์ฌ ์์ฑํ๋ ์ ์ง์ ์ด๊ธฐํ ์ฝ๋๊ฐ MaybeUninit
์์ฑํ๋ ๊ฒ๋ณด๋ค ๋ซ์ง ์์ต๋๋ค.
์ฆ, https://github.com/rust-lang/rust/pull/59284 ๋ ์์ง ์ฐฉ๋ฅํ์ง ์์์ผ๋ฏ๋ก 1.35๋ก ์๋๋ฌ์ผํฉ๋๋ค. TBH ๋๋ ์ฌ๋๋ค์ด ์๋ก์ด ๋ฐฉ๋ฒ ์ด๋ฆ์ ๊ฐ์ง๊ณ ๋๋ฉด์ ๊ทธ๋ค์ด ์ด๋ป๊ฒ ๋๋ผ๋์ง ๋ณผ ์ ์๋๋ก ์ ์ด๋ ํ ๋ฒ์์ฃผ๊ธฐ๋ฅผ ๋ ๊ธฐ๋ค๋ฆฌ๋ ๊ฒ์ ์ ํธํฉ๋๋ค.
MaybeInit
์ ๊ตฌ์ฑ ํจ์๊ฐ const
์์ต๋๊น?
init
๋ฐ new
๋ const
์
๋๋ค. zeroed
๋ ๊ทธ๋ ์ง ์์ต๋๋ค. const
๋๊ธฐ ์ ์ const ํจ์๊ฐ ํ ์์๋ ์์
์ ๋ํ ํ์ฅ์ด ํ์ํฉ๋๋ค.
MaybeUninit
์ ๋ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ๊ณ ์ถ์์ต๋๋ค. ์ค์ ์ฝ๋ ๋ณ๊ฒฝ ์ฌํญ์ https://github.com/Thomasdezeeuw/mio-st/pull/71 ์์ . ์ ๋ฐ์ ์ผ๋ก API์ ๋ํ ๋์ (์ ํ๋) ๊ฒฝํ์ ๊ธ์ ์ ์ด์์ต๋๋ค.
๋ด๊ฐ ๋ฐ๊ฒฌํ๋ ์ ์ผํ ์์ ๋ฌธ์ ๋ ๋์ ์ค๋ ๊ฒ์ด ์์ต๋๋ค &mut T
์์ MaybeUninit::set
์๋์ ๋ฆฌ๋๋ฅผ ์ฌ์ฉํ๊ธฐ let _ = ...
(https://github.com/Thomasdezeeuw/mio-st/pull/๋ฅผ 71 / files # diff-1b9651542d08c6eca04e6025b1c6fd53R116) ์ฝ๊ฐ ์ด์ํ์ง๋ง ํฐ ๋ฌธ์ ๋ ์๋๋๋ค.
๋ํ ์์ฃผ C์ ํจ๊ป ํตํฉ ๋ฐฐ์ด๋ก ์์ ํ ๋ ์ํ๋ API๋ฅผ ์ถ๊ฐํด์ผํฉ๋๋ค.
&mut [MaybeUninit<T>]
์์ &mut [T]
๋ก ์ด๋ํ๋ ๋ฐฉ๋ฒ์ด ์ข์ ๊ฒ์
๋๋ค. ์ฌ์ฉ์๋ ์ฌ๋ผ์ด์ค์ ๋ชจ๋ ๊ฐ์ด ์ ๋๋ก ์ด๊ธฐํ๋์๋์ง ํ์ธํด์ผํฉ๋๋ค.uninitialized_array
์ ๊ฐ์ ๊ณต๊ฐ ๋ฐฐ์ด ์ด๋์
๋ผ์ด์ ํจ์ ๋๋ ๋งคํฌ๋ก๋ ์ ๋ง ์ข์ ์ถ๊ฐ ๊ธฐ๋ฅ์
๋๋ค.MaybeUninit์ ๋ํ ํผ๋๋ฐฑ์ ์ ๊ณตํ๊ณ ์ถ์์ต๋๋ค.
๊ฐ์ฌํฉ๋๋ค!
MaybeUninit :: set์์ & mut T๋ฅผ ๋ฐํํ๋ฉด let _ = ...
์ ๊ทธ๋ด๊น์? ๋ฐํ ๊ฐ์ "๋ฒ๋ฆด"์ ์์ต๋๋ค. ์ค์ ๋ก ๋ฌธ์ ์ ์์ ๋ let _ = ...
์ํํ์ง ์์ต๋๋ค. ( write
/ set
์๋ ์์ง ์์ ๊ฐ ์์ต๋๋ค ...ํ์ง๋ง ์ค์ ๋ก๋ read
์ ๊ฑฐ์ ๋์ผํฉ๋๋ค. ๋งํฌ ๋ง ์์ผ๋ฉด๋ฉ๋๋ค.)
foo.write(bar);
๋ let
์์ด ์ ์๋ํฉ๋๋ค.
๋จ์ผํ ๋ฐฐ์ด ์์
๋ค, ๊ทธ๊ฒ์ ํ์คํ ๋ฏธ๋์ ๊ด์ฌ ๋ถ์ผ์ ๋๋ค.
๋ฟก๋ฟก
MaybeUninit :: set์์ & mut T๋ฅผ ๋ฐํํ๋ฉด let _ = ...
์ ๊ทธ๋ด๊น์? ๋ฐํ ๊ฐ์ "๋ฒ๋ฆด"์ ์์ต๋๋ค. ์ค์ ๋ก ๋ฌธ์ ์ ์์ ๋
let _ = ...
์ํํ์ง ์์ต๋๋ค. (write
/set
์๋ ์์ง ์์ ๊ฐ ์์ต๋๋ค ...ํ์ง๋ง ์ค์ ๋ก๋read
์ ๊ฑฐ์ ๋์ผํฉ๋๋ค. ๋งํฌ ๋ง ์์ผ๋ฉด๋ฉ๋๋ค.)
unused_results
๋ํ ๊ฒฝ๊ณ ๋ฅผ ํ์ฑํ ํ์ผ๋ฏ๋ก let _ = ...
์์ด๋ ๊ฒฝ๊ณ ๊ฐ ์์ฑ๋ฉ๋๋ค. ๊ธฐ๋ณธ๊ฐ์ด ์๋์ ์์์ต๋๋ค.
์, ๊ทธ ๊ฒฝ๊ณ ์ ๋ํด ๋ชฐ๋์ต๋๋ค. ํฅ๋ฏธ ๋กญ๊ตฐ.
์ด๋ write
๊ฐ ์ฐธ์กฐ๋ฅผ ๋ฐํํ์ง ์๋๋กํ๋ ์ธ์ ์ผ ์ ์์ผ๋ฉฐ ๋ ๋ง์ ์์๊ฐ์๋ ๊ฒฝ์ฐ ๋ณ๋์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.
uninitialized_array
์ ๊ฐ์ ๊ณต๊ฐ ๋ฐฐ์ด ์ด๋์ ๋ผ์ด์ ํจ์ ๋๋ ๋งคํฌ๋ก๋ ์ ๋ง ์ข์ ์ถ๊ฐ ๊ธฐ๋ฅ์ ๋๋ค.
์ด๊ฒ์ [MaybeUninit::uninit(); EVENTS_CAP]
์
๋๋ค. https://github.com/rust-lang/rust/issues/49147์ ์ฐธ์กฐ
๊ธฐ๋ณธ๊ฐ์ด ์๋์ ์์์ต๋๋ค.
์ด๋
write
๊ฐ ์ฐธ์กฐ๋ฅผ ๋ฐํํ์ง ์๋๋กํ๋ ์ธ์ ์ผ ์ ์์ผ๋ฉฐ ๋ ๋ง์ ์์๊ฐ์๋ ๊ฒฝ์ฐ ๋ณ๋์ ๋ฉ์๋๋ฅผ ์ ๊ณตํฉ๋๋ค.
ํ์ ์์ฅ ๊ฐ๋์? ์์ผ๋ก ๋ ๋ง์ ์์๊ฐ์์ ๊ฒฝ์ฐ ์ฐธ์กฐ๋ฅผ ๋ฐํ ํ์ง ์๋ ๋ฉ์๋๋ฅผ ์ถ๊ฐ ํ ์ ์์ต๋๋ค.
ํ์ ์์ฅ ๊ฐ๋์?
์, ๊ฐ์ ์ค์ ํ ๋ค์ ์ด์ ๋ํ ๊ฐ๋ณ ์ฐธ์กฐ๋ฅผ ๋ฐํํ๋ ์๋ง์ ๋ฉ์๋๊ฐ ์์ต๋๋ค.
@Centril Heh, ๋ค๋ฅธ ๊ณณ์์์ด ๊ธ์ ์ผ์ ๋ ์ฌ๊ธฐ์์ ๊ทํ์ ์๊ฒฌ์ ๋ณด์ง ๋ชปํ ๊ฒ ๊ฐ์ต๋๋ค : https://github.com/rust-lang/rust/issues/54542#issuecomment -478261027
https://github.com/rust-lang/rust/pull/59912 ์์ ๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ์ด์ ์ด๋ฆ์ด ๋ณ๊ฒฝ๋ ํจ์๋ฅผ ์ ๊ฑฐํฉ๋๋ค
๊ทธ ํ ๋ค์์ผ๋ก ํ ์ผ์ ์์ ํ๋ฅผ ์ ์ํ๋ ๊ฒ์ ๋๋ค ... : tada :
๋๋ Rust-lang / rfcs # 2582๊ฐ ์ฌ์ ํ ๊ณต๊ธฐ์์ ์ผ๋ง๋ ์ ์ ์ผ๋ก ์ฌ๋ผ๊ฐ๋ ์ง ๊ฐ์ํ ๋ ์ด๊ฒ์ ๋ฐ์ด ๋ถ์ด๋ ๊ฒ์ ๋ํด ์ฝ๊ฐ ์ถฉ๋ํฉ๋๋ค. : / RFC ์์ด๋ ๊ตฌ์กฐ์ฒด์ ์ ์ง์ ์ธ ์ด๊ธฐํ๋ ์ฌ์ ํ ๋ถ๊ฐ๋ฅํ์ง๋ง ์ฌ๋๋ค์ ์ด์จ๋ ๊ทธ๋ ๊ฒ ํ ๊ฒ์ ๋๋ค.
OTOH,MaybeUninit
์ (๋) ์ถฉ๋ถํ ์ค๋ ๊ธฐ๋ค๋ ธ์ต๋๋ค. ๊ทธ๋ฆฌ๊ณ ์ฌ๋๋ค์ด ํ์ฌ ์์ฑํ๋ ์ ์ง์ ์ด๊ธฐํ ์ฝ๋๊ฐMaybeUninit
์์ฑํ๋ ๊ฒ๋ณด๋ค ๋ซ์ง ์์ต๋๋ค.
๊ทธ ํ ๋ค์์ผ๋ก ํ ์ผ์ ์์ ํ๋ฅผ ์ ์ํ๋ ๊ฒ ๊ฐ์์ ... ๐
@RalfJung ์ฌ๊ธฐ ๋ฌธ์์ ์ํ๋ ์ด๋ป์ต๋๊น? ๋ ๋์ ์๋ฉด์ ๋์์ด๋๋ ๋ช ํํ ๋ฌธ์๋ฅผ ์ฌ์ฉํ์ฌ "์ฌ๋๋ค์ ์ด์จ๋ ํ ๊ฒ"์ ์ํ ํ ์ ์๋ค๋ฉด ... :)
MaybeUninit
, ํนํ assume_init
๋ฌธ์๋ฅผ ์ฝ์ด ๋ณด๋ฉด "์์ "์น์
์์ mu.assume_init()
ํธ์ถ ํ ๋ค์ ํด๋น ๊ฒฐ๊ณผ๋ฅผ ๋ฐํํ๋ ๊ฒ์ด ๋ช
ํํ์ง ์์ต๋๋ค. ์์ ํ fn
์์ ์์ ๋ถ๋ณ๋ ์ ์งํด์ผํฉ๋๋ค. ์์ ํํ๊ธฐ ์ ์ ํด๋น ๋ฌธ์๋ฅผ ํฅ์์ํค๊ณ MaybeUninit
์ฌ์ฉํ ๋๋ ์ ์ง๋์ด์ผํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ๊ณต ์์ ๋ถ๋ณ์ ์ค ๋ํซ์ ์ ๊ณตํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ฌ๊ธฐ ๋ฌธ์์ ์ํ๋ ์ด๋ป์ต๋๊น? ๋ ๋์ ์๋ฉด์ ๋์์ด๋๋ ๋ช ํํ ๋ฌธ์๋ฅผ ์ฌ์ฉํ์ฌ "์ฌ๋๋ค์ ์ด์จ๋ ํ ๊ฒ"์ ์ํ ํ ์ ์๋ค๋ฉด ... :)
ํ์ฌ ์ง์๋์ง ์๋ ๊ตฌ์กฐ์ ์ ์ง์ ์ด๊ธฐํ์ ๋ํ ์น์ ์ ์ถ๊ฐ ํ ๊ฒ์ ๋๋ค. ์ด๊ฒ์ ์ฝ๋ ์ฌ๋๋ค์ "WTF, ์ ๋ง๋ก?"์ ๊ฐ์ ๊ฒ์ ๋๋ค.
TBH ๋๋ ์ด๊ฒ์ด ๋ค์ ์ค๋ง ์ค๋ฝ์ต๋๋ค. :( ์ง๊ธ ์ฏค์ด๋ฉด ๊ทธ์ ๋ํ ์กฐ์ธ์ ๋ด๋๋ ๊ฒ์ด ๋งค์ฐ ๊ฐ๋ฅํ๋ค๊ณ ์๊ฐํ๋ฉฐ ๊ทธ๋ ๊ฒ ํ ์ ์์ด์ ์ฌํ๋ค.
"์์ "์น์ ์์๋ mu.assume_init ()๋ฅผ ํธ์ถ ํ ๋ค์ ๊ทธ ๊ฒฐ๊ณผ๋ฅผ ์์ ํ fn์ผ๋ก ๋ฐํํ๋ฉด ์์ ๋ถ๋ณ๋ ์ ์งํด์ผํ๋ค๋ ๊ฒ์ด ๋ช ํํ์ง ์์ต๋๋ค. ์์ ํํ๊ธฐ ์ ์ ํด๋น ๋ฌธ์๋ฅผ ๊ฐ์ ํ๊ณ MaybeUninit๋ฅผ ์ฌ์ฉํ ๋๋ ์ ์ง๋์ด์ผํ๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ ์ ๊ณต ์์ ๋ถ๋ณ์ ์ค ๋ํซ์ ์ ๊ณตํ๋ ๊ฒ์ด ์ข์ต๋๋ค.
๊ธฐ๋ณธ์ ์ผ๋ก ์ด๊ฒ์ ๋ฐ์ดํฐ ์ ํ ๋ถ๋ณ์ ์ ์ฒด ๊ฐ๋
๊ณผ Rust์์ ์ด๋ป๊ฒ ์ ๊ฐ๋๋์ง๋ฅผ ์ค๋ช
ํ๋ ๋ฌธ์๋ก ๋ฐ๊พธ๋ผ๊ณ ์ ์ํ๊ณ ์์ต๋๋ค. ์ ๋ MaybeUninit
์ด ์๋ชป๋ ๊ณณ์ด๋ผ๊ณ ์๊ฐํฉ๋๋ค. ์ด ๋ฌธ์ ๋ MaybeUninit
์๋ง ํด๋น๋๋ ๊ฒ์ฒ๋ผ ๋ค๋ฆฌ์ง๋ง ์ค์ ๋ก๋ ๊ทธ๋ ์ง ์์ต๋๋ค. ๋น์ ์ด ์๊ตฌํ๋ ๊ฒ์ Nomicon๊ณผ ๊ฐ์ ๋ ๋์ ์์ค์ ์ฅ์์์ ์ค๋ช
๋์ด์ผํฉ๋๋ค. ์ด ์ ํ์ ํต์ฌ ๋ฌธ์ ์ MaybeUninit
๋ฌธ์๋ฅผ ์ง์คํ ๊ณํ์
๋๋ค. ์ ์ฉํ๋ค๊ณ ์๊ฐ๋๋ฉด ์์ ๋กญ๊ฒ ํ์ฅํ์ญ์์ค. :)
๊ธฐ๋ณธ์ ์ผ๋ก ์ด๊ฒ์ ๋ฐ์ดํฐ ์ ํ ๋ถ๋ณ์ ์ ์ฒด ๊ฐ๋ ๊ณผ Rust์์ ์ด๋ป๊ฒ ์ ๊ฐ๋๋์ง๋ฅผ ์ค๋ช ํ๋ ๋ฌธ์๋ก ๋ฐ๊พธ๋ผ๊ณ ์ ์ํ๊ณ ์์ต๋๋ค.
์ด๊ฒ์ ์ฝ๊ฐ ๊ฐ๋ ฅํฉ๋๋ค ... ์ ๋ MaybeUninit<T>
์ ๋ฌธ์์ ์ ๋ต์ ์์น์์ "์ค, __ ๊ทธ๋ฐ๋ฐ __, ์์ ๋ถ๋ณ ๋ฌธ์ ๋ MaybeUninit<T>
์ฌ์ฉํ๋ ๋๋ถ๋ถ์ ์ฌ๋๋ค์ ๋๋ถ๋ถ ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ ๋ฌธ์์ ์ธํฐํ์ด์ค ํ ๊ฐ๋ฅ์ฑ์ด ์์ต๋๋ค.
์ข์์, ์ ๋์ด ๋ชจ๋ ๊ฒ์ ์์ ํ PR์ ํตํฉํ๋ ค๊ณ ํ์ต๋๋ค : https://github.com/rust-lang/rust/pull/60445
๋ ๊ทธ๋ฅ์ ์ฌ์ฉ ์ฐ์ฐํ mem::uninitialized
ํ์ค ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ๋ฌธ์์, ์ ๋ง ์ด๋ ๋ค๋ฅธ ๊ฒ์ ์ฐธ๊ณ ๋ชฐ๋๋ค ์ ๋ง์ง๋ง ์๋ฅผ ๋ค์ด core::ptr::drop_in_place
์๊ตฌ ์์ด๋ฌ๋์ ์ข
๋ฅ๋ (์
๋ฐ์ดํธ ํ https://github.com/rust-lang/rfcs/pull/2582์ ์ํด์๋ง ์น์ธ๋๋ ๋ค๋ฅธ ํํ์ UB๋ฅผ ๋ณด์ฌ ์ฃผ๋ฏ๋ก ๊ฐ์ธ์ ์ผ๋ก ์ ๊ฑฐํ๊ฒ ์ต๋๋ค).
@HeroicKatora ๊ฐ์ฌํฉ๋๋ค! ์ด์ ๋ํ ์์ ์ฌํญ์ https://github.com/rust-lang/rust/pull/60445์ ํตํฉํ์ต๋๋ค
์ฐ๋ฆฌ๋ ํ์ฌ ref-to-unaligned-field์ ๋ํด ์๋ฌด๊ฒ๋ ํ ์ ์์ง๋ง ๋ฌธ์๋ฅผ ์ ๊ฑฐํ๋ ๊ฒ์ด ์ข์ ์๊ฐ์ธ์ง ํ์คํ์ง ์์ต๋๋ค.
๋ฉํ ๋ฐ์ดํฐ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๋ฐ์ดํฐ๋ฅผ ๋ถ๋ถ์ ์ผ๋ก ์ด๊ธฐํํ๋ PartialUninit
(๋๋ PartialInit
) ํน์ฑ์ ์ถ๊ฐ ํ ์ ์์ต๋๋ค.
์ : MODULEENTRY32W .
์ฒซ ๋ฒ์งธ ํ๋ ( dwSize
)๋ ๊ตฌ์กฐ ํฌ๊ธฐ ( size_of::<MODULEENTRY32W>()
)๋ก ์ด๊ธฐํ๋์ด์ผํฉ๋๋ค.
pub trait PartialUninit: Sized {
fn uninit() -> MaybeUninit<Self>;
}
impl<T> PartialUninit for T {
default fn uninit() -> MaybeUninit<Self> {
MaybeUninit::uninit()
}
}
impl PartialUninit for MODULEENTRY32W {
unsafe fn uninit() -> MaybeUninit<MODULEENTRY32W> {
let uninit = MaybeUninit { uninit: () };
uninit.get_mut().dwSize = size_of::<MODULEENTRY32W>();
uninit
}
}
๋น์ ์ ์ด๋ป๊ฒ ์๊ฐํ์ญ๋๊น?
@kgv ๊ทํ์ ์ ์์ ์ดํดํ์ง ๋ชปํ๋ ๊ฒ ๊ฐ์ต๋๋ค. ํด๊ฒฐํ๋ ค๋ ๋ฌธ์ ๋ฅผ ์ค๋ช ํ๋ ์ถ๊ฐ ์ปจํ ์คํธ๊ฐ ๋์์ด ๋ ์ ์์ต๋๊น? ๊ทธ๋ฆฌ๊ณ ์ ์ ๋ ์๋ฃจ์ ์ ๋ ์์ ํ ์์ผ๊น์?
@scottjmaddox ๊ณ ์ . ๋ ๋ช ํํฉ๋๊น?
@kgv ์ด๊ฒ์ด ํด๊ฒฐํ๋ ๋ฌธ์ ๋ ๋ฌด์์ ๋๊น (์ด์ ๋ํ ๋์ฐ๋ฏธ ํจ์๋ฅผ ์์ฑํ๋ ์ฌ๋๊ณผ ๋ฐ๋๋ก)? ์ libstd๊ฐ ์ฌ๊ธฐ์ ์ด๋ค ์ผ์ํด์ผํ๋์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
๊ตฌ์กฐ์ฒด์ ํ ๋น ๊ธฐ๋ฐ ๋ถ๋ถ ์ด๊ธฐํ๋ ์ญ์ ๊ฐ ํ์ํ์ง ์์ ์ ํ์ ๋ํด์๋ง ์๋ํฉ๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด uninit.get_mut().foo = bar
๋ UB ์ธ foo
๋จ์ด ๋จ๋ฆฝ๋๋ค.
@RalfJung ๋ด๊ฐ ํด๊ฒฐํ๋ ค๋ ๋ฌธ์ self
์ ์์กดํ์ง ์์ต๋๋ค ( Self
์๋ง ์์กดํ๊ฑฐ๋ ์๋ฌด๊ฒ๋ ์์กดํ์ง ์์ (์์)), ์๋ฅผ ๋ค์ด-ํ๋ ์ค ํ๋๋ Self
ํฌ๊ธฐ์
๋๋ค.
@kgv ์ฌ๊ธฐ์ @RalfJung ๊ณผ ๋์ํด์ผํฉ๋๋ค. ์ด๋ฌํ ์ฌ์ฉ ์ฌ๋ก๋ ๋์ฐ๋ฏธ ๋ชจ๋์ด๋ ์์์์ ๋ ์ ์ฒ๋ฆฌ ํ ์ โโ์์ต๋๋ค.
์์ ํ PR์ ๋ฒ ํ์๊ธฐ์ ๋ง์ถฐ ๋์ฐฉํ์ต๋๋ค. :) ๋ ธ์กฐ์ ์ด๊ธฐํ๋์ง ์์ ๊ธฐ์ต์ ๊ดํ ์ํฉ์ ์กฐ์ฌํ๊ธฐ ์์ํ ์ง ์ฝ 8 ๊ฐ์์ด ์ง๋ฌ์ต๋๋ค. ๋ง์นจ๋ด 6 ์ฃผ ์์ ๋ฐฐ์ก ๋ ๊ฒ์ ๋๋ค. ์ด ์ผ๋ง๋ ์ฌํ! ๋์์ ์ฃผ์ ๋ชจ๋ ๋ถ๋ค๊ป ๊ฐ์ฌ๋๋ฆฝ๋๋ค. :๋
๋ฌผ๋ก ์์ง ๋๋์ง ์์์ต๋๋ค. ํด๊ฒฐํด์ผ ํ https://github.com/rust-lang/rfcs/pull/2582 ๊ฐ ์์ต๋๋ค. libstd๋ ์ฌ์ ํ ์ด์์ด ํ์ํ mem::uninitialized
(๋๋ถ๋ถ ํ๋ซํผ ๋ณ ์ฝ๋)๋ฅผ ๋ง์ด ์ฌ์ฉํฉ๋๋ค. ํ์ฌ ์ฐ๋ฆฌ๊ฐ ๊ฐ์ง๊ณ ์๋ ์์ ์ ์ธ API๋ ๋งค์ฐ ๋ฏธ๋ฏธํฉ๋๋ค. read
๋ฐ write
๋ฌด์์ํด์ผํ๋์ง ํ์
ํด์ผํ๋ฉฐ read
๋ฐฐ์ด ๋ฐ ์์ ์์
์ ๋๋ API๋ฅผ ๋ง๋ค์ด์ผํฉ๋๋ค MaybeUninit
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋ ์ ์ฒด ์ํ๊ณ๋ฅผ mem::uninitialized
์์ ์ฒ์ฒํ ์ด๋์ํค๊ธฐ ์ํดํด์ผ โโํ ์ผ์ด ๋ง์ด ์์ต๋๋ค.
๊ทธ๋ฌ๋ ์ฐ๋ฆฌ๋ ๊ฑฐ๊ธฐ์ ๋๋ฌ ํ ๊ฒ์ ๋๋ค.์ด ์ฒซ ๋ฒ์งธ ๋จ๊ณ๋ ์๋ง๋ ๊ฐ์ฅ ์ค์ํ ๋จ๊ณ์์ต๋๋ค. :)
๊ทธ๋ฆฌ๊ณ ์ฐ๋ฆฌ๋
MaybeUninit
๋ฐฐ์ด๊ณผ ์์ ์์ ์ ๋๋ API๋ฅผ ์ฐพ์์ผํฉ๋๋ค.
@RalfJung ๋๊น์ง; ์ด์ https://github.com/rust-lang/rust/issues/49147์์ ์์ ์ ์์ํ ๋๊ฐ
๋ํ ๋๋จธ์ง ๋นํธ์ ๋ํด ๋ ์์ ๋ฌธ์ ๋ฅผ ์ ํธํ์ฌ์ด ์ถ์ ๋ฌธ์ ๋ฅผ ๋ถํ ํ๊ณ ๋ซ์์ผํฉ๋๋ค.
๋ง์ง๋ง๊น์ง; ์ง๊ธ์ด # 49147 ์์ ์ ์์ํ ๋์ผ๊น์? = P
๋ฐฉ๊ธ ์์ ํ์ต๋๊น? ;) (๋๋ ๊ทธ๋ด ์๊ฐ์ด ์์ ๊ฒ ๊ฐ์ต๋๋ค.)
๋๋จธ์ง ๋นํธ์ ๋ํด ๋ ์์ ๋ฌธ์ ๋ฅผ ์ ํธํ์ฌ์ด ์ถ์ ๋ฌธ์ ๋ฅผ ๋ถํ ํ๊ณ ๋ซ์์ผํฉ๋๋ค.
ํ๋ก์ธ์ค ์ ๋ฌธ๊ฐ์๊ฒ ๋งก๊ธฐ๊ฒ ์ต๋๋ค. ๊ทธ๋ฌ๋ ๋๋ ๋์ํ๋ ๊ฒฝํฅ์ด ์์ต๋๋ค.
๋ฐฉ๊ธ ์์ ํ์ต๋๊น? ;) (๋๋ ๊ทธ๋ด ์๊ฐ์ด ์์ ๊ฒ ๊ฐ์ต๋๋ค.)
๋ด๊ฐ ํ ์ผ ... = D-์ด๋ฏธ ์์ ์ค์ธ ํ๋ก์ ํธ๊ฐ ์์ผ๋ฏ๋ก ์๊ฐ์ด ์ข ๊ฑธ๋ฆด ๊ฒ์ ๋๋ค. ๋ค๋ฅธ ์ฌ๋์ด ๊ด์ฌ์ ๊ฐ์ง๊น์? (์๋ ๊ฒฝ์ฐ ์ถ์ ๋ฌธ์ ๋ก ์ด๋)
ํ๋ก์ธ์ค ์ ๋ฌธ๊ฐ์๊ฒ ๋งก๊ธฐ๊ฒ ์ต๋๋ค. ๊ทธ๋ฌ๋ ๋๋ ๋์ํ๋ ๊ฒฝํฅ์ด ์์ต๋๋ค.
๊ทธ๊ฒ ๋ ์ผ๊ฑฐ์ผ ...;) ์กฐ๋ง๊ฐ ์ชผ๊ฐ์ ๋ซ์ ๋ณด๋๋กํ๊ฒ ์ต๋๋ค.
@RalfJung let x: bool = mem::uninitialized();
๊ฐ UB๋ผ๋ ๊ทํ์ ์ง์ ์ ๋ํ ์ง๋ฌธ์ ์ ์๋ชป๋ ํ๋ฆฌ๋ฏธํฐ๋ธ๊ฐ ๊ทธ๋ ๊ฒ ๊ฐ์ฃผ ๋๋๊ฐ์
๋๋ค. ๋ด๊ฐ ์ดํดํ๋ฏ์ด UB๋ฅผ ํธ๋ฆฌ๊ฑฐํ๋ ๊ฒ์ ์ ํจํ์ง ์์ ๊ฒ์ ๊ด์ฐฐํ๊ธฐ ์ํด ๊ฐ์ ์ฝ์ด์ผํฉ๋๋ค. ํ์ง๋ง ์ฝ์ง ์์ผ๋ฉด ์ด๋กํ์ฃ ?
๊ฐ์น๋ฅผ ์ฐฝ์ถํ๋ ๊ฒ์กฐ์ฐจ ๋์ ์ผ์ด๋ผ๊ณ ์๊ฐํ์ง๋ง, ์ ๋ น์ด ๊ทธ๊ฒ์ ํ์ฉํ์ง ์๋์ง ์ด์ ๋ฅผ ์๊ณ ์ถ์ต๋๋ค. ์ ํจํ์ง ์์ ์ํ๋ฅผ ๊ด์ฐฐํ์ง ์์ผ๋ฉด ์๋ฌด๋ฐ ํด๊ฐ์๋ ๊ฒ ๊ฐ์ต๋๋ค. ์ด๊ธฐ ์ค๋ฅ๋ฅผ์ํ ๊ฒ์ผ๊น ์ ์๋๋ฉด ๋ค๋ฅธ ๊ฒ์ผ๊น ์?
์ด๋ฌํ ๊ฐ์ ์ ์์กด ํ ๋ ์ปดํ์ผ๋ฌ์ ์ค์ ์ฌ๋ก๊ฐ ์์ต๋๊น?
์๋ฅผ ๋ค์ด, x
๊ฐ ์ ํจํ ๋ถ์ธ์์ LLVM์ ์๋ฆฌ๋ foo(x: bool)
์ ๊ฐ์ ํจ์์ ์ฃผ์์ ๋ต๋๋ค. ๊ทธ๋ฌ๋ฉด ํจ์๊ฐ ์๋ x
๋ณด์ง ์์๋๋ผ๋ true
๋๋ false
์ด ์๋ bool
๋ฅผ ์ ๋ฌํ๋ ๊ฒ์ด UB๊ฐ๋ฉ๋๋ค. ์ด๊ฒ์ ๋๋๋ก ์ปดํ์ผ๋ฌ๊ฐ ์ด์ ์ ์ฌ์ฉํ์ง ์์ ๋ณ์์ ์ฌ์ฉ์ ๋์
ํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ ์ ์ฉํฉ๋๋ค (ํนํ ๋ฃจํ๊ฐ ํ ๋ฒ ์ด์ ์ฌ์ฉ๋๋ค๋ ๊ฒ์ ์ฆ๋ช
ํ์ง ์๊ณ ๋ฌธ์ ๋ฃจํ ๋ฐ์ผ๋ก ์ด๋ํ ๋ ๋ฐ์ํฉ๋๋ค).
AFAIK ์ฐ๋ฆฌ๋ ๋ํ ํจ์ ๊ฒฝ๊ณ๋ฟ๋ง ์๋๋ผ ํจ์ ๋ด์์ ์ด๋ฌํ ์ฃผ์ ์ค ์ผ๋ถ๋ฅผ ์ค์ ํ๊ฑฐ๋ ์ค์ ํ๋ ค๊ณ ํฉ๋๋ค. ๊ทธ๋ฆฌ๊ณ ์์ผ๋ก ๊ทธ๋ฌํ ์ ๋ณด๊ฐ ์ ์ฉ ํ ์์๋ ๋ ๋ง์ ์ฅ์๋ฅผ ์ฐพ์ ์์์ ๊ฒ์ ๋๋ค. "๋ณ์ ์ฌ์ฉ"์ด๋ผ๋ ์๋ฆฌํ ์ ์ (์ ์ํ์ง ์๊ณ ์ฌ์ฉํ ์ฉ์ด์ด๋ฉฐ ์ค์ ๋ก ์ ์ํ๊ธฐ ์ฝ์ง ์์)๋ก ๋ค๋ฃฐ ์ ์์ง๋ง ์์ ํ์ง ์์ ์ฝ๋์์ UB์ ๊ดํด์๋ ๊ฐ๋ฅํ ํ ๊ฐ๋จํ ๊ท์น์ ๊ฐ๋ ๊ฒ์ด ์ค์ํฉ๋๋ค.
๋ฐ๋ผ์ ์ฐ๋ฆฌ๋ ์์ ํ์ง ์์ ์ฝ๋์์๋ ์ฝ๋์ ์ ํ์ด ์๋ฏธ๊ฐ ์๋์ง ํ์ธํ๊ณ ์ถ์ต๋๋ค. ์ด๋ ๋ณ์์ ๋ด์ฉ์ ๋ํด ์ปดํ์ผ๋ฌ์ ๊ฑฐ์ง๋ง์ํ๋ ์์ "yolo"์ ๊ทผ ๋ฐฉ์ ๋์ ์ ์ฉ ์ ํ์ ์ฌ์ฉํ์ฌ ์ ์ ํ ๋ฐฉ์์ผ๋ก ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฒ๋ฆฌ ํ ๋๋ง ๊ฐ๋ฅํฉ๋๋ค ( "๋๋ ์ด๊ฒ์ด bool
๋ผ๊ณ ์ฃผ์ฅํฉ๋๋ค. ,ํ์ง๋ง ์ค์ ๋ก ์ด๊ธฐํํ์ง๋ ์๊ฒ ์ต๋๋ค. ").
์๋ฅผ ๋ค์ด, LLVM์ x๊ฐ ์ ํจํ ๋ถ์ธ์์ ์๋ฆฌ๋ foo (x : bool)๊ณผ ๊ฐ์ ํจ์์ ์ฃผ์์ ๋ฌ์์ต๋๋ค. ๋ฐ๋ผ์ ํจ์๊ฐ ์๋ x๋ฅผ ๋ณด์ง ์์๋๋ผ๋ true ๋๋ false๊ฐ ์๋ bool์ ์ ๋ฌํ๋ ๊ฒ์ด UB๊ฐ๋ฉ๋๋ค. ์ด๊ฒ์ ๋๋๋ก ์ปดํ์ผ๋ฌ๊ฐ ์ด์ ์ ์ฌ์ฉํ์ง ์์ ๋ณ์์ ์ฌ์ฉ์ ๋์ ํ๋ ค๊ณ ํ๊ธฐ ๋๋ฌธ์ ์ ์ฉํฉ๋๋ค (ํนํ ๋ฃจํ๊ฐ ํ ๋ฒ ์ด์ ์ฌ์ฉ๋๋ค๋ ๊ฒ์ ์ฆ๋ช ํ์ง ์๊ณ ๋ฌธ์ ๋ฃจํ ๋ฐ์ผ๋ก ์ด๋ํ ๋ ๋ฐ์ํฉ๋๋ค).
์ด๊ฒ์ ์ฌ์ฉ์ผ๋ก ๊ฐ์ฃผ ๋ ์ ์์ต๋๋ค. ๋๋ ๊ฐ์ ์ด๊ธฐํํ๋ ๊ฒ์ ๋ํด ๋ฌป๊ณ ์ ํจํ ๊ฐ์ผ๋ก ๋ฎ์ด ์ฐ๊ธฐ ์ ์ ์๋ฌด๋ฐ๋ ์ฝ๊ฑฐ๋ ์ ๋ฌํ์ง ์์ต๋๋ค.
๋ฏธ๋ฌํ ๋ฐฉ์์ผ๋ก ๊ฐ์ ์ด๊ธฐํํ๋ ๋ฐ ์ ์ฉํ ์ฌ์ฉ ์ฌ๋ก๋ ์์ง๋ง ๊ถ๊ธํฉ๋๋ค.
์์ปจ๋, ๋ด ์ง๋ฌธ์์ด ์ฝ๋๊ฐ UB์ธ์ง (๋ฌธ์์ ๋ฐ๋ฅด๋ฉด), ๊ทธ๋ ๋ค๋ฉด ๊ทธ๋ ๊ฒ ์์ฑํ๋ฉด ์ ํํ ๋ฌด์์ ๊นจ๋จ๋ฆด ์ ์์ต๋๊น?
let _: bool = unsafe { mem::unitialized };
์ฃผ์ ์์ฒด์ ๋ํ ๋ ๋ค๋ฅธ ์ง๋ฌธ : ํ์ ์ง์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํ ๋น ํ ์์๋ box
๊ตฌ๋ฌธ์ด ์์ผ๋ฉฐ ๋๋ก๋ stackalloc ๋ฉ๋ชจ๋ฆฌ ์ธ Box::new()
์๋ ๋ฌ๋ฆฌ ํญ์ ์๋ํฉ๋๋ค. ๊ทธ๋์ box MaybeUninit::new()
ํ๊ณ ๊ทธ๊ฒ์ ์ฑ์ฐ๋ฉด ์ด๋ป๊ฒ Box<MaybeUninit<T>>
๋ฅผ Box<T>
๋ก ๋ณํ ํ ์ ์์ต๋๊น? ์ด๋ค ๋ณํ์ด๋ ๋ฌด์์ ์จ์ผํฉ๋๊น? ์๋ง๋ ๋ฌธ์์์์ด ์ ์ ๋์ณค์ ๊ฒ์
๋๋ค.
@Pzixel ์ฐ๋ฆฌ๋ ์ด ์ค๋ ๋์์ ์ด๋ฏธ Box
์ MaybeUninit
์ฌ์ด์ ์ํธ ์์ฉ์ ๋ํด ๋
ผ์ํ์ต๋๋ค.
@Centril ์
๋ค, ๊ทธ ํ ๋ก ์ ๊ธฐ์ตํ์ง๋ง ํน์ API๋ ๊ธฐ์ตํ์ง ์์ต๋๋ค.
๊ฐ๋จํ ๋งํด์, ๋๋ ๋ค์๊ณผ ๊ฐ์ ๊ฒ์ ๊ฐ๊ณ ์ถ๋ค.
fn into_inner<A,T>(value: A<MaybeUninit<T>>) -> A<T> { unsafe { std::mem::transmute() } }
๊ทธ๋ฌ๋ ๋๋ ๊ทธ๋ฐ API๊ฐ ์๋ค๊ณ ์๊ฐํ๊ณ ์ธ์ด ์งํ์์ด ์์ ์์ ์ปดํ์ผ๋ฌ ์ง์ ์์ด๋ ๊ตฌํ ๋ ์์๋ ๊ฒ ๊ฐ์ต๋๋ค.
๋๋ ๊ทธ๊ฒ์ ๋ํด ์กฐ๊ธ ๋ ์๊ฐํ๊ณ ์ด๋ค ์์ค์ ์ค์ฒฉ์์๋ ์๋ํด์ผ ํ ๊ฒ ๊ฐ์ต๋๋ค. ๊ทธ๋์ Vec<Result<Option<MaybeUninit<u8>>>>
์์ด์ผํ๋ค into_inner
๋ฐํ ๋ฐฉ๋ฒ์ Vec<Result<Option<u8>>>
get_ref์ get_mut์ด ๋์์ ์์ ํ ๋ ๊ฒ์ด๋ผ๊ณ ๊ฐ์ ํ์ต๋๋ค (๋ชจ๋ ๊ธฐ๋ฅ์ด์ด ๋ฌธ์ ๋ฅผ ๊ฐ๋ฆฌํด). ํ์ง ์๋ ์ด์ ๊ฐ ์์ต๋๊น? ๊ทธ๋ค์ ํ๋ฅญํ๊ณ ๊ทธ๋ค์ด ์ํํ๋ ์์ ์ ์ํํ๋ ๊ฒ์ด ํ์ฉ ๋๋ค๋ ์ ์ผํ ํ์์ ๋๋ค (๋ถ๋ช ํ ์ฌ์ค์ด์ด์ผ ํจ).
์ด๊ฒ์ ์ฌ์ฉ์ผ๋ก ๊ฐ์ฃผ ๋ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ let x: bool = mem::uninitialized()
๋ bool
์ฌ์ฉํ์ง ์์ต๋๋ค ( x
!์ ํ ๋น ๋๋๋ผ๋).
fn id(x: bool) -> bool { x }
let x: bool = id(mem::uninitialized());
๊ทธ๊ฒ์ ์ฌ์ฉํฉ๋๊น? ๋ ์ด๋
fn uninit() -> bool { mem::uninitialized() }
let x: bool = uninit();
์ฌ๊ธฐ ๋ฐํ์ด ์ฉ๋์ ๋๊น?
์ด๊ฒ์ ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋งค์ฐ ๋ฏธ๋ฌ ํด์ง๋๋ค. ๊ทธ๋์ ์ฐ๋ฆฌ๊ฐ ์ค์ผํ๋ค๊ณ ์๊ฐํ๋ ๋๋ต์ ๋ชจ๋ ํ ๋น (MIR๋ก ๋ด๋ฆฐ ํ์ ๋ชจ๋ ํ ๋น์์์ ๊ฐ์ด ์ค์ ๋ก ๋ชจ๋ ์ฌ๋ณธ)์ด ์ฌ์ฉ์ด๊ณ , ์ฌ๊ธฐ์๋ let x: bool = mem::uninitialized()
์ ํ ๋น์ด ํฌํจ๋๋ค๋ ๊ฒ์
๋๋ค.
get_ref์ get_mut์ด ๋์์ ์์ ํ ๋ ๊ฒ์ด๋ผ๊ณ ๊ฐ์ ํ์ต๋๋ค (๋ชจ๋ ๊ธฐ๋ฅ์ด์ด ๋ฌธ์ ๋ฅผ ๊ฐ๋ฆฌํด). ํ์ง ์๋ ์ด์ ๊ฐ ์์ต๋๊น? ๊ทธ๋ค์ ํ๋ฅญํ๊ณ ๊ทธ๋ค์ด ์ํํ๋ ์์ ์ ์ํํ๋ ๊ฒ์ด ํ์ฉ๋๋ค๋ ์ ์ผํ ํ์์ ๋๋ค (๋ถ๋ช ํ ์ฌ์ค์ด์ด์ผ ํจ).
์ด๊ฒ์ https://github.com/rust-lang/unsafe-code-guidelines/issues/77 ํด๊ฒฐ์ ์ฐจ๋จ๋ฉ๋๋ค : ์ด๊ธฐํ๋์ง ์์ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๊ฐ๋ฆฌํค๋ &mut bool
๋ฅผ ๊ฐ๋ ๊ฒ์ด ์์ ํฉ๋๊น? ๋๋ต์ "์"๋ผ๊ณ ์๊ฐํ์ง๋ง ์ฌ๋๋ค์ ๋์ํ์ง ์์ต๋๋ค.
์ด๊ฒ์ rust-lang / unsafe-code-guidelines # 77 ํด๊ฒฐ์ ์ฐจ๋จ๋ฉ๋๋ค.
๋๋ ์ฐจ๋จ์ด ์ผ์ด๋ ํ์๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๋ฅผ ์์ ํํ๊ณ "๋ฉ๋ชจ๋ฆฌ๊ฐ ์ด๊ธฐํ๋์ง ์์ ๊ฒฝ์ฐ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด UB์ ๋๋ค"๋ผ๊ณ ๋งํ ๋ค์ ๋์ค์ ๊ด์ฐฎ๋ค๊ณ ํ๋จ๋๋ฉด ์๊ตฌ ์ฌํญ์ ์ํ ํ ์ ์์ต๋๋ค. ์ด๊ธฐํ ํ ์ฌ์ฉํ๊ธฐ์ ์ข์ ๋ฐฉ๋ฒ์ ๋๋ค.
๊ทธ๋ฐ ๋ค์ ๋์ค์ ์๊ตฌ ์ฌํญ์ ๋ถ๋๋ฝ๊ฒ
์ฆ, ํฅํ ๋ฒ์ ์ ๋ฌธ์์ ๋ํด ์ฝ๋๋ฅผ ์์ฑํ์ง๋ง ๋๊ตฐ๊ฐ (API ํธํ ๊ฐ๋ฅ!) ์ด์ ๋ฒ์ ์ ์ปดํ์ผ๋ฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ด ์ฝ๋๋ฅผ ์ปดํ์ผํ๋ฉด ์ด์ UB๊ฐ ์์ต๋๊น?
@Gankro
๋๋ ์ฐจ๋จ์ด ์ผ์ด๋ ํ์๊ฐ ์๋ค๊ณ ์๊ฐํฉ๋๋ค. ์ด๋ฅผ ์์ ํํ๊ณ "๋ฉ๋ชจ๋ฆฌ๊ฐ ์ด๊ธฐํ๋์ง ์์ ๊ฒฝ์ฐ์ด๋ฅผ ์ฌ์ฉํ๋ ๊ฒ์ด UB์ ๋๋ค"๋ผ๊ณ ๋งํ ๋ค์ ๋์ค์ ๊ด์ฐฎ๋ค๊ณ ํ๋จ๋๋ฉด ์๊ตฌ ์ฌํญ์ ์ํ ํ ์ ์์ต๋๋ค. ์ด๊ธฐํ ํ ์ฌ์ฉํ๊ธฐ์ ์ข์ ๋ฐฉ๋ฒ์ ๋๋ค.
๊ทธ๊ฒ์ ๋์๊ฒ ๋งค์ฐ ํ๊ฑด์ฒ๋ผ ๋ณด์
๋๋ค. ์ &mut *foo.as_mut_ptr()
์ฐ์ง ์์ต๋๊น? ๋ชจ๋ ๊ฒ์ด ์ด๊ธฐํ๋๋ฉด ์ ์๋ํ์ง ์์ต๋๊น? IOW, ๋๋ ์ง๊ธ ๋น์ ์ด ๋งํ๋ ๊ฒ์ด ๊ถ๊ธํฉ๋๋ค.
๊ทธ๋ค์ด ์ํํ๋ ์์ ์ ์ํ ํ ์ ์๋ค๋ ์ ์ผํ ํ์
๊ทธ๊ฒ์ดํ์ง ์์ ์ด์ ๋๋ฌธ์? ๊ฐ์ ์ด๊ธฐํ ํ ํ ํ ์์๋ ๋ชจ๋ ๊ฒ์ ๊ผผ๊ผผํ ๋์ดํ๋ฉด ๊ธด ๋ชฉ๋ก์ด ๋ ๊ฒ์ ๋๋ค. ^^
๋ฟก๋ฟก
์ฆ, ํฅํ ๋ฒ์ ์ ๋ฌธ์์ ๋ํด ์ฝ๋๋ฅผ ์์ฑํ์ง๋ง ๋๊ตฐ๊ฐ (API ํธํ ๊ฐ๋ฅ!) ์ด์ ๋ฒ์ ์ ์ปดํ์ผ๋ฌ๋ฅผ ์ฌ์ฉํ์ฌ ๋ด ์ฝ๋๋ฅผ ์ปดํ์ผํ๋ฉด ์ด์ UB๊ฐ ์์ต๋๊น?
์ฌ๋๋ค์ด &mut *foo.as_mut_ptr()
ํ๋ค๋ฉด ์ค๋๋ ์๋ ๋ง์ฐฌ๊ฐ์ง์
๋๋ค. ๋๋ ๊ทธ๊ฒ์ ํผํ ๋ฐฉ๋ฒ์ด ์์ต๋๋ค.
๋ํ ํด๋น ๋ฌธ์๋ฅผ ์์ฑํ ๋ ์ค์ ๋ก ๋ณ๊ฒฝํด์ผํ๋ ๊ฒฝ์ฐ์๋ง UB๊ฐ ์์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ์ฐ๋ฆฌ๋ ๋ณด์ฆ์ํ๊ธฐ ์ ์ ๊ฐ์ ์ปดํ์ผ๋ฌ๋ก ๊ฐ์ ์ฝ๋๊ฐ ์คํ ๋์๋ค๋ฉด UB๊ฐ
๋ง์์, ์ ๋ ๊ทธ ๊ณผ์ ์ด
๋ฟก๋ฟก
์ฌ๊ธฐ ๋ฐํ์ด ์ฉ๋์ ๋๊น?
์, ๊ฐ์ ๋ฐํํ๊ฑฐ๋ ์๋ฌด ๊ณณ์ ๋ ์ ๋ฌํ๋ ๊ฒ์ด ์ฌ์ฉ์ ๋๋ค.
์ด๊ฒ์ ๋งค์ฐ ๋น ๋ฅด๊ฒ ๋งค์ฐ ๋ฏธ๋ฌ ํด์ง๋๋ค. ๊ทธ๋์ ์ฐ๋ฆฌ๊ฐ ์ฃผ์ด์ผํ๋ค๊ณ ์๊ฐํ๋ ๋๋ต์ ๋ชจ๋ ํ ๋น (MIR๋ก ๋ด๋ฆฐ ํ์ ๋ชจ๋ ํ ๋น๊ณผ ๊ฐ์ด ์ค์ ๋ก ๋ชจ๋ ์ฌ๋ณธ)์ด ์ฉ๋์ด๋ฉฐ let x : bool = mem :: uninitialized ()์ ํ ๋น์ ํฌํจํ๋ค๋ ๊ฒ์ ๋๋ค.
์ ํจํ ๊ฒ ๊ฐ์ต๋๋ค.
์ด์จ๋ , ๊ทธ๊ฒ์ ์ค์ฌ์ ๊ดํ ๊ฒ์ ๋๋ค MaybeUninit ์ค์ฒฉ? ์ฌ์ฉ์๊ฐ ๋ชจ๋ ๋ํผ ์ ํ์ ๋ํด ๋ณํ์ ์์ฑํ์ง ์๊ณ ๋ ์์ ํ๊ฒ ๋ณํ ํ ์ ์์ต๋๊น?
@Pzixel ๊ทํ์ ์ง๋ฌธ์ ์ดํดํ๋์ง ํ์คํ์ง ์์ง๋ง https://github.com/rust-lang/rust/issues/61011 ์์ ๋ ผ์๋๊ณ ์๋ค๊ณ ์๊ฐํฉ๋๋ค
์ฌ์ ํ ๋ถ์์ ํ MaybeUninit::write()
๋ฉ์๋๊ฐ unsafe
๊ฐ ์๋๋ผ๋ ๊ฒ์ ์์์ต๋๋ค. ์ด๋ฏธ ์กด์ฌํ๋ T
์์ drop ํธ์ถ์ ๊ฑด๋ ๋ธ ์ ์์ง๋ง ์์ ํ์ง ์๋ค๊ณ ๊ฐ์ ํ์ต๋๋ค. ์ด๊ฒ์ด ์์ ํ ๊ฒ์ผ๋ก ๊ฐ์ฃผ๋๋ ์ ๋ก๊ฐ ์์ต๋๊น?
https://doc.rust-lang.org/nomicon/leaking.html#leaking
https://doc.rust-lang.org/nightly/std/mem/fn.forget.html
forget
๋unsafe
๋ก ํ์๋์ง ์์ต๋๋ค. Rust์ ์์ ๋ณด์ฅ์๋ ์๋ฉธ์๊ฐ ํญ์ ์คํ๋๋ค๋ ๋ณด์ฅ์ด ํฌํจ๋์ด ์์ง ์๊ธฐ ๋๋ฌธ์ ๋๋ค.
๊ทธ๋ฌ๋ https://github.com/rust-lang-nursery/nomicon/issues/135 ๋ ์ฐธ์กฐ
MaybeUninit
MaybeUninit<T> -> NonNull<T>
๋ฉ์๋๋ฅผ ์ถ๊ฐ ํ ์ ์์ต๋๊น? AFAICT MaybeUninit::as_mut_ptr() -> *mut T
์ํด ๋ฐํ ๋ ํฌ์ธํฐ๋ null์ด ์๋๋๋ค. ๊ทธ๋ฌ๋ฉด ๋ค์์์ NonNull<T>
๋ฅผ ์ฌ์ฉํ๋ API์ ์ธํฐํ์ด์คํด์ผํ๋ ์ดํ์ ์ค์ผ ์ ์์ต๋๋ค.
let mut x = MaybeUninit<T>::uninit();
foo(unsafe { NonNull::new_unchecked(x.as_mut_ptr() });
์:
let mut x = MaybeUninit<T>::uninit();
foo(x.ptr());
MaybeUninit :: as_mut_ptr ()-> * mut T์ ์ํด ๋ฐํ ๋ ํฌ์ธํฐ๋ ์ ๋ null์ด ์๋๋๋ค.
๋ง์ต๋๋ค.
์ผ๋ฐ์ ์ผ๋ก (๊ทธ๋ฆฌ๊ณ ๋๋ @Gankro ๊ฐ ์ด๊ฒ์ ๋งํ๋ ๊ฒ์ NonNull
๋ "ํด์ ์ํ์์"์๋นํ ์ ์๋ํ์ง๋ง ์ค์ ๋ก ํฌ์ธํฐ๋ฅผ ์ฌ์ฉํ ๋ ์์ ํฌ์ธํฐ๋ฅผ ์ต๋ํ ๋นจ๋ฆฌ ์ป๊ณ ์ถ์ดํฉ๋๋ค. ๊ทธ๊ฒ์ ํจ์ฌ ๋ ์ฝ๊ธฐ ์ฝ์ต๋๋ค.
๊ทธ๋ฌ๋ NonNull
๋ฅผ ๋ฐํํ๋ ๋ฉ์๋๋ฅผ ์ถ๊ฐํ๋ ๊ฒ์ ๊ด์ฐฎ์ ๋ณด์
๋๋ค. ๊ทธ๋๋ ๋ญ๋ผ๊ณ ๋ถ๋ฌ์ผํ ๊น์? ์ฐ์ ๊ถ์ด ์์ต๋๊น?
https://github.com/rust-lang/rust/issues/47336์ ๋ํ ์ ๋ก๊ฐ ์์ง๋ง ์ด๋ฆ์ด ์ข์ง ์์์ด ๋ฐฉ๋ฒ์ ์์ ํ ํ ์ ์์์ง ๋ชจ๋ฅด๊ฒ ์ต๋๋ค.
https://github.com/rust-lang/rust/pull/60445#issuecomment -488818677์ ์ธ๊ธ ๋ ๋ถํ๊ตฌ ์คํ์ด ๋ฐ์ ํ์ต๋๊น?
@centril์ด ์ธ๊ธ ํ 3 ๊ฐ์์ ์ฌ์ฉ ๊ฐ๋ฅ ์๊ฐ์ ๋ํ ์์ด๋์ด๋ ๋ฒ ํ, ์์ ๋ฐ ์ผ๊ฐ์ ๋ํด ๊ฒฝ๊ณ ๊ฐ ๋ฐ์ํ์ง ์๊ธฐ๋ฅผ ์ํ๋ ์ฌ๋๋ค์๊ฒ๋ ์คํ๋์ง ์์ต๋๋ค. 1.36.0์ 1 ์ฃผ์ผ ์ ์ ์ถ์๋์์ผ๋ฉฐ ์ผ๊ฐ์๋ ์ด๋ฏธ ๊ฒฝ๊ณ ๋ฅผ ๋ด ๋ณด๋ ๋๋ค.
์ง์ ์ค๋จ์ด 1.40.0์ผ๋ก ์ฐ๊ธฐ ๋ ์ ์์ต๋๊น?
์ง์ ์ค๋จ ๊ฒฝ๊ณ ๊ฐ์ด๋ฅผ ๋ด๋นํ๋ ์์์ ํญ์ ๊ณ ๋ฆฝ๋๋ ๊ฒ์ ์๋๋๋ค. ์๋ฅผ ๋ค์ด ํฌ๋ ์ดํธ๊ฐ ๋ด๋ถ์ ์ผ๋ก std::mem::uninitialized
์ ์ฌ์ฉํ๋ ๋งคํฌ๋ก๋ฅผ ๋
ธ์ถํ๋ ๊ฒฝ์ฐ ํ์ฌ ํฌ๋ ์ดํธ์ ์ฌ์ฉ์ ์ฌ์ ํ โโ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ํธ์ถํฉ๋๋ค. ์ค๋ ๋ฐค ์ปดํ์ผ๋ฌ๋ก ๋ด ํ๋ก์ ํธ ์ค ํ๋๋ฅผ ์ปดํ์ผํ์ ๋ ์ด๊ฒ์ ๋ฐ๊ฒฌํ์ต๋๋ค. ์ฝ๋์ uninitialized
๋ํ ๋จ์ผ ์ธ๊ธ์ด ํฌํจ๋์ด ์์ง ์์ง๋ง glium์ implement_vertex
๋งคํฌ๋ก๋ฅผ ํธ์ถํ๊ธฐ ๋๋ฌธ์ ์ฌ์ฉ ์ค๋จ ๊ฒฝ๊ณ ๊ฐ ํ์๋์์ต๋๋ค.
glium master์์ cargo +nightly test
๋ฅผ ์คํํ๋ฉด 1400 ์ค์ด ๋๋ ์ถ๋ ฅ์ด ์ ๊ณต๋๋ฉฐ, ๋๋ถ๋ถ uninitialized
ํจ์์ ์ฌ์ฉ ์ค๋จ ๊ฒฝ๊ณ ๋ก ๊ตฌ์ฑ๋ฉ๋๋ค (๊ฒฝ๊ณ ๋ฅผ 200 ๋ฒ ๊ณ์ฐํ์ง๋ง rg "uninitialized" | wc -l
์ถ๋ ฅ์ 561)์
๋๋ค.
๋๋จธ์ง ๋ฐฉ๋ฒ์ ์์ ํ๋ฅผ ๋ฐฉํดํ๋ ๋๋จธ์ง ์ฐ๋ ค ์ฌํญ์ ๋ฌด์์
๋๊น? *foo.as_mut_ptr()
๋ฅผ ํตํด ๋ชจ๋ ์์
์ ์ํํ๋ ๊ฒ์ ๋งค์ฐ ์ง๋ฃจํ๋ฉฐ ๋๋ก๋ ( write
) ํ์ ์ด์์ผ๋ก unsafe
๋ธ๋ก์ด ํ์ํฉ๋๋ค.
@SimonSapin write
์๋ฎฌ๋ ์ด์
ํ๋ ค๋ฉด MaybeUninit
๋ฅผ ์ฌ์ฉํ์ฌ *val = MaybeUninit::new(new_val)
MaybeUninit
์ ์ฒด๋ฅผ ์์ ํ์ง ์์ ๊ฒ์ผ๋ก ๋์ฒด ํ ์ ์์ต๋๋ค. ์ฌ๊ธฐ์ val: &mut MaybeUninit<T>
๋ฐ new_val: T
๋๋ ๋ค์์ ์ฌ์ฉํ ์ ์์ต๋๋ค. ์ด์ ๊ฐ์ ์ํ๋ค๋ฉด std::mem::replace
.
@ est31 ์ด๊ฒ๋ค์ ์ข์ ์ ์ ๋๋ค. ํ๋ ๋ฒ์ ์ถ์๋ก ์ง์ ์ค๋จ์ ๋ฏธ๋ฃจ๋ ๊ฒ์ด ์ข์ต๋๋ค.
์ด์๊ฐ ์์ต๋๊น?
1.36.0 ๋ฆด๋ฆฌ์ค ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์์ ์ด๋ฏธ ์ธ๊ธํ์ต๋๋ค.
MaybeUninit๋ก
Rust 1.38๋ถํฐ ๋ ์์ ํ ๋์์ด๋ฉฐ mem :: uninitialized ํจ์๋ ๋ ์ด์ ์ฌ์ฉ๋์ง ์์ต๋๋ค.
๋ฐ๋ผ์ ๋๋ ์ข์ ๋ฉ์์ง๋ฅผ ๋ณด๋ด์ง ์๊ณ ํผ๋ ์ค๋ฝ๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ํ ํ๋ฆฝ ํ ๋กํผ๋ฅผ ํผํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค. ๋ํ ์ฌ์ฉ ์ค๋จ ๋ ์ง๋ ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ธ๊ธ๋์์ผ๋ฏ๋ก ๋๋ฆฌ ์๋ ค์ผํฉ๋๋ค.
uninitialized
์ ์ง์ ์ค๋จ์ผ๋ก ๋์๊ฐ๋ ๊ฒ์ด ๋ฆ์ ์ ์์ต๋๋ค. ๊ทธ๋ฌ๋ ๊ต์ฒด๊ฐ ์ผ์ ๊ธฐ๊ฐ ๋์ Stable ์ฑ๋์์๋ ์ดํ Nightly์์๋ง ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ํ์ํ๋ ์ ์ฑ
์ ๊ฒฐ์ ํ ์ ์์๊น์?
์๋ฅผ ๋ค์ด, Firefox ๋ ์ถ์ 2 ์ฃผ ํ ์๋ก์ด Rust ๋ฒ์ ์ด ํ์ํ๋ค๋ ์ ์์ ํํํ์ต๋๋ค.
1.36.0 ๋ฆด๋ฆฌ์ค ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์์ ์ด๋ฏธ ์ธ๊ธํ์ต๋๋ค.
๋๋ ๋ธ๋ก๊ทธ ํฌ์คํธ์์ ๋ ์ง์ ๋ํ ์ธ๊ธ์ด ๊ทธ๋ ๊ฒ ์ฒ ๋์ฒ ๋ฏธ ํ ์ ๋๋ผ๋ ๋ฐ ๋์ํ์ง ์๋๋ค. ์ ์ฅ์์ ์์ผ๋ฉฐ ํธ์ง์ ์ ์ถํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ ๋๋ ์ข์ ๋ฉ์์ง๋ฅผ ๋ณด๋ด์ง ์๊ณ ํผ๋ ์ค๋ฝ๊ธฐ ๋๋ฌธ์ ์ด๊ฒ์ ๋ํ ํ๋ฆฝ ํ ๋กํผ๋ฅผ ํผํด์ผํ๋ค๊ณ ์๊ฐํฉ๋๋ค.
"ํ๋ฆฝ ํ๋ก ํผ๋ฆฌ"๋ ๋์ ์ผ์ด์ง๋ง ๋ฐ์ดํฐ์ ํผ๋๋ฐฑ์ ๊ธฐ๋ฐ์ผ๋ก ๋ง์์ ๋ฐ๊พธ๋ ๊ฒ์ ์๋๋๋ค.
๋๋ ์ค์ ๊ฒฐ์ ์ ๋ํด ์ด๋ค ์ ์ผ๋ก๋ ์๊ดํ์ง ์์ง๋ง ์ฌ๋๋ค์ด ์ ์์ ๋ํด ํผ๋ ์ค๋ฌ์ธ ๊ฒ์ด๋ผ๊ณ ๋ฏฟ์ง ์์ต๋๋ค. ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ด๋ ์ง์ ์ค๋จ ๊ฒฝ๊ณ ๋ฅผ ๋ณธ ์ฌ๋๋ค์ ์๋ก์ด ๊ฒ์ผ๋ก ์ด๋ํ ์ ์์ต๋๋ค. ๊ทธ๋ ์ง ์์ ์ฌ๋๋ค์ ๋ค๋ฅธ ๋ช ๊ฐ์ง ๋ฆด๋ฆฌ์ค์ ๊ด์ฌ์ด ์์ต๋๋ค.
"ํ๋ฆฝ ํ๋ก ํผ๋ฆฌ"๋ ๋์ ์ผ์ด์ง๋ง ๋ฐ์ดํฐ์ ํผ๋๋ฐฑ์ ๊ธฐ๋ฐ์ผ๋ก ๋ง์์ ๋ฐ๊พธ๋ ๊ฒ์ ์๋๋๋ค.
์์ ํ ๋์ํ์ต๋๋ค. "์ด๋ด, ์ฐ๋ฆฌ์ ์ง์ ์ค๋จ ์ผ์ ์ด ๋๋ฌด ๊ณต๊ฒฉ์ ์ด์์ด, ์ฐ๋ฆฌ๋ ๋ฆด๋ฆฌ์ค๋ก ๋ฌผ๊ฑด์ ๋ค์ ์ฎ๊ฒผ์ต๋๋ค."๋ผ๋ ๋์ ๋ฉ์์ง๊ฐ ์ ์ก๋๋ ๊ฒ์ ๋ณด์ง ๋ชปํ์ต๋๋ค. ์ค์ ๋ก๋ ์ ๋ฐ๋์
๋๋ค.
์ฌ์ค IIRC๋ ์์ ํ PR์ ์์ํ๋ฉด์ 2 ๊ฐ๊ฐ ์๋ ํฅํ 3 ๊ฐ ๋ฆด๋ฆฌ์ค๋ฅผ ์ง์ ์ค๋จํ๋ ๊ฒ์ด๋ผ๊ณ ์ธ๊ธํ์ง๋ง ์ด๋ค ์ด์ ๋ก 2 ๊ฐ๋ฅผ ์ฌ์ฉํ์ต๋๋ค. 3 ๊ฐ ๋ฆด๋ฆฌ์ค๋ stable-gets-released-with-the -deprecation-announcement ๋ฐ deprecated-on-nightly, ๊ทธ๊ฒ์ ์ฌ๋๋ค์ด ์ผ๊ฐ ์ถ์ ์ ์ํด ๊ณต์ ํ ์๊ฐ์ฒ๋ผ ๋ณด์
๋๋ค. 6์ฃผ๋ ์์จ ์ด์ฃ ? ;)
๋ฐ๋ผ์ ๋ด์ผ ์ฌ์ฉ ์ค๋จ ๋ฒ์ ์ 1.39.0์ผ๋ก ๋ณ๊ฒฝํ๋ PR์ ์ ์ถํ ๊ณํ์ ๋๋ค. ์ฌ๋๋ค์ด ์ค์ํ๋ค๊ณ ์๊ฐํ๋ ๊ฒฝ์ฐ ํด๋น ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ ๋ฐ์ดํธํ๊ธฐ ์ํด PR์ ์ ์ถํ ์๋ ์์ต๋๋ค.
๋ฐ๋ผ์ ๋ด์ผ ์ฌ์ฉ ์ค๋จ ๋ฒ์ ์ 1.39.0์ผ๋ก ๋ณ๊ฒฝํ๋ PR์ ์ ์ถํ ๊ณํ์ ๋๋ค. ์ฌ๋๋ค์ด ์ค์ํ๋ค๊ณ ์๊ฐํ๋ ๊ฒฝ์ฐ ํด๋น ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ์ ์ ๋ฐ์ดํธํ๊ธฐ ์ํด PR์ ์ ์ถํ ์๋ ์์ต๋๋ค.
๋๋ 1.39์ ๋์ํ์ง๋ง ๊ทธ๋ณด๋ค ๋ฆ์ง ์์ ๊ฒ์ ๋๋ค. ๋ธ๋ก๊ทธ ๊ฒ์๋ฌผ ์ธ์๋ ๋ฆด๋ฆฌ์ค ๋ ธํธ๋ฅผ ์ ๋ฐ์ดํธํด์ผํฉ๋๋ค.
๋ณ๊ฒฝ๋ ์ง์ ์ค๋จ ์ผ์ ์ ๋ํ PR ์ ์ถ : https://github.com/rust-lang/rust/pull/62599.
๋ฟก ๋นต๋จ
๋๋จธ์ง ๋ฐฉ๋ฒ์ ์์ ํ๋ฅผ ๋ฐฉํดํ๋ ๋๋จธ์ง ์ฐ๋ ค ์ฌํญ์ ๋ฌด์์ ๋๊น? * foo.as_mut_ptr ()์ ํตํด ๋ชจ๋ ์์ ์ ์ํํ๋ ๊ฒ์ ๋งค์ฐ ์ง๋ฃจํ๊ณ ๋๋ก๋ (์ฐ๊ธฐ๋ฅผ ์ํด) ํ์ ์ด์์ผ๋ก ์์ ํ์ง ์์ ๋ธ๋ก์ด ํฌํจ๋ฉ๋๋ค.
as_ref
/ as_mut
๊ฒฝ์ฐ, ์ฐธ์กฐ๊ฐ ์ด๊ธฐํ ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฆฌ์ผ ์ผํ๋์ง ์ ๋๊น์ง ์์งํ ๊ธฐ๋ค๋ฆฌ๊ณ ์ถ์์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ํด๋น ๋ฐฉ๋ฒ์ ๋ํ ๋ฌธ์๊ฐ ๋๋ฌด ์๋น ์ ์
๋๋ค.
read
/ write
๊ฒฝ์ฐ ๋ชจ๋ ์ฌ๋์ด ์ด๋ฆ๊ณผ ์๋ช
์ด ํฉ๋ฆฌ์ ์ด๋ผ๋ ๋ฐ ๋์ํ๋ฉด ์์ ํํฉ๋๋ค. ๋๋ ์ด๊ฒ์ด ManuallyDrop::take/read
์ ํจ๊ป ์กฐ์ ๋์ด์ผํ๋ค๊ณ ์๊ฐํ๊ณ ์๋ง๋ ManuallyDrop::write
๋ ์์ด์ผํ ๊น์?
์์งํ ์ฐธ์กฐ๊ฐ ์ด๊ธฐํ ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฆฌ์ผ ์ผํ๋์ง ์ ๋๊น์ง ๊ธฐ๋ค๋ฆฌ๊ณ ์ถ์์ต๋๋ค.
์์ ํ์ง ์์ ์ฝ๋ ์ง์นจ WG์ ์ธ์ด ํ์ด์ด ์ฃผ์ ์ ๋ํ ๊ฒฐ์ ์ ๋ด๋ฆฌ๋ ค๋ฉด ์ด๋ป๊ฒํด์ผํฉ๋๊น? ๋ช ์ฃผ, ๋ช ๋ฌ ๋๋ ๋ช ๋ ํ์ ๋ ๋ง์ด ๋ฐ์ํ ๊ฒ์ผ๋ก ์์ํ์ญ๋๊น?
๊ทธ ๋์ as_mut
์ด ๋ถ์์ ํ๋ค๊ณ ํด์ ์ฌ์ฉ์๊ฐ ๋ฌด์ธ๊ฐ๋ฅผํด์ผ ํ ๋ &mut *manually_drop.as_mut_ptr()
๋ฅผ ์ฐ๋ ๊ฒ์ ๋ง์ง๋ ์์ต๋๋ค.
์์ ํ์ง ์์ ์ฝ๋ ์ง์นจ WG์ ์ธ์ด ํ์ด์ด ์ฃผ์ ์ ๋ํ ๊ฒฐ์ ์ ๋ด๋ฆฌ๋ ค๋ฉด ์ด๋ป๊ฒํด์ผํฉ๋๊น? ๋ช ์ฃผ, ๋ช ๋ฌ ๋๋ ๋ช ๋ ํ์ ๋ ๋ง์ด ๋ฐ์ํ ๊ฒ์ผ๋ก ์์ํ์ญ๋๊น?
๋ช ๋ฌ, ์ด์ฉ๋ฉด ๋ช ๋ .
๊ทธ ๋์ as_mut์ด ๋ถ์์ ํ๋ค๊ณ ํด์ ์ฌ์ฉ์๊ฐ ์์ ์ ์ํํด์ผ ํ ๋ & mut * manually_drop.as_mut_ptr () ์์ฑํ๋ ๊ฒ์ ๋ง์ง๋ ์์ต๋๋ค.
๋ค, ์์์. ํฌ๋ง์ ์ฌ๋๋ค์ด ๊ฐ๋ฅํ ํ &mut
๋ถ๋ถ์ โโ์ง์ฐ์ํค๊ณ ์์ ํฌ์ธํฐ๋ก ์์
ํ๋๋ก ์ ๋ํ๋ ๊ฒ์
๋๋ค. ๋ฌผ๋ก https://github.com/rust-lang/rfcs/pull/2582 ์์ด๋ ์ข
์ข
์ด๋ ต์ต๋๋ค.
MaybeUninit์ ๋ํ ๋ฌธ์๋ ์ ์ด๋ ์ด๊ฒ์ด ์ธ์ด์ ์๋ฏธ๋ก ์์ ๋ชจํธํ๊ณ ์ฌ์ฉ์๊ฐ ๋ณด์์ ์ผ๋ก ๊ทธ๊ฒ์ด ์ข์ง ์๋ค๊ณ ๊ฐ์ ํด์ผํ๋ค๋ ๊ฒ์ ๋ ผ์ํ๊ธฐ์ ๊ฐ์ฅ ์ข์ ์ฅ์ ์ธ ๊ฒ ๊ฐ์ต๋๋ค.
์ฌ์ค, ๊ทธ๊ฒ์ ๋ค๋ฅธ ์ ํ์ด ๋ ๊ฒ์ ๋๋ค.
๋ณด์์ ์ธ ๊ฐ์ ์์๋ as_mut
๋ ๊ฐ์ด ์์ ํ ์ด๊ธฐํ ๋ ํ์ ์ ํจํฉ๋๋ค.
๋ฐฐ์ด์ ๋ณด์์ ์ผ๋ก ์ฌ์ฉํ๋ ํ ๊ฐ์ง ๋ฐฉ๋ฒ์ MaybeUninit<[MaybeUninit<Foo>; N]>
์
๋๋ค. ์ธ๋ถ ๋ํผ๋ฅผ ์ฌ์ฉํ๋ฉด ๋จ์ผ uninit()
ํธ์ถ๋ก ๋ฐฐ์ด์ ๋ง๋ค ์ ์์ต๋๋ค. (๋๋ ์๊ฐ [expr; N]
๋ฌธ์๊ฐ ํ์ Copy
๋ด๋ถ ๋ํผ์ ํธ์๋ฅผ ์ฌ์ฉํ๋ ๊ฒฝ์ฐ์๋ ๋ณด์์ ์ธ ๊ฐ์ ์์ ์์ ํ๊ฒ ๋ง๋ค์ด?) slice::IterMut
๋ฐฐ์ด์ ํต๊ณผํ๊ธฐ ์ํด, ๊ทธ๋ฆฌ๊ณ ๊ทธ๋ฐ ๋ค์ Foo
๊ฐ์ ํ๋์ฉ ์ด๊ธฐํํฉ๋๋ค.
@SimonSapin ์ uninitialized_array!
๋งคํฌ๋ก๋ฅผ ๋ด
๋๋ค .
@RalfJung ์๋ง๋ uninit_array!
์ด ๋ ๋์ ์ด๋ฆ์ด ๋ ๊ฒ์
๋๋ค.
@Stargateur ๋ฌผ๋ก , ์ด๊ฒ์ ํ์คํ ํ์ฌ ์ด๋ฆ์ผ๋ก ์์ ํ๋์ง ์์ ๊ฒ์ ๋๋ค. https://github.com/rust-lang/rust/issues/49147์ด ๊ณง ๋ฐ์ํ๋ฉด (TM) ์์ ํ๋์ง ์๊ธฐ๋ฅผ
@RalfJung Ugh , ๊ทธ๊ฒ ๋ด ์๋ชป์ ๋๋ค. ํฐ ์ด์ ์์ด PR์ ์ฐจ๋จํ์ต๋๋ค. https://github.com/rust-lang/rust/pull/61749#issuecomment -512867703
@eddyb ์ด๊ฒ์ libcore์์ ์๋ํฉ๋๋ค. ํ์ง๋ง liballoc์ ๊ธฐ๋ฅ์ ์ฌ์ฉํ๋ ค๊ณ ํ๋ฉด ์ด๋ป๊ฒ ๋ ํ๋๊ทธ๋ฅผ ์ค์ ํด๋ ์ปดํ์ผ์ด๋์ง ์์ต๋๋ค. https://github.com/rust-lang/rust/commit/4c2c7e0cc9b2b589fe2bab44173acc2170b20c09๋ฅผ ์ฐธ์กฐ
Building stage1 std artifacts (x86_64-unknown-linux-gnu -> x86_64-unknown-linux-gnu)
Compiling alloc v0.0.0 (/home/r/src/rust/rustc.2/src/liballoc)
error[E0277]: the trait bound `core::mem::MaybeUninit<K>: core::marker::Copy` is not satisfied
--> <::core::macros::uninit_array macros>:1:32
|
1 | ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
| - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<K>`
| _|
| |
2 | | ;
| |_- in this expansion of `uninit_array!`
|
::: src/liballoc/collections/btree/node.rs:109:19
|
109 | keys: uninit_array![_; CAPACITY],
| -------------------------- in this macro invocation
|
= help: consider adding a `where core::mem::MaybeUninit<K>: core::marker::Copy` bound
= note: the `Copy` trait is required because the repeated element will be copied
error[E0277]: the trait bound `core::mem::MaybeUninit<V>: core::marker::Copy` is not satisfied
--> <::core::macros::uninit_array macros>:1:32
|
1 | ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
| - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<V>`
| _|
| |
2 | | ;
| |_- in this expansion of `uninit_array!`
|
::: src/liballoc/collections/btree/node.rs:110:19
|
110 | vals: uninit_array![_; CAPACITY],
| -------------------------- in this macro invocation
|
= help: consider adding a `where core::mem::MaybeUninit<V>: core::marker::Copy` bound
= note: the `Copy` trait is required because the repeated element will be copied
error[E0277]: the trait bound `core::mem::MaybeUninit<collections::btree::node::BoxedNode<K, V>>: core::marker::Copy` is not satisfied
--> <::core::macros::uninit_array macros>:1:32
|
1 | ($ t : ty ; $ size : expr) => ([MaybeUninit :: < $ t > :: uninit () ; $ size])
| - ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the trait `core::marker::Copy` is not implemented for `core::mem::MaybeUninit<collections::btree::node::BoxedNode<K, V>>`
| _|
| |
2 | | ;
| |_- in this expansion of `uninit_array!`
|
::: src/liballoc/collections/btree/node.rs:162:20
|
162 | edges: uninit_array![_; 2*B],
| --------------------- in this macro invocation
|
= help: the following implementations were found:
<core::mem::MaybeUninit<T> as core::marker::Copy>
= note: the `Copy` trait is required because the repeated element will be copied
error: aborting due to 3 previous errors
๋ฏธ์คํฐ๋ฆฌ ํด๊ฒฐ : libcore์ ๋ฐ๋ณต ํํ์ ์ฌ์ฉ์ด ์ค์ ๋ก ๋ณต์ฌ๋ฉ๋๋ค ์ ํ์ด์๋ค.
๊ทธ๋ฆฌ๊ณ liballoc์์ ์๋ํ์ง ์๋ ์ด์ ๋ MaybeUninit::uninit
์ด ํ๋ณด ํ ์ ์๊ธฐ ๋๋ฌธ์
๋๋ค.
@RalfJung ์ด์ฉ๋ฉด ์์ ํ ๋ถํ์ํ ๋งคํฌ๋ก ์ฌ์ฉ์ ์ ๊ฑฐํ๋ PR์ ์ด ์ ์์ต๋๊น?
@eddyb https://github.com/rust-lang/rust/pull/62799์ ํด๋น ๋ถ๋ถ์ ๋ง๋ค์์ต๋๋ค
maybe_uninit_ref
as_ref / as_mut์ ๊ฒฝ์ฐ, ์ฐธ์กฐ๊ฐ ์ด๊ธฐํ ๋ ๋ฐ์ดํฐ๋ฅผ ๊ฐ๋ฆฌ์ผ ์ผํ๋์ง ์ ๋๊น์ง ์์งํ ๊ธฐ๋ค๋ฆฌ๊ณ ์ถ์์ต๋๋ค. ๊ทธ๋ ์ง ์์ผ๋ฉด ํด๋น ๋ฐฉ๋ฒ์ ๋ํ ๋ฌธ์๊ฐ ๋๋ฌด ์๋น ์ ์ ๋๋ค.
๋ถ์์ ํ get_ref
/ get_mut
์ (๋) ํ์คํ ๊ถ์ฅ๋ฉ๋๋ค. ๊ทธ๋ฌ๋ get_ref
/ get_mut
์ฌ์ฉํ ์์๋ ๊ฒฝ์ฐ๊ฐ ์์ต๋๋ค. MaybeUninit
๊ฐ ์ด๊ธฐํ๋์์ ๋ : (ํ์ฌ ์๋ ค์ง ์ด๊ธฐํ ๋) ๋ฐ์ดํฐ๋ฅผ ์์ ํ๊ฒ ์ฒ๋ฆฌํ๊ธฐ ์ํด memcpy
( ๋์ assume_init
ํธ๋ฆฌ๊ฑฐ ํ ์์๋ํ๋ memcpy
).
์ด ๋๋ฌธ์ assume_init_by_ref
/ assume_init_by_mut
๊ฐ ์์ผ๋ฉด ์ข์ ์ ์๋ค๊ณ ์๊ฐํฉ๋๋ค ( into_inner
์ด assume_init
๋ผ๊ณ ๋ถ๋ ธ ๊ธฐ ๋๋ฌธ์ ref
/ ref mut
๊ฒํฐ๋ ์ด๊ฒ์ ๋ฐ์ํ๊ธฐ ์ํด ํน๋ณํ ์ด๋ฆ์ ์ป์ต๋๋ค).
Drop
์ํธ ์์ฉ๊ณผ ๊ด๋ จ๋ 2/3 ๊ฐ์ง ์ต์
์ด ์์ต๋๋ค.
get_ref
๋ฐ get_mut
์ ์ ํํ ๋์ผํ API๋ก, ๋๋กญ ๊ธ๋ฃจ๊ฐ์์ ๋ ๋ฉ๋ชจ๋ฆฌ ๋์๊ฐ ๋ฐ์ํ ์ ์์ต๋๋ค.
get_ref
/ get_mut
์ ๋์ผํ API์ด์ง๋ง Copy
๊ฒฝ๊ณ๊ฐ ์์ต๋๋ค.๋๋กญ์ ๋ณด์ฅํ๊ธฐ์ํ ํด๋ก์ ์คํ์ผ API :
impl<T> MaybeUninit<T> {
/// # Safety
///
/// - the contents must have been initialised
unsafe
fn assume_init_with_mut<R, F> (mut self: MaybeUninit<T>, f: F) -> R
where
F : FnOnce(&mut T) -> R,
{
if mem::needs_drop::<T>().not() {
return f(unsafe { self.get_mut() });
}
let mut this = ::scopeguard::guard(self, |mut this| {
ptr::drop_in_place(this.as_mut_ptr());
});
f(unsafe { MaybeUninit::<T>::get_mut(&mut *this) })
}
}
( scopeguard
์ ๋ก์ง์ ์ฝ๊ฒ ๋ค์ ๊ตฌํํ ์ ์์ผ๋ฏ๋ก ์์กด ํ ํ์๊ฐ ์์ต๋๋ค.)
๋ช
์์ ์ธ assume_init
์๊ตฌ ์ฌํญ์ด ์ฃผ์ด์ง๋ฉด get_ref
/ get_mut
๋ณด๋ค ๋น ๋ฅด๊ฒ ์์ ํ ๋ ์ ์์ต๋๋ค.
.1
์ต์
์ ๋ณํ์ด ์ ํ๋๊ณ get_ref
/ get_mut
๊ฐ assume_init
์ํฉ์์ด ์ฌ์ฉ ๊ฐ๋ฅ ํด์ง๋ฉด์ด API๋ ๊ฑฐ์ ์๊ฒฉํ๊ฒ ์ด๋ฑ ํด์ง๋๋ค. (์ ์ ๋ API๋ฅผ ์ฌ์ฉํ๋ฉด ์ฐธ์กฐ์์ ์ฝ๋ ๊ฒ์ด ๊ด์ฐฎ์ ๊ฒ์ด๊ธฐ ๋๋ฌธ์ ๊ฑฐ์ ๋งํฉ๋๋ค. get_ref
๋ฐ get_mut
์ ๊ฒฝ์ฐ์๋ ์ ๋ ๋ถ๊ฐ๋ฅํฉ๋๋ค)
@danielhenrymantilla ๊ฐ get_{ref,mut}
์ ๋ํด ์ผ๋ ๊ฒ๊ณผ ์ ์ฌํ๊ฒ, ์ ๋ read
์ด๋ฆ์ read_init
๋๋ read_assume_init
๋ฐ๊ฟ์ผํ๋ค๊ณ ์๊ฐํ๊ธฐ ์์ํ์ต๋๋ค. ์ด๊ธฐํ๊ฐ ์๋ฃ๋ ํ์ ๋ง โโ์ํ ํ ์ ์์ต๋๋ค.
@RalfJung ์ด๊ฒ์ ๋ํด ์ง๋ฌธ์ด ์์ต๋๋ค.
fn foo<T>() -> T {
let newt = unsafe { MaybeUninit::<T>::zeroed().assume_init() };
newt
}
์๋ฅผ ๋ค์ด foo<NonZeroU32>
ํฉ๋๋ค. foo
ํจ์๋ฅผ ์ ์ธ ํ ๋ UB๋ฅผ ํธ๋ฆฌ๊ฑฐํฉ๋๊น (๋ชจ๋ T
s์ ๋ํด ์ ํจํด์ผํ๊ฑฐ๋ UB๋ฅผ ํธ๋ฆฌ๊ฑฐํ๋ ์ ํ์ผ๋ก ์ธ์คํด์คํ ํ ๋ ๋๋ฌธ์
๋๊น? ์๋ชป๋ ์ฅ์ ์ธ ๊ฒฝ์ฐ ์ฃ์กํฉ๋๋ค. ์ง๋ฌธํ์ญ์์ค.
@Pzixel ์ฝ๋๋ ์คํ๋ ๋๋ง UB๋ฅผ ์ ๋ฐํ ์ ์์ต๋๋ค.
๋ฐ๋ผ์ foo::<i32>()
์ ๊ด์ฐฎ์ต๋๋ค. ํ์ง๋ง foo::<NonZeroU32>()
์ UB์
๋๋ค.
๊ฐ๋ฅํ ๋ชจ๋ ํธ์ถ ๋ฐฉ๋ฒ์ ๋ํด ์ ํจํ ์์ฑ์ "soundness"๋ผ๊ณ ํ๋ฉฐ ์ฐธ์กฐ๋ฅผ ์ฐธ์กฐ ํ์ญ์์ค. Rust์ ์ผ๋ฐ์ ์ธ ๊ณ์ฝ์ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์์ ํ API ํ๋ฉด์ด ๊ฑด์ ํด์ผํ๋ค๋ ๊ฒ์ ๋๋ค. ์ด๋ฅผ ํตํด ๋์๊ด ์ด์ฉ์๋ UB์ ๋ํด ๊ฑฑ์ ํ ํ์๊ฐ ์์ต๋๋ค. Rust์ ์ ์ฒด ์์ ์ด์ผ๊ธฐ๋ ์ฌ์ด๋ API๊ฐ์๋ ๋ผ์ด๋ธ๋ฌ๋ฆฌ์ ์์ต๋๋ค.
@RalfJung ๊ฐ์ฌํฉ๋๋ค.
๋ฐ๋ผ์ ๋ด๊ฐ ์ฌ๋ฐ๋ฅด๊ฒ ์ดํดํ๋ฉด์ด ํจ์๋ ์๋ฆฌ๊ฐ ๋์ง ์์ต๋๋ค (๋ฐ๋ผ์ ์ ํจํ์ง ์์).ํ์ง๋ง unsafe
๋ก ํ์ํ๋ฉด์ด ๋ณธ๋ฌธ์ด ์ ํจํ๊ณ ์๋ฆฌ๊ฐ๋ฉ๋๋ค.
@Pzixel์ ์์ ํ์ง ์๋ค๊ณ ํ์ํ๋ฉด ๊ฑด์ ์ฑ์ ๋ ์ด์ ์ ์ฉ๋๋ ๊ฐ๋ ์ด ์๋๋๋ค. "์ด ์๋ฆฌ์ธ๊ฐ"๋ ์์ ํ ์ฝ๋์ ๋ํ ์ง๋ฌธ์ผ๋ก ๋ง ์๋ฏธ๊ฐ ์์ต๋๋ค.
์, ์ผ๋ถ ์
๋ ฅ์ด UB๋ฅผ ํธ๋ฆฌ๊ฑฐ ํ ์ ์์ผ๋ฏ๋ก unsafe
ํจ์๋ฅผ ํ์ํด์ผํฉ๋๋ค. ๊ทธ๋ฌ๋ ๊ทธ๋ ๊ฒํ๋๋ผ๋ ํด๋น ์
๋ ฅ์ ์ฌ์ ํ โโUB๋ฅผ ํธ๋ฆฌ๊ฑฐํ๋ฏ๋ก ํจ์๋ ์ฌ์ ํ ๊ทธ๋ฐ ๋ฐฉ์์ผ๋ก ํธ์ถ๋์ง ์์์ผํฉ๋๋ค. ์์ ํ์ง ์์ ์ฝ๋์์๋ UB๋ฅผ ํธ๋ฆฌ๊ฑฐํ๋ ๊ฒ์ ์ข์ง ์์ต๋๋ค.
์, ๋ฌผ๋ก ์
๋๋ค. ๋ถ๋ถ ๊ธฐ๋ฅ์ด unsafe
๋ก ํ์๋์ด์ผํ๋ค๊ณ ๊ฒฐ๋ก ์ ๋ด๋ฆฌ๊ณ ์ถ์์ต๋๋ค. ๋ง์ด๋์ง๋ง ๋๋ตํ๊ธฐ ์ ์ ์๊ฐํ์ง ์์์ต๋๋ค.
์ด ์ถ์ ๋ฌธ์ ์ ๋ํ ๋
ผ์๊ฐ ๋๋ฌด ๊ธธ์ด ์ง๊ธ๋ ๋ถ์์ ํ MaybeUninit
์ ๊ฐ ๊ธฐ๋ฅ์ ๋ํด ๋ช ๊ฐ์ง ๋ค๋ฅธ ์ถ์ ๋ฌธ์ ๋ก ๋๋ ์ ์์ต๋๊น?
maybe_uninit_extra
maybe_uninit_ref
maybe_uninit_slice
ํฉ๋ฆฌ์ ์ธ ๊ฒ ๊ฐ์ต๋๋ค. https://github.com/rust-lang/rust/issues/63291 ๋
๋ ์ผ๋ฐ์ ์ผ๋ก MaybeUninit<T>
์ ์ถ์ ํ๋ ๋ฉํ ๋ฌธ์ ๋ฅผ ์ํด ์ด๊ฒ์ ๋ซ์ต๋๋ค. # 63566
๊ฐ์ฅ ์ ์ฉํ ๋๊ธ
mem::zeroed()
๋ C ํจ์๋ฅผ ํธ์ถํ๊ธฐ ์ ์memset(&x, 0, sizeof(x))
๋ก ๊ฐ์ 0์ผ๋ก ์ค์ ํด์ผํ๋ ํน์ FFI ๊ฒฝ์ฐ์ ์ ์ฉํฉ๋๋ค. ๋๋ ์ด๊ฒ์ด ๋ ์ด์ ์ฌ์ฉ๋์ง ์๋ ๊ฒ์ผ๋ก ์ ์งํ๊ธฐ์ ์ถฉ๋ถํ ์ด์ ๋ผ๊ณ ์๊ฐํฉ๋๋ค.