C++ 模板字典操作工具类

最新推荐文章于 2024-07-23 17:03:30 发布
最新推荐文章于 2024-07-23 17:03:30 发布
阅读量232 收藏
点赞数 2
分类专栏： C/C++ 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/liulilittle/article/details/138662747
版权

用来操作，map、unordered_map、hash_map 等字典类型集合，用这个单纯是为了代码阅读起来更好一点。

        class Dictionary final {
        public:
            template <typename PredicateHandler, typename TObjects, typename... Args>
            static int                                              PredicateAllObjects(PredicateHandler&& predicate, TObjects& objects, Args&&... args) noexcept {
                using TKey = typename TObjects::key_type;
                using TValue = typename TObjects::value_type::second_type;

                ppp::vector<TKey> release_object_keys;
                for (auto&& kv : objects) {
                    auto& obj = kv.second;
                    if (obj) {
                        if (predicate(obj, std::forward<Args&&>(args)...)) {
                            release_object_keys.emplace_back(kv.first);
                        }
                    }
                    else {
                        release_object_keys.emplace_back(kv.first);
                    }
                }

                for (auto&& object_key : release_object_keys) {
                    auto tail = objects.find(object_key);
                    auto endl = objects.end();
                    if (tail == endl) {
                        continue;
                    }

                    auto obj = std::move(tail->second);
                    objects.erase(tail);

                    IDisposable::Dispose(*obj);
                }

                return (int)release_object_keys.size();
            }

            template <typename TObjects, typename... Args>
            static int                                              UpdateAllObjects(TObjects& objects, Args&&... args) noexcept {
                using TKey = typename TObjects::key_type;
                using TValue = typename TObjects::value_type::second_type; 

                /* __cplusplus >= 201402L || _MSC_VER >= 1900 */
                return PredicateAllObjects(
                    [](TValue& obj, Args&& ...args) noexcept {
                        return obj->IsPortAging(std::forward<Args&&>(args)...);
                    }, objects, std::forward<Args&&>(args)...);
            }

            template <typename TObjects, typename... Args>
            static int                                              UpdateAllObjects2(TObjects& objects, Args&&... args) noexcept {
                using TKey = typename TObjects::key_type;
                using TValue = typename TObjects::value_type::second_type;

                /* __cplusplus >= 201402L || _MSC_VER >= 1900 */
                return PredicateAllObjects(
                    [](TValue& obj, Args&& ...args) noexcept { /* cpp14: auto&&... */
                        return !obj->Update(std::forward<Args&&>(args)...);
                    }, objects, std::forward<Args&&>(args)...);
            }

            template <typename TObjects>
            static void                                             ReleaseAllObjects(TObjects& objects) noexcept {
                using TKey = typename TObjects::key_type;
                using TValue = typename TObjects::value_type::second_type;

                if (IDisposable::HAS_MEMBER_DISPOSE_FUNCTION<typename std::remove_reference<decltype(**(TValue*)NULL)>::type>::value) {
                    ppp::vector<TValue> release_objects;
                    for (auto&& kv : objects) {
                        release_objects.emplace_back(std::move(kv.second));
                    }

                    objects.clear();
                    for (auto&& obj : release_objects) {
                        IDisposable::Dispose(*obj);
                    }
                }
                else {
                    objects.clear();
                }
            }

            template <typename TObjects>
            static typename TObjects::value_type::second_type       ReleaseObjectByKey(TObjects& objects, const typename TObjects::key_type& key) noexcept {
                typename TObjects::value_type::second_type obj{};

                auto tail = objects.find(key);
                auto endl = objects.end();
                if (tail != endl) {
                    obj = std::move(tail->second);
                    objects.erase(tail);
                }

                if (NULL != obj) {
                    IDisposable::Dispose(*obj);
                }

                return obj;
            }

            template <typename TObjects>
            static typename TObjects::value_type::second_type       FindObjectByKey(TObjects& objects, const typename TObjects::key_type& key) noexcept {
                auto tail = objects.find(key);
                auto endl = objects.end();
                if (tail == endl) {
                    return NULL;
                }
                else {
                    return tail->second;
                }
            }

        public:
            template <typename TCallbacks, typename... TArgs>
            static void                                             ReleaseAllCallbacks(TCallbacks& callbacks, TArgs&&... args) noexcept {
                ppp::vector<typename TCallbacks::value_type::second_type> list;
                for (auto&& kv : callbacks) {
                    list.emplace_back(std::move(kv.second));
                }

                callbacks.clear();
                for (auto&& weak : list) {
                    auto cb = weak.lock();
                    if (cb) {
                        (*cb)(std::forward<TArgs&&>(args)...);
                    }
                }
            }

        public:
            template <typename TDictionary>
            static bool                                             ContainsKey(TDictionary& dictionary, const typename TDictionary::key_type& key) noexcept {
                auto tail = dictionary.find(key);
                auto endl = dictionary.end();
                return tail != endl;
            }

            template <typename TDictionary>
            static bool                                             RemoveValueByKey(TDictionary& dictionary, const typename TDictionary::key_type& key, typename TDictionary::value_type::second_type* value = NULL) noexcept {
                auto tail = dictionary.find(key);
                auto endl = dictionary.end();
                if (tail != endl) {
                    if (NULL != value) {
                        *value = std::move(tail->second);
                    }

                    dictionary.erase(tail);
                    return true;
                }
                else {
                    return false;
                }
            }

            template <typename TResultValue, typename TDictionary, typename TFetchResult>
            static bool                                             RemoveValueByKey(TDictionary& dictionary, const typename TDictionary::key_type& key, TResultValue& result_value, TFetchResult&& fetch_result) noexcept {
                auto tail = dictionary.find(key);
                auto endl = dictionary.end();
                if (tail != endl) {
                    result_value = fetch_result(tail->second);
                    dictionary.erase(tail);
                    return true;
                }
                else {
                    return false;
                }
            }

        public:
            template <typename TDictionary, typename TKey>
            static int                                              GetAllKeys(TDictionary& dictionary, std::vector<TKey>& keys) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();

                int length = 0;
                for (; tail != endl; tail++) {
                    length++;
                    keys.push_back(tail->first);
                }

                return length;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static int                                              GetAllPairs(TDictionary& dictionary, std::vector<std::pair<const TKey&, const TValue&> >& keys) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();

                int length = 0;
                for (; tail != endl; tail++) {
                    length++;
                    keys.push_back(std::make_pair(tail->first, tail->second));
                }

                return length;
            }

            template <typename TDictionary, typename CloseHandler>
            static int                                              ReleaseAllPairs(TDictionary& dictionary, CloseHandler&& handler) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();

                typedef typename TDictionary::value_type TKeyValuePair;
                typedef typename TKeyValuePair::second_type TValue;

                std::vector<TValue> releases;
                if (dictionary.size()) {
                    typename TDictionary::iterator tail = dictionary.begin();
                    typename TDictionary::iterator endl = dictionary.end();
                    for (; tail != endl; tail++) {
                        releases.push_back(std::move(tail->second));
                    }
                    dictionary.clear();
                }

                std::size_t length = releases.size();
                for (std::size_t index = 0; index < length; index++) {
                    TValue p = std::move(releases[index]);
                    handler(p);
                }

                return length;
            }

            template <typename TDictionary>
            static int                                              ReleaseAllPairs(TDictionary& dictionary) noexcept {
                typedef typename TDictionary::value_type TKeyValuePair;
                typedef typename TKeyValuePair::second_type TValue;

                return ReleaseAllPairs(dictionary,
                    [](TValue& p) noexcept {
                        p->Dispose();
                    });
            }

            template <typename TDictionary, typename CloseHandler>
            static int                                              ReleaseAllPairs2Layer(TDictionary& dictionary, CloseHandler&& handler) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();

                typedef typename TDictionary::value_type::second_type TSubDictionary;
                typedef typename TSubDictionary::value_type TKeyValuePair;
                typedef typename TKeyValuePair::second_type TValue;

                std::vector<TValue> releases;
                if (dictionary.size()) {
                    typename TDictionary::iterator tail = dictionary.begin();
                    typename TDictionary::iterator endl = dictionary.end();
                    for (; tail != endl; tail++) {
                        TSubDictionary& subdictionary = tail->second;
                        typename TSubDictionary::iterator tail2 = subdictionary.begin();
                        typename TSubDictionary::iterator endl2 = subdictionary.end();
                        for (; tail2 != endl2; tail2++) {
                            releases.push_back(std::move(tail2->second));
                        }

                        subdictionary.clear();
                    }

                    dictionary.clear();
                }

                std::size_t length = releases.size();
                for (std::size_t index = 0; index < length; index++) {
                    TValue p = std::move(releases[index]);
                    handler(p);
                }

                return length;
            }

            template <typename TDictionary>
            static int                                              ReleaseAllPairs2Layer(TDictionary& dictionary) noexcept {
                typedef typename TDictionary::value_type::second_type TSubDictionary;
                typedef typename TSubDictionary::value_type TKeyValuePair;
                typedef typename TKeyValuePair::second_type TValue;

                return ReleaseAllPairs2Layer(dictionary,
                    [](TValue& p) noexcept {
                        p->Dispose();
                    });
            }

            template <typename TDictionary, typename TKey>
            static bool                                             TryRemove(TDictionary& dictionary, const TKey& key) noexcept {
                typename TDictionary::iterator tail = dictionary.find(key);
                typename TDictionary::iterator endl = dictionary.end();
                if (tail == endl) {
                    return false;
                }

                dictionary.erase(tail);
                return true;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryRemove(TDictionary& dictionary, const TKey& key, TValue& value) noexcept {
                typename TDictionary::iterator tail = dictionary.find(key);
                typename TDictionary::iterator endl = dictionary.end();
                if (tail == endl) {
                    return false;
                }

                value = std::move(tail->second);
                dictionary.erase(tail);
                return true;
            }

            template <typename TDictionary, typename TKey1, typename TKey2>
            static bool                                             TryRemove2Layer(TDictionary& dictionary, const TKey1& key1, const TKey2& key2) noexcept {
                typedef typename TDictionary::value_type::second_type TSubDictionary;

                TSubDictionary* subdictionary = NULL;
                if (!Dictionary::TryGetValuePointer(dictionary, key1, subdictionary)) {
                    return false;
                }
                elif(!Dictionary::TryRemove(*subdictionary, key2)) {
                    return false;
                }
                elif(!subdictionary->empty()) {
                    return true;
                }
                else {
                    return Dictionary::TryRemove(dictionary, key1);
                }
            }

            template <typename TDictionary, typename TKey1, typename TKey2, typename TValue>
            static bool                                             TryRemove2Layer(TDictionary& dictionary, const TKey1& key1, const TKey2& key2, TValue& value) noexcept {
                typedef typename TDictionary::value_type::second_type TSubDictionary;

                TSubDictionary* subdictionary = NULL;
                if (!Dictionary::TryGetValuePointer(dictionary, key1, subdictionary)) {
                    return false;
                }
                elif(!Dictionary::TryRemove(*subdictionary, key2, value)) {
                    return false;
                }
                elif(!subdictionary->empty()) {
                    return true;
                }
                else {
                    return Dictionary::TryRemove(dictionary, key1);
                }
            }

            template <typename TDictionary, typename TKey1, typename TKey2, typename TValue>
            static bool                                             TryGetValuePointer2Layer(TDictionary& dictionary, const TKey1& key1, const TKey2& key2, TValue*& value) noexcept {
                typedef typename TDictionary::value_type::second_type TSubDictionary;

                TSubDictionary* subdictionary = NULL;
                if (!Dictionary::TryGetValuePointer(dictionary, key1, subdictionary)) {
                    return false;
                }
                else {
                    return Dictionary::TryGetValuePointer(*subdictionary, key2, value);
                }
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryGetValuePointer(TDictionary& dictionary, const TKey& key, TValue*& value) noexcept {
                typename TDictionary::iterator tail = dictionary.find(key);
                typename TDictionary::iterator endl = dictionary.end();
                if (tail == endl) {
                    value = NULL;
                    return false;
                }

                value = addressof(tail->second);
                return true;
            }

            template <typename TDictionary, typename TKey1, typename TKey2, typename TValue>
            static bool                                             TryGetValue2Layer(TDictionary& dictionary, const TKey1& key1, const TKey2& key2, TValue& value) noexcept {
                typedef typename TDictionary::value_type::second_type TSubDictionary;

                TSubDictionary* subdictionary = NULL;
                if (!Dictionary::TryGetValuePointer(dictionary, key1, subdictionary)) {
                    return false;
                }
                else {
                    return Dictionary::TryGetValue(*subdictionary, key2, value);
                }
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryGetValue(TDictionary& dictionary, const TKey& key, TValue& value) noexcept {
                TValue* out = NULL;
                if (!TryGetValuePointer(dictionary, key, out)) {
                    return false;
                }

                value = *out;
                return true;
            }

            template <typename TDictionary, typename TKey>
            static bool                                             ContainsKey2(TDictionary& dictionary, const TKey& key) noexcept {
                typename TDictionary::iterator tail = dictionary.find(key);
                typename TDictionary::iterator endl = dictionary.end();
                return tail != endl;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryAdd(TDictionary& dictionary, const TKey& key, const TValue& value, typename TDictionary::iterator& indexer) noexcept {
                std::pair<typename TDictionary::iterator, bool> pair = dictionary.emplace(std::make_pair(key, value));
                indexer = pair.first;
                return pair.second;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryAdd(TDictionary& dictionary, const TKey& key, const TValue& value) noexcept {
                return dictionary.emplace(std::make_pair(key, value)).second;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryAdd(TDictionary& dictionary, const TKey& key, TValue&& value) noexcept {
                return dictionary.emplace(std::make_pair(key, value)).second;
            }

            template <typename TDictionary, typename TKey, typename TValue>
            static bool                                             TryAdd(TDictionary& dictionary, TKey&& key, TValue&& value) noexcept {
                return dictionary.emplace(std::make_pair(key, value)).second;
            }

            template <typename TKey, typename TDictionary>
            static TKey                                             Min(TDictionary& dictionary, const TKey& defaultKey) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();
                if (tail == endl) {
                    return defaultKey;
                }

                TKey key = defaultKey;
                std::size_t key_size = 0;

                for (; tail != endl; tail++) {
                    std::size_t nxt_size = tail->second;
                    if (!key || key_size > nxt_size) {
                        key = tail->first;
                        key_size = nxt_size;
                    }
                }

                return key;
            }

            template <typename TKey, typename TDictionary>
            static TKey                                             Max(TDictionary& dictionary, const TKey& defaultKey) noexcept {
                typename TDictionary::iterator tail = dictionary.begin();
                typename TDictionary::iterator endl = dictionary.end();
                if (tail == endl) {
                    return defaultKey;
                }

                TKey key = defaultKey;
                std::size_t key_size = 0;

                for (; tail != endl; tail++) {
                    std::size_t nxt_size = tail->second;
                    if (!key || key_size < nxt_size) {
                        key = tail->first;
                        key_size = nxt_size;
                    }
                }

                return key;
            }

            template <class TDictionary>
            static void                                             Deduplication(TDictionary& x, TDictionary& y) noexcept {
                auto x_tail = x.begin();
                auto x_endl = x.end();

                for (; x_tail != x_endl;) {
                    auto k = x_tail->first;
                    auto y_tail = y.find(k);
                    auto y_endl = y.end();

                    if (y_tail == y_endl) {
                        x_tail++;
                    }
                    else {
                        x_tail = x.erase(x_tail);
                    }
                }
            }

            template <class TList>
            static void                                             DeduplicationList(TList& x, TList& y) noexcept {
                auto x_tail = x.begin();
                auto x_endl = x.end();

                for (; x_tail != x_endl;) {
                    auto k = *x_tail;
                    auto y_tail = y.find(k);
                    auto y_endl = y.end();

                    if (y_tail == y_endl) {
                        x_tail++;
                    }
                    else {
                        x_tail = x.erase(x_tail);
                    }
                }
            }
        };

liulilittle
关注
专栏目录
ros项目开发之在clion开发工具中增加c++模板类
苏凯的博客
11-20 1168
ros项目开发之在clion开发工具中增加c++模板类 模板功能： 1.包含一个类 文件名即类名，与main方法 2.包含一个 与该节点的 service 通讯，消息名称用次文件名命名； 3.包含一个定时执行器 4.包含一个多线程函数 5.保函数据库查询和刷新（需要有此服务功能的才能使用，目前数据库服务只能我自己用）
C++容器——字典（map）
shouhu010的博客
03-22 2478
c++容器map 初始化 元素查找 修改 迭代器
c++字典列表
08-12
自己写一个map + list 的c++数据结构。双迭代器，里面有有个简单例子。
数据结构C++——字典、跳表和散列
最新发布
qq_60987997的博客
07-23 746
线性表: (p0, p1, p2, …, pn-1),表示，关键字从左到右。i 级链所包含的数对是i-1级链所有数对的子集。映射到散列表/哈希表(hash table)中的。0级链表： n 个数对（元素/记录）删除数对erase：类似于链表元素的删除。从最高级链表开始，在每一级链中搜索，遇到。多重字典：两个或多个数对有相同的关键字。个数对，散列表中的桶用一个链表来配置。插入insert：类似于链表的插入。——> 数对p在散列表中的。(元素/记录)所组成的集合。1级链表：½ n 个数对。
C++中的“字典”
t54SB的博客
07-16 235
可能某些神通广大的读者可能会问: 字典不是Python特有的数据类型吗?怎么还扯上C++了?请不要震惊, 这里的"字典"是打引号的, 它其实是通过数组来实现字典的效果!
c++字典
qq_44691564的博客
06-24 744
如果更关注性能且不需要有序性，可以选择std::unordered_map。在C++中，“字典”通常指的是std::map或std::unordered_map，它们是标准库中提供的关联容器，用于存储键值对。std::unordered_map：键值对无序，但查找、插入和删除速度更快，适用于不需要顺序的场景。例如，如果你需要按字母顺序遍历元素。使用 std::map std::map 是一种有序的关联容器，键值对按键排序。使用 std::unordered_map std::unordered_map。
数据结构——线性表：字典（C++）
Hodge_Z的博客
12-25 3776
内容概要： 字典的相关概念 注意事项 简单的字典实现 一、字典的相关概念 字典（dictionary）是在数据库中具有存储、查询和删除记录的功能的线性表。 数据库中的记录一般是靠关键码（key）描述的，类似人们的ID号码。 关键码应当具有可比性（comparable）。 二、注意事项 由于关键码类型非常多，不能编写出通用的字典。 关键码不是记录的类的基本属性，也不是类中任意的域，它...
c++ 字典操作
qq_44691564的博客
01-31 776
【代码】c++ 字典操作。
c++英语字典
09-10
本“C++英语小词典”可能数据库不全，但作为学习辅助工具，它可以帮助初学者快速查找和理解C++中的专业术语。你可以根据自己的需求，扩展和定制词典内容，使其更加符合个人的学习路径。通过这样的自我实践，不仅可以...
C_C++指令字典
09-19
2. **指针**：C++沿袭了C语言的指针特性，它是直接操作内存地址的工具，能够实现高效的数据访问和复杂的数据结构。理解指针的声明、初始化、解引用和指针算术是至关重要的。 3. **函数**：函数是C和C++中组织代码的...
NOIP c++常用模板。。。
10-24
C++模板是一种泛型编程工具，允许程序员创建函数或类的通用版本，以处理不同类型的参数。函数模板允许我们编写一个函数，适用于多种数据类型，而类模板则可以用于创建可应用于多种类型的类。 例如，一个简单的函数...
C++ 简单的英汉词典
05-16
文档建立保存，英文增查改，简单的英文语句翻译，平衡二叉树
英文字典 C++开发
05-02
简单英文字典C++开发的，实现单词添加和查询
C++指令字典详细说明指导
08-15
总的来说，"C++指令字典"是一个非常实用的工具，它涵盖了C++语言的关键概念、语法和库函数。无论是初学者还是经验丰富的开发者，都可以从中受益，快速查找和理解所需的知识点，提升编程能力。通过深入学习和实践，你...
字典树 C++ 模板
qq_46279105的博客
09-28 250
#include<iostream> #include<cstdio> using namespace std; int trie[1000010][26];//解释数组，26代表开头可能有26种可能，即a-z//1000010则用来记录查询字符的下一个字符的位置 int num[1000010]={0}; int pos = 1;//字典树的层数，深度 void Insert(char word[]) { int i; int c = 0; fo
C++模板：字典树
weixin_30952535的博客
03-04 186
//插入 void insert(char *s,char *s1){ for(int l=strlen(s),x=0,i=0;i<l;i++){ if(!trie[x].son[s[i]-'a'])trie[x].son[s[i]-'a']=++cnt; x=trie[x].son[s[i]-'a']; if(i==l-1)...
C/C++基础字典
ShawnDung的博客
10-21 924
C/C++基础知识内容
C++ 字典遍历
缘故的博客
05-10 4863
CCDictElement * pElement;    CCDICT_FOREACH(result, pElement)    {        const char * key = pElement->getStrKey();        CCString * value = (CCString *)pElement->getObject();        CCLog(key);
C++字典操作
weixin_51047199的博客
03-04 656
c++字典操作
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值