str转wstr的三种方法和从网站获取json数据到数据随机提取，返回拼接字符串和动态数组

库的设置 hv库
外部包含目录：…\include\libhv_new\hv;
库目录：…\include\libhv_new\lib\x86\Release;
附加依赖项：hv.lib;

//Get请求 获取json数据，然后提取符合 条件的，time值大于自定义变量的值，然后取出来，再抽取自定义个数，比如3个，把name拼接返回，再把数据放进动态数组也返回，两种类型的返回！23-11-21

#include "requests.h"
#include <unordered_set> 
struct DataItem {
	int id;
	std::wstring name;
	bool isChange;
};
using Json = nlohmann::json;
std::vector<DataItem> dataItems;


struct ServerDataResult {
	std::wstring concatenatedNames;
	std::vector<DataItem> dataItems;
};
//--------------str 转 wstr 的三种方法 -----------------
std::wstring convertToWideString1(const std::string& str) {
	std::wstring wideStr(str.begin(), str.end());
	return wideStr;//构造函数 更简洁
}
std::wstring convertToWideString2(const std::string& str) {
	std::wstring wideStr;
	wideStr.resize(str.size(), L' ');
	std::copy(str.begin(), str.end(), wideStr.begin());
	return wideStr;
}
//-----------------第三种通用，但需要头文件--------------------------
#include <locale>
#include <codecvt>
/*
这种方法使用了 std::wstring_convert 类模板和 std::codecvt_utf8 类模板，它们提供了跨平台的支持，能够在不同的字符编码环境中进行字符串转换。
这里的示例使用了 UTF-8 编码，你可以根据需要选择其他字符编码，如 UTF-16 或 UTF-32。
这种方法的优点是它是标准库提供的通用解决方案，不依赖于特定的平台或编译器。它能够在不同的机器和代码之间保持一致，并且适用于大多数常见的字符编码方案。
*/
std::wstring convertToWideString3(const std::string& str) {
	std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
	return converter.from_bytes(str);
}

std::string convertToNarrowString(const std::wstring& wstr) {
	std::wstring_convert<std::codecvt_utf8<wchar_t>> converter;
	return converter.to_bytes(wstr);
}
//==========================================================================================



std::pair<std::wstring, std::vector<DataItem>> GetServerData(int numNamesToExtract, int times) {
	std::wstring concatenatedNames{};
	std::vector<DataItem> dataItems;
	printf("等待网站返回数据中.....\n");

	// 发起 HTTP 请求获取数据
	requests::Response resp = requests::get("http://124.222.37.232/api/list?ok=1");
	if (resp->status_code != 200) {
		printf("Request failed!\n");
		return std::make_pair(L"", dataItems);
	}

	// 解析返回的JSON
	Json json;
	try {
		json = Json::parse(resp->body);  // 使用 parse() 方法解析 JSON 字符串
	}
	catch (const nlohmann::json::parse_error& e) {
		printf("Failed to parse JSON: %s\n", e.what());
		return std::make_pair(L"", dataItems);
	}
	//===========打印所有数据======
	printf("Complete data:\n");
	printf("%s\n", json.dump().c_str());  // 打印全部网站获取的数据

	// 检查 JSON 数据中的字段
	if (json.is_object() && json.contains("total") && json["total"].is_number()) {
		int total = json["total"];
		printf("Total count: %d\n", total);

		if (json.contains("data") && json["data"].is_array()) {
			const nlohmann::json& dataArray = json["data"];
			srand(static_cast<unsigned int>(time(nullptr)));
			std::vector<const nlohmann::json*> filteredData;

			// 过滤符合条件的数据
			for (const nlohmann::json& item : dataArray) {
				if (item.is_object() && item.contains("name") && item["name"].is_string()
					&& item.contains("time") && item["time"].is_string()) {
					std::string time = item["time"].get<std::string>();
					int timeValue = std::stoi(time);
					if (timeValue < times) {
						filteredData.push_back(&item);
					}
				}
			}

			// 随机选择 numNamesToExtract 个名称
			std::vector<size_t> randomIndices;
			if (filteredData.size() <= static_cast<size_t>(numNamesToExtract)) {
				// 数据量不足 numNamesToExtract 个时，选择全部数据
				for (size_t i = 0; i < filteredData.size(); ++i) {
					randomIndices.push_back(i);
				}
			}
			else {
				// 数据量足够时，随机选择 numNamesToExtract 个索引
				std::unordered_set<size_t> selectedIndices;
				while (selectedIndices.size() < static_cast<size_t>(numNamesToExtract)) {
					size_t randomIndex = rand() % filteredData.size();
					selectedIndices.insert(randomIndex);
				}
				randomIndices.assign(selectedIndices.begin(), selectedIndices.end());
			}

			// 提取名称数据
			for (size_t index : randomIndices) {
				const nlohmann::json& item = *filteredData[index];
				std::string name = item["name"].get<std::string>();
				std::string time = item["time"].get<std::string>();
				std::wstring wideName = convertToWideString3(name);

				DataItem dataItem;
				dataItem.id = static_cast<int>(dataItems.size()) + 1;
				dataItem.name = wideName;
				dataItem.isChange = false;  // 默认设置为 false，因为无法比较之前的数据
				dataItems.push_back(dataItem);

				if (!concatenatedNames.empty()) {
					concatenatedNames += L",";
				}
				concatenatedNames += wideName;
				// 输出 "time" 字段的值进行调试
				printf("Time value: %s\n", time.c_str());
			}

			const wchar_t* tCharStr = concatenatedNames.c_str();
			printf("Concatenated names: %ls\n", tCharStr);
		}
	}
	else {
		printf("Failed to parse 'total' field!\n");
	}

	// 打印 dataItems 中的数据
	printf("DataItems:\n");
	for (const DataItem& item : dataItems) {
		printf("ID: %d, Name: %ls \n", item.id, item.name.c_str());
		// 打印其他字段的值
	}

	return std::make_pair(concatenatedNames, dataItems);
}

int main() {
	int numNamesToExtract = 3;
	int times = 50;

	std::pair<std::wstring, std::vector<DataItem>> result = GetServerData(numNamesToExtract, times);

	std::wstring concatenatedNames = result.first;
	std::vector<DataItem> dataItems = result.second;

	std::wcout << "Concatenated Names: " << concatenatedNames << std::endl;
	for (const auto& item : dataItems) {
		std::wcout << "ID: " << item.id << std::endl;
		std::wcout << "Name: " << item.name << std::endl;
		// 打印其他字段的值
		std::wcout << std::endl;
	}

	return 0;
}