小工具

最新推荐文章于 2023-09-18 20:47:37 发布
最新推荐文章于 2023-09-18 20:47:37 发布
阅读量174 收藏
点赞数
分类专栏： C/C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lightjia/article/details/79897193
版权 
#ifndef __UTIL__H_
#define __UTIL__H_
#include <algorithm>
#include "common.h"

//mem
#define DOFREE(X) do{if(nullptr != X) {free(X); X = nullptr;}}while(0)
#define DODELETE(X) do{if(nullptr != X) {delete X; X = nullptr;}}while(0)
#define BZERO(X) memset(&X, 0, sizeof(X))
void* do_malloc(size_t iLen);

//time
struct systemtime_t get_now_time();
uint64_t get_time_ms();	//获取时间毫秒级
void sleep_ms(DWORD dwMillions);

//thread
DWORD get_thread_id_self();
long atomic_change(volatile long* value, int off);

//strings
bool str_cmp(const char* pStr1, const char* pStr2, bool bIgnoreCase);
int safe_snprintf(char * _DstBuf, size_t _SizeInBytes, size_t _MaxCount, const char * _Format, ...);
bool str_start_with(const std::string& str, const std::string& prefix);
bool str_end_with(const std::string& str, const std::string& suffix);
bool str_cmp_nocase(std::string str1, std::string str2);
std::string& str_ltrim(std::string& str);
std::string& str_rtrim(std::string& str);
std::string& str_trim(std::string& str);
std::string str_2_lower(std::string& str);
std::string str_2_upper(std::string& str);
wchar_t* char_2_wchar(const char* pStr);
char* wchar_2_char(const wchar_t* pStr);
int split_str(std::string strSource, std::string strSep, std::vector<std::string>& vecRet);

//files
FILE* safe_open_file(const char* pFileName, const char* pMode);
len_str get_bmp(const void* pBmp, int width, int height, int bitCount);
const long get_file_len(const char* pFileName, const char* pMode);
size_t file_write(const char* pFileName, const char* pMode, const unsigned char* pData, const size_t iLen);
size_t file_read(const char* pFileName, const char* pMode, unsigned char* pData, const size_t iLen, const long lOffset);
char* file_read(const char* pFileName, const char* pMode, size_t& lLen);
std::string get_app_path();
bool file_exits(const char*  strFileName);
bool directory_exists(const char* strDirectory);
int make_dir(const char* path);	//创建目录
int make_dirs(const char* path);	//创建多层目录
const char* get_flietype(const char *pFileName);

//network
int init_platform();
int uninit_platform();

//error
void perror_desc(const char* pStr);
#endif

 

 


#include "util.h"

void* do_malloc(size_t iLen)
{
	if (iLen <= 0)
	{
		return nullptr;
	}

	void* pRet = nullptr;
	while (nullptr == pRet)
	{
		pRet = malloc(iLen);
	}

	memset(pRet, 0, iLen);
	
#if defined(WIN32) || defined(_WIN32)
	fprintf(stderr, "malloc mem:%I64u\n", iLen);
#elif  __linux__
	fprintf(stderr, "malloc mem:%llu\n", iLen);
#endif
	return pRet;
}

const char* get_flietype(const char *pFileName)
{
	int n = (int)strlen(pFileName);

	if (n < 5)
		return nullptr;

	if (!strcmp(&pFileName[n - 4], ".ico"))
		return "image/x-icon";

	if (!strcmp(&pFileName[n - 4], ".png"))
		return "image/png";

	if (!strcmp(&pFileName[n - 5], ".html"))
		return "text/html";

	if (!strcmp(&pFileName[n - 4], ".css"))
		return "text/css";

	if (!strcmp(&pFileName[n - 3], ".js"))
		return "text/javascript";

	return nullptr;
}

uint64_t get_time_ms()
{
	uint64_t iRet = 0;
#if defined(WIN32) || defined(_WIN32)
	iRet = GetTickCount();
#elif  __linux__
	struct timeval current;
	gettimeofday(&current, nullptr);
	iRet = (uint64_t)(current.tv_sec * 1000) + current.tv_usec/1000;
#endif

	return iRet;
}

void sleep_ms(DWORD dwMillions)
{
#if defined(WIN32) || defined(_WIN32)
	Sleep(dwMillions);
#elif  __linux__
	usleep(dwMillions * 1000);
#endif
}

struct systemtime_t get_now_time()
{
	struct systemtime_t stRet;
	time_t rawtime;
	struct tm tmnow;
#if defined(WIN32) || defined(_WIN32)
	time(&rawtime);
	localtime_s(&tmnow, &rawtime);
	struct timeb tp;
	ftime(&tp);
	stRet.tmmilliseconds = tp.millitm;
#elif  __linux__
	struct timeval tv_now;
	gettimeofday(&tv_now, nullptr);
	rawtime = (time_t)tv_now.tv_sec;
	
	localtime_r(&rawtime, &tmnow);
	stRet.tmmilliseconds = static_cast<int>(tv_now.tv_usec);
#endif

	stRet.tmyear = tmnow.tm_year + 1900;
	stRet.tmmon = tmnow.tm_mon + 1;
	stRet.tmmday = tmnow.tm_mday;
	stRet.tmhour = tmnow.tm_hour;
	stRet.tmmin = tmnow.tm_min;
	stRet.tmsec = tmnow.tm_sec;
	stRet.tmwday = tmnow.tm_wday;
	stRet.tmyday = tmnow.tm_yday;
	stRet.tmisdst = tmnow.tm_isdst;
	
	return stRet;
}

DWORD get_thread_id_self()
{
	DWORD iRet = 0;
#if defined(WIN32) || defined(_WIN32)
	iRet = ::GetCurrentThreadId();
#elif  __linux__
	iRet = pthread_self();
#endif

	return iRet;
}

long atomic_change(volatile long* value, int off)
{
  long lRet = 0;
	if (nullptr != value)
	{
#ifdef _WIN32
    lRet = InterlockedExchangeAdd(value, off);
#elif  __linux__
    lRet = __sync_fetch_and_add(value, off);
#endif
	}

  return lRet;
}

int split_str(std::string strSource, std::string strSep, std::vector<std::string>& vecRet)
{
    size_t i = 0;
    vecRet.clear();
    while (i < strSource.size()) {
        size_t iPos = strSource.find(strSep, i);
        if (iPos == std::string::npos) {
            vecRet.push_back(strSource.substr(i));
            break;
        }
        else {
            vecRet.push_back(strSource.substr(i, iPos - i));
            i = iPos + strSep.size();
        }
    }

    return (int)vecRet.size();
}

bool str_cmp(const char* pStr1, const char* pStr2, bool bIgnoreCase)
{
	if (pStr1 == pStr2)
	{
		return true;
	}

	if (nullptr == pStr1 || nullptr == pStr2)
	{
		return false;
	}

	size_t iLen = strlen(pStr1);
	if (iLen != strlen(pStr2))
	{
		return false;
	}

	for (int i = 0; i <= iLen; ++i)
	{
		char c1 = pStr1[i];
		char c2 = pStr2[i];
		if (bIgnoreCase)
		{
			c1 = toupper(c1);
			c2 = toupper(c2);
		}

		if (c1 != c2)
		{
			return false;
		}
	}

	return true;
}

int safe_snprintf(char * _DstBuf, size_t _SizeInBytes, size_t _MaxCount, const char * _Format, ...)
{
	int iRet = 0;
	va_list ap;
	va_start(ap, _Format);
#if defined(WIN32) || defined(_WIN32)
	iRet = vsnprintf_s(_DstBuf, _SizeInBytes, _MaxCount, _Format, ap);
#elif  __linux__
	iRet = vsnprintf(_DstBuf, _MaxCount, _Format, ap);
#endif
	va_end(ap);
	return iRet;
}

bool str_start_with(const std::string& str, const std::string& prefix)
{
	if (prefix.length() > str.length())
	{
		return false;
	}

	if (memcmp(str.c_str(), prefix.c_str(), prefix.length()) == 0) 
	{
		return true;
	}

	return false;
}

bool str_end_with(const std::string& str, const std::string& suffix)
{
	if (suffix.length() > str.length())
	{
		return false;
	}

	return (str.substr(str.length() - suffix.length()) == suffix);
}

std::string& str_ltrim(std::string& str) 
{ // NOLINT
	std::string::iterator it = find_if(str.begin(), str.end(), (int(*)(int))isspace);
	str.erase(str.begin(), it);
	return str;
}

std::string& str_rtrim(std::string& str) 
{ // NOLINT
	std::string::reverse_iterator it = find_if(str.rbegin(),
		str.rend(), (int(*)(int))isspace);

	str.erase(it.base(), str.end());
	return str;
}

std::string& str_trim(std::string& str) 
{ // NOLINT
	return str_rtrim(str_ltrim(str));
}

std::string str_2_lower(std::string& str)
{
	std::string strRet = str;
	transform(strRet.begin(), strRet.end(), strRet.begin(), (int(*)(int))tolower);
	return strRet;
}

std::string str_2_upper(std::string& str)
{
	std::string strRet = str;
	transform(strRet.begin(), strRet.end(), strRet.begin(), (int(*)(int))toupper);
	return strRet;
}

bool str_cmp_nocase(std::string str1, std::string str2)
{
	std::string strTmp1 = str_2_upper(str1);
	std::string strTmp2 = str_2_upper(str2);

	return strTmp1 == strTmp2;
}

wchar_t* char_2_wchar(const char* pStr)
{
	wchar_t* pRet = nullptr;
	if (nullptr != pStr)
	{
		size_t iLen = strlen(pStr);
		if (iLen > 0)
		{
			iLen += 1;
			fprintf(stderr, "char_2_wchar malloc\n");
			pRet = (wchar_t*)do_malloc(iLen * sizeof(wchar_t));
			if (nullptr != pRet)
			{
#if defined(WIN32) || defined(_WIN32)
				size_t converted = 0;
				mbstowcs_s(&converted, pRet, iLen, pStr, _TRUNCATE);
#elif  __linux__
				mbstowcs(pRet, pStr, iLen - 1);
#endif	
			}	
		}
	}

	return pRet;
}

char* wchar_2_char(const wchar_t* pStr)
{
	char* pRet = nullptr;
	if (nullptr != pStr)
	{
		size_t iLen = wcslen(pStr);
		if (iLen > 0)
		{
			iLen += 1;
			fprintf(stderr, "wchar_2_char malloc\n");
			pRet = (char*)do_malloc(iLen * sizeof(char));
			if (nullptr != pRet)
			{
#if defined(WIN32) || defined(_WIN32)
				size_t converted = 0;
				wcstombs_s(&converted, pRet, iLen, pStr, _TRUNCATE);
#elif  __linux__
				wcstombs(pRet, pStr, iLen - 1);
#endif	
			}
		}
	}

	return pRet;
}

const long get_file_len(const char* pFileName, const char* pMode)
{
	long lRet = 0;
	FILE *pFile = safe_open_file(pFileName, pMode);
	if (nullptr != pFile)
	{
		fseek(pFile, 0L, SEEK_END);
		lRet = ftell(pFile);
		fclose(pFile);
	}
	
	return lRet;
}

size_t file_write(const char* pFileName, const char* pMode, const unsigned char* pData, const size_t iLen)
{
	size_t iWrite = 0;
	do
	{
		if (nullptr == pData || iLen <= 0)
		{
			break;
		}

		FILE *pFile = safe_open_file(pFileName, pMode);
		if (nullptr != pFile)
		{
			while (iWrite < iLen)
			{
				iWrite += fwrite((void*)(pData + iWrite), sizeof(unsigned char), iLen - iWrite, pFile);
			}
			fclose(pFile);
		}
	} while (0);

	return iWrite;
}

size_t file_read(const char* pFileName, const char* pMode, unsigned char* pData, const size_t iLen, const long lOffset)
{
	size_t iRead = 0;
	do
	{
		if (nullptr == pData || iLen <= 0)
		{
			break;
		}

		FILE *pFile = safe_open_file(pFileName, pMode);
		if (nullptr != pFile)
		{
			if (fseek(pFile, lOffset, SEEK_SET) != 0)
			{
				break;
			}

			while (iRead < iLen && !feof(pFile))
			{
				iRead += fread((void*)(pData + iRead), sizeof(unsigned char), 1, pFile);
			}
			fclose(pFile);
		}
	} while (0);

	return iRead;
}

char* file_read(const char* pFileName, const char* pMode, size_t& lLen)
{
	char* pRet = nullptr;
	lLen = get_file_len(pFileName, pMode);
	if (lLen > 0)
	{
		pRet = (char*)do_malloc(lLen);
		if (pRet != nullptr)
		{
			FILE *pFile = safe_open_file(pFileName, pMode);
			if (nullptr != pFile)
			{
				size_t iRead = 0;
				while (iRead < lLen && !feof(pFile))
				{
					iRead += fread((void*)(pRet + iRead), sizeof(char), lLen - iRead, pFile);
				}
				fclose(pFile);
			}
		}
	}

	return pRet;
}

bool file_exits(const char*  strFileName)
{
	bool bRet = false;
#if defined(WIN32) || defined(_WIN32)
	DWORD dwRet = GetFileAttributesA(strFileName);
	bRet = (dwRet != INVALID_FILE_ATTRIBUTES) && (!(dwRet & FILE_ATTRIBUTE_DIRECTORY));
#elif  __linux__
	bRet = (access(strFileName, F_OK) == 0);
#endif
	return bRet;
}

bool directory_exists(const char* strDirectory)
{
	bool bRet = false;
#if defined(WIN32) || defined(_WIN32)
	DWORD dwRet = GetFileAttributesA(strDirectory);
	bRet = (dwRet != INVALID_FILE_ATTRIBUTES) && (dwRet & FILE_ATTRIBUTE_DIRECTORY);
#elif  __linux__
	struct stat sb;
	bRet = (lstat(strDirectory, &sb) == 0 && S_ISDIR(sb.st_mode));
#endif
	return bRet;
}

std::string get_app_path()
{
	std::string strRet = "";
#if defined(WIN32) || defined(_WIN32)
	char szExePath[MAX_PATH] = { 0 };
	GetModuleFileNameA(nullptr, szExePath, MAX_PATH);
	char *pstr = strrchr(szExePath, '\\');
	memset(pstr + 1, '\0', 1);
	strRet = szExePath;
#elif  __linux__
#define MAX_PATH 0x100
	char szFilePath[MAX_PATH];
	int cnt = readlink("/proc/self/exe", szFilePath, MAX_PATH);
	if (cnt < 0 || cnt >= MAX_PATH)
	{
		return strRet;
	}

	for (int i = cnt; i >= 0; --i)
	{
		if (szFilePath[i] == '/')
		{
			szFilePath[i + 1] = '\0';
			break;
		}
	}
	strRet = szFilePath;
#endif
	
	return strRet;
}

FILE* safe_open_file(const char* pFileName, const char* pMode)
{
	FILE* pRet = nullptr;
#if defined(WIN32) || defined(_WIN32)
	/*if (0 != fopen_s(&pRet, pFileName, pMode))
	{
		pRet = nullptr;
	}*/
	//fopen_s(&pRet,pFileName, pMode);
    pRet = fopen(pFileName, pMode);
#elif  __linux__
	pRet = fopen(pFileName, pMode);
#endif

	//设置非缓冲
	if (nullptr != pRet)
	{
		setvbuf(pRet, nullptr, _IONBF, 0);
	}

	return pRet;
}

len_str get_bmp(const void* pBmp, int width, int height, int bitCount)
{
	len_str stImg;
	memset(&stImg, 0, sizeof(len_str));
	if (nullptr == pBmp)
	{
		return stImg;
	}

	int bmp_size = width*height*(bitCount / 8);

	// 【写位图文件头】
	BITMAPFILEHEADER bmpHeader;
	bmpHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + bmp_size;    // BMP图像文件的大小
	bmpHeader.bfType = 0x4D42;    // 位图类别，根据不同的操作系统而不同，在Windows中，此字段的值总为‘BM’
	bmpHeader.bfOffBits = sizeof(BITMAPFILEHEADER)+sizeof(BITMAPINFOHEADER);            // BMP图像数据的偏移位置
	bmpHeader.bfReserved1 = 0;    // 总为0
	bmpHeader.bfReserved2 = 0;    // 总为0

	stImg.iLen = bmpHeader.bfSize;
	fprintf(stderr, "get_bmp malloc\n");
	stImg.pStr = (unsigned char*)do_malloc(sizeof(unsigned char)*bmpHeader.bfSize);
	if (nullptr == stImg.pStr)
	{
		stImg.iLen = 0;
		return stImg;
	}

	size_t iOffset = 0;
	memcpy(stImg.pStr, &bmpHeader, sizeof(bmpHeader));
	iOffset += sizeof(bmpHeader);

	BITMAPINFOHEADER bmiHeader;
	bmiHeader.biSize = sizeof(bmiHeader);                // 本结构所占用字节数，即sizeof(BITMAPINFOHEADER);
	bmiHeader.biWidth = width;                            // 位图宽度（单位：像素）
	bmiHeader.biHeight = height;                        // 位图高度（单位：像素）
	bmiHeader.biPlanes = 1;                                // 目标设备的级别，必须为1
	bmiHeader.biBitCount = bitCount;                    // 像素的位数（每个像素所需的位数，范围：1、4、8、24、32）
	bmiHeader.biCompression = 0;                        // 压缩类型（0：不压缩 1：BI_RLE8压缩类型 2：BI_RLE4压缩类型）
	bmiHeader.biSizeImage = bmp_size;                    // 位图大小（单位：字节）
	bmiHeader.biXPelsPerMeter = 0;                        // 水平分辨率(像素/米)
	bmiHeader.biYPelsPerMeter = 0;                        // 垂直分辨率(像素/米)
	bmiHeader.biClrUsed = 0;                            // 位图实际使用的彩色表中的颜色索引数
	bmiHeader.biClrImportant = 0;                        // 对图象显示有重要影响的颜色索引的数目

	// 【写位图信息头（BITMAPINFO的bmiHeader成员）】
	memcpy(stImg.pStr + iOffset, &bmiHeader, sizeof(bmiHeader));
	iOffset += sizeof(bmiHeader);

	// 【写像素内容】
	memcpy(stImg.pStr + iOffset, pBmp, bmp_size);

	return stImg;
}

int make_dir(const char* path)
{
	if (nullptr == path || strlen(path) <= 0)
	{
		return 1;
	}

	if(directory_exists(path))
	{
		return 0;
	}

#if defined(WIN32) || defined(_WIN32)
	if (!::CreateDirectoryA(path, nullptr))
	{
		return 1;
	}
#elif  __linux__
	if (mkdir(path, 0755) != 0)
	{
		fprintf(stderr, "mkdir %s failed(%s)\n", path, strerror(errno));
		return 1;
	}
#endif
	
	return 0;
}

int make_dirs(const char* path)
{
	size_t len = 0;
	if (nullptr == path || (len = strlen(path)) <= 0)
	{
		return 1;
	}

	fprintf(stderr, "make_dirs malloc\n");
	char* pTmp = (char*)do_malloc(len + 3);
	if (nullptr == pTmp)
	{
		return 1;
	}

	safe_snprintf(pTmp, len + 1, _TRUNCATE, "%s", path);

	for (int i = 0; i < (int)len; i++) 
	{
		if (pTmp[i] != '\\' && pTmp[i] != '/')
		{
			continue;
		}

		if (0 == i) {
			continue;
		}

		pTmp[i] = '\0';
		if (make_dir(pTmp) != 0)
		{
			break;
		}

		pTmp[i] = '/';
	}

	DOFREE(pTmp);

	return make_dir(path);
}

int init_platform()
{
	int iRet = 0;
#if defined(WIN32) || defined(_WIN32)
	WSADATA wsd;
	if (WSAStartup(MAKEWORD(2, 2), &wsd) != 0)
	{
		iRet = 1;
	}
	_setmode(0, _O_BINARY);
	_setmode(1, _O_BINARY);
	_setmode(2, _O_BINARY);
#elif  __linux__
    signal(SIGPIPE, SIG_IGN);
#endif

	//输出非缓冲
	setvbuf(stdout, nullptr, _IONBF, 0);
	setvbuf(stderr, nullptr, _IONBF, 0);
	return iRet;
}

int uninit_platform()
{
#if defined(WIN32) || defined(_WIN32)
	WSACleanup();
#elif  __linux__
#endif

	return 0;
}

void perror_desc(const char* pStr)
{
#if defined(WIN32) || defined(_WIN32)
	wchar_t* pWstr = char_2_wchar(pStr);
	if (nullptr == pWstr)
	{
		return;
	}

	wchar_t* pBuf = nullptr;
	if (FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_IGNORE_INSERTS | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_MAX_WIDTH_MASK,
		nullptr,
		GetLastError(),
		MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
		pBuf,
		0,
		nullptr))
	{
		wchar_t* pFormat = char_2_wchar("%s: %s");
		if (nullptr != pFormat)
		{
			fwprintf_s(stderr, pFormat, pWstr, pBuf);
			fflush(stderr);
			DOFREE(pFormat);
		}
		LocalFree((HLOCAL)pBuf);
	}
	else
	{
		wchar_t* pFormat = char_2_wchar("%s: unknown Windows error\n");
		if (nullptr != pFormat)
		{
			fwprintf_s(stderr, pFormat, pWstr);
			fflush(stderr);
			DOFREE(pFormat);
		}
	}

	DOFREE(pWstr);
#elif  __linux__
	if (nullptr != pStr)
	{
		perror(pStr);
	}
#endif
}

 

lightjia
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
web在线小工具
laoziyoumingzi的博客
08-15 1824
在线工具，json格式化，unix时间戳转换，base64加解密
一些小工具
伊始的博客
07-06 2071
小工具
开发小工具
liangchunjiang的博客
08-21 306
这里记录一些简单实用的小工具，方便文档和程序的编写，通常都能使用简单的团队开发！ 1.在线编写文档的工具 https://www.showdoc.cc/index.php?s=home/item/index 2.在线流程编辑工具 https://www.draw.io/
猿如意|初识CSDN的开发者工具合集
zsk_john的技术分享专用博客
12-17 979
总的来说，猿如意这个工具集合还是不错的，虽然有一些问题，但看在ChatGPT的面子上也是值得一用的，难道不是吗？
实用小工具
it_much_nice
08-10 288
工作常用的小工具
常用小工具
Li_and_Li的博客
06-08 277
文档格式转换 画图 processon Latex在线编辑器 Latex在线编辑器 markdown在线编辑器 markdown在线编辑器2 图表工具
自制【CAN数据实时解析小工具】
02-12
1.解析*.dbc文件格式文件 2.解析由CANTest保存的CAN数据（txt文件），翻译成可以直接看懂的数据 3..显示某个帧ID的帧内容的实时曲线图 4.接收实时CAN数据翻译后保存为txt文件 5.可以收发调试CAN数据
PHP API接口测试小工具
09-24
**PHP API接口测试小工具详解** API（Application Programming Interface）接口是软件系统间进行交互的一种方式，它定义了不同服务之间如何通信。在现代互联网应用开发中，API接口的测试至关重要，因为它确保了服务...
css sprite雪碧图生成小工具 v4.3
05-26
css sprite 雪碧图生成小程序,已在github上开源，地址：https://github.com/iwangx/sprite ,请需要的朋友注意版本更新，下载最新版。 博客园地址：http://www.cnblogs.com/wang4517/
win7桌面小工具 非常多
12-16
在Windows 7操作系统中，桌面小工具是一种便捷的功能，它允许用户在桌面上直观地查看各种信息或执行简单任务，从而提高工作效率。这些小工具包括天气预报、日历、时钟、记事本、计算器等，能够快速提供所需的数据或...
如何玩转CSDN AI工具集（测试文章，请无视）
测试0901-1
09-18 559
chatDOC定位：一款AI文件阅读工具，可以快速解析、定位和总结上传的pdf等文档内容。功能：对照翻译、导出、摘要、润色、写作助手视频处理定位：一款视频处理工具，可以上传视频并完成翻译总结。功能：翻译字幕、摘要生成、Chat视频角色机器人定位：定义身份和行为方式的专业AI顾问，可以在领域内精准回复。功能：100+种专业团队，个性化筛选机器人，定制对话风格C知道定位：CSDN和外部合作伙伴合作研发的生成式AI产品。功能：泛用性AI对话随着研发团队的推进，将计划陆续解锁更多的实用功能。
关于C语言如何解决stream=nullptr的问题
highlighters的博客
10-26 6374
c语言关于 ”stream!=nullptr“ 的错误解决
C语言出现stream！=NULL情况的错误
ZIV555的博客
04-21 8939
err=fopen_s(&fd,addon,"rb" );       fseek(fd,0,0);       fread(Buff,sizeof(double),SIZEDATA,fd); 类似于这种读文件的时候，出现了这个情况，查出的原因是数据没有找到，一般来讲出现这种问题的时候考虑你的数据格式是否正确，路径是否正确，然后再查看我们程序的问题。 另外，可以在读之前判断
fopen_s / fprintf 报错 stream!=nullptr
Eric-lsl的博客
01-05 4553
bug 用fopen_s()函数打开文件，然后用fprintf()函数向文件写入内容。 跟踪调试显示，fopen_s()函数没有报错，fprintf()函数报错，stream!=nullptr。 原来是fprintf()所用的文件指针为空，而fopen_s()得到的文件指针恰恰为空。   原因 这是由所要打开的文件被占用导致的。...
printf_s与printf的异同
热门推荐
xupeng1644的博客
09-25 1万+
MSDN的解释为： The main difference between printf_s and printf is that printf_s checks the format string for valid formatting characters, whereas printf only checks if the format string is a null pointer....
c++ 以UTF-16LE编码方式保存文件
Quellaaa的博客
09-02 2926
1. 前言 正常情况下，c++保存文件的编码方式一般为ANSI。但为了满足一些需求，会要求保存文件的编码方式为UTF-16LE、UTF-8或Unicode。 了解相关知识发现，决定文件编码方式主要是在于文件的BOM（Byte Order Mark）。 0xFE 0xFF => UTF-16 大端序 0xFF 0xFE => UTF-16 小端序 0x00...
【极客】神器——常用的一些小工具
方小块的博客
05-13 1万+
整理一些常用的小工具，方便自己用1.everything 搜索神器  网盘地址：https://pan.baidu.com/s/1ZvaWcWEFJpZHGw3o3_gWSA不占内存仅有1m左右，搜索速度极快，远超win系统自带的搜索功能;2.fiddler      抓包工具  官网链接：https://www.telerik.com/fiddler方便的抓取对于微信或者app的一些页面和接口;...
ANSI和UNICODE字符串处理常用函数
深之JohnChen的专栏
05-30 4079
ANSI和UNICODE字符串处理函数 在windows中ANSI和UNICODE字符串操作分别提供了相应的函数，也提供了一套兼容两者的函数。比如： #ifdef  UNICODE       #define _tcscpy     wcscpy  #else      #define _tcscpy     strcpy  #endif 字符串处理函数常用函数对照 ANSI UNIC...
websocket小工具
最新发布
11-30
WebSocket小工具是一种用于在网络上实现双向通信的工具。它通常用于创建实时的、交互式的网络应用程序，如在线游戏、聊天室和股票市场实时更新等。WebSocket小工具提供了一个持久连接，允许客户端和服务器之间实现低延迟的双向通信。 WebSocket小工具具有许多优点，比如它是基于标准的，可以跨平台使用，并且可以与现有的HTTP端口一起使用。另外，使用WebSocket小工具可以减少服务器和客户端之间的通信量，从而减少了网络延迟和带宽消耗。 对于开发人员来说，WebSocket小工具也是一种非常方便的工具。它提供了一整套API，使得在应用程序中实现WebSocket变得非常容易。开发人员可以使用JavaScript、Python、Java等各种语言来创建WebSocket应用程序，并且可以利用WebSocket的事件驱动模式来处理即时通信的需求。 总之，WebSocket小工具是一种非常实用的工具，可以为开发人员提供便捷的双向通信解决方案，同时也可以为用户提供更流畅、更实时的网络应用体验。相信随着网络应用的不断发展，WebSocket小工具将会越来越受到开发者和用户的青睐。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值