The Swap Trick
๐ซ The Swap Trick : ๋ฉ๋ชจ๋ฆฌ ์ฌํ ๋น
์ฐธ๊ณ 0
์ฐธ๊ณ 1
์ฐธ๊ณ 2 ์ฐธ๊ณ 3
์ฝ๊ธฐ ์ข์ ์ฝ๋๊ฐ ์ข์ ์ฝ๋๋ค์ 84p ์์ ์ธ๊ธ๋ The Swap Trick.
์๋๋ ์ฑ
์ ๋์จ ์์ ์ฝ๋๋ค.
1
2
3
4
5
6
7
8
9
10
struct Recorder
{
vector<float> data;
...
void Clear()
{
vector<float>().swap(data);
// ๋ญ? ๊ทธ๋ฅ data.clear() ๋ฅผ ํธ์ถํ์ง ์๋ ์ด์ ๊ฐ ๋ญ์ง?
}
}
์ ์ฝ๋๋ฅผ ๋ณด๋ฉด ์ฃผ์์ ์ ํ ๋ง์ฒ๋ผ ๋จ์ํ data.clear() ํธ์ถํ๋ฉด ๋ ๊ฒ ๊ฐ์๋ฐ,
๋น ๋ฒกํฐ (vector
์ด๋ โ์ ์๋ ค์ง์ง ์์ C++ ์ธ์ด ํน์ ์ ์ธ๋ถ ์ฌํญ ใ ก ์ ์์ ๋ฐ๋ฅด๋ฉดโ ์ ์์์ผ ํ๋ค.
vector.clear()๋ vector ์์ ์ ์ฅ๋ ๊ฐ๋ค์ ์ ๊ฑฐ์์ผ์ฃผ์ง๋ง,
vector์ ํ ๋น๋ ๋ฉ๋ชจ๋ฆฌ๋ ํด์ ๋์ง ์๋๋ค!
๋๋ฌธ์ ๊ฐ์ ๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ํด์ ํด์ฃผ๊ธฐ ์ํด,
๋น vector์ swap์ ํด์ฃผ๋ ๊ฒ์ด๋ค.
์ค์ฝํ๊ฐ ๋๋๋ ์์ ์๋ ์๋์ผ๋ก ํ์์ ๋ฉ๋ชจ๋ฆฌ๊ฐ ํด์ ๋๊ธฐ ๋๋ฌธ์,
๊ณ์ํด์ ์ฌ์ฉํ๋ vector๊ฐ ์๋๋ผ๋ฉด ์ด๋ ๊ฒ ์ธ ํ์๋ ์์ ๊ฒ ๊ฐ๋ค.
์ฑ
์์ ๋์ค๋ The Swap Trick ์ ์ด๋ฅผ ์๋ฏธํ๋ ๊ฒ ๊ฐ๊ณ ,
๊ฒ์ํด๋ณด๋ ๋ค๋ฅธ ๊ฒ๋ ์๋ ๊ฒ ๊ฐ๋ค.
1
vector<float>(data).swap(data);
์ด๋ ๊ฒ ๊ฐ์ vector๋ฅผ ๊ทธ๋๋ก swap ํด์ฃผ๋ฉด,
vector๊ฐ ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ฑ ์ ์ฅ๋ ์์๋ค๋งํผ๋ง ์ฌ์ฉํ๊ฒ ๋๋ค.
๋ฌด์จ ๋ง์ด๋ ํ๋ฉด,
vector๋ ์ฉ๋์ด ๊ฝ ์ฐผ์๋ ์ค์ค๋ก ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ฌํ ๋นํ์ฌ ์ผ์ ๋น์จ๋ก ํฌ๊ธฐ๋ฅผ ํค์ฐ๋๋ฐ,
์ด๋ ์ปค์ง ๋ฉ๋ชจ๋ฆฌ๋ฅผ ๋ชจ๋ ์ฌ์ฉํ์ง ์๋ ์ด์, ๋ญ๋น๋๋ ๋ฉ๋ชจ๋ฆฌ๊ฐ ์๊ธฐ๊ฒ ๋๋ค.
๋๋ฌธ์ ์์ ๊ฐ์ ๋ฐฉ๋ฒ์ผ๋ก The Swap Trick์ ์ฌ์ฉํด ๋ฉ๋ชจ๋ฆฌ๋ฅผ ์ ์ฝํ๋ค.
์ด๋ vector ๋ฟ๋ง ์๋๋ผ string, deque ๊ฐ์ด ๋์ ์ผ๋ก ๋ฉ๋ชจ๋ฆฌ ํ ๋น๋์ด ๋ฐ๋๋ ์น๊ตฌ๋ค์๊ฒ๋ ์ ์ฉ๋๋ค๊ณ ํ๋ค.
C++ 11 ์์๋ ์ด์ ๊ฐ์ ๊ธฐ๋ฅ์ ํ๋ shrink_to_fit() ํจ์๊ฐ ์๋ค๊ณ ํ๋๋ฐ,
์ด๋ ์๋ก์ด vector๋ฅผ ๋ง๋ค๊ณ , ๋ณต์ฌํ๋ ๊ฒ์ด๊ธฐ์,
ํฐ vector์ ๋ํ์ฌ ์ฌ์ฉํ ๊ฒฝ์ฐ, CPU ์ค๋ฒํค๋๋ฅผ ํ ๋ฒ ๊ณ ๋ฏผํด๋ด์ผ ํ๋ค.
๋, ๋ฐฉ๊ธ ์ธ๊ธํ ๊ฒ ์ฒ๋ผ ๊ณผ๋ํ ์ค๋ฒํค๋๊ฐ ๋ฐ์ํ ์ ์๊ธฐ์,
shrink_to_fit() ํจ์๋ non-binding ํจ์ (๋ชจ๋ ์ปดํ์ผ๋ฌ์์ ๋ฐ๋์ ๊ตฌํ๋์ง๋ ์๋) ์ด๋ผ๊ณ ํ๋ค.
๋๋ฌธ์ ์ด์ ์ ์ฌ์ฉํ๋ ์ปดํ์ผ๋ฌ์์ ํธํ์ฑ ์ญ์ ์๊ฐํด์ผ ํ ๊ฒ์ด๋ค.