3 개의 32 비트 식별자를 하나의 32 비트 식별자로 결합합니까?

Question

세 개의 식별자가 있으면 단일 32 비트 값으로 결합하십시오.

첫 번째 식별자는 (2^8) -1 개의 다른 값을 가질 수 있습니다. 유사하게 두 번째 (2^8) -1과 세 번째 (2^10) -1. 따라서 모든 종류의 식별자의 총 개수는 (2^32) -1을 초과하지 않습니다.

예 용액 맵을 가질 수 있었다 :

• 키를 32 비트
• 값 : 8 (또는 10) 비트.

값은 0에서 시작하여 새 식별자가 제공 될 때마다 증가합니다.

더 잘 할 수 있습니까? (3 개지도 대신)이 솔루션에 문제가 있습니까? 명확히

---

는 식별자 범위 < 0, 32^2)에서 어떤 값을 보유 할 수있다. 주어진 유일한 정보는 그것들의 총 수가 (2^8) -1 (또는 10)을 초과하지 않는다는 것입니다.

식별자의 값은 동일 할 수 있습니다 (완전히 임의적입니다). OS가 힙 할당 메모리 (예 : 포인터를 식별자로 사용)에 제공 한 임의성 소스 메모리 주소를 고려하십시오. 이것이 x64 시스템에서 다르게 작동한다는 것을 알았지 만, 일반적인 문제 해결 방법이이 특정 시스템과 유사하기를 바랍니다.

이것은 간단한 비트 시프트가 문제가되지 않는다는 것을 의미합니다.

Answer 1

이 같은 것을 시도해 볼 수도 있습니다 : -

#include <map> 
#include <iostream> 

class CombinedIdentifier 
{ 
public: 
    CombinedIdentifier (unsigned id1, unsigned id2, unsigned id3) 
    { 
     m_id [0] = id1; 
     m_id [1] = id2; 
     m_id [2] = id3; 
    } 

    // version to throw exception on ID not found 
    static CombinedIdentifier GetIdentifier (unsigned int id) 
    { 
     // search m_store for a value = id 
     // if found, get key and return it 
     // else....throw an exception->id not found 
    } 

    // version to return found/not found instead of throwing an exception 
    static bool GetIdentifier (unsigned int id, CombinedIdentifier &out) 
    { 
     // search m_store for a value = id 
     // if found, get key and save it to 'out' and return true 
     // else....return false 
    } 

    int operator [] (int index) { return m_id [index]; } 

    bool operator < (const CombinedIdentifier &rhs) const 
    { 
     return m_id [0] < rhs.m_id [0] ? true : 
       m_id [1] < rhs.m_id [1] ? true : 
       m_id [2] < rhs.m_id [2]; 
    } 

    bool operator == (const CombinedIdentifier &rhs) const 
    { 
     return m_id [0] == rhs.m_id [0] && 
       m_id [1] == rhs.m_id [1] && 
       m_id [2] == rhs.m_id [2]; 
    } 

    bool operator != (const CombinedIdentifier &rhs) const 
    { 
     return !operator == (rhs); 
    } 

    int GetID() 
    { 
     int 
      id; 

     std::map <CombinedIdentifier, int>::iterator 
      item = m_store.find (*this); 

     if (item == m_store.end()) 
     { 
      id = m_store.size() + 1; 
      m_store [*this] = id; 
     } 
     else 
     { 
      id = item->second; 
     }   

     return id; 
    } 

private: 
    int 
     m_id [3]; 

    static std::map <CombinedIdentifier, int> 
     m_store; 
}; 

std::map <CombinedIdentifier, int> 
    CombinedIdentifier::m_store; 

int main() 
{ 
    CombinedIdentifier 
     id1 (2, 4, 10), 
     id2 (9, 14, 1230), 
     id3 (4, 1, 14560), 
     id4 (9, 14, 1230); 

    std::cout << "id1 = " << id1.GetID() << std::endl; 
    std::cout << "id2 = " << id2.GetID() << std::endl; 
    std::cout << "id3 = " << id3.GetID() << std::endl; 
    std::cout << "id4 = " << id4.GetID() << std::endl; 
} 

Answer 2

비트 이동 및 안전하지 않은 코드로이 작업을 수행 할 수 있습니다. SO를에 기사가

: What are bitwise shift (bit-shift) operators and how do they work?

그런 다음 당신은 당신의 세 가지 값을 전체 32 비트 범위를 사용할 수는

---- 8 비트 ---- | ---- 8 비트 ---- | ---- 10 비트 ---- | ----되지 않는 6 비트 ----

int result = firstValue << (8 + 10 + 6); 
result += secondValue << (10 + 6); 
result += thirdValue << 6; 

Answer 3

난 당신이 a Perfect Hash Function의 사용을 만들 수 있다고 생각. 특히, Pearson Hashing에 해당 기사가 제공된 링크가 적절하다고 판단됩니다. 포함 된 C 프로그램의 두 번째 기사를 잘라내어 붙여 넣을 수도 있습니다. 단, 출력은 32 비트가 아닌 64 비트입니다. 당신이

for (j=0; j<4; j++) { 
    // standard Pearson hash (output is h) 

에

for (j=0; j<8; j++) { 
    // standard Pearson hash (output is h) 

약간 수정한다면 당신은 당신이 필요로 할 것이다.