unordered_map 및 해당 시뮬레이션 구현에 익숙해지기 위한 기사

발 2023-10-01 10:14:29 독서 시간: null

여기에 이미지 설명을 삽입하세요.

unordered_map 및 모의 구현에 익숙함

unordered_map의 정의

C++ 표준 라이브러리의 해시 테이블 구현에는 역사가 있습니다. C++98/03 표준에는 표준 해시 테이블 컨테이너에 대한 공식적인 정의가 없습니다. 그러나 많은 C++ 표준 라이브러리 구현(예: STLPort, SGI STL 등)은 해시 테이블 기능을 제공하는 hash_map및 와 같은 확장 컨테이너를 제공합니다.hash_set

std::unordered_mapC++11 표준이 도입되면서 및 같은 해시 테이블 컨테이너가 std::unordered_setC++ 표준 라이브러리의 일부로 공식적으로 도입되었습니다 . 이러한 컨테이너는 C++11 표준으로 표준화되었으며 개발자가 다양한 C++ 표준 라이브러리 구현 간에 코드를 보다 쉽게 ​​포팅할 수 있도록 표준 인터페이스와 구문을 제공합니다.

따라서 해시 테이블 컨테이너는 C++98/03 표준 이전에도 존재했지만 C++11 표준에서 몇 가지 중요한 개선과 표준화를 거쳐 C++ 표준 라이브러리의 일부가 되면서 더 널리 사용되었습니다. .

1. unordered_map의 템플릿 정의

template < class Key,                                    // unordered_map::key_type
           class T,                                      // unordered_map::mapped_type
           class Hash = hash<Key>,                       // unordered_map::hasher
           class Pred = equal_to<Key>,                   // unordered_map::key_equal
           class Alloc = allocator< pair<const Key,T> >  // unordered_map::allocator_type
           > class unordered_map;

C++의 템플릿 정의 std::unordered_map는 키-값 쌍의 해시 테이블을 구현하는 데 사용되는 C++ 표준 라이브러리의 연관 컨테이너(Associative Container)입니다. 템플릿 매개변수에 대한 설명은 다음과 같습니다.

  1. Key : 해시 테이블의 키 유형을 나타내며, 값을 찾는 데 사용되는 유형입니다.
  2. T : 해시 테이블의 값 유형, 즉 키와 연관된 값의 유형을 나타냅니다.
  3. Hash : 키의 해시 값을 계산하는 데 사용되는 해시 함수 유형을 나타냅니다. 기본적으로 std::hash<Key>해시 함수로 사용됩니다.
  4. Pred : 두 키가 동일한지 여부를 결정하는 데 사용되는 키 비교를 나타내는 조건자입니다. 기본적으로 std::equal_to<Key>키 비교 조건자로 사용됩니다.
  5. Alloc : 메모리 할당에 사용되는 할당자 유형을 나타냅니다. 기본적으로 std::allocator<std::pair<const Key, T>>할당자 유형으로 사용됩니다.

std::unordered_map빠른 조회 및 삽입을 위해 해시 테이블을 사용하는 키-값 쌍을 저장하기 위한 컨테이너입니다. 이러한 템플릿 매개변수를 제공함으로써 키, 값 유형, 해시 함수, 키 비교 방법 및 메모리 할당 방법을 사용자 정의하여 다양한 애플리케이션 요구 사항을 충족할 수 있습니다.

예를 들어 std::unordered_map문자열을 키로, 정수를 값으로 사용하고 사용자 지정 해시 함수와 키 비교를 사용하는 인스턴스를 생성할 수 있습니다. 예는 다음과 같습니다.

#include <iostream>
#include <unordered_map>
#include <string>

// 自定义哈希函数
struct MyHash {
    
    
    size_t operator()(const std::string& key) const {
    
    
        // 简单示例：将字符串的长度作为哈希值
        return key.length();
    }
};

// 自定义键比较谓词
struct MyEqual {
    
    
    bool operator()(const std::string& lhs, const std::string& rhs) const {
    
    
        // 比较字符串是否相等
        return lhs == rhs;
    }
};

int main() {
    
    
    std::unordered_map<std::string, int, MyHash, MyEqual> myMap;
    myMap["apple"] = 5;
    myMap["banana"] = 3;

    std::cout << "apple: " << myMap["apple"] << std::endl;
    std::cout << "banana: " << myMap["banana"] << std::endl;

    return 0;
}

이 예에서는 사용자 정의 해시 함수 MyHash와 키 비교 조건자를 생성 MyEqual하고 이를 std::unordered_map템플릿 매개변수에 사용하여 키 해시 및 비교 방법을 사용자 정의합니다. 이를 통해 문자열 길이를 기준으로 해시를 계산하고 문자열이 동일한지 확인할 수 있습니다.

2. unordered_map의 멤버 유형

다음 별칭은 unordered_map의 멤버 유형입니다. 멤버 함수의 매개변수 및 반환 유형으로 널리 사용됩니다.

이미지 설명을 추가해주세요

무순 지도 생성자

empty (1)	
explicit unordered_map ( size_type n = /* see below */,
                         const hasher& hf = hasher(),
                         const key_equal& eql = key_equal(),
                         const allocator_type& alloc = allocator_type() );
explicit unordered_map ( const allocator_type& alloc );
range (2)	
template <class InputIterator>
unordered_map ( InputIterator first, InputIterator last,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );
copy (3)	
unordered_map ( const unordered_map& ump );
unordered_map ( const unordered_map& ump, const allocator_type& alloc );
move (4)	
unordered_map ( unordered_map&& ump );
unordered_map ( unordered_map&& ump, const allocator_type& alloc );
initializer list (5)	
unordered_map ( initializer_list<value_type> il,
                size_type n = /* see below */,
                const hasher& hf = hasher(),
                const key_equal& eql = key_equal(),
                const allocator_type& alloc = allocator_type() );
  1. 기본 생성자(1) :
    • explicit unordered_map ( size_type n = /* see below */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& alloc = allocator_type() );
    • unordered_map선택적으로 컨테이너의 초기 버킷 번호 n, 해시 함수 hf, 키 비교 조건자 eql및 할당자를 지정하여 빈 항목을 만듭니다 alloc.
  2. 할당자의 생성자(1) 사용 :
    • explicit unordered_map ( const allocator_type& alloc );
    • unordered_map지정된 할당자를 사용하여 빈 할당자를 만듭니다 alloc.
  3. 범위 생성자(2) :
    • template <class InputIterator> unordered_map ( InputIterator first, InputIterator last, size_type n = /* see below */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& alloc = allocator_type() );
    • 반복자 범위 [first, last)의 요소로 초기화되며 unordered_map선택적으로 초기 버킷 수 n, 해시 함수 hf, 키 비교 조건자 eql및 할당자를 지정합니다 alloc.
  4. 복사 생성자(3) :
    • unordered_map ( const unordered_map& ump );
    • 새로운 것을 만들고 unordered_map다른 unordered_map ump것의 내용을 사용하여 복사 구성하십시오.
    • unordered_map ( const unordered_map& ump, const allocator_type& alloc );
    • 할당자를 지정하여 새 항목을 만들고 unordered_map다른 unordered_map ump항목의 내용을 사용하여 복사 구성합니다 alloc.
  5. 생성자 이동(4) :
    • unordered_map ( unordered_map&& ump );
    • 새 콘텐츠를 만들고 unordered_map다른 unordered_map ump콘텐츠를 이동하세요.
    • unordered_map ( unordered_map&& ump, const allocator_type& alloc );
    • 할당자를 지정하여 새 항목을 만들고 unordered_map다른 항목의 콘텐츠를 이동합니다 .unordered_map umpalloc
  6. 초기화 목록 생성자(5) :
    • unordered_map ( initializer_list<value_type> il, size_type n = /* see below */, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& alloc = allocator_type() );
    • 초기화 목록의 요소를 사용하여 il초기화되며 unordered_map선택적으로 초기 버킷 수 n, 해시 함수 hf, 키 비교 조건자 eql및 할당자를 지정합니다 alloc.

std::unordered_map다음은 생성자를 사용하는 방법에 대한 몇 가지 예 입니다 .

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    
    
    // 示例 1: 默认构造函数
    std::unordered_map<int, std::string> myMap;  // 创建一个空的 unordered_map

    // 示例 2: 范围构造函数
    std::unordered_map<char, int> charCount;
    std::string text = "hello world";
    for (char c : text) {
    
    
        charCount[c]++;
    }
    std::unordered_map<char, int> copyMap(charCount.begin(), charCount.end());

    // 示例 3: 拷贝构造函数
    std::unordered_map<int, double> sourceMap = {
    
    {
    
    1, 1.1}, {
    
    2, 2.2}, {
    
    3, 3.3}};
    std::unordered_map<int, double> copyOfSource(sourceMap);

    // 示例 4: 移动构造函数
    std::unordered_map<std::string, int> source;
    source["apple"] = 5;
    source["banana"] = 3;
    std::unordered_map<std::string, int> destination(std::move(source));

    // 示例 5: 初始化列表构造函数
    std::unordered_map<std::string, int> fruitCount = {
    
    
        {
    
    "apple", 5},
        {
    
    "banana", 3},
        {
    
    "cherry", 8}
    };

    // 输出示例
    for (const auto& pair : fruitCount) {
    
    
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

unordered_map 할당 연산자 오버로드

copy (1)	
unordered_map& operator= ( const unordered_map& ump );
move (2)	
unordered_map& operator= ( unordered_map&& ump );
initializer list (3)	
unordered_map& operator= ( intitializer_list<value_type> il );

할당 연산자를 사용하면 std::unordered_map한 내용을 다른 내용에 할당 할 수 있습니다 std::unordered_map. 다음은 이러한 연산자와 오버로드 방법에 대한 간략한 설명입니다.

  1. 복사 할당 연산자(1) :
    • unordered_map& operator= (const unordered_map& ump);
    • 기존 의 내용을 std::unordered_map다른 기존 에 복사합니다 std::unordered_map.
  2. 이동 할당 연산자(2) :
    • unordered_map& operator= (unordered_map&& ump);
    • 기존 의 콘텐츠를 std::unordered_map다른 기존 으로 이동합니다 std::unordered_map. 이 작업을 수행하면 원본이 std::unordered_map유효하지만 더 이상 사용할 수 없는 상태로 설정됩니다.
  3. 초기화 목록 할당 연산자 (3) :
    • unordered_map& operator= (initializer_list<value_type> il);
    • il초기화 목록의 요소를 사용하여 에 할당합니다 std::unordered_map. 이 작업은 원본 콘텐츠를 대체합니다.

이러한 할당 연산자를 사용하면 다양한 상황에서 해시 테이블의 내용을 업데이트할 수 std::unordered_map있으며 해시 테이블의 키-값 쌍을 복사, 이동 또는 교체하는 데 사용할 수 있습니다. 여기 몇 가지 예가 있어요.

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    
    
    std::unordered_map<std::string, int> source = {
    
    {
    
    "apple", 5}, {
    
    "banana", 3}};
    std::unordered_map<std::string, int> destination;

    // 拷贝赋值操作符示例
    destination = source;

    // 移动赋值操作符示例
    std::unordered_map<std::string, int> otherSource = {
    
    {
    
    "cherry", 8}};
    destination = std::move(otherSource);

    // 初始化列表赋值操作符示例
    destination = {
    
    {
    
    "grape", 12}, {
    
    "orange", 6}};

    // 输出示例
    for (const auto& pair : destination) {
    
    
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

std::unordered_map이 예에서는 다양한 할당 연산자를 사용하여 의 내용을 업데이트하는 방법을 보여줍니다 . 복사, 이동 또는 초기화 목록으로 대체하는 경우 해시 테이블 개체의 내용은 필요에 따라 쉽게 업데이트될 수 있습니다.

unordered_map 용량 함수(Capacity)

  1. empty()기능 :
    • bool empty() const noexcept;
    • std::unordered_map비어 있는지 확인하는 데 사용됩니다 . 해시 테이블에 키-값 쌍이 포함되어 있지 않으면 를 반환하고 true, 그렇지 않으면 를 반환합니다 false. 이 함수는 예외를 발생시키지 않습니다.
  2. size()기능 :
    • size_type size() const noexcept;
    • std::unordered_map에 저장된 키-값 쌍의 수를 반환합니다 . 즉, 해시 테이블의 크기를 반환합니다. 해시 테이블이 비어 있으면 0이 반환됩니다. 이 함수는 예외를 발생시키지 않습니다.
  3. max_size()기능 :
    • size_type max_size() const noexcept;
    • std::unordered_map수용할 수 있는 최대 키-값 쌍 수를 반환하며 일반적으로 시스템 리소스에 의해 제한됩니다. 이 값은 시스템과 컴파일러에 따라 다를 수 있습니다. 이 함수는 예외를 발생시키지 않습니다.

std::unordered_map이러한 기능을 사용하면 의 상태를 쿼리하고 관리할 수 있습니다 . empty()예를 들어 해시 테이블이 비어 있는지 확인하는 데 사용하고 , size()현재 크기를 가져오는 데 사용하고, max_size()해시 테이블이 보유할 수 있는 최대 크기를 확인하는 데 사용할 수 있습니다.

예 :

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> myMap;

    // 使用 empty() 函数检查是否为空
    if (myMap.empty()) {
    
    
        std::cout << "Map is empty." << std::endl;
    } else {
    
    
        std::cout << "Map is not empty." << std::endl;
    }

    // 添加一些键值对
    myMap[1] = "one";
    myMap[2] = "two";
    myMap[3] = "three";

    // 使用 size() 函数获取大小
    std::cout << "Size of the map: " << myMap.size() << std::endl;

    // 使用 max_size() 函数获取最大容量
    std::cout << "Max size of the map: " << myMap.max_size() << std::endl;

    return 0;
}

unordered_map 반복자(반복자)

1. 시작()

container iterator (1)	
      iterator begin() noexcept;
	  const_iterator begin() const noexcept;
bucket iterator (2)	
      local_iterator begin ( size_type n );
	  const_local_iterator begin ( size_type n ) const;

  1. begin()함수(컨테이너 반복자):

    • iterator begin() noexcept;
    • const_iterator begin() const noexcept;
    • 두 버전의 begin()함수 모두 std::unordered_map의 첫 번째 요소(키-값 쌍)를 가리키는 반복자를 반환합니다. 첫 번째 버전은 const가 아닌 반복자를 반환하고 두 번째 버전은 const 반복자를 반환합니다. 이러한 함수는 예외를 발생시키지 않습니다.

  2. begin(size_type n)함수(버킷 반복자):

    • local_iterator begin(size_type n);

    • const_local_iterator begin(size_type n) const;

    • 두 버전의 begin(size_type n)함수 모두 특정 버킷의 첫 번째 요소를 가리키는 반복자를 반환합니다. 여기서 는 n액세스할 버킷의 인덱스입니다. 첫 번째 버전은 상수가 아닌 버킷 반복자를 반환하고, 두 번째 버전은 상수 버킷 반복자를 반환합니다. 이러한 기능을 사용하면 해시 테이블의 특정 버킷 내의 요소를 반복할 수 있습니다.

2. 끝()

container iterator (1)	
      iterator end() noexcept;
	  const_iterator end() const noexcept;
bucket iterator (2)	
      local_iterator end (size_type n);
 	  const_local_iterator end (size_type n) const;

  1. end()함수(컨테이너 반복자)

    :

    • iterator end() noexcept;
    • const_iterator end() const noexcept;
    • 이 두 버전의 end()함수는 std::unordered_map의 꼬리(끝)를 가리키는 반복자를 반환합니다. 첫 번째 버전은 const가 아닌 반복자를 반환하고 두 번째 버전은 const 반복자를 반환합니다. 이러한 함수는 예외를 발생시키지 않습니다.

  2. end(size_type n)함수(버킷 반복자):

    • local_iterator end(size_type n);

    • const_local_iterator end(size_type n) const;

    • 두 버전의 end(size_type n)함수 모두 특정 버킷의 끝(끝)을 가리키는 반복자를 반환합니다. 여기서 는 n액세스할 버킷의 인덱스입니다. 첫 번째 버전은 상수가 아닌 버킷 반복자를 반환하고, 두 번째 버전은 상수 버킷 반복자를 반환합니다. 이러한 함수를 사용하면 해시 테이블의 특정 버킷 내의 요소 끝을 반복할 수 있습니다.

이러한 반복기 함수를 사용하면 std::unordered_map전체 컨테이너뿐만 아니라 특정 버킷 내의 요소에 대해서도 의 요소를 반복할 수 있습니다. 다음은 몇 가지 샘플 코드입니다.

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    
    
    std::unordered_map<int, std::string> myMap = {
    
    {
    
    1, "one"}, {
    
    2, "two"}, {
    
    3, "three"}};

    // 使用容器迭代器 begin()
    for (auto it = myMap.begin(); it != myMap.end(); ++it) {
    
    
        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
    }

    // 使用桶迭代器 begin(size_type n)
    size_t bucketIndex = myMap.bucket(2); // 获取键 2 所在的桶索引
    for (auto it = myMap.begin(bucketIndex); it != myMap.end(bucketIndex); ++it) {
    
    
        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
    }

    return 0;
}

이 예에서는 컨테이너 반복자를 사용 begin()하고 end()전체 해시 테이블과 버킷 반복자를 순회 begin(size_type n)하고 end(size_type n)특정 버킷의 요소를 반복하는 방법을 보여줍니다. std::unordered_map이러한 반복기 함수를 사용하면 의 요소를 효율적으로 반복하고 액세스할 수 있습니다 .

3.cbegin()

container iterator (1)	
	  const_iterator cbegin() const noexcept;
bucket iterator (2)	
	  const_local_iterator cbegin ( size_type n ) const;
  1. cbegin()기능(상수 컨테이너 반복자) :
    • const_iterator cbegin() const noexcept;
    • 이 함수는 std::unordered_map의 첫 번째 요소(키-값 쌍)를 가리키는 상수 반복자를 반환합니다. 이는 해시 테이블의 읽기 전용 순회를 허용하고 해시 테이블의 내용 수정을 허용하지 않습니다. 이 함수는 예외를 발생시키지 않습니다.
  2. cbegin(size_type n)기능(상수 버킷 반복자) :
    • const_local_iterator cbegin(size_type n) const;
    • 이 함수는 특정 버킷(버킷)의 첫 번째 요소를 가리키는 상수 버킷 반복자를 반환하는 데 사용됩니다. 여기서 는 n액세스할 버킷의 인덱스입니다. 이는 특정 버킷에 있는 요소의 읽기 전용 순회를 허용하며 해시 테이블의 내용 수정을 허용하지 않습니다. 이 함수는 예외를 발생시키지 않습니다.

4.센드()

container iterator (1)	
	  const_iterator cend() const noexcept;
bucket iterator (2)	
	  const_local_iterator cend ( size_type n ) const;
  1. cend()기능(상수 컨테이너 반복자) :
    • const_iterator cend() const noexcept;
    • 이 함수는 std::unordered_map의 꼬리(끝)를 가리키는 상수 반복자를 반환합니다. 이는 해시 테이블의 읽기 전용 순회를 허용하고 해시 테이블의 내용 수정을 허용하지 않습니다. 이 함수는 예외를 발생시키지 않습니다.
  2. cend(size_type n)기능(상수 버킷 반복자) :
    • const_local_iterator cend(size_type n) const;
    • 이 함수는 특정 버킷(버킷)의 끝(끝)을 가리키는 상수 버킷 반복자를 반환하는 데 사용됩니다. 여기서 는 n액세스할 버킷의 인덱스입니다. 이는 특정 버킷에 있는 요소의 읽기 전용 순회를 허용하며 해시 테이블의 내용 수정을 허용하지 않습니다. 이 함수는 예외를 발생시키지 않습니다.

이러한 상수 반복자 함수는 std::unordered_map읽기 전용 모드에서 요소에 액세스하는 데 유용합니다. 다음은 샘플 코드입니다.

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    
    
    std::unordered_map<int, std::string> myMap = {
    
    {
    
    1, "one"}, {
    
    2, "two"}, {
    
    3, "three"}};

    // 使用常量容器迭代器 cbegin()
    for (auto it = myMap.cbegin(); it != myMap.cend(); ++it) {
    
    
        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
    }

    // 使用常量桶迭代器 cbegin(size_type n)
    size_t bucketIndex = myMap.bucket(2); // 获取键 2 所在的桶索引
    for (auto it = myMap.cbegin(bucketIndex); it != myMap.cend(bucketIndex); ++it) {
    
    
        std::cout << "Key: " << it->first << ", Value: " << it->second << std::endl;
    }

    return 0;
}

이 예에서는 상수 컨테이너 반복자를 사용하여 전체 해시 테이블을 탐색하고, 상수 버킷 반복자를 사용하여 cbegin()특정 버킷 의 요소를 탐색합니다. 이러한 상수 반복자 함수를 사용하면 읽기 전용 모드에서 요소에 액세스할 수 있으므로 해시 테이블의 내용이 수정되지 않습니다.cend()cbegin(size_type n)cend(size_type n)std::unordered_map

unordered_map 요소 액세스 및 요소 검색 기능

1. 연산자[]

  1. mapped_type& operator[] ( const key_type& k );：
    • const이 오버로드된 함수는 참조 유형 키( )를 허용 key_type하고 mapped_type키( )와 연결된 값에 대한 참조를 반환합니다.
    • 키( k)가 있으면 unordered_map해당 키 값에 대한 참조를 반환하므로 값을 수정할 수 있습니다.
    • 키( k)가 없으면 unordered_map키-값 쌍을 삽입하고 기본 구성 값(일반적으로 해당 유형의 기본값)에 대한 참조를 반환합니다.
    • 즉 , 키가 존재하는지 명시적으로 확인하거나 키-값 쌍을 삽입하지 않고도 에서 값을 operator[]읽거나 수정할 수 있다는 의미입니다 .unordered_map
  2. mapped_type& operator[] ( key_type&& k );：
    • 이 오버로드된 함수는 rvalue 참조 유형 키( key_type)를 허용하고 mapped_type키와 연결된 값( )에 대한 참조를 반환합니다.
    • 첫 번째 오버로드된 함수와 유사하게 키( k)가 있으면 unordered_map해당 키 값에 대한 참조를 반환하므로 해당 값을 수정할 수 있습니다.
    • 키( k)가 없으면 unordered_map키-값 쌍을 삽입하고 기본 구성 값에 대한 참조를 반환합니다.

다음은 std::unordered_map사용된 operator[]오버로드된 함수의 예 입니다.

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<std::string, int> myMap;

    // 使用 operator[] 插入键-值对
    myMap["apple"] = 3;
    myMap["banana"] = 2;
    myMap["cherry"] = 5;

    // 访问键的值并修改它
    std::cout << "Number of apples: " << myMap["apple"] << std::endl;
    myMap["apple"] = 4;

    // 访问不存在的键，会插入默认值并返回引用
    std::cout << "Number of oranges: " << myMap["orange"] << std::endl;

    // 使用右值引用的 operator[] 插入键-值对
    std::string fruit = "grape";
    myMap[std::move(fruit)] = 6;

    // 遍历输出所有键-值对
    for (const auto& kv : myMap) {
    
    
        std::cout << kv.first << ": " << kv.second << std::endl;
    }

    return 0;
}

이 예에서는 키-값 쌍 삽입을 사용하고 operator[], 기존 키 값에 액세스 및 수정하고, 기본값을 자동으로 삽입하는 존재하지 않는 키에 액세스합니다. 또한 새로운 키-값 쌍을 삽입하기 위해 rvalue 참조를 사용하는 방법도 보여줍니다 operator[]. 마지막으로 모든 키-값 쌍을 반복하고 출력합니다.

2. 에

  1. 값을 수정하는 at함수 :

    mapped_type& at(const key_type& k);
mapped_type& at(key_type&& k);

    이 두 가지 오버로드 버전을 사용하면 k키를 기반으로 연결된 컨테이너의 값을 수정할 수 있습니다. 키가 k컨테이너에 있으면 해당 값에 대한 참조를 반환하므로 값을 수정할 수 있습니다. 키가 존재하지 않으면 예외가 k발생합니다 .std::out_of_range

    샘플 코드:

    std::unordered_map<std::string, int> myMap;
myMap["apple"] = 3;

// 使用 at 函数修改值
myMap.at("apple") = 4;

    키가 "apple"존재하면 값이 로 수정됩니다 4.

  2. 값에 대한 읽기 전용 액세스 at기능 :

    const mapped_type& at(const key_type& k) const;

    이 오버로드된 버전을 사용하면 컨테이너의 값에 읽기 전용으로 액세스할 수 있습니다. key k와 연관된 값에 대한 상수 참조를 반환합니다. 키가 존재하지 않는 경우 k에도 예외가 발생합니다 std::out_of_range.

    샘플 코드:

    std::unordered_map<std::string, int> myMap;
myMap["apple"] = 3;

// 使用 at 函数只读访问值
int numberOfApples = myMap.at("apple");

    키가 "apple"존재하면 값이 반환되며 3이를 변수에 저장할 수 있습니다 numberOfApples.

요약하면, at함수는 키가 존재하는지 확인하고 필요한 경우 예외를 발생시키기 때문에 연관 컨테이너의 요소에 안전하게 액세스하기 위한 방법입니다. 이는 존재하지 않는 키에 액세스하여 발생하는 정의되지 않은 동작을 방지하는 데 도움이 됩니다.

3. 찾기

  1. const가 아닌 컨테이너를 위한 find함수 :

    iterator find(const key_type& k);

    이 버전의 find함수는 const가 아닌 컨테이너에서 작동하고 반복자를 반환합니다. 키가 컨테이너에 있으면 k반복자는 k키와 연결된 요소를 가리키고, 키가 없으면 k컨테이너의 end()반복자를 반환하여 찾을 수 없음을 나타냅니다.

    샘플 코드:

    std::unordered_map<std::string, int> myMap;
myMap["apple"] = 3;

// 使用 find 函数查找键 "apple"
auto it = myMap.find("apple");
if (it != myMap.end()) {
      
      
    // 找到了，输出值
    std::cout << "Value of 'apple': " << it->second << std::endl;
} else {
      
      
    // 未找到
    std::cout << "Key 'apple' not found." << std::endl;
}

  2. 상수 컨테이너 find기능 :

    const_iterator find(const key_type& k) const;

    이 버전의 find함수는 상수 컨테이너와 함께 작동하며 const 반복자(const_iterator)를 반환합니다. const가 아닌 버전과 동일하게 작동하지만 컨테이너의 요소 수정을 허용하지 않습니다.

    샘플 코드:

    const std::unordered_map<std::string, int> myMap = {
      
      
    {
      
      "apple", 3},
    {
      
      "banana", 2},
    {
      
      "cherry", 5}
};

// 使用 const find 函数查找键 "banana"
auto it = myMap.find("banana");
if (it != myMap.end()) {
      
      
    // 找到了，输出值
    std::cout << "Value of 'banana': " << it->second << std::endl;
} else {
      
      
    // 未找到
    std::cout << "Key 'banana' not found." << std::endl;
}

요약하자면, find함수는 연관 컨테이너에서 특정 키를 찾는 데 매우 유용한 방법입니다. 키가 존재하는지 확인하고 이와 관련된 값에 액세스해야 하는 경우 find함수는 안전하고 효율적인 선택입니다.

4. 카운트

size_type count(const key_type& k) const;
  • k: 찾아야 할 열쇠.
  • size_type: 일반적으로 부호 없는 정수 유형인 반환 값 유형은 k컨테이너에서 키의 발생 횟수를 나타냅니다.

count이 함수는 컨테이너에서 키를 찾고 k해당 키의 발생 횟수를 반환합니다. 키가 k컨테이너에 있으면 count함수는 키가 발생한 횟수를 나타내는 1 이상의 양의 정수를 반환합니다. 키가 k존재하지 않으면 함수는 0을 반환하여 키가 나타나지 않음을 나타냅니다.

샘플 코드:

std::unordered_map<std::string, int> myMap = {
    
    
    {
    
    "apple", 3},
    {
    
    "banana", 2},
    {
    
    "cherry", 5}
};

// 计算键 "apple" 在容器中的出现次数
size_t appleCount = myMap.count("apple");
std::cout << "The count of 'apple': " << appleCount << std::endl;

// 计算键 "grape" 在容器中的出现次数
size_t grapeCount = myMap.count("grape");
std::cout << "The count of 'grape': " << grapeCount << std::endl;

위의 예에서 count함수는 먼저 컨테이너에서 "apple" 키의 발생 횟수(1이어야 함)를 계산한 다음 컨테이너에서 "grape" 키의 발생 횟수(0이어야 함)를 계산합니다. count함수는 컨테이너에 키가 있는지 확인하고 키 발생 횟수를 계산하는 데 유용합니다. 특정 키가 존재하는지, 몇 번이나 나타나는지 알고 싶다면 count이 기능을 이용해 쿼리하면 됩니다.

5. 동일 범위

pair<iterator,iterator>
   equal_range ( const key_type& k );
pair<const_iterator,const_iterator>
   equal_range ( const key_type& k ) const;
  • k: 찾아야 할 열쇠.
  • pair: 반환 값 유형으로, 범위의 시작 위치와 끝 위치를 나타내는 두 개의 반복자를 포함하는 컨테이너입니다.
  • iteratorand const_iterator: 반복자 유형, 컨테이너 반복자와 상수 반복자를 나타냅니다.

equal_range이 함수는 컨테이너에서 키를 조회 하고 첫 번째 요소가 범위의 시작을 가리키는 반복자이고 두 번째 요소가 범위의 끝을 가리키는 반복자인 키를 k반환합니다 . pair이 범위에는 k키가 와 같은 모든 요소가 포함됩니다.

샘플 코드:

std::map<int, std::string> myMap = {
    
    
    {
    
    1, "one"},
    {
    
    2, "two"},
    {
    
    2, "another two"}, // 注意：键 2 重复
    {
    
    3, "three"}
};

// 查找键 2 在容器中的范围
auto range = myMap.equal_range(2);

// 输出范围中的元素
for (auto it = range.first; it != range.second; ++it) {
    
    
    std::cout << it->first << ": " << it->second << std::endl;
}

위의 예에서 equal_range함수는 myMap키 2가 있는 범위를 찾고 범위의 시작과 끝을 포함하는 반복자를 반환합니다 pair. 그런 다음 반복자를 사용하여 범위를 탐색하고 범위의 요소를 출력합니다.

equal_range이 함수는 동일한 키를 가진 모든 요소를 ​​찾아 반복할 수 있으므로 연관 컨테이너에서 중복 키를 처리할 때 유용합니다.

unordered_map 수정자 함수

1. 위치

template <class... Args>
pair<iterator, bool> emplace ( Args&&... args );

std::unordered_map이 emplace함수는 새로운 키-값 쌍을 해시 테이블에 삽입하고 std::pair부울 값을 포함하는 반복자를 반환합니다.

  • Args&&... args원하는 수의 매개변수를 전달할 수 있는 템플릿 매개변수 팩입니다.
  • pair<iterator, bool>반환 값 유형입니다. 여기서 는 삽입 성공 여부를 나타내는 iterator삽입 반복자 또는 기존 키-값 쌍입니다 . bool키가 이미 존재하는 경우 반복자는 기존 키-값 쌍을 가리키고 부울 값은 입니다. false키가 존재하지 않으면 반복자는 새로 삽입된 키-값 쌍을 가리키며 부울 값은 입니다 true.

emplace다음은 함수의 사용 예 입니다 .

#include <iostream>
#include <unordered_map>
#include <string>

int main() {
    
    
    std::unordered_map<int, std::string> myMap;

    // 使用 emplace 插入键值对
    auto result1 = myMap.emplace(1, "One");
    if (result1.second) {
    
    
        std::cout << "Insertion successful. Key: " << result1.first->first << ", Value: " << result1.first->second << std::endl;
    } else {
    
    
        std::cout << "Key already exists. Key: " << result1.first->first << ", Value: " << result1.first->second << std::endl;
    }

    // 尝试再次插入相同的键值对
    auto result2 = myMap.emplace(1, "Another One");
    if (result2.second) {
    
    
        std::cout << "Insertion successful. Key: " << result2.first->first << ", Value: " << result2.first->second << std::endl;
    } else {
    
    
        std::cout << "Key already exists. Key: " << result2.first->first << ", Value: " << result2.first->second << std::endl;
    }

    return 0;
}

위의 예에서는 emplace함수를 사용하여 키-값 쌍을 먼저 삽입한 다음 동일한 키-값 쌍을 다시 삽입하려고 시도합니다. 반환된 부울 값을 기반으로 삽입 성공 여부와 삽입된 키-값 쌍이 이미 존재하는지 아니면 새로 삽입되었는지 확인할 수 있습니다.

2. emplace_hint

와 달리 삽입 작업의 성능 emplace을 emplace_hint향상시키기 위해 힌트 위치를 제공할 수 있습니다.

다음은 emplace_hint함수의 매개변수와 사용법에 대한 간략한 설명입니다.

  • position: 삽입 위치의 힌트를 나타내는 반복자입니다. 새 요소는 앞에 삽입됩니다 position. 이 매개변수는 컨테이너가 요소를 보다 효율적으로 삽입하는 데 도움이 되지만 필수는 아닙니다.
  • Args&&... args: 이것은 새 요소의 구성 매개변수를 전달하는 데 사용되는 가변 템플릿입니다. 요소 유형의 생성자에 따라 원하는 만큼의 인수를 전달할 수 있습니다.
  • 반환 값: emplace_hint삽입된 새 요소를 가리키는 반복기를 반환하거나, 삽입에 실패하면 컨테이너의 기존 요소를 가리키는 반복기를 반환합니다.

다음은 새 키-값 쌍을 에 삽입하는 방법을 보여주는 예입니다 emplace_hint.std::unordered_map

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> myMap;

    // 使用 emplace_hint 插入元素
    auto hint = myMap.emplace_hint(myMap.begin(), 1, "One");
    myMap.emplace_hint(hint, 2, "Two");
    myMap.emplace_hint(hint, 3, "Three");

    // 遍历 unordered_map 并打印键值对
    for (const auto& pair : myMap) {
    
    
        std::cout << pair.first << ": " << pair.second << std::endl;
    }

    return 0;
}

이 예에서는 삽입 효율성을 높이기 위해 위치를 묻는 메시지를 표시하여 emplace_hint새 키-값 쌍을 삽입하는 데 사용됩니다 . hint요소 는 emplace_hint어느 위치에나 삽입될 수 있지만 일반적으로 불필요한 검색 및 이동 작업을 피하기 위해 힌트 위치를 사용합니다.

3. 삽입

  1. pair<iterator, bool> insert(const value_type& val): 키-값 val쌍을 에 삽입합니다 unordered_map. 삽입이 성공하면 삽입 성공 여부를 나타내는 삽입된 요소를 가리키는 one pair을 반환합니다.iteratorbool

    예:

    std::unordered_map<int, std::string> myMap;
std::pair<int, std::string> pairToInsert(1, "One");
auto result = myMap.insert(pairToInsert);
if (result.second) {
      
      
    std::cout << "Insertion successful." << std::endl;
} else {
      
      
    std::cout << "Insertion failed (key already exists)." << std::endl;
}

  2. template <class P> pair<iterator, bool> insert(P&& val): 이동 의미론을 사용하여 키-값 쌍을 에 val삽입합니다 unordered_map. 또한 pair삽입 결과를 나타내는 하나를 반환합니다.

    예:

    std::unordered_map<int, std::string> myMap;
auto result = myMap.insert(std::make_pair(1, "One"));
if (result.second) {
      
      
    std::cout << "Insertion successful." << std::endl;
} else {
      
      
    std::cout << "Insertion failed (key already exists)." << std::endl;
}

  3. iterator insert(const_iterator hint, const value_type& val): 주어진 위치에 hint키-값 쌍을 삽입합니다 val. 이 기능을 사용하면 위치 힌트를 제공하여 삽입 효율성을 높일 수 있습니다.

    예:

    std::unordered_map<int, std::string> myMap;
auto hint = myMap.begin(); // 可以是任何迭代器位置
myMap.insert(hint, std::make_pair(1, "One"));

  4. template <class P> iterator insert(const_iterator hint, P&& val): 세 번째 함수와 유사하게 키-값 쌍은 위치 힌트를 제공하면서 이동 의미론을 사용하여 삽입됩니다.

    예:

    std::unordered_map<int, std::string> myMap;
auto hint = myMap.begin(); // 可以是任何迭代器位置
myMap.insert(hint, std::make_pair(1, "One"));

  5. template <class InputIterator> void insert(InputIterator first, InputIterator last): 반복자 쌍 [first, last)으로 지정된 범위의 요소를 에 삽입합니다 unordered_map.

    예:

    std::unordered_map<int, std::string> myMap;
std::vector<std::pair<int, std::string>> data = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}};
myMap.insert(data.begin(), data.end());

  6. void insert(initializer_list<value_type> il): 초기화 목록의 요소를 사용하여 삽입합니다 unordered_map.

    예:

    std::unordered_map<int, std::string> myMap;
myMap.insert({
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}});

이러한 함수는 키-값 쌍을 삽입하는 다양한 방법을 제공하므로 필요에 따라 가장 적절한 방법을 선택할 수 있습니다.

4. 지우다

  1. iterator erase(const_iterator position): 반복자 위치를 통해 position해당 키-값 쌍을 삭제합니다 . 요소를 제거한 후 위치를 가리키는 반복자를 반환합니다.

    예:

    std::unordered_map<int, std::string> myMap = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}};
auto it = myMap.find(2); // 找到键为2的位置
if (it != myMap.end()) {
      
      
    myMap.erase(it); // 删除键为2的元素
}

  2. size_type erase(const key_type& k): key 로 k해당 키-값 쌍을 삭제합니다 . 제거된 요소 수를 반환합니다(키가 에서 unordered_map고유하므로 0 또는 1).

    예:

    std::unordered_map<int, std::string> myMap = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}};
size_t erased = myMap.erase(2); // 删除键为2的元素
std::cout << "Erased " << erased << " element(s)." << std::endl;

  3. iterator erase(const_iterator first, const_iterator last): 한 쌍의 반복자를 통해 [first, last)지정된 범위의 키-값 쌍을 삭제합니다 . 삭제 작업 이후의 위치를 ​​가리키는 반복자를 반환합니다.

    예:

    std::unordered_map<int, std::string> myMap = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}};
auto first = myMap.begin(); // 范围起始位置
auto last = myMap.find(2);  // 范围结束位置，找到键为2的位置
if (last != myMap.end()) {
      
      
    myMap.erase(first, last); // 删除范围内的元素
}

이러한 기능은 에서 요소를 삭제하는 다양한 방법을 제공하며 unordered_map필요에 따라 가장 적절한 방법을 선택할 수 있습니다.

5. 클리어

  • void clear() noexcept;: unordered_map에서 모든 키-값 쌍을 지웁니다. 이 작업은 unordered_map컨테이너를 비우지만 컨테이너의 용량은 변경하지 않습니다.

    예:

    std::unordered_map<int, std::string> myMap = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}, {
      
      3, "Three"}};
std::cout << "Size before clear: " << myMap.size() << std::endl;

myMap.clear(); // 清空 unordered_map

std::cout << "Size after clear: " << myMap.size() << std::endl;

    산출:

    Size before clear: 3
Size after clear: 0

이 함수는 예외가 없는 연산( noexcept)입니다. 즉, 예외를 발생시키지 않습니다. unordered_map컨테이너가 차지하는 리소스를 해제하기 위해 비워야 할 때 사용할 수 있습니다 .

6. 교환

  • void swap ( unordered_map& ump );: 현재의 내용 unordered_map과 매개변수 ump로 표시되는 내용을 교환합니다 unordered_map. 이 작업은 컨테이너의 용량을 변경하지 않고 내용만 교환합니다.

    예:

    std::unordered_map<int, std::string> map1 = {
      
      {
      
      1, "One"}, {
      
      2, "Two"}};
std::unordered_map<int, std::string> map2 = {
      
      {
      
      3, "Three"}, {
      
      4, "Four"}};

std::cout << "map1 before swap:" << std::endl;
for (const auto& pair : map1) {
      
      
    std::cout << pair.first << ": " << pair.second << std::endl;
}

std::cout << "map2 before swap:" << std::endl;
for (const auto& pair : map2) {
      
      
    std::cout << pair.first << ": " << pair.second << std::endl;
}

map1.swap(map2); // 交换 map1 和 map2 的内容

std::cout << "map1 after swap:" << std::endl;
for (const auto& pair : map1) {
      
      
    std::cout << pair.first << ": " << pair.second << std::endl;
}

std::cout << "map2 after swap:" << std::endl;
for (const auto& pair : map2) {
      
      
    std::cout << pair.first << ": " << pair.second << std::endl;
}

    산출:

    map1 before swap:
1: One
2: Two
map2 before swap:
3: Three
4: Four
map1 after swap:
3: Three
4: Four
map2 after swap:
1: One
2: Two

이 기능은 임시 객체를 생성하지 않고도 두 개의 내용을 효율적으로 교환할 수 있기 때문에 매우 유용합니다 unordered_map.

unordered_map 버킷 함수

1. 버킷 개수

bucket_countstd::unordered_map이 함수는 컨테이너에 있는 현재 버킷 수를 가져오는 데 사용됩니다 . 버킷은 키-값 쌍을 저장하는 해시 테이블의 저장 위치입니다.

size_type bucket_count() const noexcept;
  • size_type: 부호 없는 정수 유형을 나타냅니다. 일반적으로 size_t.
  • bucket_count(): 이 함수에는 매개변수가 없습니다.
  • const: 이 함수가 컨테이너의 내용을 수정하지 않음을 나타냅니다.
  • noexcept: 함수가 예외를 발생시키지 않음을 나타냅니다.

이 함수는 unordered_map현재 컨테이너에 있는 버킷 수를 반환합니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;
    map[1] = "One";
    map[2] = "Two";
    map[3] = "Three";
    map[4] = "Four";

    std::cout << "Bucket count: " << map.bucket_count() << std::endl;

    return 0;
}

이 예에서 함수는 해시 함수 및 로드 계수와 같은 요소에 따라 달라지는 의 bucket_count현재 버킷 수를 반환합니다 . std::unordered_map이 숫자는 일반적으로 요소가 버킷에 고르게 분산되어 쿼리 성능이 향상되도록 컨테이너의 실제 요소 수보다 큽니다.

2. 최대 버킷 개수

max_bucket_countstd::unordered_map이 함수는 컨테이너가 지원하는 최대 버킷 수를 얻는 데 사용됩니다 . 버킷은 키-값 쌍을 저장하는 해시 테이블의 저장 위치입니다.

size_type max_bucket_count() const noexcept;
  • size_type: 부호 없는 정수 유형을 나타냅니다. 일반적으로 size_t.
  • max_bucket_count(): 이 함수에는 매개변수가 없습니다.
  • const: 이 함수가 컨테이너의 내용을 수정하지 않음을 나타냅니다.
  • noexcept: 함수가 예외를 발생시키지 않음을 나타냅니다.

이 함수는 std::unordered_map컨테이너가 지원하는 최대 버킷 수를 반환합니다. 이 값은 일반적으로 기본 해시 테이블 구현 및 시스템 리소스 제한의 영향을 받습니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 获取最大桶数量并输出
    std::cout << "Max bucket count: " << map.max_bucket_count() << std::endl;

    return 0;
}

이 예에서 max_bucket_count함수는 std::unordered_map컨테이너가 지원하는 최대 버킷 수를 반환합니다. 이 값은 컴파일러 및 시스템에서 결정되며 일반적으로 시스템의 사용 가능한 메모리 및 해시 테이블 구현에 따라 달라집니다.

3. 버킷_크기

bucket_size이 함수는 지정된 버킷의 요소 수를 가져오는 데 사용되며, 버킷의 인덱스를 매개변수로 전달해야 합니다.

size_type bucket_size(size_type n) const;
  • size_type: 부호 없는 정수 유형을 나타냅니다. 일반적으로 size_t.
  • bucket_size(n)n: 이 함수는 쿼리할 버킷의 인덱스를 나타내는 매개변수를 허용합니다 .
  • const: 이 함수가 컨테이너의 내용을 수정하지 않음을 나타냅니다.

이 함수는 지정된 버킷의 요소 수를 반환합니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 插入一些键值对
    map[1] = "one";
    map[2] = "two";
    map[3] = "three";

    // 获取第一个桶中的元素数量
    size_t bucketIndex = map.bucket(1); // 获取键为1的元素所在的桶的索引
    size_t bucketSize = map.bucket_size(bucketIndex); // 获取该桶的元素数量

    std::cout << "Bucket size for key 1: " << bucketSize << std::endl;

    return 0;
}

이 예에서는 컨테이너를 만들고 std::unordered_map일부 키-값 쌍을 삽입한 다음 bucket_size함수를 사용하여 특정 버킷의 요소 수를 가져옵니다. 먼저 bucket이 함수를 사용하여 키 1을 가진 요소가 있는 버킷의 인덱스를 가져왔습니다. 그런 다음 이 함수를 사용하여 bucket_size버킷의 요소 수를 가져옵니다.

4. 양동이

bucket이 함수는 특정 키가 속한 버킷의 인덱스를 가져오는 데 사용되며, 키를 매개변수로 전달해야 합니다.

size_type bucket(const key_type& k) const;
  • size_type: 부호 없는 정수 유형을 나타냅니다. 일반적으로 size_t.
  • bucket(k): 이 함수는 k쿼리할 키를 나타내는 매개변수를 허용합니다.
  • const: 이 함수가 컨테이너의 내용을 수정하지 않음을 나타냅니다.

이 함수는 지정된 키가 속한 버킷의 인덱스를 반환합니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<std::string, int> map;

    // 插入一些键值对
    map["one"] = 1;
    map["two"] = 2;
    map["three"] = 3;

    // 获取键所属的桶的索引
    size_t bucketIndex1 = map.bucket("one");
    size_t bucketIndex2 = map.bucket("three");

    std::cout << "Bucket index for key 'one': " << bucketIndex1 << std::endl;
    std::cout << "Bucket index for key 'three': " << bucketIndex2 << std::endl;

    return 0;
}

이 예에서는 컨테이너를 생성하고 std::unordered_map일부 키-값 쌍을 삽입한 후 bucket함수를 사용하여 특정 키가 속한 버킷의 인덱스를 가져옵니다. "1"과 "3" 키가 있는 버킷의 인덱스를 얻습니다.

unordered_map 해시 전략 함수

1. 부하_계수

float load_factor() const noexcept;

load_factor이 함수는 현재 해시 테이블의 로드 팩터를 구하는 데 사용되며 float로드 팩터를 나타내는 값을 반환합니다.

로드율은 총 버킷 수에 대한 해시 테이블에 현재 포함된 요소 수의 비율입니다. 일반적으로 로드 팩터가 작을수록 충돌 가능성이 낮기 때문에 해시 테이블의 성능이 좋아집니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 设置一些键值对
    map[1] = "one";
    map[2] = "two";
    map[3] = "three";

    // 获取当前负载因子
    float lf = map.load_factor();

    std::cout << "Load Factor: " << lf << std::endl;

    return 0;
}

이 예에서는 컨테이너를 만들고 std::unordered_map일부 키-값 쌍을 삽입합니다. 그런 다음 load_factor함수를 사용하여 현재 부하율을 구하고 이를 인쇄합니다.

2. 최대 부하 계수

max_load_factor해시 테이블의 최대 부하율을 설정하거나 가져오는 데 사용되는 함수입니다. 최대 부하율은 재해싱이 발생하기 전에 허용되는 최대 부하율입니다.

  • float max_load_factor() const noexcept;: 현재 해시 테이블의 최대 부하율을 가져옵니다.
  • void max_load_factor(float z);: 해시 테이블의 최대 로드율을 로 설정합니다 z.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 获取当前最大负载因子
    float maxLF = map.max_load_factor();
    std::cout << "Current Max Load Factor: " << maxLF << std::endl;

    // 设置最大负载因子为新值
    map.max_load_factor(0.75);

    // 获取新的最大负载因子
    maxLF = map.max_load_factor();
    std::cout << "Updated Max Load Factor: " << maxLF << std::endl;

    return 0;
}

이 예에서는 먼저 해시 테이블의 현재 최대 로드 비율을 얻은 다음 이를 새 값으로 수정합니다. 이 함수를 호출하면 max_load_factor성능을 최적화하기 위해 해시 테이블을 다시 해시하기 전에 해시 테이블의 로드 비율을 제어할 수 있습니다.

3. 재해시

rehashn이 기능은 해시 테이블의 성능을 향상시키기 위해 최소한의 요소를 수용하도록 해시 테이블의 버킷 수를 다시 조정하는 데 사용됩니다 . 다시 해싱하면 버킷 수가 변경되고 요소가 재배포되므로 시간이 걸릴 수 있습니다.

  • void rehash(size_type n);: 최소한의 요소를 수용할 수 있도록 해시 테이블의 버킷 수 크기를 조정합니다 n.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 添加一些元素
    map[1] = "One";
    map[2] = "Two";
    map[3] = "Three";

    // 获取当前桶的数量
    size_t currentBucketCount = map.bucket_count();
    std::cout << "Current Bucket Count: " << currentBucketCount << std::endl;

    // 重新调整桶的数量
    map.rehash(10);

    // 获取新的桶的数量
    currentBucketCount = map.bucket_count();
    std::cout << "Updated Bucket Count: " << currentBucketCount << std::endl;

    return 0;
}

이 예에서는 먼저 해시 테이블에 일부 요소를 추가한 다음 rehash함수를 사용하여 버킷 수를 10으로 다시 조정합니다. 로드 팩터가 적절한 범위 내에 유지되도록 하기 위해 많은 수의 요소를 추가한 후 성능을 최적화하기 위해 리해싱을 사용할 수 있습니다.

4. 예약

reserven이 기능은 해시 테이블의 성능을 향상시키기 위해 최소한의 요소를 수용할 수 있는 버킷 공간을 예약하는 데 사용됩니다 . 이 기능은 빈번한 재해시 작업을 피하기 위해 많은 수의 요소를 삽입하기 전에 충분한 버킷 공간을 할당하는 데 도움이 될 수 있습니다.

  • void reserve(size_type n);: 최소한의 n요소를 담을 수 있는 버킷 공간을 예약합니다.

샘플 코드:

#include <iostream>
#include <unordered_map>

int main() {
    
    
    std::unordered_map<int, std::string> map;

    // 预留足够的桶空间
    map.reserve(100);  // 预留至少能容纳 100 个元素的桶空间

    // 添加一些元素
    for (int i = 0; i < 100; ++i) {
    
    
        map[i] = "Value " + std::to_string(i);
    }

    // 获取当前桶的数量
    size_t currentBucketCount = map.bucket_count();
    std::cout << "Current Bucket Count: " << currentBucketCount << std::endl;

    return 0;
}

이 예에서는 이 함수를 사용하여 reserve최소 100개의 요소를 보유할 수 있는 버킷을 예약한 다음 해시 테이블에 100개의 요소를 추가합니다. 충분한 버킷 공간이 예약되어 요소를 삽입할 때 빈번한 재해싱 작업을 방지하므로 성능을 향상시키는 데 도움이 될 수 있습니다.

Unordered_map은 해시 양식 시뮬레이션 구현을 엽니다.

이전 해시 블로그의 해시 테이블 구현 수정

template<class K>
struct HashFunc
{
    
    
	size_t operator()(const K& key)
	{
    
    
		return (size_t)key;
	}
};
  • operator()함수 호출 연산자의 오버로드로, 객체를 함수처럼 호출할 수 있습니다.
  • key이 함수는 해시 값을 계산할 키를 나타내는 매개변수를 허용합니다 .
  • 함수 본문 내에서 (size_t)key키를 유형 key으로 캐스팅하여 size_t해시 값을 가져옵니다.
  • 해시 값은 해시 테이블에서 키의 위치를 ​​식별하는 숫자 값입니다. 일반적으로 해시 함수는 해시 테이블에서 효율적인 조회 작업을 허용하기 위해 서로 다른 키를 서로 다른 해시 값에 매핑합니다.

해시 반복자 증분

template<class K, class T, class Hash, class KeyOfT>
struct __HashIterator
{
    
    
	typedef HashNode<T> Node;
	typedef HashTable<K, T, Hash, KeyOfT> HT;
	typedef __HashIterator<K, T, Hash, KeyOfT> Self;

	Node* _node;
	HT* _pht;

	__HashIterator(Node* node, HT* pht)
		:_node(node)
		, _pht(pht)
	{
    
    }

	T& operator*()
	{
    
    
		return _node->_data;
	}

	T* operator->()
	{
    
    
		return &_node->_data;
	}

	Self& operator++()
	{
    
    
		if (_node->_next)
		{
    
    
			// 当前桶中迭代
			_node = _node->_next;
		}
		else
		{
    
    
			// 找下一个桶
			Hash hash;
			KeyOfT kot;
			size_t i = hash(kot(_node->_data)) % _pht->_tables.size();
			++i;
			for (; i < _pht->_tables.size(); ++i)
			{
    
    
				if (_pht->_tables[i])
				{
    
    
					_node = _pht->_tables[i];
					break;
				}
			}

			// 说明后面没有有数据的桶了
			if (i == _pht->_tables.size())
			{
    
    
				_node = nullptr;
			}
		}

		return *this;
	}

	bool operator!=(const Self& s) const
	{
    
    
		return _node != s._node;
	}

	bool operator==(const Self& s) const
	{
    
    
		return _node == s._node;
	}
};
  1. typedef HashNode<T> Node;: 일반적 으로 해시 테이블의 노드를 나타내는 HashNode<T>유형에 별칭을 지정합니다.NodeHashNode
  2. typedef HashTable<K, T, Hash, KeyOfT> HT;: 일반적으로 해시 테이블을 나타내는 HashTable템플릿 클래스를 인스턴스화한 후 유형에 별칭을 HT지정 합니다.HashTable
  3. typedef __HashIterator<K, T, Hash, KeyOfT> Self;: 반복자 자체의 유형에 별칭을 지정합니다 Self. 이 별칭은 반복자 유형을 정의하기 위해 반복자 내부에서 사용됩니다.
  4. Node* _node;: 현재 반복 노드에 대한 포인터입니다. 반복자는 해시 테이블의 노드를 순회하는 데 사용되며 현재 노드의 정보는 에 저장됩니다 _node.
  5. HT* _pht;: 해시 테이블에 대한 포인터입니다. 해시 테이블의 정보는 에 저장되며 _pht반복자는 반복 작업을 구현하기 위해 해시 테이블의 속성에 액세스해야 할 수 있습니다.
  6. T& operator*(): *반복자를 포인터처럼 사용하여 *현재 노드의 데이터에 액세스할 수 있도록 연산자를 오버로드합니다.
  7. T* operator->(): ->반복자를 포인터처럼 사용하여 ->현재 노드의 데이터에 액세스할 수 있도록 연산자를 오버로드합니다.
  8. Self& operator++(): ++반복자가 다음 노드로 이동할 수 있도록 이전 증분 연산자를 오버로드합니다. 이 함수는 현재 버킷에 노드가 있는지 확인하여 노드가 있으면 다음 노드로 이동하고, 비어 있지 않은 다음 버킷이 발견되면 _node버킷의 첫 번째 노드를 가리킵니다.
  9. bool operator!=(const Self& s) const: 오버로드된 불평등 연산자 !=, 두 반복자가 같지 않은지 비교하는 데 사용됩니다.
  10. bool operator==(const Self& s) const: 오버로드된 같음 연산자 ==, 두 반복자가 같은지 비교하는 데 사용됩니다.
typedef __HashIterator<K, T, Hash, KeyOfT> iterator;

iterator begin()
{
    
    
	for (size_t i = 0; i < _tables.size(); ++i)
	{
    
    
		if (_tables[i])
		{
    
    
			return iterator(_tables[i], this);
		}
	}

	return end();
}

iterator end()
{
    
    
	return iterator(nullptr, this);
}
  1. typedef __HashIterator<K, T, Hash, KeyOfT> iterator;: 이 줄은 iteratortype 의 별칭을 정의하여 __HashIterator일반 C++ 반복자처럼 사용할 수 있도록 합니다.
  2. iterator begin()기능: 이 함수는 해시 테이블에서 비어 있지 않은 첫 번째 버킷을 가리키는 반복자를 반환합니다. _tables컨테이너의 버킷을 순회하여 비어 있지 않은 첫 번째 버킷을 찾고 해당 반복자를 생성한 다음 반복자를 반환합니다. end()비어 있지 않은 버킷이 발견되지 않으면 순회 종료를 나타내는 반복자가 반환됩니다 .
  3. iterator end()기능: 이 함수는 순회 끝을 나타내는 반복자를 반환합니다. _node멤버가 인 반복자를 반환합니다 nullptr. 이는 현재 반복할 유효한 노드가 없음을 나타냅니다. 이는 반복의 끝을 식별하는 데 유용합니다.

__stl_num_primes 함수 추가

inline size_t __stl_next_prime(size_t n)
{
    
    
	static const size_t __stl_num_primes = 28;
	static const size_t __stl_prime_list[__stl_num_primes] =
	{
    
    
		53, 97, 193, 389, 769,
		1543, 3079, 6151, 12289, 24593,
		49157, 98317, 196613, 393241, 786433,
		1572869, 3145739, 6291469, 12582917, 25165843,
		50331653, 100663319, 201326611, 402653189, 805306457,
		1610612741, 3221225473, 4294967291
	};

	for (size_t i = 0; i < __stl_num_primes; ++i)
	{
    
    
		if (__stl_prime_list[i] > n)
		{
    
    
			return __stl_prime_list[i];
		}
	}

	return -1;
}
  • __stl_num_primes일련의 소수 값을 포함하는 상수 배열을 정의합니다. 이러한 소수 값은 데이터 구조의 용량이 확장될 때 새로운 용량의 후보가 되도록 신중하게 선택됩니다.
  • 함수는 먼저 소수 배열을 반복하고, n주어진 숫자보다 큰 첫 번째 소수를 찾아서 반환합니다. 이 작업을 통해 컨테이너의 크기는 항상 해시 충돌 가능성을 줄이기에 충분한 소수로 선택됩니다.
  • 적합한 소수가 발견되지 않으면 함수는 -1을 반환합니다. 이는 예외가 발생했으며 필요에 따라 오류 처리가 수행될 수 있음을 나타냅니다.

이 기능의 주요 목적은 해시 테이블의 성능을 최적화하고 해당 용량이 항상 적절한 소수인지 확인하여 해시 알고리즘의 효율성을 향상시키는 것입니다(STL 소스 코드 참조) .

삽입 기능 수정

pair<iterator, bool> Insert(const T& data)
{
    
    
	Hash hash;
	KeyOfT kot;

	// 去重
	iterator ret = Find(kot(data));
	if (ret != end())
	{
    
    
		return make_pair(ret, false);
	}

	// 负载因子到1就扩容
	if (_size == _tables.size())
	{
    
    
		vector<Node*> newTables;
		newTables.resize(__stl_next_prime(_tables.size()), nullptr);
		// 旧表中节点移动映射新表
		for (size_t i = 0; i < _tables.size(); ++i)
		{
    
    
			Node* cur = _tables[i];
			while (cur)
			{
    
    
				Node* next = cur->_next;

				size_t hashi = hash(kot(cur->_data)) % newTables.size();
				cur->_next = newTables[hashi];
				newTables[hashi] = cur;

				cur = next;
			}

			_tables[i] = nullptr;
		}

		_tables.swap(newTables);
	}

	size_t hashi = hash(kot(data)) % _tables.size();
	// 头插
	Node* newnode = new Node(data);
	newnode->_next = _tables[hashi];
	_tables[hashi] = newnode;
	++_size;

	return make_pair(iterator(newnode, this), true);
}
  1. 먼저 코드는 키의 해시와 키 자체를 가져오는 Hashand 의 인스턴스를 만듭니다.KeyOfT
  2. 다음으로, 코드는 Find(kot(data))함수를 호출하여 동일한 키를 가진 요소가 이미 존재하는지 확인합니다. 동일한 키가 발견되면 삽입 작업이 수행되지 않지만 요소가 반환됩니다. pair그 iterator중 일부는 기존 요소를 가리키고 bool일부는 false삽입이 실패했음을 나타내도록 설정됩니다.
  3. 동일한 키가 발견되지 않으면 삽입 작업이 계속됩니다. 먼저, 코드는 현재 해시 테이블의 로드 팩터가 1에 도달했는지(즉, 요소의 개수가 해시 테이블의 크기와 같은지) 확인하고, 그렇다면 확장이 필요합니다.
  4. newTables확장 작업은 호출을 통해 크기가 결정되는 새 해시 테이블을 생성하며 __stl_next_prime(_tables.size()), 이는 새 테이블 크기가 소수임을 보장합니다. 그런 다음 코드는 이전 해시 테이블을 통과하여 각 노드를 새 해시 테이블에 다시 매핑합니다. 이는 해시의 균등한 분포를 유지하고 해시 충돌 가능성을 줄이기 위한 것입니다.
  5. 마지막으로 코드는 삽입할 요소의 해시 값을 계산하고 새 해시 테이블에 새 노드를 삽입합니다. 이는 헤드에 삽입함으로써 이루어지며, _next새 노드의 포인터는 현재 버킷의 헤드 노드를 가리키며, 그러면 현재 버킷의 헤드 노드가 새 노드로 업데이트됩니다. 동시에 요소수도 _size1씩 증가합니다.
  6. 궁극적으로 코드는 새로 삽입된 요소를 가리키는 부분과 pair성공적인 삽입을 나타내 도록 설정된 부분을 반환합니다.iteratorbooltrue

버킷 기능 추가

size_t Size()
{
    
    
	return _size;
}

// 表的长度
size_t TablesSize()
{
    
    
	return _tables.size();
}

// 桶的个数
size_t BucketNum()
{
    
    
	size_t num = 0;
	for (size_t i = 0; i < _tables.size(); ++i)
	{
    
    
		if (_tables[i])
		{
    
    
			++num;
		}
	}

	return num;
}

size_t MaxBucketLenth()
{
    
    
	size_t maxLen = 0;
	for (size_t i = 0; i < _tables.size(); ++i)
	{
    
    
		size_t len = 0;
		Node* cur = _tables[i];
		while (cur)
		{
    
    
			++len;
			cur = cur->_next;
		}

		if (len > maxLen)
		{
    
    
			maxLen = len;
		}
	}

	return maxLen;
}
  1. Size(): 해시 테이블의 크기인 해시 테이블의 전체 요소 수를 반환하는 함수입니다.
  2. TablesSize(): 해시 테이블의 실제 크기인 해시 테이블 내부의 버킷 개수를 반환하는 함수입니다.
  3. BucketNum(): 이 함수는 현재 해시 테이블에서 비어 있지 않은 버킷의 개수, 즉 요소를 포함하는 버킷의 개수를 계산하는 데 사용됩니다.
  4. MaxBucketLenth(): 해시 테이블에서 가장 긴 버킷의 길이, 즉 요소가 가장 많은 버킷의 요소 수를 구하는 함수입니다.

수정 후 HashTable.h의 모든 코드

#pragma once
#include<iostream>
#include<utility>
#include<vector>
#include<string>
using namespace std;
template<class K>
struct HashFunc
{
    
    
	size_t operator()(const K& key)
	{
    
    
		return (size_t)key;
	}
};

template<>
struct HashFunc<string>
{
    
    
	size_t operator()(const string& key)
	{
    
    
		size_t val = 0;
		for (auto ch : key)
		{
    
    
			val *= 131;
			val += ch;
		}

		return val;
	}
};
namespace Bucket
{
    
    
	template<class T>
	struct HashNode
	{
    
    
		T _data;
		HashNode<T>* _next;

		HashNode(const T& data)
			:_data(data)
			, _next(nullptr)
		{
    
    }
	};

	// 前置声明
	template<class K, class T, class Hash, class KeyOfT>
	class HashTable;

	template<class K, class T, class Hash, class KeyOfT>
	struct __HashIterator
	{
    
    
		typedef HashNode<T> Node;
		typedef HashTable<K, T, Hash, KeyOfT> HT;
		typedef __HashIterator<K, T, Hash, KeyOfT> Self;

		Node* _node;
		HT* _pht;

		__HashIterator(Node* node, HT* pht)
			:_node(node)
			, _pht(pht)
		{
    
    }

		T& operator*()
		{
    
    
			return _node->_data;
		}

		T* operator->()
		{
    
    
			return &_node->_data;
		}

		Self& operator++()
		{
    
    
			if (_node->_next)
			{
    
    
				// 当前桶中迭代
				_node = _node->_next;
			}
			else
			{
    
    
				// 找下一个桶
				Hash hash;
				KeyOfT kot;
				size_t i = hash(kot(_node->_data)) % _pht->_tables.size();
				++i;
				for (; i < _pht->_tables.size(); ++i)
				{
    
    
					if (_pht->_tables[i])
					{
    
    
						_node = _pht->_tables[i];
						break;
					}
				}

				// 说明后面没有有数据的桶了
				if (i == _pht->_tables.size())
				{
    
    
					_node = nullptr;
				}
			}

			return *this;
		}

		bool operator!=(const Self& s) const
		{
    
    
			return _node != s._node;
		}

		bool operator==(const Self& s) const
		{
    
    
			return _node == s._node;
		}
	};

	template<class K, class T, class Hash, class KeyOfT>
	class HashTable
	{
    
    
		typedef HashNode<T> Node;

		template<class K, class T, class Hash, class KeyOfT>
		friend struct __HashIterator;
	public:
		typedef __HashIterator<K, T, Hash, KeyOfT> iterator;

		iterator begin()
		{
    
    
			for (size_t i = 0; i < _tables.size(); ++i)
			{
    
    
				if (_tables[i])
				{
    
    
					return iterator(_tables[i], this);
				}
			}

			return end();
		}

		iterator end()
		{
    
    
			return iterator(nullptr, this);
		}

		~HashTable()
		{
    
    
			for (size_t i = 0; i < _tables.size(); ++i)
			{
    
    
				Node* cur = _tables[i];
				while (cur)
				{
    
    
					Node* next = cur->_next;
					delete cur;
					cur = next;
				}
				_tables[i] = nullptr;
			}
		}

		inline size_t __stl_next_prime(size_t n)
		{
    
    
			static const size_t __stl_num_primes = 28;
			static const size_t __stl_prime_list[__stl_num_primes] =
			{
    
    
				53, 97, 193, 389, 769,
				1543, 3079, 6151, 12289, 24593,
				49157, 98317, 196613, 393241, 786433,
				1572869, 3145739, 6291469, 12582917, 25165843,
				50331653, 100663319, 201326611, 402653189, 805306457,
				1610612741, 3221225473, 4294967291
			};

			for (size_t i = 0; i < __stl_num_primes; ++i)
			{
    
    
				if (__stl_prime_list[i] > n)
				{
    
    
					return __stl_prime_list[i];
				}
			}

			return -1;
		}

		pair<iterator, bool> Insert(const T& data)
		{
    
    
			Hash hash;
			KeyOfT kot;

			// 去重
			iterator ret = Find(kot(data));
			if (ret != end())
			{
    
    
				return make_pair(ret, false);
			}

			// 负载因子到1就扩容
			if (_size == _tables.size())
			{
    
    
				vector<Node*> newTables;
				newTables.resize(__stl_next_prime(_tables.size()), nullptr);
				// 旧表中节点移动映射新表
				for (size_t i = 0; i < _tables.size(); ++i)
				{
    
    
					Node* cur = _tables[i];
					while (cur)
					{
    
    
						Node* next = cur->_next;

						size_t hashi = hash(kot(cur->_data)) % newTables.size();
						cur->_next = newTables[hashi];
						newTables[hashi] = cur;

						cur = next;
					}

					_tables[i] = nullptr;
				}

				_tables.swap(newTables);
			}

			size_t hashi = hash(kot(data)) % _tables.size();
			// 头插
			Node* newnode = new Node(data);
			newnode->_next = _tables[hashi];
			_tables[hashi] = newnode;
			++_size;

			return make_pair(iterator(newnode, this), true);
		}

		iterator Find(const K& key)
		{
    
    
			if (_tables.size() == 0)
			{
    
    
				return end();
			}

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* cur = _tables[hashi];
			while (cur)
			{
    
    
				if (kot(cur->_data) == key)
				{
    
    
					return iterator(cur, this);
				}

				cur = cur->_next;
			}

			return end();
		}

		bool Erase(const K& key)
		{
    
    
			if (_tables.size() == 0)
			{
    
    
				return false;
			}

			Hash hash;
			KeyOfT kot;
			size_t hashi = hash(key) % _tables.size();
			Node* prev = nullptr;
			Node* cur = _tables[hashi];
			while (cur)
			{
    
    
				if (kot(cur->_data) == key)
				{
    
    
					// 1、头删
					// 2、中间删
					if (prev == nullptr)
					{
    
    
						_tables[hashi] = cur->_next;
					}
					else
					{
    
    
						prev->_next = cur->_next;
					}

					delete cur;
					--_size;

					return true;
				}

				prev = cur;
				cur = cur->_next;
			}

			return false;
		}

		size_t Size()
		{
    
    
			return _size;
		}

		// 表的长度
		size_t TablesSize()
		{
    
    
			return _tables.size();
		}

		// 桶的个数
		size_t BucketNum()
		{
    
    
			size_t num = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
    
    
				if (_tables[i])
				{
    
    
					++num;
				}
			}

			return num;
		}

		size_t MaxBucketLenth()
		{
    
    
			size_t maxLen = 0;
			for (size_t i = 0; i < _tables.size(); ++i)
			{
    
    
				size_t len = 0;
				Node* cur = _tables[i];
				while (cur)
				{
    
    
					++len;
					cur = cur->_next;
				}

				if (len > maxLen)
				{
    
    
					maxLen = len;
				}
			}

			return maxLen;
		}

	private:
		vector<Node*> _tables;
		size_t _size = 0; // 存储有效数据个数
	};
};

해시 테이블 캡슐화를 사용하여 unordered_map 구현

#pragma once
#include "HashTable.h"

namespace yulao
{
    
    
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
    
    
		struct MapKeyOfT
		{
    
    
			const K& operator()(const pair<K, V>& kv)
			{
    
    
				return kv.first;
			}
		};
	public:
		typedef typename Bucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT>::iterator iterator;

		iterator begin()
		{
    
    
			return _ht.begin();
		}

		iterator end()
		{
    
    
			return _ht.end();
		}

		pair<iterator, bool> Insert(const pair<K, V>& kv)
		{
    
    
			return _ht.Insert(kv);
		}

		V& operator[](const K& key)
		{
    
    
			pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
			return ret.first->second;
		}

	private:
		Bucket::HashTable<K, pair<K, V>, Hash, MapKeyOfT> _ht;
	};
}

여기서는 unordered_map의 기본 기능을 간단히 구현하겠습니다! ! !

추천

출처blog.csdn.net/kingxzq/article/details/133364438
추천
행
서로 소 오일러 함수 연구 노트
객체 지향 프로그래밍 응용 프로그램을 이동
[11.4] 테스트 시장
Thinkphp5.1 새 모듈
flaskjinjia2 템플릿
기계 학습 도구
일식보기 파일은 JSP, 서블릿을 컴파일
아치 리눅스는 새로운 프로젝트 리더 레 벤테 Polyak 선출
서버 로그인 및 사용 우분투
C #을 폐기
아카이브
기타
2020-04-08(1460)
2020-04-07(1517)
2020-04-06(1499)
2020-04-05(1440)
2020-04-04(1629)
2020-04-03(1644)
2020-04-02(1572)
2020-04-01(1665)
2020-03-31(1639)
2020-03-30(1334)

코드 세계

© 2018 codetd.com