条件编译代码记录

#include <iostream>// 基类模板
template<typename T>
class Base {
public:void func() {std::cout << "Base function" << std::endl;}
};// 特化的子类
template<typename T>
class Derived : public Base<T> {
public:void func() {std::cout << "Derived function" << std::endl;}
};// 完全特化的子类
template<>
class Derived<int> : public Base<int> {
public:void func() {std::cout << "Specialized Derived<int> function" << std::endl;}
};int main() {Derived<double> d1;  // 这个对象使用的是 Derived<double>d1.func();           // 输出: "Derived function"Derived<int> d2;     // 这个对象使用的是完全特化的 Derived<int>d2.func();           // 输出: "Specialized Derived<int> function"Base<double> b;      // 基类实例b.func();            // 输出: "Base function"return 0;
}

std::enable_if_t<std::is_same_v<U, Dim3>, Ptr> 如何使用？

#include <iostream>
#include <type_traits>// 定义不同的MyType子类型
class MyTypeA {
public:void process() {std::cout << "Processing MyTypeA" << std::endl;}
};class MyTypeB {
public:void process() {std::cout << "Processing MyTypeB" << std::endl;}
};class MyTypeC {
public:void process() {std::cout << "Processing MyTypeC" << std::endl;}
};// 函数模板，用于处理MyTypeA
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeA>, void> process(T& obj) {obj.process(); // 处理MyTypeA
}// 函数模板，用于处理MyTypeB
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeB>, void> process(T& obj) {obj.process(); // 处理MyTypeB
}// 函数模板，用于处理MyTypeC
template <typename T>
typename std::enable_if_t<std::is_same_v<T, MyTypeC>, void> process(T& obj) {obj.process(); // 处理MyTypeC
}template <typename U>
void templateFunction(U& obj) {process(obj); // 调用具体的process函数
}int main() {MyTypeA myObjA;MyTypeB myObjB;MyTypeC myObjC;templateFunction(myObjA);  // 输出: Processing MyTypeAtemplateFunction(myObjB);  // 输出: Processing MyTypeBtemplateFunction(myObjC);  // 输出: Processing MyTypeC// 如果你尝试以下代码，将导致编译错误：// std::string str; // 这里是一个不支持的类型// templateFunction(str); // 编译错误，因为没有对应的process函数处理std::string
}

if constexpr (std::is_same_v< >和std::enable_if_t<std::is_same_v>有什么区别 

template<typename T, typename U>；

std::enable_if_t<std::is_same_v<U, Dim3>, void> 代码里可以对T和U多条件判断吗？

对模板参数 T 和 U 进行多条件判断。在 C++ 中，可以通过使用 std::enable_if、constexpr 表达式以及组合多种类型特性（比如 std::is_integral、std::is_floating_point 等）来实现复杂的条件逻辑。

以下是几种常见的方法来对 T 和 U 进行多条件判断：

1. 使用 std::enable_if

可以将多个条件组合在一起，例如使用逻辑运算符 && 或 ||。以下是示例代码：

#include <type_traits>template<typename T, typename U>
class Shaper {
public:// 当 T 是整型且 U 是 Dim3 时，启用 reshape 函数template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3>>>void reshape(float* data, ...) {// 实现}// 另外一个 reshape 函数，当 U 是其他类型时（例如，浮点型）template<typename = std::enable_if_t<std::is_floating_point<U>::value>>void reshape(float* data, ...) {// 实现其他逻辑}
};

2. 通过类型萃取和其他类型特性进行组合

您可以还可以使用组合类型特性进行更复杂的判断：

#include <type_traits>template<typename T, typename U>
class Shaper {
public:// 当 T 是整型且 U 是 Dim3 或者 U 是某个其他类型时启用 reshape 函数template<typename = std::enable_if_t<std::is_integral<T>::value && (std::is_same_v<U, Dim3> || std::is_floating_point<U>::value)>>void reshape(float* data, ...) {// 实现}
};

3. 组合多个 enable_if 条件

您也可以在模板上直接组合多个 enable_if 条件：

#include <type_traits>template<typename T, typename U>
class Shaper {
public:template<typename = std::enable_if_t<std::is_integral<T>::value && std::is_same_v<U, Dim3> && SomeOtherCondition<U>::value>>void reshape(float* data, ...) {// 实现}
};

has_value_member


// 模板函数，只有在T没有value成员时才会启用
template<typename T>
typename std::enable_if<!has_value_member<T>::value>::type

#include <iostream>
#include <type_traits>// 用于检测类型T是否有一个名为 value_type 的类型成员
template <typename T, typename = void>
struct has_value_type : std::false_type {};// 特化 if 提供实现
template <typename T>
struct has_value_type<T, std::void_t<typename T::value_type>> : std::true_type {};// 一个示例结构体，具备 value_type
struct StructWithValue {using value_type = int; // 定义类型成员value_type value; // 实例成员
};// 一个不具备 value_type 的结构体
struct StructWithoutValue {double value; // 没有定义类型成员value_type
};template<typename T, typename Enable = void>
class Widget;// 特化 Widget，当T有value_type时
template<typename T>
class Widget<T, typename std::enable_if<has_value_type<T>::value>::type> {
public:void printIfHasValue() {std::cout << "T has value type member." << std::endl;}
};// 特化 Widget，当T没有value_type时
template<typename T>
class Widget<T, typename std::enable_if<!has_value_type<T>::value>::type> {
public:void print() {std::cout << "This type doesn't have a value_type member." << std::endl;}
};int main() {Widget<StructWithValue> wa;wa.printIfHasValue(); // 正确: T是有值类型成员的结构体Widget<StructWithoutValue> wb;wb.print(); // 输出: This type doesn't have a value_type member.return 0;
}

多模版参数处理

template <typename T, typename U,bool DeviceType>，有时需要template <typename T, typename U, typename D,bool DeviceType>,怎么设计呢？

1特化：

#include <iostream>
#include <type_traits>// 主模板，使用 std::conditional 选取 D 类型
template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate;// 特化，处理只有两个类型和布尔值的情况
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, void> {
public:void print() {std::cout << "Using template with two types (T, U) and a bool." << std::endl;}
};// 特化，处理带有第三个类型 D 的情况
template <typename T, typename U, typename D, bool DeviceType>
class MyTemplate<T, U, DeviceType, D> {
public:void print() {std::cout << "Using template with two types (T, U), an additional type (D), and a bool." << std::endl;}
};int main() {MyTemplate<int, double, true> instance1;  // 使用两个类型的模板instance1.print();MyTemplate<int, double, true, char> instance2;  // 使用三个类型的模板instance2.print();return 0;
}

特化二：

#include <iostream>
#include <type_traits>// 基本模板，两个类型和一个布尔值
template <typename T, typename U, typename D = void, bool DeviceType = false>
class MyTemplate {
public:void print() {std::cout << "Using template with T, U, D (defaulted), and DeviceType." << std::endl;}
};// 特化版本，当 D 不是 void 时
template <typename T, typename U, typename D>
class MyTemplate<T, U, D, true> {
public:void print() {std::cout << "Using template with T, U, and a third type D, with DeviceType set to true." << std::endl;}
};int main() {MyTemplate<int, double> myInstance1; // 使用默认的D为void，DeviceType为falsemyInstance1.print();MyTemplate<int, double, char, true> myInstance2; // 指定了D和DeviceTypemyInstance2.print();return 0;
}

 

当您希望根据条件选择不同数量的模板参数时，一种常见的方法是使用递归模板或辅助结构如类型特征来处理这种情况。然而，对于您提出的特定需求（即有条件地在模板中使用额外的类型参数），一种实际的方法是使用模板偏特化和默认模板参数联合使用，但不能通过改变参数数量的方式来实现。

下面我们将使用默认模板参数和SFINAE（Substitution Failure Is Not An Error）技巧来提供一个解决方案。

方案说明

一个更实用的方法是设计一个包裹类型或使用一个已经存在的如 std::enable_if，std::conditional 或自定义类型特征来根据条件启用或禁用第三个类型参数。但对于直接添加或移除模板参数，在C++模板中这是不可能实现的。取而代之的是，我们可以按需使用第三个类型参数，让它在某些情况下为 void 类型或其他不影响的类型。

改进后的例子

考虑到上述限制，如果我们要实现一个这样的结构，我们必须以稍微不同的方式思考。以下是一种使用 std::conditional 来选择第三个参数是一个有效类型还是 void 的方法。此方法并不完美，但展示了如何基于给定的布尔值 DeviceType 来静态选择类型。

#include <iostream>
#include <type_traits>template <typename T, typename U, bool DeviceType, typename D = void>
class MyTemplate {
public:using ConditionallyEnabledType = typename std::conditional<DeviceType, D, void>::type;void print() {if constexpr (std::is_same<ConditionallyEnabledType, void>::value) {std::cout << "Template with T, U, and DeviceType, D is void." << std::endl;} else {std::cout << "Template with T, U, DeviceType and D as an additional type." << std::endl;}}
};int main() {MyTemplate<int, double, false> myInstance1; // D will be considered voidmyInstance1.print();MyTemplate<int, double, true, char> myInstance2; // D will be enabled as 'char'myInstance2.print();return 0;
}

 

为什么不完美？

你的代码使用了模板的SFINAE（Substitution Failure Is Not An Error）技术，来根据编译时的条件（是否指定了类型参数D）来选择性地启用某个类型。这个设计对于特定模板类的某些条件来说是有效的，但有几个潜在的问题和局限性需要注意：

  1. 模板参数默认值不完整：你的模板参数D默认值是void，这会导致在某些情况下不完全匹配预期行为。如果DeviceType为false，你默认没有为D提供任何类型信息，这使得编译器难以解析你的模板，因为它无法确定哪个类型是默认的。虽然你的代码可能能够编译成功，但这种不明确性可能会导致混淆或误解。通常更好的做法是明确指定所有模板参数的类型，即使它们有默认值。

  2. 模板参数不完整：你的模板类依赖于一个布尔值来决定是否启用某个类型，这种设计对于特定的用例可能是有效的，但它限制了模板的灵活性。如果模板设计用于更广泛的用途，可能需要更复杂的逻辑来根据多个条件启用或禁用类型。此外，使用布尔值作为模板参数通常不是一个好的做法，因为它增加了代码与特定编译逻辑的耦合性。更常见的是使用条件模板或别名来达成同样的效果。

针对这些问题，一个改进的方式是重新定义模板以考虑所有的参数依赖和上下文，比如：

template <typename T, typename U> // 无需显式的DeviceType和D类型参数，因为这些可以作为函数内部逻辑的一部分处理
class MyTemplate {
public:template <typename D = void> // 使用默认模板参数来处理可能的额外类型Dvoid print() { // 此函数将根据是否提供了额外的类型D来处理不同的逻辑if constexpr (std::is_void<D>::value) { // 使用std::is_void而不是直接比较来检查类型是否为voidstd::cout << "Template with T and U." << std::endl; // 根据是否提供了额外的类型输出不同的消息} else {std::cout << "Template with T, U, and additional type D." << std::endl;}}
};
```在这个修改中，`DeviceType`是隐藏在逻辑内部而不作为一个独立的模板参数出现的。我们通过将布尔值与`void`进行比较（如检查类型是否为void），或者在编译器基于上下文的情境中创建内部函数而不是完整的独立参数集来解决前面的问题。然而这种方式虽然避免了对非用户直接参与的中间类型的直接引用，但它仍然依赖于特定的编译逻辑来根据条件启用或禁用某些功能。在设计复杂的模板时，需要权衡灵活性和清晰度之间的权衡。

#include <iostream>
#include <type_traits>struct Color {};// 假设 Linear 是某种类型
struct Gray {};// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:template <typename D = Gray> //默认void print() {if constexpr (std::is_same_v<D, Color>) {std::cout << "Template with T and U." << std::endl;}else {std::cout << "Template with T, U, and additional type D." << std::endl;}}
};int main() {// 使用基本模板实例化，T = int, U = floatMyTemplate<int, float> myTemplate1;myTemplate1.print();  // 输出：Template with T, U, and additional type D.// 使用额外的类型D，这里我们指定为LinearmyTemplate1.print<Color>();  // 输出：Template with T and U.// 另一个实例化，使用不同的类型MyTemplate<double, char> myTemplate2;myTemplate2.print();  // 输出：Template with T, U, and additional type D.// 继续使用额外的类型myTemplate2.print<Gray>();  // 输出：Template with T and U.return 0;
}

上面程序只判断一层模版，如果判断多层模版呢？

#include <iostream>
#include <type_traits>struct dim3
{};struct dim2
{};struct Color {};// 假设 Linear 是某种类型
struct Gray {};// 模板类定义
template <typename T, typename U>
class MyTemplate {
public:template <typename D = Gray> //默认void print() {if constexpr (std::is_same_v<D, Color> && std::is_same_v<U, dim3>) {std::cout << "Template with T and U." << std::endl;}else {std::cout << "Template with T, U, and additional type D." << std::endl;}}
};int main() {// 使用基本模板实例化，T = int, U = floatMyTemplate<int, dim3> myTemplate1;myTemplate1.print();  // 输出：Template with T, U, and additional type D.// 使用额外的类型D，这里我们指定为LinearmyTemplate1.print<Color>();  // 输出：Template with T and U.// 另一个实例化，使用不同的类型MyTemplate<double, char> myTemplate2;myTemplate2.print();  // 输出：Template with T, U, and additional type D.// 继续使用额外的类型myTemplate2.print<Gray>();  // 输出：Template with T and U.MyTemplate<double, dim3> myTemplate3;myTemplate3.print<Color>();  // 输出：Template with T, U, and additional type D.return 0;
}

使用变参模板

另一种方式是使用变参模板。这种方法允许更灵活的参数数量和类型。下面的示例展示了如何设计可以接受不同参数数量的模板：

#include <iostream>
#include <type_traits>// 基本模板定义
template <typename T, typename U, bool DeviceType, bool HasExtraType = false, typename... Args>
class MyTemplate;// 特化版本，仅基于两种类型和布尔值
template <typename T, typename U, bool DeviceType>
class MyTemplate<T, U, DeviceType, false> {
public:void print() {std::cout << "Using template with two types and a bool." << std::endl;}
};// 特化版本，带有额外类型参数
template <typename T, typename U, bool DeviceType, typename... Args>
class MyTemplate<T, U, DeviceType, true, Args...> {
public:void print() {std::cout << "Using template with two types, one additional type, and a bool." << std::endl;}
};int main() {MyTemplate<int, double, true> myInstance1;myInstance1.print(); // 将调用第一个特化版本MyTemplate<int, double, true, true, char> myInstance2; // 需要明确指定有额外类型myInstance2.print(); // 将调用第二个特化版本return 0;
}

 

 功能：指定类型才能调用成员函数

  typename std::enable_if<std::is_same<D, Dim2>::value>::type 是 C++ 中一种常用的 SFINAE（Substitution Failure Is Not An Error）技术，主要用于条件性地启用或禁用模板函数。让我们逐步解析这个表达式。

逐步解析

  1. std::is_same<D, Dim2>::value：

    • std::is_same 是 C++ 标准库中的一个类型特性，它用于检查两个类型是否相同。
    • std::is_same<D, Dim2>::value 将返回一个布尔值：如果 D 是 Dim2 类型，则为 true；否则为 false。

  2. std::enable_if：

    • std::enable_if 是一个模板类，它的作用是在满足特定条件时定义类型，同时在不满足条件时不定义类型。
    • std::enable_if<Condition, T>::type 的逻辑是：
      • 如果 Condition 为 true，那么 std::enable_if 将定义一个类型 T。
      • 如果 Condition 为 false，则不定义这个类型，并导致 SFINAE（替代失败不是错误）。

  3. typename std::enable_if<std::is_same<D, Dim2>::value>::type：

    • 如果 std::is_same<D, Dim2>::value 为 true，enable_if 会定义一个类型，并通过 typename 关键字进行引用。通常，这个类型会被设为 void（默认）。
    • 如果条件不成立（即 D 不是 Dim2），那么这个类型不会被定义，导致这一重载函数在不满足的情况下被排除。

用法示例

在模板函数中使用这个技术的目的是：

  • 条件编译：使得某个特定的函数重载只有在某些情况下可用。
#include <iostream>
#include <type_traits>struct Dim2 {};
struct Dim3 {};class Resizer {
public:// 当 D 为 Dim2 时有效template<typename D>typename std::enable_if<std::is_same<D, Dim2>::value>::typeresize() {std::cout << "Resizing for Dim2!" << std::endl;}// 当 D 为 Dim3 时有效template<typename D>typename std::enable_if<std::is_same<D, Dim3>::value>::typeresize() {std::cout << "Resizing for Dim3!" << std::endl;}
};int main() {Resizer resizer;resizer.resize<Dim2>(); // 输出: Resizing for Dim2!resizer.resize<Dim3>(); // 输出: Resizing for Dim3!// resizer.resize<int>(); // 如果取消注释，这将导致编译错误return 0;
}

总结

      通过 std::enable_if，可以实现特定条件下的函数重载功能。在这个例子中，resize 函数的版本只有在模板参数 D 为 Dim2 或 Dim3 时才是可用的。其他类型（如 int）将导致编译错误，而不会使程序崩溃或其他运行时错误，有效地增强了类型安全性。

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

如若内容造成侵权/违法违规/事实不符，请联系一条长河网进行投诉反馈，一经查实，立即删除！

相关文章

代码随想录算法训练营第40天 动态规划part07| 题目： 198.打家劫舍 、 213.打家劫舍II 、 337.打家劫舍III

代码随想录算法训练营第40天 动态规划part07| 题目： 198.打家劫舍 、 213.打家劫舍II 、 337.打家劫舍III

代码随想录算法训练营第40天 动态规划part07| 题目&#xff1a; 198.打家劫舍 、 213.打家劫舍II 、37.打家劫舍III 文章来源&#xff1a;代码随想录 题目名称&#xff1a;198.打家劫舍 你是一个专业的小偷&#xff0c;计划偷窃沿街的房屋。每间房内都藏有一定的现金&#xff…
阅读更多...
青柠视频云——如何开启HTTPS服务?

青柠视频云——如何开启HTTPS服务?

前言 由于青柠视频云的语音对讲会使用到HTTPS服务&#xff0c;这里我们说一下如何申请证书以及如何在实战中部署并且配置使用。 一、证书申请 1、进入控制台 我们拿阿里云的免费个人证书为例&#xff0c;首先登录阿里云&#xff0c;在控制台找到数字证书管理服务&#xff0c;进…
阅读更多...
web基础—dvwa靶场（九）Weak Session IDs

web基础—dvwa靶场（九）Weak Session IDs

Weak Session IDs&#xff08;弱会话&#xff09; Weak Session IDs&#xff08;弱会话&#xff09;&#xff0c;用户访问服务器的时候&#xff0c;一般服务器都会分配一个身份证 session id 给用户&#xff0c;用于标识。用户拿到 session id 后就会保存到 cookies 上&#x…
阅读更多...
运动规划第二节【深蓝学院，高飞】笔记

运动规划第二节【深蓝学院，高飞】笔记

文章目录 Graph Search BasisConfiguration SpaceConfiguration Space ObstacleWorkspace and Configuration Space Obstacle Graph and Search MethodGraph Search OverviewGraph TraversalBreadth First Search (BFS)Depth First Search (DFS)versus Heuristic SearchGreedy …
阅读更多...
关于安卓App自动化测试的一些想法

关于安卓App自动化测试的一些想法

安卓App自动化一般使用PythonAppium。页面元素通常是使用AndroidStudio中的UI Automator Viewer工具来进行页面元素的追踪。但是这里涉及到一个问题就是&#xff0c;安卓apk在每次打包的时候&#xff0c;会进行页面的混淆以及加固&#xff0c;所以导致每次apk打包之后会出现页面…
阅读更多...
强弱电的基本知识和区别

强弱电的基本知识和区别

什么是弱电&#xff1a; 弱电一般是指直流电路或音频、视频线路、网络线路、电话线路&#xff0c;直流电压一般在36V以内。家用电器中的电话、电脑、电视机的信号输入&#xff08;有线电视线路&#xff09;、音响设备&#xff08;输出端线路&#xff09;等用电器均为弱电电气设…
阅读更多...
2024年软考——系统集成项目管理工程师30天冲刺学习指南！！！

2024年软考——系统集成项目管理工程师30天冲刺学习指南！！！

距离2024下半年软考已经只剩一个多月了&#xff0c;还没有开始备考的小伙伴赶紧行动起来。为了帮助大家更好的冲刺学习&#xff0c;特此提供一份考前30天学习指南。本指南包括考情分析、学习规划、冲刺攻略三个部分&#xff0c;可以参考此指南进行最后的复习要领&#xff0c;相…
阅读更多...
如何配置 谷歌Gmail邮箱 开启SMTP/IMAP服务流程

如何配置 谷歌Gmail邮箱 开启SMTP/IMAP服务流程

本篇专门定向讲解谷歌Gmail邮箱&#xff0c;如何开通SMTP协议的流程&#xff0c;在讲篇幅前&#xff0c;我需要你确定3件事&#xff1a; 1.你已经有谷歌账号了 2.你很清楚自己为什么想要开通SMTP服务 3.你已经掌握一定的基础知识&#xff0c;能够达到翻出了 谷歌Gmail邮箱开启S…
阅读更多...
什么是HTTP DDOS，如何防护

什么是HTTP DDOS，如何防护

在当今高度互联的网络世界中&#xff0c;网络安全威胁日益严峻&#xff0c;其中HTTP DDoS&#xff08;Distributed Denial of Service&#xff0c;分布式拒绝服务&#xff09;攻击作为一种常见的网络攻击手段&#xff0c;给企业和个人用户带来了巨大的挑战。今天我们就来详细介…
阅读更多...
react hooks--useCallback

react hooks--useCallback

概述 useCallback缓存的是一个函数&#xff0c;主要用于性能优化!!! 基本用法 如何进行性能的优化呢&#xff1f; useCallback会返回一个函数的 memoized&#xff08;记忆的&#xff09; 值&#xff1b;在依赖不变的情况下&#xff0c;多次定义的时候&#xff0c;返回的值是…
阅读更多...
基于PHP的新闻管理系统

基于PHP的新闻管理系统

作者&#xff1a;计算机学姐 开发技术&#xff1a;SpringBoot、SSM、Vue、MySQL、JSP、ElementUI、Python、小程序等&#xff0c;“文末源码”。 专栏推荐&#xff1a;前后端分离项目源码、SpringBoot项目源码、SSM项目源码 系统展示 【2025最新】基于phpMySQL的新闻管理系统。…
阅读更多...
谈勒索攻击 — 趋势、手法、应对

谈勒索攻击 — 趋势、手法、应对

就在近日&#xff0c;鸿海集团旗下半导体设备大厂——京鼎精密科技股份有限公司&#xff08;以下简称“京鼎”&#xff09;遭到了黑客的入侵。黑客在京鼎官网公布信息直接威胁京鼎客户与员工&#xff0c;如果京鼎不支付赎金&#xff0c;客户资料将会被公开&#xff0c;员工也将…
阅读更多...
list(一)

list(一)

list是可以在常数范围内在任意位置进行插入和删除的序列式容器&#xff0c;并且该容器可以前后双向迭代。list的底层是双向链表结构&#xff0c;双向链表中每个元素存储在互不相关的独立节点中&#xff0c;在节点中通过指针指向 其前一个元素和后一个元素。 支持 -- 但是不支持…
阅读更多...
3 种自然语言处理(NLP)技术：RNN、Transformers、BERT

3 种自然语言处理(NLP)技术：RNN、Transformers、BERT

自然语言处理 (NLP) 是人工智能的一个领域&#xff0c;旨在使机器能够理解文本数据。NLP 研究由来已久&#xff0c;但直到最近&#xff0c;随着大数据和更高计算处理能力的引入&#xff0c;它才变得更加突出。 随着 NLP 领域的规模越来越大&#xff0c;许多研究人员都试图提高…
阅读更多...
大数据-141 - ClickHouse 集群 副本和分片 Zk 的配置 Replicated MergeTree原理详解

大数据-141 - ClickHouse 集群 副本和分片 Zk 的配置 Replicated MergeTree原理详解

点一下关注吧&#xff01;&#xff01;&#xff01;非常感谢&#xff01;&#xff01;持续更新&#xff01;&#xff01;&#xff01; 目前已经更新到了&#xff1a; Hadoop&#xff08;已更完&#xff09;HDFS&#xff08;已更完&#xff09;MapReduce&#xff08;已更完&am…
阅读更多...
python | x-y 网格切片

python | x-y 网格切片

写在前面 通常&#xff0c; 我们处理的毕竟完善的nc产品&#xff0c;一般呈现未timexlatxlon的维度&#xff0c;且lon和lat都是规则的网格&#xff0c;我们可以方便的使用xarray.sel()选择合适的区域进行切片。但是&#xff0c;部分nc产品比如卫星轨道或者模式输出的数据&…
阅读更多...
二、编译原理-词法分析

二、编译原理-词法分析

一、词法分析器的作用 1、词法分析器的作用 读入字符流&#xff0c;组成词素&#xff0c;输出词法单元序列 过滤空白、换行、制表符、注释等 将词素添加到符号表中&#xff0c;以便编译的各个阶段取用 2、词法单元、模式、词素 &#xff08;1&#xff09;词法单元 (token…
阅读更多...
NLP开端：Tokenizer-文本向量化

NLP开端：Tokenizer-文本向量化

Tokenizer 问题背景 An was a algorithm engineer 如上所示&#xff0c;在自然语言处理任务中&#xff0c;通常输入处理的数据是原始文本。但是算法模型自能处理数值类型&#xff0c;因此需要找到一种方法&#xff0c;将原始的文本数据转换为数值类型的数据。这就是分词器所…
阅读更多...
Java 方法重写（难）

Java 方法重写（难）

目录 1&#xff0e;A类和B类都写一个相同的方法&#xff0c;先用static&#xff0c;两边都是一样的&#xff1a; 2&#xff0e;A类和B类都去掉static&#xff0c;出现了两个圆圈的符号&#xff0c;代表重写&#xff1a; 3&#xff0e;总结 4&#xff0e;为什么需要重写&…
阅读更多...
thinkPHP 8.0.4 安装

thinkPHP 8.0.4 安装

windows 上安装最新版 thinkPHP8.0.4 下载phpStudy V8.1&#xff1a;小皮面板安装Composer2.x&#xff0c;Composer是PHP的一个依赖管理工具&#xff0c;主要功能包括依赖管理、版本控制、自动加载、扩展开发以及集成其他工具。安装 php8.0.2 4. 网站-管理-compose&#xff0c…
阅读更多...
最新文章

Copyright @ 2022~2023