C/C++ JSON ORM

news2024/9/30 11:36:37
structs
#include "json_struct.h"
#include <vector>

JS_ENUM(Error, None, InvalidRange, IllegalParam, Nullptr, OverLimitLen)
JS_ENUM_DECLARE_STRING_PARSER(Error)

// 搜索匹配区域
struct RangeContent {
    size_t      start;
    size_t      end;
    std::string content;
    JS_OBJ(start, end, content);
};

struct Result {
    Error                   errorCode;
    std::vector<RangeContent> contents;
    JS_OBJECT(JS_MEMBER(errorCode), JS_MEMBER(contents));
};

void test() {
	// 序列
	Result result;
	std::string json = JS::serializeStruct(result, JS::SerializerOptions(JS::SerializerOptions::Compact));
	
	// 反序列
	Result resultNew;
    JS::ParseContext      parseContext(json);
    auto                  error = parseContext.parseTo(resultNew);
    if (JS::Error::NoError != error) {
        std::string errorStr = parseContext.makeErrorString();
        fprintf(stderr, "Error parsing struct %s\n", errorStr.c_str());
    }
}
jsonifier
//
// Created by ws on 2024/8/29.
//
#include <vector>
#include "jsonifier/String.hpp"
#include "jsonifier/Tuple.hpp"
#include "jsonifier/Index.hpp"
#include "jsonifier/Serializer.hpp"
#include "jsonifier/JsonifierCore.hpp"

namespace TestNS {

	struct fixed_object_t {
		std::vector<int32_t> int_array;
		std::vector<float> float_array;
		std::vector<double> double_array;
	};

	struct fixed_name_object_t {
		jsonifier::string name0{};
		jsonifier::string name1{};
		jsonifier::string name2{};
		jsonifier::string name3{};
		jsonifier::string name4{};
	};

	struct nested_object_t {
		std::vector<std::array<double, 3>> v3s{};
		jsonifier::string id{};
	};

	struct another_object_t {
		jsonifier::string string{};
		jsonifier::string another_string{};
		bool boolean{};
		nested_object_t nested_object{};
	};

	struct obj_t {
		fixed_object_t fixed_object{};
		fixed_name_object_t fixed_name_object{};
		another_object_t another_object{};
		std::vector<jsonifier::string> string_array{};
		jsonifier::string string{};
		double Number{};
		bool boolean{};
		bool another_bool{};
	};
}

namespace jsonifier {

	template<> struct core<TestNS::fixed_object_t> {
		using value_type = TestNS::fixed_object_t;
		static constexpr auto parseValue = createValue("int_array", &value_type::int_array, "float_array", &value_type::float_array, "double_array", &value_type::double_array);
	};

	template<> struct core<TestNS::fixed_name_object_t> {
		using value_type = TestNS::fixed_name_object_t;
		static constexpr auto parseValue = createValue("name0", &value_type::name0, "name1", &value_type::name1, "name2", &value_type::name2, "name3", &value_type::name3, "name4", &value_type::name4);
	};

	template<> struct core<TestNS::nested_object_t> {
		using value_type = TestNS::nested_object_t;
		static constexpr auto parseValue = createValue("v3s", &value_type::v3s, "id", &value_type::id);
	};

	template<> struct core<TestNS::another_object_t> {
		using value_type = TestNS::another_object_t;
		static constexpr auto parseValue =
			createValue("string", &value_type::string, "another_string", &value_type::another_string, "boolean", &value_type::boolean, "nested_object", &value_type::nested_object);
	};

	template<> struct core<TestNS::obj_t> {
		using value_type = TestNS::obj_t;
		static constexpr auto parseValue =
			createValue("fixed_object", &value_type::fixed_object, "fixed_name_object", &value_type::fixed_name_object, "another_object", &value_type::another_object, "string_array",
				&value_type::string_array, "string", &value_type::string, "Number", &value_type::Number, "boolean", &value_type::boolean, "another_bool", &value_type::another_bool);
	};
}

int main() {
	jsonifier::jsonifier_core myParser{};

	// jsonifier::string buffer{ json_data };

	TestNS::obj_t obj{};
	obj.string = "hello world";
	obj.Number = 12.33242;

	// Serialize and obtain the serialized JSON string directly.
	jsonifier::serialize_options options;
	options.prettify = true; // Enable prettifying
	options.indentSize = 2; // Set custom prettifyJson options if needed.
	auto stringToWrite = myParser.serializeJson(obj);
	std::cout << stringToWrite << std::endl;


	// Deserialize
	TestNS::obj_t newObj{};
	std::string dataToParse = "{\"Number\":12.33242,\"another_object\":{\"another_string\":\"\",\"boolean\":false,\"nested_object\":{\"id\":\"\",\"v3s\":[]},\"string\":\"\"},\"another_bool\":false,\"boolean\":false,\"fixed_object\":{\"double_array\":[],\"float_array\":[],\"int_array\":[]},\"fixed_name_object\":{\"name0\":\"\",\"name1\":\"\",\"name2\":\"\",\"name3\":\"\",\"name4\":\"\"},\"string_array\":[],\"string\":\"hello world\"}";
	auto result = myParser.parseJson<jsonifier::parse_options{ .validateJson = true, .minified = false }>(newObj, dataToParse);

	std::cout << newObj.string << "   " << newObj.Number << std::endl;
}

{"Number":12.33242,"another_object":{"another_string":"","boolean":false,"nested_object":{"id":"","v3s":[]},"string":""}
,"another_bool":false,"boolean":false,"fixed_object":{"double_array":[],"float_array":[],"int_array":[]},"fixed_name_obj
ect":{"name0":"","name1":"","name2":"","name3":"","name4":""},"string_array":[],"string":"hello world"}
hello world   12.3324 

nlohmann
#include "nlohmann/json.hpp"
using json = nlohmann::json;

template <typename T>
bool json2obj(const char* pcJson, T &out, std::string *err = nullptr)
{
    try {
        out = json::parse(pcJson);
        return true;
    } catch (const json::exception &e) {
        if (err != nullptr)
            *err = e.what();
        return false;
    }
}

enum class Type {
    MAN = 4,
    WONMAN,
    NONE,
};
NLOHMANN_JSON_SERIALIZE_ENUM(Type, {{Type::WONMAN, "WONMAN"}, 
                                      {Type::MAN, "MAN"}, {Type::NONE, "NONE"}, });

struct Value{
    std::optional<bool> isBeyond;//是否超出
    std::optional<Type> type;//类型
};
NLOHMANN_DEFINE_TYPE_NON_INTRUSIVE_WITH_DEFAULT(Value, isBeyond, type)

/* 自定义Key-Value映射解析
inline void to_json(nlohmann::json& j, const Value& t)
{
	j["dataType"] = t.type;
	j["over"] = t.isBeyond;
}

inline void from_json(const nlohmann::json& j, Value& t)
{
	t.type = j["dataType"];
	t.isBeyond = j["over"];
}*/

// json解析
int main() {
	Value value;
    nlohmann::json json_data = value;
	value = json_data;
	// Value value = nlohmann::json::parse(event->argument());
	
	// nlohmann::json json_data = nlohmann::json::parse(json_string);
	// nlohmann::json json_data = json_string;
	// std::string json_string = json_data.dump();
}
draw_json_link
#include <daw/daw_span.h>
#include <daw/daw_tuple_forward.h>
#include <daw/json/daw_json_link.h>
#include <daw/json/daw_json_schema.h>

#include <cassert>
#include <cstdio>
#include <iostream>
#include <map>
#include <string>
#include <tuple>
#include <variant>

struct Bar {
	int a = 9;
	int type = 0;
};

struct Umm {
	double a = 12.1;
	int type = 1;
};

struct Foo {
	int a = 1;
	double b = 2.2;
	std::string c = "3";
	std::vector<int> d = { 1, 2, 3, 4 };
	Bar e;
	std::map<std::string, Bar> f;
	std::map<int, float> g;
	std::variant<int, std::string, bool> h;
	std::variant<int, std::string, bool, Bar, Umm> i;
	std::optional<int> j;
	std::unique_ptr<int[]> l = std::unique_ptr<int[]>( new int[0] );
	int k;
	std::tuple<int, double> m{ 99, 98.8 };
	std::variant<Bar, Umm> n{ Umm{} };
	std::tuple<double, std::string, int, std::variant<Bar, Umm>> o{ 1.1, "2", 1,
	                                                                Umm{} };
};

struct FooBoo {
	int a = 1;
	double b = 2.2;
	std::string_view c = "3";
	Bar e{ };
	std::variant<int, std::string_view, bool> h{ 5 };
	std::variant<int, std::string_view, bool, Bar, Umm> i{ bool{} };
	std::optional<int> j{ };
	int k{ };
	std::tuple<int, double> m{ 99, 98.8 };
	std::variant<Bar, Umm> n{ Umm{} };
	std::tuple<double, std::string_view, int, std::variant<Bar, Umm>> o{
	  1.1, "2", 1, Umm{} };
};

template<typename... Ts>
struct IdentitySwitcher {
	constexpr std::size_t operator( )( std::size_t n ) const {
		assert( n < sizeof...( Ts ) );
		return n;
	}

	inline std::size_t operator( )( Foo const &f ) const {
		return f.i.index( );
	}

	inline std::size_t operator( )( FooBoo const &f ) const {
		return f.i.index( );
	}
};

template<typename T>
struct UniquePtrArrayCtor {
	constexpr std::unique_ptr<T[]> operator( )( ) const {
		return { };
	}

	template<typename Iterator>
	inline std::unique_ptr<T[]> operator( )( Iterator first, Iterator last,
	                                         std::size_t sz ) const {
		auto result = std::unique_ptr<T[]>( new T[static_cast<std::size_t>( sz )] );
		auto out_last = std::copy( first, last, result.get( ) );
		(void)out_last;
		auto const elements_copied = out_last - result.get( );
		(void)elements_copied;
		assert( elements_copied >= 0 );
		assert( static_cast<std::size_t>( elements_copied ) == sz );

		return result;
	}
};

namespace daw::json {
	inline constexpr char const mem_a[] = "a";
	inline constexpr char const mem_b[] = "b";
	inline constexpr char const mem_c[] = "c";
	inline constexpr char const mem_d[] = "d";
	inline constexpr char const mem_e[] = "e";
	inline constexpr char const mem_f[] = "f";
	inline constexpr char const mem_g[] = "g";
	inline constexpr char const gkey[] = "k";
	inline constexpr char const gvalue[] = "v";
	inline constexpr char const mem_h[] = "h";
	inline constexpr char const mem_type[] = "type";
	inline constexpr char const mem_i[] = "i";
	inline constexpr char const mem_j[] = "j";
	inline constexpr char const mem_k[] = "k";
	inline constexpr char const mem_l[] = "l";
	inline constexpr char const mem_m[] = "m";
	inline constexpr char const mem_n[] = "n";
	inline constexpr char const mem_o[] = "o";

	template<>
	struct json_data_contract<Bar> {
		using type = json_tuple_member_list<int, int>;

		static constexpr auto to_json_data( Bar const &b ) {
			return std::forward_as_tuple( b.a, b.type );
		}
	};

	template<>
	struct json_data_contract<Umm> {
		using type = json_tuple_member_list<double, int>;

		static constexpr auto to_json_data( Umm const &b ) {
			return std::forward_as_tuple( b.a, b.type );
		}
	};

	template<>
	struct json_data_contract<Foo> {
		using force_aggregate_construction = void;

		using type = json_member_list<
		  json_link<mem_a, int>, json_link<mem_b, double>,
		  json_link<mem_c, std::string>, json_link<mem_d, std::vector<int>>,
		  json_link<mem_e, Bar>, json_link<mem_f, std::map<std::string, Bar>>,
		  json_key_value_array<mem_g, std::map<int, float>,
		                       json_link<gvalue, float>, json_link<gkey, int>>,
		  json_variant<mem_h, std::variant<int, std::string, bool>>,
		  json_tagged_variant<mem_i, std::variant<int, std::string, bool, Bar, Umm>,
		                      json_link<mem_type, std::size_t>,
		                      IdentitySwitcher<int, std::string, bool, Bar, Umm>>,
		  json_link<mem_j, std::optional<int>>,
		  json_sized_array<mem_l, int, json_link<mem_k, int>,
		                   std::unique_ptr<int[]>, UniquePtrArrayCtor<int>>,
		  json_link<mem_k, int>, json_tuple<mem_m, std::tuple<int, double>>,
		  json_intrusive_variant<mem_n, std::variant<Bar, Umm>,
		                         json_tuple_member<1, std::size_t>,
		                         IdentitySwitcher<Bar, Umm>>,
		  json_tuple<mem_o,
		             std::tuple<double, std::string, int, std::variant<Bar, Umm>>,
		             json_tuple_types_list<
		               double, std::string, int,
		               json_tagged_variant_no_name<
		                 std::variant<Bar, Umm>, json_tuple_member<2, std::size_t>,
		                 IdentitySwitcher<Bar, Umm>>>>>;

		static inline auto to_json_data( Foo const &v ) {
			return daw::forward_nonrvalue_as_tuple(
			  v.a, v.b, v.c, v.d, v.e, v.f, v.g, v.h, v.i, v.j,
			  daw::span( v.l.get( ), static_cast<std::size_t>( v.k ) ), v.k, v.m, v.n,
			  v.o );
		}
	};

	template<>
	struct json_data_contract<FooBoo> {
		using force_aggregate_construction = void;

		using type = json_member_list<
		  json_link<mem_a, int>, json_link<mem_b, double>,
		  json_link<mem_c, std::string_view>, json_link<mem_e, Bar>,
		  json_variant<mem_h, std::variant<int, std::string_view, bool>>,
		  json_tagged_variant<
		    mem_i, std::variant<int, std::string_view, bool, Bar, Umm>,
		    json_link<mem_type, std::size_t>,
		    IdentitySwitcher<int, std::string_view, bool, Bar, Umm>>,
		  json_link<mem_j, std::optional<int>>,

		  json_link<mem_k, int>, json_tuple<mem_m, std::tuple<int, double>>,
		  json_intrusive_variant<mem_n, std::variant<Bar, Umm>,
		                         json_tuple_member<1, std::size_t>,
		                         IdentitySwitcher<Bar, Umm>>,
		  json_tuple<
		    mem_o,
		    std::tuple<double, std::string_view, int, std::variant<Bar, Umm>>,
		    json_tuple_types_list<
		      double, std::string_view, int,
		      json_tagged_variant_no_name<std::variant<Bar, Umm>,
		                                  json_tuple_member<2, std::size_t>,
		                                  IdentitySwitcher<Bar, Umm>>>>>;

		static inline auto to_json_data( FooBoo const &v ) {
			return daw::forward_nonrvalue_as_tuple( v.a, v.b, v.c, v.e, v.h, v.i, v.j,
			                                        v.k, v.m, v.n, v.o );
		}
	};
} // namespace daw::json

int main( ) {
	using namespace daw::json::options;
	std::string result = daw::json::to_json_schema<Foo>(
	  "", "Foo", output_flags<SerializationFormat::Pretty> );
	puts( result.c_str( ) );
	puts( "----\n" );
	std::string json_str1 =
	  daw::json::to_json( Foo{ }, output_flags<SerializationFormat::Pretty> );
	puts( json_str1.c_str( ) );
	puts( "\n----\n\n" );

	auto foo2 = daw::json::from_json<Foo>( json_str1 );
	(void)foo2;

	std::string json_str2 = daw::json::to_json( FooBoo{ } );
	puts( json_str2.c_str( ) );
	auto fooboo = daw::json::from_json<FooBoo>( json_str2 );
	std::cout << "\n----------------------------------------\n"
	          << daw::json::to_json( fooboo ) << '\n';
}
参考

GitHub - RealTimeChris/Jsonifier: A few classes for parsing and serializing objects from/into JSON, in C++ - very rapidly.

GitHub - jorgen/json_struct: json_struct is a single header only C++ library for parsing JSON directly to C++ structs and vice versa

GitHub - nlohmann/json: JSON for Modern C++

 GitHub - beached/daw_json_link: Fast, convenient JSON serialization and parsing in C++

GitHub - stephenberry/json_performance: Performance profiling of JSON libraries

创作不易，小小的支持一下吧！

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

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

相关文章

基于协同过滤与情感分析的酒店评论分析与景区推荐系统实现

基于协同过滤与情感分析的酒店评论分析与景区推荐系统实现

文章目录 有需要本项目的代码或文档以及全部资源&#xff0c;或者部署调试可以私信博主项目介绍系统界面推荐模块主题分类文本可视化每文一语 有需要本项目的代码或文档以及全部资源&#xff0c;或者部署调试可以私信博主 项目介绍 近年来&#xff0c;旅游行业风生水起&#…
阅读更多...
#单片机高级 硬件部分笔记

#单片机高级 硬件部分笔记

课程内容 硬件基础知识PCB基础知识嘉立创EDA&#xff08;专业版&#xff09;软件的安装及使用PCB设计PCB设计规则&#xff08;原理图、布局、布线&#xff09;项目&#xff08;暂定&#xff09; 1、硬件基础 初级硬件工程师 熟练掌握数字电路、模拟电路知识&#xff0c;熟悉常用…
阅读更多...
unity的问题记录（信息管理）

unity的问题记录（信息管理）

闭包 捕获引用&#xff1a;当你在委托或 lambda 表达式中使用外部变量时&#xff0c;它们捕获的是这个变量的引用&#xff0c;而不是当时的值。变量的生命周期&#xff1a;捕获的变量的生命周期不受限于它的作用域&#xff0c;委托可以在变量的作用域结束后继续访问它。 为了…
阅读更多...
今晚8点直播预告——模拟RCT，真实世界研究新方法，快来了解一下吧

今晚8点直播预告——模拟RCT，真实世界研究新方法，快来了解一下吧

这是讲座预告&#xff0c;我们来向大家介绍一下真实世界研究的新方法—模拟RCT&#xff01; 郑老师喜欢交流&#xff0c;于是在2024年&#xff0c;决定邀请各位一起参加统计学沙龙&#xff0c;基本每周一期&#xff0c;欢迎各位朋友来交流、讲课。 本期沙龙&#xff0c;在8月29…
阅读更多...
【ubuntu笔记】拉取docker镜像

【ubuntu笔记】拉取docker镜像

拉取docker镜像 更换国内源 修改配置文件 sudo vim /etc/docker/daemon.json{"registry-mirrors": ["https://ustc-edu-cn.mirror.aliyuncs.com/","https://hub-mirror.c.163.com","https://mirror.baidubce.com","https://cc…
阅读更多...
【Java】Maven多环境切换实战（实操图解）

【Java】Maven多环境切换实战（实操图解）

Java系列文章目录 补充内容 Windows通过SSH连接Linux 第一章 Linux基本命令的学习与Linux历史 文章目录 Java系列文章目录一、前言二、学习内容&#xff1a;三、问题描述四、解决方案&#xff1a;4.1 Maven多环境配置学习4.2 切换环境4.2.1 先打包4.2.2 之后可以切换 五、总结…
阅读更多...
聊聊Netty异常传播链与最佳实践

聊聊Netty异常传播链与最佳实践

写在文章开头 Netty通过责任链的思想解耦了各个业务的处理逻辑，是的用户可以非常方便的根据不同的生命周期进行相应的业务处理。而本文将针对Netty中的异常和异常传播过程进行分析，并给出最佳的处理技巧，希望对你有帮助。 Hi，我是 sharkChili ，是个不断在硬核技术上作死的…
阅读更多...
Electron 项目实战 03: 实现一个截图功能

Electron 项目实战 03: 实现一个截图功能

实现效果 实现思路 创建两个window&#xff0c;一个叫mainWindow&#xff0c;一个叫cutWindowmainWindow&#xff1a;主界面用来展示截图结果cutWindow&#xff1a;截图窗口&#xff0c;加载截图页面和截图交互逻辑mainWindow 页面点击截图&#xff0c;让cutWIndow 来实现具体…
阅读更多...
WEB应用服务器TOMCAT知识点

WEB应用服务器TOMCAT知识点

TOMCAT介绍 Tomcat是一个开源的Java Web应用服务器&#xff0c;主要用于运行Java编写的网站。 Apache Tomcat是由Apache Software Foundation&#xff08;ASF&#xff09;开发的一个开源Java Web应用服务器&#xff0c;最初由Sun Microsystems捐赠给Apache软件基金会&#xf…
阅读更多...
数据结构(Java实现)：栈和队列相关练习题

数据结构(Java实现)：栈和队列相关练习题

文章目录 1. 题目链接2. 题目解析2.1 括号匹配2.2 逆波兰表达式求值2.3 出栈入栈次序匹配2.4 最小栈2.5 环形数组队列2.6 用队列实现栈2.7 用栈实现队列 1. 题目链接 括号匹配逆波兰表达式求值出栈入栈次序匹配最小栈设计循环队列用队列实现栈用栈实现队列 2. 题目解析 2.1 …
阅读更多...
基于RK3568平台移植ffmpeg3.4.5及ffmpeg验证

基于RK3568平台移植ffmpeg3.4.5及ffmpeg验证

目录 一、概述二、环境要求2.1 硬件环境2.2 软件环境三、移植流程3.1 编译x2643.2 编译mpp3.3 编译ffmpeg四、ffmpeg验证4.1 ffmpeg配置说明4.2 ffmpeg推流/拉流使用说明4.2.1 使用http方式推流/拉流4.2.1.1 先执行ffmpeg服务4.2.1.2 再执行ffmpeg进行推流4.2.1.3 最后执行vlc进…
阅读更多...
等保测评中的数据安全保护：重点与挑战

等保测评中的数据安全保护：重点与挑战

在信息安全等级保护&#xff08;等保&#xff09;测评中&#xff0c;数据安全保护是核心关注点之一&#xff0c;它不仅关系到企业的合规性&#xff0c;还直接影响到企业的运营安全和用户信任。本文将深入探讨等保测评中数据安全保护的重点与挑战&#xff0c;为企业提供有效的应…
阅读更多...
JavaScript初级——事件传播

JavaScript初级——事件传播

1、事件的传播 关于事件的传播网景公司和微软公司有不同的理解&#xff1a; 微软公司认为事件应该是由内向外传播&#xff0c;也就是当事件触发时&#xff0c;应该先触发当前元素上的事件&#xff0c;然后再向当前元素的祖先元素上传播&#xff0c;也就说事件应该在冒泡阶段执行…
阅读更多...
如何解决U盘无法压缩卷或删除卷的问题

如何解决U盘无法压缩卷或删除卷的问题

U盘在日常使用中&#xff0c;偶尔会遇到无法压缩卷或删除卷的情况。出现这些问题通常与U盘的磁盘状态或文件系统有关。本文将介绍一种有效的解决方法&#xff0c;通过使用Windows自带的磁盘管理工具diskpart来解决这些问题。 一、问题原因 U盘无法压缩卷或删除卷的常见原因包…
阅读更多...
Nginx部署Vue前端项目全攻略：从构建到上线一步到位！

Nginx部署Vue前端项目全攻略：从构建到上线一步到位！

要将前端 Vue 项目部署到 Nginx&#xff0c;你需要遵循以下步骤&#xff1a; 首先确保你已经安装了 Node.js 和 npm。如果没有&#xff0c;请访问 Node.js 官网 下载并安装。 使用 Vue CLI 创建一个新的 Vue 项目&#xff08;如果你还没有一个&#xff09;&#xff1a; npm i…
阅读更多...
探索未知，悦享惊喜 —— 您的专属盲盒小程序，即将开启奇妙之旅

探索未知，悦享惊喜 —— 您的专属盲盒小程序，即将开启奇妙之旅

在这个充满无限可能的数字时代&#xff0c;每一次点击都可能是通往惊喜的门户。我们匠心打造的“惊喜盲盒”小程序&#xff0c;正是为了给您带来前所未有的娱乐体验与心灵触动。在这里&#xff0c;每一份盲盒都蕴藏着精心挑选的宝藏&#xff0c;等待着与您的不期而遇。 【探索…
阅读更多...
学习bat脚本

学习bat脚本

内容包含一些简单命令或小游戏&#xff0c;在乐趣中学习知识。 使用方法&#xff1a; 新建文本文档&#xff0c;将任选其一代码保存到文档中并保存为ASCII编码。将文件后缀改为.bat或.cmd双击运行即可。 一. 关机脚本 1. 直接关机 echo off shutdown -s -t 00秒直接关机。 2…
阅读更多...
H5手机端调起支付宝app支付

H5手机端调起支付宝app支付

1.调起APP页面如下 步骤 1.让后端对接一下以下文档&#xff08;手机网站支付通过alipays协议唤起支付宝APP&#xff09; https://opendocs.alipay.com/open/203/107091?pathHash45006f4f&refapi 2.后端接口会返回一个form提交表单 html&#xff1a;在页面中定义一个d…
阅读更多...
halcon2

halcon2

halcon自带图片路径 C:\Users\Public\Documents\MVTec\HALCON-18.11-Progress\examples 案例1&#xff1a;blob 固定阈值分割图像-车牌号识别 案例2&#xff1a;blob 动态阈值分割 匹配字母 案例1:打开窗口并画几何图形 &#xff08;ROI 感兴趣区域&#xff09; 并且距离测量…
阅读更多...
IO进程day05（线程、同步、互斥、条件变量、进程间通信IPC）

IO进程day05（线程、同步、互斥、条件变量、进程间通信IPC）

目录 【1】线程 1》什么是线程 1> 概念 2> 进程和线程的区别 3> 线程资源 2》 函数接口 1> 创建线程&#xff1a;pthread_create 2> 退出线程&#xff1a;pthread_exit 3> 回收线程资源 练习1&#xff1a;通过父子进程完成对文件的拷贝&#xff08…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023