GPT代码记录

news2024/9/21 12:21:59 
#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 MyTypeA
	templateFunction(myObjB);  // 输出: Processing MyTypeB
	templateFunction(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为false
	myInstance1.print();

	MyTemplate<int, double, char, true> myInstance2; // 指定了D和DeviceType
	myInstance2.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 void
    myInstance1.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> // 使用默认模板参数来处理可能的额外类型D
    void print() { // 此函数将根据是否提供了额外的类型D来处理不同的逻辑
        if constexpr (std::is_void<D>::value) { // 使用std::is_void而不是直接比较来检查类型是否为void
            std::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 = float
	MyTemplate<int, float> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.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 = float
	MyTemplate<int, dim3> myTemplate1;
	myTemplate1.print();  // 输出：Template with T, U, and additional type D.

	// 使用额外的类型D，这里我们指定为Linear
	myTemplate1.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;
}

 

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

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

相关文章

收集松果-第15届蓝桥省赛Scratch中级组真题第4题

收集松果-第15届蓝桥省赛Scratch中级组真题第4题

[导读]&#xff1a;超平老师的《Scratch蓝桥杯真题解析100讲》已经全部完成&#xff0c;后续会不定期解读蓝桥杯真题&#xff0c;这是Scratch蓝桥杯真题解析第189讲。 如果想持续关注Scratch蓝桥真题解读&#xff0c;可以点击《Scratch蓝桥杯历年真题》并订阅合集&#xff0c;…
阅读更多...
我的AI工具箱Tauri版-FunAsr音频转文本

我的AI工具箱Tauri版-FunAsr音频转文本

本教程基于自研的AI工具箱Tauri版进行FunAsr音频转文本服务。 FunAsr音频转文本服务 是自研AI工具箱Tauri版中的一个高效模块&#xff0c;专为将音频或视频中的语音内容自动转化为文本或字幕而设计。用户只需简单配置输入、输出路径&#xff0c;即可通过FunAsr工具快速批量处理…
阅读更多...
教你把PDF电子画册加背景音乐

教你把PDF电子画册加背景音乐

​如何让您的PDF电子画册更具吸引力&#xff0c;让人一眼就能爱上它呢&#xff1f;答案就是为画册添加背景音乐&#xff01;添加背景音乐的PDF电子画册相较于普通画册&#xff0c;更能吸引读者的注意力&#xff0c;提升阅读体验。那么&#xff0c;如何为PDF电子画册添加背景音乐…
阅读更多...
杭电OJ1009——猫鼠交换问题

杭电OJ1009——猫鼠交换问题

杭电的OJ居然通不过<bits/stdc.h>这个头文件&#xff0c;需要小心 提供一个翻译版本 这里给两个版本 简单贪心拿下 //#include<bits/stdc.h> #include<iostream> #include<algorithm> using namespace std; struct Node{double j,f,p;//p是单价 }a[…
阅读更多...
29. 查看threejs自带几何体顶点

29. 查看threejs自带几何体顶点

查看three.js自带几何体顶点结构&#xff0c;基类(父类)BufferGeometry three.js提供的矩形平面PlaneGeometry、长方体BoxGeometry、球体SphereGeometry等各种形状的几何体&#xff0c;他们都有一个共同的父类BufferGeometry。这意味着这些几何体有哪些属性或方法&#xff0c;…
阅读更多...
Java进阶之集合框架(Set)

Java进阶之集合框架(Set)

【基本内容】 二、Set接口(接上一章) Set是Java集合框架中不允许有重复元素的无序集合&#xff0c;其典型的实现类是HashSet&#xff0c;它完全是遵循Set接口特性规范实现的&#xff0c;无序且不允许元素重复&#xff1b;而Set接口下的实现类还有LinkedHashSet和TreeSort&#…
阅读更多...
Submariner 部署全过程

Submariner 部署全过程

Submariner 部署全过程 部署集群配置 broker 集群&#xff1a; pod-cidr&#xff1a;11.244.0.0/16 service-cidr 11.96.0.0/12 broker 172.100.0.109 node 172.100.0.108 集群 1&#xff08; pve3 &#xff09;&#xff1a; pod-cidr&#xff1a;10.244.0.0/16 service-…
阅读更多...
nodejs 011: nodejs事件驱动编程 EventEmitter 与 IPC

nodejs 011: nodejs事件驱动编程 EventEmitter 与 IPC

在 Node.js 和许多 JavaScript 环境中&#xff0c;EventEmitter 是一个非常重要的类&#xff0c;用于处理事件驱动编程。EventEmitter 是一个能够发射&#xff08;emit&#xff09;和监听&#xff08;on&#xff09;事件的对象。它常用于创建和处理事件机制&#xff0c;使得程序…
阅读更多...
Dubbo与SpringCloud的区别和优缺点

Dubbo与SpringCloud的区别和优缺点

经常会有同学问我&#xff0c;Dubbo和SpringCloud的选择。甚至也经常会有面试官就这个问题刨根问底。 说实话&#xff0c;其实我不太喜欢回答这个问题&#xff0c;本质上来讲&#xff0c;Dubbo的SpringCloud可以算是完全不同赛道的两种东西&#xff0c;就好像问大家西瓜和土豆我…
阅读更多...
【Java】多线程前置知识 初识Thread

【Java】多线程前置知识 初识Thread

多线程前置知识 & 初识Thread 冯诺依曼体系结构初步认识存储设备CPU指令 操作系统初识操作系统内核态和用户态 进程/任务进程是什么进程的管理进程的调度虚拟内存地址进程间的通信 线程线程的出现线程是什么线程可能出现的问题线程与进程的联系和区别 协程初识Thread类Thre…
阅读更多...
VSCode引用Eigen库无法识别问题解决

VSCode引用Eigen库无法识别问题解决

VSCode引用Eigen库无法识别问题解决 问题解决 问题 在Ubuntu下使用vscode开发C/C项目时引用了Eigen库&#xff0c;出现Eigen::Vector3d无法识别的问题&#xff0c;提示"no definition found for Vector3d"。但是程序可以正常编译通过。 解决 将 intelli Sense Engi…
阅读更多...
【学习资料】袋中共36个球，红白黑格12个，问能一次抽到3个红4个白5个黑的概率是多少？

【学习资料】袋中共36个球，红白黑格12个，问能一次抽到3个红4个白5个黑的概率是多少？

1、公式计算 1.1 题目1 袋中共 36 36 36个球&#xff0c; 红 \fcolorbox{red}{#FADADE}{\color{red}{红}} 红​ 白 \fcolorbox{white}{#808080}{\color{white}{白}} 白​ 黑 \fcolorbox{#808080}{#0D0D0D}{\color{#808080}{黑}} 黑​各 12 12 12个&#xff0c;问能一次抽到 3…
阅读更多...
事件循环异步代码输出顺序题目【基础考核】

事件循环异步代码输出顺序题目【基础考核】

简单的事件循环&#xff0c;一道异步代码执行输出顺序问题? 第一题 setTimeout(() > {console.log("A")Promise.resolve().then(() > { console.log("B"); });}, 1000);Promise.resolve().then(() > { console.log("c"); });new Prom…
阅读更多...
JSON.parseArray 内存溢出

JSON.parseArray 内存溢出

实际上我的JSON如下&#xff1a; 如果用以下代码&#xff1a;JVM的内存直接飙到内存溢出&#xff0c;报错OutOfMemoryError: Java heap space Object oo JSON.parseArray(json, TestVo.class) 如果我换成了这样&#xff0c;就没事&#xff1a; Object oo JSON.parseObject(…
阅读更多...
1.2 测试基础

1.2 测试基础

欢迎大家订阅【软件测试】 专栏&#xff0c;开启你的软件测试学习之旅&#xff01; 文章目录 前言1 测试分类1.1 按生产阶段划分1.2 按代码可见度划分1.3 其他测试 2 质量模型 前言 在软件开发过程中&#xff0c;测试是确保产品质量的重要环节。本文详细讲解了软件测试分类以及…
阅读更多...
Python Email库：发送与接收邮件完整指南！

Python Email库：发送与接收邮件完整指南！

Python Email库如何集成&#xff1f;怎么优化Python Email库性能&#xff1f; Python作为一种强大的编程语言&#xff0c;提供了丰富的库来处理电子邮件&#xff0c;其中最著名的就是Python Email库。AokSend将深入探讨如何使用Python Email库来发送和接收邮件&#xff0c;帮助…
阅读更多...
SpringCloud config native 配置

SpringCloud config native 配置

SpringCloud config native 配置 1.概述 最近项目使用springCloud 框架&#xff0c;使用config搭建git作为配置中心。 在私有化部署中&#xff0c;出现很多比较麻烦的和鸡肋的设计。 每次部署都需要安装gitlab 有些环境安装完gitlab&#xff0c;外面不能访问&#xff0c;不给开…
阅读更多...
适合运动的骨传导耳机哪款好？分享五款性能卓越骨传导耳机

适合运动的骨传导耳机哪款好？分享五款性能卓越骨传导耳机

面对琳琅满目的骨传导耳机市场&#xff0c;是不是既兴奋又迷茫&#xff1f;别怕&#xff0c;我来给你支几招&#xff01;选耳机&#xff0c;最重要的是适合自己&#xff0c;别被各种噱头和价格差异绕晕了头。价格高低与品质好坏并非绝对正比&#xff0c;关键看性价比和个人需求…
阅读更多...
Google SERP API 对接说明

Google SERP API 对接说明

Google SERP API 对接说明 Google SERP&#xff08;Search Engine Results Page&#xff09;是用户在Google搜索引擎中输入查询后看到的结果页面。它显示自然搜索结果、广告、特色摘要、知识图谱以及图片、视频等多种内容&#xff0c;旨在为用户提供最相关的信息。 本文将详细…
阅读更多...
物联网开发+充电桩管理系统+充电桩系统源码

物联网开发+充电桩管理系统+充电桩系统源码

简述 SpringBoot 框架&#xff0c;充电桩平台充电桩系统充电平台充电桩互联互通协议云快充协议1.5新能源汽车电动自行车公交车-四轮车充电充电源代码充电平台源码Java源码无加密项目 介绍 云快充协议云快充1.5协议云快充协议开源代码云快充底层协议云快充桩直连桩直连协议充…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023