子版块

• ---

• Sunrisepeak's Blog

  Sunrisepeak的博客

  7 主题

  16 帖子

  S

  文章导读 一、类模板与模板特化(全特化与偏特化) 二、类模板与其模板特化的应用 三、模板特化存在性问题 一、类模板与模板特化(全特化与偏特化)

  从接受类型的角度
  类模板：全集R
  模板偏特化(部分特化)：为全集的一个子集A
  模板全特化：为R中的一个"点"，或者说为R中的一个元素
  匹配规则：越特化匹配优先级越高(见下面例子)

  98a9da6a-01af-4fc4-83ad-91b7ca549699-image.png

  1.类模板

  可以接受任意类型

  // R template<typename T> class A {}; // 类模板是能接受任意类型，A后面不需要(不能)任何处理 2.模板偏特化(局部特化)

  可以接受任意指针类型

  // A template<typename T> class A<T *> {}; // 类模板A的偏特化版本，在A后指出特化的范围 3.模板全特化

  指定接受int类型

  template<> class A<int> {} // 类模板A的全特化版本(已经是类模板的一个实例了)，在A后直接指出明确类型int 4.例子： #include <iostream> #include <string> using namespace std; template<typename T> class A { public: A() { cout << "R" << endl; } }; /* 注释1　－－　接受指针 template<typename T> class A<T *> { public: A() { cout << "A" << endl; } }; */ /* 注释2　－－　接受int template<> class A<int> { public: A() { cout << "int" << endl; } }; */ int main() { A<string> r; // 1 A<char *> a; // 2 A<int> i; // 3 return 0; } 5.测试不同情况:

  当只有一个类模板(可接受任意类型R)存在时，1, ２, 3都使用类模板实例化

  v2-a53836d6d2a913d69c2fd90b0dd4371f_1440w.png

  注释１是接受所以指针类型(R的子集A),所以称其为类模板A的偏特化(范围特化)。即把类模版A所能接受的指针类型单独处理(实例化)。当取消注释１时：char * 将由这个模板类A的偏特化版本(范围特化，局部特化)处理。

  v2-2bd02b7f6a4dbb5cdbc586f98d76b92b_1440w.png

  注释２只接受int类型的参数(可以看出是全局R中的一个元素)。当你用int实例化A时，将会由这个全特化版本来实现(而不会使用可以接受任意类型的版本(泛化版))。

  v2-6a08120bfe6da8471d8fb374b2665a65_1440w.png

  二、类模板与其模板特化的应用 用模板的偏特化　实现一个　能移除任意类型const属性的模板类：remove_const 主要功能和用法： 功能： 给remove_const一个类型后 －－１．(情况１)如果这个类型没有const属性则获得这个类型本身。 －－２．(情况２)如果这个类型有const属性则移除它。 用法： remove_const<Type>::type 使用场景： 当拿到一个未知变量时，想获得这个变量(或对象)的非const的类型 1.实现情况１

  似乎没做什么事，aa是int符合情况１。但情况２不符合，bb没有变成int。

  #include <iostream> #include <type_traits> template<typename T> struct remove_const { using type = T; }; int main() { int a = 1; const int b = 2; remove_const<decltype(a)>::type aa = 3; remove_const<decltype(b)>::type bb = 4; std::cout << std::is_same<decltype(aa), int>::value << std::endl; std::cout << std::is_same<decltype(bb), int>::value << std::endl; return 0; }

  运行结果:
  v2-7a36de2df8473699ecc173f27351c876_1440w.png

  2.实现情况2

  从上面的实现可以看出，当传给模板的参数是带const类型时它还会返回带const属性的类型。同时从remove_const的定义也可以看出他是个　复读机　你给他什么类型他就给你什么类型。

  这时候可以使用上面介绍的偏特化的性质，来把带有带const的类型这个子集从全集中分离出来　特殊处理。如下：

  #include <iostream> #include <type_traits> template<typename T> struct remove_const { using type = T; }; template<typename T> struct remove_const<const T> { using type = T; }; int main() { int a = 1; const int b = 2; remove_const<decltype(a)>::type aa = 3; remove_const<decltype(b)>::type bb = 4; std::cout << std::is_same<decltype(aa), int>::value << std::endl; std::cout << std::is_same<decltype(bb), int>::value << std::endl; return 0; }

  运行结果:

  给带const的类型，写了一个特化版本。所以当remove_const接受一个带const的类型时，就会通过这个偏特化版本实例化，由于这个偏特化版本把const从类型中分离出来了，则这里的T就是没有const的类型，从而实现去除类型const的功能。

  v2-d337e4dc338fc9a90fcfa7ef9db27804_1440w.png

  三、模板特化存在性问题

  一个类模板的特化，是对某一个类模板的子集做特化处理的。而它不能"独立存在"。既只有存在一个类模板X, 才能存在对它特化的版本。

  template<typename T> class A<T *> {}; int main() { return 0; }

  v2-1023f2d6ec20e5efa6300629068527d6_1440w.png

• invoker__qq's Blog

  invoker__qq的博客

  1 主题

  2 帖子

  S

  @tiansongyu 在 使用AI代理游玩所有任天堂NES游戏(红白机)详细教程----基于gym-retro、pygame、stable-baselines3 中说：

  示例图片 2

  这个中间的游戏 很经典的对站游戏。里面的 能发地波的忍者 和 哪个龙的 大鹏展翅 记忆深刻

• pinkie_ctfer's Blog

  pinkie ctfer的博客

  3 主题

  7 帖子

  妈

  本系列博客作为我学习的一个笔记,注重于代码实现,本人非数学专业,证明能力非常弱,本文掺杂着大量我自己的理解,如有数学大佬光顾,请尽情指正,谢谢
  本系列默认大家都学会了C/C++基本语法

  集合 书上的定义 集合是指具有某种特定性质的不同对象无序聚集成的一个整体。 集合中的每一个对象称为集合的元素； 通常用大写字母表示集合； 用小写字母表示集合中的元素。

  也就是说把一些东西放到一起叫做集合(个人理解)

  代码实现 #include <string> #include <vector> #include <stdint.h> #include <iostream> // 抽象基类，定义集合元素的基本接口 class elmBase { public: // 将元素转换为字节数组的纯虚函数（序列化基础） virtual std::vector<uint8_t> getUint8Array() const = 0; // 默认比较运算符，通过字节数组逐字节比较 virtual int operator==(const elmBase &other) { std::vector<uint8_t> thisDate = getUint8Array(); std::vector<uint8_t> otherDate = other.getUint8Array(); if (thisDate.size() != otherDate.size()) return 0; for (int i = 0; i < thisDate.size(); i++) { if (thisDate[i] != otherDate[i]) return 0; } return 1; } // 转换为字符串表示的纯虚函数 virtual std::string toString() = 0; // 虚析构函数确保正确释放派生类对象 virtual ~elmBase() { } }; // 特殊元素类型，始终返回比较不成立 class alwaysFalse : public elmBase { public: std::vector<uint8_t> getUint8Array() const override { return std::vector<uint8_t>(); // 返回空数组 } std::string toString() override { return {}; // 返回空字符串 } // 重载运算符始终返回false，用于占位符场景 virtual int operator==(const elmBase &other) override { return 0; } ~alwaysFalse() { } }; // 哈希表节点结构，使用链表法解决冲突 using elmNode = struct elmNode { elmBase *elm; // 元素指针 elmNode *next; // 下一个节点指针 }; // 节点工厂函数，创建新节点并初始化元素 elmNode *elmNodeFactory(elmBase *elm) { elmNode *newNode = new elmNode(); newNode->elm = elm; newNode->next = nullptr; return newNode; } // 自定义集合类，基于哈希表实现 class set { private: uint32_t prime; // 哈希表大小（通常选择质数） elmNode **setMap; // 哈希桶数组 // 初始化哈希表结构 void inline _init_(uint32_t prime) { this->prime = prime; this->setMap = new elmNode *[prime]; // 初始化每个桶为alwaysFalse哨兵节点 for (uint32_t i = 0; i < prime; ++i) { this->setMap[i] = elmNodeFactory(new alwaysFalse()); } } protected: // 查找元素对应的哈希桶 elmNode **__find__(elmBase *elm) { uint32_t hash = rotatingHash(elm->getUint8Array(), this->prime); return &(this->setMap[hash]); // 返回桶的指针 } /** * 通用链表操作函数 * @param link 链表头指针的指针 * @param elm 目标元素 * @param cmp 自定义比较函数，返回true时停止遍历 * @param finally 遍历结束后的处理函数（插入等操作） * @return 找到的节点或操作结果节点 */ elmNode *__link__(elmNode **link, elmBase *elm, bool (*cmp)(elmNode *, elmBase *), elmNode *(*finally)(elmNode **, elmNode *, elmBase *) = nullptr) { elmNode *linkPriv = *link; elmNode *linkCurrent = linkPriv; // 遍历链表查找元素 while (linkCurrent != nullptr) { if (cmp(linkCurrent, elm)) { return linkCurrent; } linkPriv = linkCurrent; linkCurrent = linkCurrent->next; } // 执行最终处理函数（如插入新节点） if (finally != nullptr) { return finally(link, linkPriv, elm); } return nullptr; } public: // 构造函数初始化哈希表 set(uint32_t prime) { _init_(prime); } ~set() { for (uint32_t i = 0; i < this->prime; ++i) { elmNode *link = this->setMap[i]; while (link != nullptr) { elmNode *tmp = link; link = link->next; if (tmp != nullptr) { if (tmp->elm != nullptr) { std::cout << "delete " << tmp->elm->toString() << std::endl; delete tmp->elm; } delete tmp; } } } } // 旋转哈希算法实现 static uint32_t rotatingHash(std::vector<uint8_t> key, uint32_t prime) { uint32_t hash = key.size(); for (uint32_t i = 0; i < key.size(); ++i) hash = (hash << 4) ^ (hash >> 28) ^ (uint32_t)(key[i]); return (hash % prime); } // 添加元素到集合 bool add(elmBase *elm, bool force = false) { elmNode **node = __find__(elm); auto finally = [](elmNode **node, elmNode *linkPriv, elmBase *elm) -> elmNode * { // 插入新节点到链表末尾 if (linkPriv->next == nullptr) { linkPriv->next = elmNodeFactory(elm); } return nullptr; }; // 使用lambda作为比较函数 elmNode *targetNode = this->__link__(node, elm, [](elmNode *node, elmBase *tag) -> bool { return *(node->elm) == *tag; }, finally); return targetNode == nullptr; // 返回是否插入成功 } // 检查元素是否存在 bool get(elmBase *elm) { elmNode **node = __find__(elm); elmNode *targetNode = this->__link__(node, elm, [](elmNode *node, elmBase *tag) -> bool { return *(node->elm) == *tag; }); return targetNode != nullptr; } // 移除集合中的元素 bool remove(elmBase *elm) { elmNode **node = __find__(elm); elmNode *ret = this->__link__(node, elm, [](elmNode *current, elmBase *tag) -> bool { // 查找前驱节点执行删除 if (current->next != nullptr && *(current->next->elm) == *tag) { elmNode *tmp = current->next; current->next = current->next->next; delete tmp->elm; // 释放元素内存 delete tmp; // 释放节点内存 return true; } return false; }); return ret != nullptr; } // 调试用打印函数，显示哈希表结构 void print() { std::cout << "[HashTable Structure]" << std::endl; for (int i = 0; i < this->prime; i++) { std::cout << "Bucket " << i << ": "; elmNode *node = this->setMap[i]; while (node != nullptr) { std::cout << node->elm->toString() << " -> "; node = node->next; } std::cout << "NULL" << std::endl; } } }; // 数值类型元素实现 class number : public elmBase { int data; public: number(int data) : data(data) {} std::vector<uint8_t> getUint8Array() const override { // 将整型转换为字节数组 return std::vector<uint8_t>( reinterpret_cast<const uint8_t *>(&data), reinterpret_cast<const uint8_t *>(&data) + sizeof(data)); } std::string toString() override { return std::to_string(data); } ~number() { } }; // 字符串类型元素实现 class string : public elmBase { std::string data; public: string(std::string data) : data(data) {} std::vector<uint8_t> getUint8Array() const override { // 将字符串内容转换为字节数组 return std::vector<uint8_t>(data.begin(), data.end()); } std::string toString() override { return data; } ~string() { } }; 集合与元素的关系 若A表示一个集合，a是集合A中的元素，记作aA，读作a属于A； 若a不是集合A中的元素，则记作aA，读作a不属于A。

  未完待续

• Maxwell1905's Blog

  Maxwell1905的博客

  4 主题

  20 帖子

  S

  @sky-littlestar 我说的意思就是把你上面的代码 整理一下 用项目(Demo)的方式 放到github, 不是说其他什么写法

• FrozenLemonTee's Blog

  冰柠配绿茶的个人博客, 记录探索技术的历程 - Github | X

  1 主题

  2 帖子

  S

  感觉关于项目相关的工程 (软件工程) 方面的东西是挺重要的

  目录结构 单元测试 文档 构建 ...

  了解这些后。要自己开发项目或要去使用/阅读一些其他项目, 就能很快上手并理解很多项目的结构以及他们为什么那么做

  (有时间感觉可以尝试把文章的一些内容 录成视频分享到视频平台, 应该会有不少人感兴趣)

• Blog :: Johan Xie

  个人博客，随想随写

  0 主题

  0 帖子

  没有新主题