【C++】—— 模板进阶

【C++】—— 模板进阶

  • 1 非类型模板参数
    • 1.1 什么是非类型模板参数
    • 1.2 非类型模板参数对比宏的优势
    • 1.3 array 简单了解
  • 2 模板的特化
    • 2.1 引子
    • 2.2 函数模板特化
    • 2.3 函数模板特化的坑
    • 2.4 类模板的特化
      • 2.4.1 全特化
      • 2.4.2 偏特化(半特化)
      • 2.4.3 选择
      • 2.4.4 偏特化的妙用
  • 3 模板分离编译
    • 3.1 什么是分离编译
    • 3.2 模板的分离编译
    • 3.3 为什么模板不支持分离编译
    • 3.4 实现分离编译的方法
  • 4 模板总结

1 非类型模板参数

1.1 什么是非类型模板参数

  模板参数分为类型非类型模板参数

类型形参:出现在模板参数列表中,跟在 class 或者 typename 这后的参数类型名称
非类型形参:就是用一个常量作为类(函数)模板的一个参数,在类(函数)模板中可将该参数当成常量来使用

  什么意思呢,我们结合代码来看一下

// 定义一个模板类型的静态数组
template<class T, size_t N>
class array
{
public :T & operator[](size_t index) { return _array[index]; }const T& operator[](size_t index)const { return _array[index]; }size_t size()const { return _size; }bool empty()const { return 0 == _size; }private:T _array[N];size_t _size;
};

   T T T 是用 c l a s s class class t y p e n a m e typename typename 定义的,为类型模板参数
   N N N 是直接用类型( s i z e size size_ t t t)定义的,即为非类型模板参数,非类型模板参数可以给缺省值

  非类型模板参数有什么用呢?比如我们要定义一个静态的数组/栈

template<size_t N = 10>
class Stack
{
private:int _a[N];size_t top;
};

   N N N 是常量,可以定义数组的大小。为什么是常量呢?因为模版在编译时就实例化了,所以 N N N 在编译器时就确定了
  
  

1.2 非类型模板参数对比宏的优势

  那么它比宏的优点是什么呢?

define N 10
class stack
{
private:int _a[N];size_t top;
};

  宏是写死的, N N N 只能为 10,比如我想一个栈存 5 个数据,一个存 10 个数据,宏就做不到。而非类型模板参数可以做到

//给了缺省值10,可以不传参
Stack<> s1;
Stack<5> s2;

:如果非类型模板参数给了缺省值,实例化时依然要加上<>(C++20之后可不加)

  当然,其底层本质还是生成了两个类,一个类 N 是 5,另一个 N 是 10。

  非类型模板参数只能用于整型,其他任何类型都不行(C++20之后支持浮点数)
  整型家族有: s i z e size size_ t t t i n t int int s h o r t short short c h a r char char b o o l bool bool
  

1.3 array 简单了解

  那非类型模板参数在 STL库 中有什么应用吗?

  C++11中提供 array 容器就运用了非类型模板参数

在这里插入图片描述

  
   a r r a y array array容器其实就是一个静态数组,这是它的函数接口:

在这里插入图片描述

  它同样支持迭代器访问等,但它不支持 p u s h push push_ b a c k back back i n s e r t insert insert 等,因为它不支持扩容。

那么 array静态数组有什么区别呢?

//有什么区别呢?
int arr1[10];
array<int, 10> arr2;

   a r r a y array array 与 静态数组 基本没有什么区别,唯一的区别是 a r r a y array array 对越界的检查非常严格
  
  普通静态数组越界读基本检查不出来
  而对于越界写是一种抽查:普通数组一般会在数组末尾给 1~3 个标志位,标志位会给某个值(假设为-1),程序结束后看标志位是否被修改,修改了就能被检查出来,没修改就检查不出。越界访问跳过标志位修改时检查不出的。

在这里插入图片描述

  但是 a r r a y array array 容器对越界检查就很准,越界读和越界写都能检查出来
  这里因为 a r r a y array array 是自定义类型,它里面重载的 operator[] 中加了 a s s e r t assert assert断言强制检查。他的机制和静态数组不一样

  但是 a r r a y array array 还是比较鸡肋,我为什么不用 v e c t o r vector vector 呢? v e c t o r vector vector 也能检查越界,还能动态增长, a r r a y array array 唯一优势是它是在栈上开辟空间 v e c t o r vector vector 是在上,频繁的开辟数组 a r r a y array array 效率略高(栈上开空间栈帧建立的时候一次性就开好了)
  
  

2 模板的特化

2.1 引子

  现在我们实现了一个函数模板,用于实现比较功能

template<class T>
bool Less(T left, T right)
{return left < right;
}
class Date
{
public:Date(int year = 1900, int month = 1, int day = 1): _year(year), _month(month), _day(day){}bool operator<(const Date& d)const{return (_year < d._year) ||(_year == d._year && _month < d._month) ||(_year == d._year && _month == d._month && _day < d._day);}bool operator>(const Date& d)const{return (_year > d._year) ||(_year == d._year && _month > d._month) ||(_year == d._year && _month == d._month && _day > d._day);}
private:int _year;int _month;int _day;
};int main()
{cout << Less(1, 2) << endl; // 可以比较,结果正确Date d1(2024, 1, 1);Date d2(2023, 1, 1);cout << Less(d1, d2) << endl; // 可以比较,结果正确return 0;
}

  用来比较 整型 和 日期 D a t e Date Date类对象 都是没有问题的
  但是传递日期类的地址去,比较结果就出问题了

int main()
{Date d1(2024, 1, 1);Date d2(2023, 1, 1);cout << Less(d1, d2) << endl; // 可以比较,结果正确Date* p1 = &d1;Date* p2 = &d2;cout << Less(p1, p2) << endl; // 可以比较,结果错误return 0;
}

在这里插入图片描述

  为什么?因为这里比较的是 d 1 d1 d1 d 2 d2 d2 两个地址的大小,不是比较他们的值。
  我们可以使用模板的特化来解决这个问题,而模板特化又分为函数模板特化类模板特化
  

2.2 函数模板特化

函数模板特化的步骤:

  • 必须先有一个基础的函数模板
  • 关键字 t e m p l a t e template template 后面接一对空的尖括号<>
  • 函数名后面跟一对尖括号<>,尖括号中指定需要特化的类型
  • 函数形参表:必须要和模板函数的基础参数类型完全相同,如果不同 ,编译器可能会报一些奇怪的错误
//函数模板 --- 参数匹配
template<class T>
bool Less(T left, T right)
{return left < right;
}//对Less函数模板进行特化
template<>
bool Less<Date*>(Date* left, Date* right)
{return *left < *right;
}

  但除了特化,还能其他方法:直接写一个函数,这种方法更加推荐

bool Less(Date* left, Date* right)
{return *left < *right;
}

  如果有模板和现成的类或函数,优先用现成的。

  

2.3 函数模板特化的坑

  模板的特化其实是很坑的,上面大家可能没有感觉到,我们下面来见识一下。

template<class T>
bool Less(const T& left, const T& right)
{return left < right;
}

  严格来说,比较函数模板形参应该用 const引用 而不是上面的传值传参,万一是自定义类型呢

  那这时 D a t e Date Date* 的函数模板特化该怎么写呢?

template<>
bool Less<Date*>(const Date*& left, cosnt Date*& right)
{return *left < *right;
}

  这样写可以吗?
  不行!

  问题出现在 c o n s t const const

  模板中的 const 修饰的是 left 和 right,即引用本身。如果传 D a t e Date Date* 类型,那 c o n s t const const 修饰的应该是 D a t e Date Date*
  但特化中的 c o n s t const const 是在 * 之前修饰的是指针所指向的内容,而不是 D a t e Date Date* 指针本身,相当于修饰 * l e f t left left 和 * r i g h t right right。如果传 D a t e Date Date* 类型,修饰的就是 D a t e Date Date
  
  所以要 c o n s t const const 放到 * 的后面

template<>
bool Less<Date*>( Date* const& left, Date* const& right)
{return *left < *right;
}

  
  那如果传 c o n s t const const D a t e Date Date* ,这特化的模板还能用吗?

template<>
bool Less<Date*>( Date* const & left, Date* const& right)
{return *left < *right;
}int main()
{Date d1(2026, 1, 1);Date d2(2025, 1, 1);const Date* p1 = &d1;const Date* p2 = &d2;cout <<" "<< Less(p1, p2) << endl; return 0;
}

  不能
  const Date*Date* 是两个类型。 c o n s t const const D a t e Date Date* 传给 D a t e Date Date* 会造成权限放大,无法编译通过
  只能再特化一个 c o n s t const const D a t e Date Date* 的函数模板

template<>
bool Less<const Date*>(const Date* const& left, const Date* const& right)
{return *left < *right;
}

  这里的两个const,我们来理一下:前一个 c o n s t const const,是属于 c o n s t const const D a t e Date Date* 类型;后一个 c o n s t const const修饰引用对象本身

  可能小伙伴对 c o n s t const const 放在后面有些不习惯
  用const修饰普通类型, c o n s t const const 既可以放在之前也可以放在之后

cosnt int i = 0;
int const j = 1;

  引用也是如此(虽然难看了点)

const int& rx = i;
int const& ry = j;

这样写函数模板可能大家更容易理解一点

template<class T>
bool Less(T const & left, T const & right)
{return left < right;
}

  
总结
  尽量别用函数模板特化,直接用普通函数不香吗

  

2.4 类模板的特化

2.4.1 全特化

//原模版
template<class T1, class T2>
class Data
{
public :Data() { cout << "Data<T1, T2>" << endl; }
private:T1 _d1;T2 _d2;
};
//全特化
template<>
class Data<int, char>
{
public :Data() { cout << "Data<int, char>" << endl; }
private:int _d1;char _d2;
};
int main()
{Data<int, int> d1;Data<int, char> d2;return 0;
}

在这里插入图片描述

  

2.4.2 偏特化(半特化)

  偏特化就是只特化一部分参数,比如上述 D a t a Data Data 类,我只特化第二个参数为 d o u b l e double double

template<class T1>
class Data<T1, double>
{
public:Data() { cout << " Data<T1, double>" << endl; }
private:int _d1;char _d2;
};int main()
{Data<int, double> d1;Data<char, double> d2;return 0;
}

在这里插入图片描述

  

2.4.3 选择

  那如果全特化和半特化都符合,编译器走谁呢?

template<>
class Data<int, char>
{
public :Data() { cout << " Data<int, char>" << endl; }
private:int _d1;char _d2;
};template<class T1>
class Data<T1, char>
{
public:Data() { cout << " Data<T1, char>" << endl; }
private:int _d1;char _d2;
};int main()
{Data<int, char> d1;return 0;
}

在这里插入图片描述

  走全特化
  我们可以认为编译器是个懒狗。半特化的 T1 还要自己推导,烦死了,直接用全特化多香。
  

2.4.4 偏特化的妙用

//两个参数偏特化为指针类型
template <typename T1, typename T2>
class Data <T1*, T2*>
{
public :Data() { cout << "Data<T1*, T2*>" << endl; }
private:T1 _d1;T2 _d2;
};

  如果传的类型是指针,就调用这个偏特化,任意类型的指针

int main()
{Data<int*, char*> d1;Data<int*, int*> d2;return 0;
}

在这里插入图片描述

  还可以引用特化

template <typename T1, typename T2>
class Data <T1&, T2&>
{
public :Data() { cout << " Data<T1&, T2&>" << endl; }
private:T1 _d1;T2 _d2;
};int main()
{Data<int&, char&> d1;Data<int&, int&*> d2;return 0;
}

在这里插入图片描述

  指针和引用混在一起特化也可以

template <typename T1, typename T2>
class Data <T1&, T2*>
{
public :Data() { cout << " Data<T1&, T2*>" << endl; }
private:T1 _d1;T2 _d2;
};int main()
{Data<int&, char*> d1;Data<int&, int*> d2;return 0;
}

在这里插入图片描述

  
应用:

template<class T>
class Less
{
public:bool operator()(const T& x, const T& y) const{return x < y;}
};template<class T>
class Less<T*>
{
public:bool operator()( T* const& x,  T* const& y) const{return *x < *y;}
};int main()
{int a = 1;int b = 0;int* pa = &a;int* pb = &b;double c = 1.0;double d = 2.0;cout << Less<int>()(a, b) << endl;cout << Less<int*>()(pa, pb) << endl;cout << Less<double*>()(&c, &d) << endl;return 0;
}

  如果不用半特化,还要全特化出 i n t int int* 和 d o u b l e double double* 两个全特化,可见半特化还是很好用的。
  
  

3 模板分离编译

3.1 什么是分离编译

  一个程序(项目)往往由若干个源文件共同实现,而每个源文件单独编译生成目标文件最后将所有目标文件链接起来形成单一的可执行文件的过程称为分离编译模式

  

3.2 模板的分离编译

  但是,模板不支持分离编译

//func.h
#pragma once
#include<iostream>using namespace std;template<class T>
T Add(const T& left, const T& right);void fun(const int& left, const int& right);//func.cpp
#define _CRT_SECURE_NO_WARNINGS
#include"func.h"template<class T>
T Add(const T& left, const T& right)
{return left + right;
}void fun(const int& left, const int& right)
{cout << " fun(const int& left, const int& right)" << endl;
}//test.cpp
int main()
{Add(1, 2);fun(3, 4);return 0;
}

在这里插入图片描述

  可以看到,编译无法通过
  

3.3 为什么模板不支持分离编译

  为什么模板不支持分离编译呢?要想理解这个问题,需对编译与链接有一些了解,详情大家可移步至:【C语言】 —— 编译和链接

我们简单回忆一下:

  • 预处理
    • 头文件的展开、宏替换、条件编译、去掉注释
    • 生成 .i 文件

  经过预处理后, f u n c func func. h h h 文件就在 f u n c func func. c p p cpp cpp t e s t test test. c p p cpp cpp 文件展开

  • 编译
    • 检查语法,生成汇编代码(报的语法错误就是这一阶段报出的)
    • 生成 .s 文件
  • 汇编
    • 汇编代码转换成二进制机器码(CPU只认识 0 和 1),生成符号表
    • 生成 .o/.obj 目标文件
  • 链接
    • 将目标文件合并在一起生成可执行程序,并且把需要的函数地址等链接上
    • 生成 .exe 可执行程序

  模板不能分离编译问题就出在 链接 这一步上


  对 func.cpp 文件,在预处理时, f u n c . h func.h func.h 文件已经展开

//func.cpp//func.h 已展开
/*******************************************
#include<iostream>
using namespace std;template<class T>
T Add(const T& left, const T& right);void fun(const int& left, const int& right);
********************************************/template<class T>
T Add(const T& left, const T& right)
{return left + right;
}void fun(const int& left, const int& right)
{cout << " fun(const int& left, const int& right)" << endl;
}

编译阶段:

   A d d Add Add f u n c func func 都有其声明和定义, f u n c func func 可以被编译成具体的汇编指令,因为 f u n c func func 的所有东西都是确定的。 A d d Add Add 不会生成具体的指令,因为 A d d Add Add 是个模版,不知道模版参数 T T T 是什么,只知道它声明了


  对 t e s t . c p p test.cpp test.cpp 文件,在预处理时, f u n c . h func.h func.h 文件已经展开

//test.cpp//func.h 已展开
/*******************************************
#include<iostream>
using namespace std;template<class T>
T Add(const T& left, const T& right);void fun(const int& left, const int& right);
********************************************/int main()
{Add(1, 2);fun(3, 4);return 0;
}

编译阶段:

   t e s t . c p p test.cpp test.cpp 中只有 A d d Add Add f u n c func func 的声明,但符合语法,依然让他们过了。但是没有 A d d Add Add f u n c func func 的地址:call Add(?)call func(?),因为没有他们的定义。他们的定义可能在其他文件,那什么时候去找呢?在链接阶段

  这里需要注意:在链接之前,各个文件都是相互独立的,互不影响

在这里插入图片描述

  链接的时候,除了将两个文件合并在一起,还有一个很重要的事情:找地址。之前我只有声明没有地址,到了编译阶段我就可以用函数名去找地址了(在符号表找)

   f u n c func func 去找地址,找到了;但是 A d d Add Add 去找,找不到

  为什么找不到呢?
  因为在 f u n c . o func.o func.o 文件中, A d d Add Add 还没有实例化
A d d Add Add 实例化的方法在 t e s t . o test.o test.o 文件中,但此时两文件并没有交集。 f u n c func func文件 中有定义和声明,但不知道T实例化成什么 t e s t test test文件 中有声明、知道实例化方法,但没有定义

  
  

3.4 实现分离编译的方法

  其实模板也不是完全不能实现分离编译,还是有方法的:显式实例化

//func.h
#include<iostream>using namespace std;template<class T>
T Add(const T& left, const T& right);void fun(const int& left, const int& right);//显式实例化
//为与特化进行区分,template后不需加尖括号<>
template
int Add(const int& left, const int& right);

  但上述只显示实例化了 i n t int int d o u b l e double double类型调用要再次显示实例化成 d o u b l e double double,因此不推荐这种方法

  模板最好的解决方案是在同一个文件(.h)中进行声明和定义
  为什么 . h .h .h同时进行声明和定义没问题呢?因为在预处理后 . c p p .cpp .cpp . h .h .h 文件展开,就同时有了模版的声明、定义和实例化方式在编译阶段就能直接将模板实例化成对应的函数,这样就有其地址,不会失败了

  

4 模板总结

【优点】

  1. 模板复用了代码,节省资源,更快的迭代开发,C++的标准模板库(STL)因此而产生
  2. 增强了代码的灵活性

【缺陷】

  1. 模板会导致代码膨胀问题,也会导致编译时间变长
  2. 出现模板编译错误时,错误信息非常凌乱,不易定位错误

  
  
  
  


  好啦,本期关于模板进阶的知识就介绍到这里啦,希望本期博客能对你有所帮助。同时,如果有错误的地方请多多指正,让我们在 C++ 的学习路上一起进步!

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.mzph.cn/web/56838.shtml

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈email:809451989@qq.com,一经查实,立即删除!

相关文章

Java最全面试题->Java基础面试题->JavaEE面试题->Web应用服务器面试题

文章目录 Web应用服务器面试题Tomcat是什么?Tomcat缺省端口是多少&#xff0c;如何修改&#xff1f;Tomcat 有那几种Connector 运行模式&#xff1f;什么是Servlet&#xff1f;Servlet请求过程&#xff1f;Tomcat执行流程&#xff1f;Tomcat部署方式?什么是JBoss ?在JBoss 7…

FPGA搭建PCIE3.0通信架构简单读写测试,基于XDMA中断模式,提供3套工程源码和技术支持

目录 1、前言工程概述免责声明 2、相关方案推荐我已有的PCIE方案本博客方案的PCIE2.0版本 3、PCIE基础知识4、工程详细设计方案工程设计原理框图XDMA配置及使用XDMA中断模块数据缓存架构用户逻辑Windows版本XDMA驱动安装Linux版本XDMA驱动安装测试应用程序工程源码架构PCIE上板…

实测体验Claude 3.5升级版:AI首次实现直接操控电脑!

前言 就在10月22日晚上&#xff0c;Anthropic发布重大升级&#xff0c;发布Claude 3.5 Sonnet和Claude 3.5 Haiku新版本。 新的 Claude 3.5 Sonnet 在所有指标上都优于其他模型&#xff0c;包括 OpenAI 的 GPT-4 和谷歌的 Gemini 1.5 Pro。 Claude 3.5 Haiku 与之前的顶级 C…

【C++开篇】

首先初阶的数据结构相信大家已经学习的差不多了&#xff0c;关于初阶数据结构排序的相关内容的总结随后我也会给大家分享出来。C语言和C有许多相同的地方&#xff0c;但也有许多不相同的地方。接下来的C部分&#xff0c;我们主要是针对C与C语言不同的地方来与大家进行分享。其中…

gin入门教程(7): 使用 Logrus + Lumberjack 创建日志中间件

结合 Logrus 和 Lumberjack&#xff0c;可以创建一个高效的日志中间件&#xff0c;用于记录请求和响应。以下是实现步骤&#xff1a; 1. 安装依赖 首先&#xff0c;确保安装了 Logrus 和 Lumberjack&#xff1a; go get github.com/sirupsen/logrus go get gopkg.in/natefin…

基于vite和vue3、 eslint、prettier、stylelint、husky规范

前言 在现代的前端开发中&#xff0c;代码规范非常重要。它可以提高团队的协作效率&#xff0c;减少代码错误&#xff0c;使代码更易于维护。为了实现代码规范化&#xff0c;我们可以使用一些工具来辅助我们的开发流程&#xff0c;包括eslint、prettier、stylelint、husky&am…

word中的内容旋转90度

在vsto、Aspose.Words 中&#xff0c;默认没有直接的 API 可以让表格整体旋转 90 度。然而&#xff0c;我们可以通过一些方式来实现类似的效果&#xff0c;具体思路如下&#xff1a; 将表格插入到一个形状&#xff08;Shape&#xff09;或文本框中&#xff0c;然后旋转该形状。…

DVD光盘解密工具 Xreveal v2.7.1 官方版

下载地址 【1】https://pan.quark.cn/s/a95d5fa38f48 【2】https://drive.uc.cn/s/1e81ba7ee01e4?public1 Xreveal是一款功能相当贴心给力的光碟工具&#xff0c;其功能可以帮助用户检测以及删除DVD、CD保护。它完全不含有任何的解密密钥以及BD转换表&#xff0c;它是基于官…

【Windows】电脑端口明明没有进程占用但显示端口被占用(动态端口)

TOC 一、问题 重启电脑后&#xff0c;启用某个服务显示1089端口被占用。 查看是哪个进程占用了&#xff1a; netstat -aon | findstr "1089"没有输出&#xff0c;但是换其他端口&#xff0c;是可以看到相关进程的&#xff1a; 现在最简单的方式是给我的服务指定另…

阿里云项目启动OOM问题解决

问题描述 随着项目业务的增长&#xff0c;系统启动时内存紧张&#xff0c;每次第一次启动的时候就会出现oom第二次或者第n的时候&#xff0c;就启动成功了。 带着这个疑问&#xff0c;我就在阿里云上提交了工单&#xff0c;咨询为什么第一次提交失败但是后面却能提交成功尼&a…

HarmonyOS 组件样式@Style 、 @Extend、自定义扩展(AttributeModifier、AttributeUpdater)

1. HarmonyOS Style 、 Extend、自定义扩展&#xff08;AttributeModifier、AttributeUpdater&#xff09; Styles装饰器&#xff1a;定义组件重用样式   ;Extend装饰器&#xff1a;定义扩展组件样式   自定义扩展&#xff1a;AttributeModifier、AttributeUpdater 1.1. 区…

SpringBoot 下的Excel文件损坏与内容乱码问题

序言 随着打包部署的方式的改变&#xff0c;原本正常运行的代码可能带来一些新的问题&#xff0c;比如我们现在使用SpringBoot 的方式生成Jar包直接运行&#xff0c;就会对我们再在Resource下的Excel文件产生影响&#xff0c;导入与预期不符的情况发生cuiyaonan2000163.com 比…

Anchor DETR论文笔记

原文链接 [2109.07107] Anchor DETR: Query Design for Transformer-Based Object Detection (arxiv.org)https://arxiv.org/abs/2109.07107 原文笔记 What 提出了一种新的基于锚点的查询设计&#xff0c;即将锚点编码为对象查询。 Why 对象检测任务是预测图像中每个对象…

el-table相关的功能实现

1. 表格嵌套表格时&#xff0c;隐藏父表格的全选框 场景&#xff1a;当table表格设置复选&#xff08;多选&#xff09;功能时&#xff0c;如何隐藏表头的复选框&#xff0c;不让用户一键多选。 <el-table :header-cell-class-name"cellClass">// 表头复选框禁…

机器视觉-相机、镜头、光源(总结)

目录 1、机器视觉光源概述 2、光源的作用 3、光谱 4、工业场景常见光源 4.1、白炽灯 4.2、卤素灯 4.3、 荧光灯 4.4、LED灯 4.5、激光灯 5、光源的基本性能 5.1、光通量 5.2、光效率 5.3、发光强度 5.4、光照度 5.5、均匀性 5.6、色温 5.7、显色性 6、基本光学…

【Linux | 网络I/O模型】五种网络I/O模型详解

1、数据传输过程 在 Linux 系统中&#xff0c;数据传输是通过 I/O 操作来实现的。I/O 操作是指数据从应用程序到内核&#xff0c;再到硬件设备&#xff08;如磁盘、网络接口&#xff09;的过程。 操作系统为了保护自己&#xff0c;设计了用户态、内核态两个状态。应用程序一般工…

基于云平台的智能家居管理系统设计与通信协议分析

案例 阅读以下关于 Web 系统架构设计的教述&#xff0c;在答题纸上回答问题1至问题3。 【说明】 某公司拟开发一个智能家居管理系统&#xff0c;该系统的主要功能需求如下: 1)用户可使用该系统客户端实现对家居设备的控制&#xff0c;且家居设备可向客户端反馈实时状态&#x…

Redis 线程控制 总结

前言 相关系列 《Redis & 目录》&#xff08;持续更新&#xff09;《Redis & 线程控制 & 源码》&#xff08;学习过程/多有漏误/仅作参考/不再更新&#xff09;《Redis & 线程控制 & 总结》&#xff08;学习总结/最新最准/持续更新&#xff09;《Redis &a…

JavaScript part2

一.前言 前面我们讲了一下js的基础语法&#xff0c;但是这些还是远远不够的&#xff0c;我们要想操作标签&#xff0c;实现一个动态且好看的页面&#xff0c;就得学会BOM和DOM&#xff0c;这些都是浏览器和页面的&#xff0c;这样我们才能实现一个好看的页面 二.BOM对象 BOM…

Radar Fields: Frequency-Space Neural Scene Representations for FMCW Radar 笔记

Code 主要思想 文章提出了一种新的神经场表示方法——Radar Fields&#xff0c;用于从FMCW&#xff08;调频连续波&#xff09;雷达数据中恢复场景几何信息。与以往的依赖于光学成像&#xff08;如RGB相机和LiDAR&#xff09;的神经场方法不同&#xff0c;该研究利用了雷达的…