์ค๋์ "ํธ๋ญ์ด์์ธ๊ต" ๋ณ์๋ฆฌ ๋ธ๋ก๊ทธ๋ฅผ ์ด์ํ๋ ๊น๋์ค๋์ ํฌ์คํ ์ ํ์ณ์๋ค !! ๋๊ฐ์ด ํฌ์คํ ํด๋ ๋๋ค๊ณ ํ๋ฝ์ ๋ฐ์๊ธฐ ๋๋ฌธ์ ์ถ์ฒ๋ฅผ ๋ฐํ๊ณ ๊ฑฐ์ 80% ๊ฐ์ ๋ด์ฉ์ ํฌ์คํ ํ๋ค. ๊ณ ๋ง์์ ๊น๋์ค๋ ~
** Map์ Key ๊ฐ์ผ๋ก Class/Struct ๋ฃ๊ธฐ **
๐๋ชฉํ
map์ key๊ฐ์ผ๋ก ๊ธฐ๋ณธ์ ์ธ ๋ฐ์ดํฐ ํ์ (int, string, float, double...)์ด ์๋ ์ฐ๋ฆฌ๊ฐ ์ง์ ๋ง๋ ํ์ (user defined type)์ ๋ฃ์ด๋ณด์.
๐ํน์ง
- Map์ key(ํค)์ Value(๊ฐ)์ด ์์ผ๋ก ์ด๋ฃจ์ด์ง ์๋ฃ๊ตฌ์กฐ๋ก ํค๋ฅผ ํตํด ๊ฐ์ ์ ๊ทผ ํ ์ ์๋๋ก ๋ง๋ค์ด์ ธ ์๋ค.
- map์ key(ํค)์ ์ค๋ณต์ ํ์ฉํ์ง ์๊ณ , value(๊ฐ)์ ์ค๋ณต์ ํ์ฉํ๋ค.
- c++์ map์ ๋ ๋๋ธ๋ํธ๋ฆฌ๋ฅผ ๊ธฐ๋ฐ์ผ๋ก ๊ตฌํ์ด ๋์ด์๋ค.
๐๋ฌธ์ ์
์ ์ 3๋ฒ ํน์ง์ผ๋ก ์ธํด ์ฐ๋ฆฌ๊ฐ ์ง์ ๋ง๋ ํ์ ์ ๊ทธ๋ฅ key๊ฐ์ผ๋ก ์ฌ์ฉํ ์ ์ปดํ์ผ ์ค๋ฅ๋ฅผ ๋ฐ์์ํจ๋ค.
๐ํด๊ฒฐ๋ฐฉ๋ฒ
map, set์ ๊ท ํ ์ด์งํธ๋ฆฌ๋ก ๊ตฌํ์ด ๋์ด ์๋ ์ฐ๊ด ์ปจํ ์ด๋๋ก ๋์๋น๊ต๊ฐ ๊ฐ๋ฅํด์ผํ๋ค. ์ฐ๋ฆฌ๊ฐ ์ง์ ๋ง๋ ํ์ ์ ๋์๋น๊ต์ฐ์ฐ์ ๋ง๋ค์ด์ค์ผํ๋ค!! ๋ฌด์์ผ๋ก ? operator๋ก ~
** ๊ตฌํ **
class CMapKey
{
public:
CMapKey(const int pKey1, const int pKey2) : mKey1(pKey1), mKey2(pKey2) {}
public:
bool operator<(const CMapKey& pOther) const
{
return mKey1 < pOther.mKey1 ? true : ((mKey2 < pOther.mKey2) ? true : false);
}
}
operator< ๋ฅผ ์ ์ํด ์ฃผ๋ ๊ฒ ๊น์ง๋ ์ข์๋๋ฐ ์์ opeator<๋ Map์ sorting์ ์ฐ์ผ ์๋ ์๋ค.
์๊ฐ์์ด ์์ ๊ฐ์ ๋ฐฉ์์ผ๋ก ์กฐ๊ฑด์ ๊ฑธ์ด ์ฃผ๊ณ ์ฝ๋๋ฅผ ์คํํ์๋ ํน์ ์ํฉ์์ ํฐ์ง๊ฒ ๋๋๋ฐ ๋ด ์๊ฐ์๋๋
ผ๋ฆฌ์ ์ผ๋ก ๋ฌธ์ ๊ฐ ์๋ค๊ณ ์๊ฐ์ ํด์ ํ์ฐธ์ ๊ณ ๋ฏผํ๋ค...
๋ค๋ฅธ๋ถ์ด ์๋ ค์ฃผ์์ง ์์์ผ๋ฉด ์์ง๋ ๋ชจ๋ฅผ ๊ฒ ๊ฐ์๋ฐ ํฐ์ง๋ ๋ถ๋ถ์ ์๋ ์ฝ๋์ด๋ฉฐ
template<class _Pr,
class _Ty1,
class _Ty2> inline
constexpr bool _Debug_lt_pred(_Pr&& _Pred, _Ty1&& _Left, _Ty2&& _Right)
noexcept(
noexcept(_Pred(_Left, _Right))
&& noexcept(_Pred(_Right, _Left)))
{
// test if _Pred(_Left, _Right) and _Pred is strict weak ordering, when the arguments are the cv-same-type
const auto _Result = static_cast<bool>(_Pred(_Left, _Right));
if (_Result) {
_STL_VERIFY(!_Pred(_Right, _Left), "invalid comparator");
}
return _Result;
}
map์ ๋ ๋ ๋ธ๋ ํธ๋ฆฌ ๊ตฌ์กฐ์ ์ ๋ ฌ ์ปจํ ์ด๋์ด๊ธฐ ๋๋ฌธ์ emplace์์ ์ฝ์ ๋ ์์์ ์์น๋ฅผ ์ฐพ๊ธฐ ์ํ ๋น๊ต๋ฅผ ์งํํ๊ฒ ๋๋ค. ์ ์ฝ๋์์ noexcept(_Pred(_Left,_Right)) &&noexcept(_Pred(_Right,_Left))) ๋น๊ตํ ์ผ์ชฝ๋ ธ๋(_Left)์ ๋น๊ต๋นํ ์ค๋ฅธ์ชฝ ๋ ธ๋(_Right)์ ๋ํ ๋น๊ต๋ฅผ ์งํ ํ ๋ (_Left)/(_Right)๋น๊ต ํ๋ฒ, ์์น๋ฅผ ๋ฐ๊ฟ์ (_Right)/(_Left) ๋น๊ต๋ฅผ ํ ๋ฒ ์งํํ์ฌ ๋๋ฒ์ ๋น๊ต ๊ฒฐ๊ณผ๊ฐ ์ผ์นํ๋ฉด ์๋ชป๋ ๋น๊ต"invaild comparator"์ค๋ฅ๋ฅผ ๋ฑ๋๋ค.
์ดํด๊ฐ ์ฝ๊ฒ ๋ ์ ์๋๋ก ๊ธ์ ๊ฐ์ฅ ์ฒ์์ ์ฒจ๋ถํ ์ฝ๋์ operator๋ฅผ ์๋ก ๋ค์ด ์ค๋ช ํ์๋ฉด Key๊ฐ์ด int key1, int key2์ธ ๋๊ฐ์ ๋ ธ๋๋ฅผ ๋น๊ตํจ์ ์์ด
A Node | mKey1 = 2, mKey2 = 5 | (2, 5) |
B Node | mKey1 = 1, mKey2 = 6 | (1, 6) |
๐นoperator< (A, B)
1.1. mKey1 < pOther.mKey1 → ( 2 < 1) : false
1.2. mKey2 < pOther.mKey2 → ( 5 < 6 ) : true
return true;
๐นoperator< (B, A)
2.1. mKey1 < pOther.mKey1 → ( 1 < 2) : true
return true;
ํด๋น ๋น๊ต์์์๋ operator< (A, B) ์ operator< (B, A)๊ฐ ๋ชจ๋ true๋ก ๊ฐ๊ธฐ ๋๋ฌธ์ ๋์๋น๊ต๋ฅผ ํ ์ ์๊ณ ๊ทธ๋์ ์ฝ์ ์์ ํฐ์ง๋ ์ฝ๋๊ฐ ๋๋ ๊ฒ์ด๋ค.
Map์ ์ฝ์ ์์ ์์ชฝ ๋น๊ต๋ฅผ ํตํด ํด๋น ์ ๋ ฌ์ด ์์ ํ ์ง์ ๋ํ ๊ฒ์ฌ๋ฅผ ํ๊ธฐ ๋๋ฌธ์ ๋ฐ์ํ ๋ฌธ์ ์๊ณ ์๋์ ๊ฐ์ด CMapKey class์ operator๋ฅผ ๋ฐ๊ฟ์ค์ผ๋ก์จ ๋ฌธ์ ๋ฅผ ํด๊ฒฐํ๋ค.
bool operator<(const CMapKey& pOther) const
{
if (mKey1 == pOther.mKey1)
{
return mKey2 < pOther.mKey2;
}
return mKey1 < pOther.mKey1;
}
** ์ถ์ฒ **
ํธ๋ญ์ด์์ธ๊ต (tistory.com)
'๐จ๐ปโ๐ป programming > โฝ c, c++' ์นดํ ๊ณ ๋ฆฌ์ ๋ค๋ฅธ ๊ธ
์ ํ๋ ๊ฒ ๋ณด๋ค ๋ซ๊ฒ ์ง
ํฌ์คํ ์ด ์ข์๋ค๋ฉด "์ข์์โค๏ธ" ๋๋ "๊ตฌ๋ ๐๐ป" ํด์ฃผ์ธ์!