对不同数据类型拼接成一个内存块的封装

最新推荐文章于 2023-03-12 08:50:21 发布
最新推荐文章于 2023-03-12 08:50:21 发布
阅读量1.3k 收藏
点赞数 1
分类专栏： PMSOFT二次开发平台
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jason_wentzel/article/details/44901845
版权 
/*================================================================*
// NSDataParser.h: interface for the CNSDataParser class.
【头文件】:	NSDataParser.h
【功  能】:	该模块属于独立模块，主要完成管理各种类型数据，
			转换成一个连续的内存数据块。返回的连续数据块为LPVOID类型，
			通过GetData()函数获取到该数据块的地址，通过GetDataSize()
			返回数据块的大小
【注  意】:	
*================================================================*/
#if !defined(AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_)
#define AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
#include <afxtempl.h>
//=========================================================================
//=========================================================================
class  CDataParser
{
public:
	CDataParser();
	virtual ~CDataParser();
public:
	// 将数据写入内存
	/*================================================================*
	【函數】:	Add(...)
	【功能】:	往内存中添加各种数据，数据内存所占的长度会根据所加入的
				数据类型动态增加
	【参数】:	
	【返回】:	
	【例子】:	
	【注意】:	当参数为CNSVarObj类型时，往内存中加的是变量的工程值，
				即pVar->GetVarData(),并不是把变量对象中所有数据全加入内存
	*================================================================*/
	virtual BOOL Add(COleVariant* pvData);
	virtual BOOL Add(WORD wData);
	virtual BOOL Add(DWORD wData);
	virtual BOOL Add(LPVOID pData,int iLen);
	virtual BOOL Add(BOOL wData);
	virtual BOOL Add(BYTE wData);
	virtual BOOL Add(char wData);
	virtual BOOL Add(short wData);
	virtual BOOL Add(long wData);
	virtual BOOL Add(float wData);
	virtual BOOL Add(double wData);
	virtual BOOL Add(const COleDateTime& wData);
	virtual BOOL Add(const CString& strData);
public:
	// 从内存中读取值,注：先调用InitData初始化内存数据然后再调用GetData
	virtual void InitData( void *pData,unsigned long nDataSize);
	virtual BOOL GetData(COleVariant& pvData);
	virtual BOOL GetData(WORD &wData);
	virtual BOOL GetData(DWORD &wData);
	virtual BOOL GetData(LPVOID pData);
	virtual BOOL GetData(BOOL &wData);
	virtual BOOL GetData(BYTE &wData);
	virtual BOOL GetData(char &wData);
	virtual BOOL GetData(short &wData);
	virtual BOOL GetData(long &wData);
	virtual BOOL GetData(float &wData);
	virtual BOOL GetData(double wData);
	virtual BOOL GetData(COleDateTime& wData);
	virtual BOOL GetData(CString& strData);
	// 获取当前内存位置
	unsigned long GetCurrentPos();
public:
	/*================================================================*
	【函數】:	RemoveAllDataItem()
	【功能】:	删除所有数据将所占的内存清空
	【参数】:	
	【返回】:	返回BOOL类型,成功为TRUE,否则为FALSE
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual BOOL	RemoveAllDataItem();

	/*================================================================*
	【函數】:	GetData()
	【功能】:	获取连续内存地址
	【参数】:	
	【返回】:	返回指向内存的首地址
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual LPVOID  GetData();

	/*================================================================*
	【函數】:	GetDataSize()
	【功能】:	获取连续内存的大小
	【参数】:	
	【返回】:	返回指向内存的大小
	【例子】:	
	【注意】:	
	*================================================================*/
	virtual DWORD	GetDataSize();
protected:
	double VarToDouble(COleVariant* pvData);
protected:
	// 数据大小
	UINT m_uDataSize;
	// 数据
	LPVOID m_pData;
	// 内存需要删除标志
	bool m_bMustClean;
	unsigned long m_pCurDataPos;
private:
	CRITICAL_SECTION CRITICAL_LOCK;
};
#endif // !defined(AFX_DATAPARSER_H__C18BF820_ED69_42B0_A8F9_9570387F753C__INCLUDED_)

#include "stdafx.h"
#include "WSDataParser.h"

#ifdef _DEBUG
#undef THIS_FILE
static char THIS_FILE[]=__FILE__;
#define new DEBUG_NEW
#endif

CDataParser::CDataParser()
{
	m_bMustClean = true;
	m_pData = NULL;
	m_uDataSize = 0;
	m_pCurDataPos = 0;
	InitializeCriticalSection( &CRITICAL_LOCK);
}

CDataParser::~CDataParser()
{
	RemoveAllDataItem();
	DeleteCriticalSection(&CRITICAL_LOCK);
}
double CDataParser::VarToDouble(COleVariant* pvData)
{
	double dfData;
	COleVariant vData;
	
	vData = *pvData;
	
	switch(pvData->vt)
	{
	case VT_I1:
		dfData = (double)vData.cVal ;
		break;
	case VT_UI1:
		dfData = (double)vData.bVal;
		break;
	case VT_I2:
		dfData = (double)vData.iVal;
		break;
	case VT_UI2:
		dfData = (double)vData.uiVal;
		break;
	case VT_INT:
		dfData = (double)vData.intVal;
		break;
	case VT_UINT:
		dfData = (double)vData.uintVal;
		break;
	case VT_I4:
		dfData = (double)vData.lVal;
		break;
	case VT_UI4:
		dfData = (double)vData.ulVal;
		break;
	case VT_R4:
		dfData = (double)vData.fltVal;
		break;
	case VT_R8:
		dfData = (double)vData.dblVal;
		break;
	case VT_BOOL:
		if(vData.boolVal == VARIANT_FALSE)
			dfData = 0;
		else
			dfData = 1;
		break;
	case VT_CY:
	case VT_DATE:
	case VT_BSTR:
	case VT_DISPATCH:
	case VT_ERROR:
	case VT_VARIANT:
	case VT_UNKNOWN:
	case VT_DECIMAL:
	case VT_EMPTY:
	case VT_NULL:
	default:
		dfData = 0.0;
		break;
	}
	
	return dfData;
}
BOOL CDataParser::Add(LPVOID pData,int iLen)
{
	BOOL bSuccess = FALSE;
	EnterCriticalSection(&CRITICAL_LOCK);
	if(pData != NULL && iLen > 0)
	{
		if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);

		// 先构造类型
		DWORD dwDataVT = VT_VOID;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
		m_uDataSize += 4;

		// 构造长度
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&iLen,4);
		m_uDataSize += 4;

		// 构造值
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iLen, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,(char*)pData,iLen);
		
		m_uDataSize += iLen;
		bSuccess = TRUE;
	}
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(const CString& strData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);

	char *chAnsiCode = CUtility::ConvertStringToChar(strData);
	if(chAnsiCode)
	{
		//=================================================================================
		
		if(!m_pData) 
			m_pData = GlobalAlloc(GMEM_FIXED,1);
		
		// 先构造变量类型
		DWORD dwDataVT = VT_BSTR;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
		m_uDataSize += 4;
		
		int istrVarNameLen = strlen(chAnsiCode);
		
		// 构造长度
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&istrVarNameLen,4);
		m_uDataSize += 4;
		
		
		//构造值
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + istrVarNameLen, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,chAnsiCode,istrVarNameLen);
		
		m_uDataSize += istrVarNameLen;
		
		//=================================================================================
		
		delete chAnsiCode;
		chAnsiCode = NULL;

		bSuccess = TRUE;
	}
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(WORD wData)
{
	BOOL bSuccess = FALSE;

	EnterCriticalSection(&CRITICAL_LOCK);
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI2;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	bSuccess = TRUE;
	//=================================================================================
	LeaveCriticalSection(&CRITICAL_LOCK);
	return bSuccess;
}
BOOL CDataParser::Add(DWORD wData)
{
	BOOL bSuccess = FALSE;

	EnterCriticalSection(&CRITICAL_LOCK);

	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}
BOOL CDataParser::Add(BOOL wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_BOOL;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}
BOOL CDataParser::Add(BYTE wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_UI1;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(char wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I1;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(short wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I2;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(long wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_I4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(float wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_R4;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(double wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_R8;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(wData);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(const COleDateTime& wData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);
	
	if(!m_pData) 
		m_pData = GlobalAlloc(GMEM_FIXED,1);
	//=================================================================================
	// 先构造类型
	DWORD dwDataVT = VT_DATE;
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&dwDataVT,4);
	m_uDataSize += 4;
	
	int iDataLen = sizeof(double);
	
	//构造值
	m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iDataLen, GMEM_MOVEABLE);
	CopyMemory((char*)m_pData + m_uDataSize,&wData.m_dt,iDataLen);
	m_uDataSize += iDataLen;
	
	//=================================================================================
	bSuccess = TRUE;
	LeaveCriticalSection(&CRITICAL_LOCK);

	return bSuccess;
}
BOOL CDataParser::Add(COleVariant* pvData)
{
	BOOL bSuccess = FALSE;
	
	EnterCriticalSection(&CRITICAL_LOCK);

	if(pvData)
	{
		if(!m_pData) 
			m_pData = GlobalAlloc(GMEM_FIXED,1);

		COleVariant nVarData = *pvData;
		// 构造数据类型
		DWORD dwvDataVT = pvData->vt;
		m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
		CopyMemory((char*)m_pData + m_uDataSize,&dwvDataVT,4);
		m_uDataSize += 4;

		double dbData = VarToDouble(pvData);
		switch(dwvDataVT)
		{
		case VT_UI1:	//Byte                    bVal;
			{
				BYTE VarDataTmp = (BYTE)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_I1:		//char                    cVal;
			{
				char VarDataTmp = (char)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_I2:		//Short                   iVal;
			{
				short VarDataTmp = (short)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 2, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,2);
				m_uDataSize += 2;
			}break;
		case VT_UI2:	//unsigned short          uiVal;
			{
				WORD VarDataTmp = (WORD)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 2, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,2);
				m_uDataSize += 2;
			}break;
		case VT_INT:	//int                     intVal;
			{
				int VarDataTmp = (int)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_UINT:	//unsigned int            uintVal;
			{

				DWORD VarDataTmp = (DWORD)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_I4:		//long                    lVal;
			{
				long VarDataTmp = (long)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_UI4:	//unsigned long           ulVal;
			{
				unsigned long VarDataTmp = (unsigned long)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_R4:		//float                   fltVal;
			{
				float VarDataTmp = (float)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,4);
				m_uDataSize += 4;
			}break;
		case VT_R8:		//double                  dblVal;
			{
				double VarDataTmp = (double)dbData;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 8, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,8);
				m_uDataSize += 8;
			}break;
		case VT_BOOL:	//VARIANT_BOOL            boolVal;
			{
				bool VarDataTmp = (dbData == 0.0) ? false : true;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 1, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,1);
				m_uDataSize += 1;
			}break;
		case VT_DATE:	//DATE                    date;
			{
				DATE VarDataTmp = nVarData.date;
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 8, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&VarDataTmp,8);
				m_uDataSize += 8;
			}break;
		case VT_BSTR:	//BSTR                    bstrVal;
			{
				CString strData = nVarData.bstrVal;
				int iLen = strData.GetLength();
				
				// 先写长度
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + 4, GMEM_MOVEABLE);
				CopyMemory((char*)m_pData + m_uDataSize,&iLen,4);
				m_uDataSize += 4;
				
				// 写字符串
				m_pData = ::GlobalReAlloc(m_pData, m_uDataSize + iLen, GMEM_MOVEABLE);

				char *chAnsiCode = CUtility::ConvertStringToChar(strData);
				if(chAnsiCode)
				{
					CopyMemory((char*)m_pData + m_uDataSize,chAnsiCode,iLen);
				
					delete chAnsiCode;
					chAnsiCode = NULL;
				}
				m_uDataSize += iLen;
			}break;
		case VT_EMPTY:
			{

			}break;
		case VT_NULL:
			{

			}break;
		default:
			break;
		}
		bSuccess = TRUE;
	}
	
	LeaveCriticalSection(&CRITICAL_LOCK);
	
	return bSuccess;
}

BOOL CDataParser::RemoveAllDataItem()
{
	if(m_bMustClean)
	{
		if(m_pData)
		{
			GlobalFree(m_pData);
			m_pData = NULL;
		}
	}
	m_uDataSize = 0;
	return TRUE;
}

LPVOID CDataParser::GetData()
{
	return m_pData;
}

DWORD CDataParser::GetDataSize()
{
	return m_uDataSize;
}
//============================================================================================
void CDataParser::InitData( void *pData,unsigned long nDataSize)
{
	m_pCurDataPos = 0;
	m_pData = pData;
	m_uDataSize = nDataSize;
	// 数据由应用层传进来，在析构中不能释放
	m_bMustClean = false;
}
unsigned long CDataParser::GetCurrentPos()
{
	return m_pCurDataPos;
}
BOOL CDataParser::GetData(COleVariant& pvData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			pvData.vt = dwDataVT;
			switch(dwDataVT)
			{
			case VT_UI1:	//Byte                    bVal;
				{
					// 构造值
					memcpy(&pvData.bVal,(char*)m_pData + m_pCurDataPos, 1);
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_I1:		//char                    cVal;
				{
					memcpy(&pvData.cVal,(char*)m_pData + m_pCurDataPos, 1);
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_I2:		//Short                   iVal;
				{
					memcpy(&pvData.iVal,(char*)m_pData + m_pCurDataPos, 2);
					m_pCurDataPos += 2;
					bSuccess = TRUE;
				}break;
			case VT_UI2:	//unsigned short          uiVal;
				{
					memcpy(&pvData.uiVal,(char*)m_pData + m_pCurDataPos, 2);
					m_pCurDataPos += 2;
					bSuccess = TRUE;
				}break;
			case VT_INT:	//int                     intVal;
				{
					memcpy(&pvData.intVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_UINT:	//unsigned int            uintVal;
				{
					memcpy(&pvData.uintVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				
				}break;
			case VT_I4:		//long                    lVal;
				{
					memcpy(&pvData.lVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_UI4:	//unsigned long           ulVal;
				{
					memcpy(&pvData.ulVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_R4:		//float                   fltVal;
				{
					memcpy(&pvData.fltVal,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;
					bSuccess = TRUE;
				}break;
			case VT_R8:		//double                  dblVal;
				{
					memcpy(&pvData.dblVal,(char*)m_pData + m_pCurDataPos, 8);
					m_pCurDataPos += 8;
					bSuccess = TRUE;
				}break;
			case VT_BOOL:	//VARIANT_BOOL            boolVal;
				{
					BOOL bData = FALSE;
					memcpy(&bData,(char*)m_pData + m_pCurDataPos, 1);
					pvData.boolVal = (bData == TRUE ) ? VARIANT_TRUE : VARIANT_FALSE;
					m_pCurDataPos += 1;
					bSuccess = TRUE;
				}break;
			case VT_DATE:	//DATE                    date;
				{
					memcpy(&pvData.date,(char*)m_pData + m_pCurDataPos, 8);
					m_pCurDataPos += 8;
					bSuccess = TRUE;
				}break;
			case VT_BSTR:	//BSTR                    bstrVal;
				{
					// 先读长度
					DWORD dwDataLen = 0;
					memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos, 4);
					m_pCurDataPos += 4;

					char *chName = new char[dwDataLen + 1];
					memcpy((char*)chName,(char*)m_pData + m_pCurDataPos,dwDataLen);
					chName[dwDataLen] = '\0';
					m_pCurDataPos += dwDataLen;

					CString strData = CString(chName);
					pvData = strData;
					delete []chName;
					bSuccess = TRUE;
				}break;
			case VT_EMPTY:
				{
					
				}break;
			case VT_NULL:
				{
					
				}break;
			default:
				{
					// 当前索引退回上一次位置
					m_pCurDataPos -= 4;
					bSuccess = FALSE;
				}break;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(WORD &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI2)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 2);
				m_pCurDataPos += 2;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(DWORD &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(LPVOID pData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_VOID)
			{
				// 先构造长度
				DWORD dwDataLen = 0;
				memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos,  4);
				m_pCurDataPos += 4;

				// 构造值
				memcpy(&pData,(char*)m_pData + m_pCurDataPos, dwDataLen);
				m_pCurDataPos += dwDataLen;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(BOOL &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_BOOL)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(BYTE &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_UI1)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(char &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I1)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 1);
				m_pCurDataPos += 1;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(short &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I2)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos, 2);
				m_pCurDataPos += 2;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(long &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_I4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(float &wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_R4)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,4);
				m_pCurDataPos += 4;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(double wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_R8)
			{
				// 构造值
				memcpy(&wData,(char*)m_pData + m_pCurDataPos,8);
				m_pCurDataPos += 8;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(COleDateTime& wData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_DATE)
			{
				// 构造值
				memcpy(&wData.m_dt,(char*)m_pData + m_pCurDataPos,8);
				m_pCurDataPos += 8;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}
BOOL CDataParser::GetData(CString& strData)
{
	BOOL bSuccess = FALSE;
	if(m_pData != NULL)
	{	
		// 当前位置小于总数据长度时
		if(m_pCurDataPos < m_uDataSize)
		{
			EnterCriticalSection(&CRITICAL_LOCK);
			
			// 先构造数据类型
			DWORD dwDataVT = VT_NULL;
			memcpy(&dwDataVT,(char*)m_pData + m_pCurDataPos,  4);
			m_pCurDataPos += 4;
			
			if(dwDataVT == VT_BSTR)
			{
				// 先构造长度
				DWORD dwDataLen = 0;
				memcpy(&dwDataLen,(char*)m_pData + m_pCurDataPos,  4);
				m_pCurDataPos += 4;
				
				char *chName = new char[dwDataLen + 1];

				// 构造值
				memcpy((char*)chName,(char*)m_pData + m_pCurDataPos, dwDataLen);
				chName[dwDataLen] = '\0';
				strData = CString(chName);
				delete []chName;

				m_pCurDataPos += dwDataLen;
				bSuccess = TRUE;
			}
			else
			{
				// 当前索引退回上一次位置
				m_pCurDataPos -= 4;
				bSuccess = FALSE;
			}
			LeaveCriticalSection(&CRITICAL_LOCK);
		}
	}
	return bSuccess;
}


孤客天涯
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
SQL Server将一列的多行内容拼接成一行的实现方法
09-10
主要介绍了SQL Server将一列的多行内容拼接成一行的实现方法,需要的朋友可以参考下
c++中类的封装性
modi000的博客
05-31 1806
c++中类的三个特性： 1、封装性 2、继承性 3、多态性 这里谈一下对类的封装性的理解： c语言中，我们将多个不同类型的数据放在一起，用struct结构体； C++中，进行了丰富，将数据（成员变量）和函数（成员函数）封装在一起，起了一个新的名字class类。 struct中默认的变量都是public; class中默认的变量属性是private,(封装性的体现，类对象无法访问）。 class中成员函数将出错处理（比如，打印错误日志，return等）封装在一个一起。（封装性的体现） cl
C语言经典面试题之深入解析字符串拷贝的sprintf、strcpy和memcpy使用与区别
╰つ栺尖篴夢ゞ
09-19 5994
sprintf 指的是字符串格式化命令，是把格式化的数据写入某个字符串中，即发送格式化输出到 string 所指向的字符串，直到出现字符串结束符 '\0' 为止。
C++如何将两块内存的数据合并到一块内存
GreenArrowMan-CSDN博客
12-19 7948
内存数据的拼接，在开发中有时候也会遇到。 内存数据p1,内存数据p2,拼接为内存数据p. p1拷贝到p的前半部分，p2拷贝到p的后半部分。 可以使用memcpy来进行数据的拷贝拼接，关键是要控制好拼接的位置：p2内存数据从哪个位置往p里面拷贝。
【C语言】字符串和内存函数介绍及模拟实现
杨同学的博客
07-07 3218
本文内容：strlen，strcpy，strncpy，strcat，strncat，strcmp，strncmp，strstr，strtok，strerror，memcpy，memmove，memcmp
如何将不同大小及宽度的数据，拼接在同一块内存中？
chipsea_mltsum的博客
06-02 671
/************************************************************************* @ brief 拼接一段数据到某个地址 step1: 先定义一块地址，用于存储拼接之后的数据. 这里介绍两种方式： 一种是用malloc一段内存： char *Ptr = NULL; Ptr = (char*)malloc(100 * sizeof...
java拼接字符串时去掉最后一个多余逗号的方法
09-03
主要介绍了java拼接字符串时去掉最后一个多余逗号的方法,实例分析了java操作字符串的技巧,具有一定参考借鉴价值,需要的朋友可以参考下
详解基于python的多张不同宽高图片拼接成大图
09-18
主要介绍了详解基于python的多张不同宽高图片拼接成大图，文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值，需要的朋友们下面随着小编来一起学习学习吧
piliangpinjieDEM_栅格数据批量拼接_arcgis_批量拼接_
10-02
可以实现栅格数据的批量拼接，无需打开arcgis软件
SQL Server 将某一列的值拼接成字符串.docx
11-07
SQL Server 将某一列的值拼接成字符串示例
内存映射文件处理图像拼接源码
08-15
vs2008 C++内存映射文件处理图像拼接源码内存映射文件处理图像拼接源码内存映射文件处理图像拼接源码内存映射文件处理图像拼接源码
memcpy, memcpy()函数，字符串拷贝
08-13
memcpy: 头文件，函数原型，函数功能，函数返回值，说明
memcpy函数的实现
01-05
一个使用memcpy的实现版本，考虑内存重叠以及效率
在同一段内存上存储不同类型的数据
06-22
使用malloc动态分配一段内存，在该段内存的首地址处的四字节下记录不同数据块的个数，使用合适的方式存入数据，并相应读取。
网络原理——数据包的封装和分用
qq_45036591的博客
12-14 1336
一、数据封装的过程 不同的协议层对数据包有不同的称谓,在传输层叫做段(segment),在网络层叫做数据报 (datagram),在链路层叫做帧(frame). 应用数据按照从上到下的顺序依次封装，每到达一层都会被加上该层的首部信息。 许多应用程序都通过TCP或者UDP来传送数据，运输层协议在生成报文首部时都会存入一个程序的标识符。 TCP/UDP将源端口号和目的端口号分别存入TCP/UDP报文...
前后端数据不同，如何封装适配，所有数据通用
fangqi20170515的博客
07-08 385
1、对适配的方法进行了封装 2、调用封装好的方法将后端传过来的数据以及需要适配的数据作为参数传过去
c语言memcopy_C语言memcpy函数的用法
weixin_39946266的博客
12-23 913
介绍memcpy是memory copy的缩写，意为内存复制，在写C语言程序的时候，我们常常会用到它。它的函原型如下：void *memcpy(void *dest, const void *src, size_t n);它的功能是从src的开始位置拷贝n个字节的数据到dest。如果dest存在数据，将会被覆盖。memcpy函数的返回值是dest的指针。memcpy函数定义在string.h头文件...
第七章-主存管理
weixin_51231121的博客
03-12 967
第七章-主存管理
操作系统内存管理总结
qq_41856950的博客
01-26 147
物理地址：总线地址 逻辑地址：在CPU运行的进程看到的地址 编译：将高级语言转换为汇编源代码（确定逻辑地址与物理地址的映射关系） 汇编：将汇编源代码变成二进制代码（机器代码） 链接：把多个模块和你用到的函数库搁在一起排成一个线性的序列 重定位：让程序的存储位置正确 MMU:进行逻辑地址和物理地址的转换 连续内存分配：给进程分配一块不小于指定大小的连续的物理内存区域 内存碎片：空闲内存不能被利用的碎片 物理地址=装入基址+逻辑地址 空闲区表：描述内存空闲区的位置和大小的数据结构 覆盖技术目的：在较小的内存空间
C#数据类型与Python数据类型的区别
最新发布
08-20
### 回答1： C#和Python都是面向对象语言，但它们的数据类型有些不同。 1. 整数类型 在C#中，整数类型有 byte、sbyte、short、ushort、int、uint、long 和 ulong。而在Python中，整数类型只有 int。Python的 int 类型可以表示任意大小的整数，而C#的整数类型有固定的大小。 2. 浮点数类型 在C#中，浮点数类型有 float 和 double，而在Python中，浮点数类型只有 float。Python的 float 类型可以表示任意精度的浮点数，而C#的浮点数类型有固定的精度。 3. 字符串类型 在C#中，字符串类型是 string，而在Python中，字符串类型是 str。两种语言都支持字符串的基本操作，如拼接、截取等。但是在Python中，字符串是不可变的，而在C#中，字符串是可变的。 4. 布尔类型 在C#中，布尔类型是 bool，而在Python中，布尔类型是 bool。两种语言都支持逻辑运算符，如 and、or 和 not。 5. 列表类型 在C#中，列表类型是 List，而在Python中，列表类型是 list。两种语言都支持列表的基本操作，如添加元素、删除元素等。但是在C#中，列表是强类型的，即只能存储一种类型的元素，而在Python中，列表可以存储任意类型的元素。 总的来说，C#和Python的数据类型有些不同，但都支持基本的数据类型和面向对象的编程。 ### 回答2： C是一种广泛使用的编程语言，具有高效性、可移植性和可扩展性。它由贝尔实验室的Dennis Ritchie在20世纪70年代初期开发，用于UNIX操作系统的开发。C语言被广泛用于系统软件、嵌入式系统、驱动程序以及其他需要高性能和对硬件细节的控制的应用程序。 C语言具有简单的语法和丰富的编程结构，使得开发人员可以更容易地实现复杂的功能。它提供了大量的库函数和数据类型，可以方便地处理输入输出、字符串操作和内存管理等任务。同时，C语言也支持指针操作，使得开发人员可以直接访问和操作内存，从而提高性能和灵活性。 C语言还具有良好的可移植性，即在不同的平台上编写的代码可以简单地移植到其他平台上运行。这是因为C语言是一种较低级的语言，可以直接访问硬件。虽然不同的平台可能有不同的编译器和库函数，但是通过修改少量的代码，就可以在不同平台上编译和运行。 另外，C语言也支持模块化编程，可以将代码拆分成多个模块，提高代码的可读性和维护性。开发人员可以编写自己的函数和数据类型，将功能逻辑进行封装，方便代码的重复使用。 总的来说，C语言是一种强大、灵活且高效的编程语言，广泛应用于各种领域。它不仅仅是一种编程语言，更是一种思维方式和工程实践，有助于开发人员实现复杂的功能并提高软件的性能和可移植性。 ### 回答3： C是一种广泛应用的编程语言，它具有简洁灵活的语法和强大的功能。C被广泛用于开发操作系统、编译器、数据库等高性能和底层系统软件，也用于嵌入式系统和移动应用开发。 C的语法简单明了，易于学习和理解。它提供了丰富的数据类型，包括整数、浮点数、字符、数组、结构体和指针等，使得开发者能够更灵活地处理数据。C还提供了强大的控制结构，如条件语句和循环语句，使得程序的逻辑控制更加灵活。 C还提供了丰富的库函数，使得开发者可以方便地实现各种功能。标准C库提供了大量常用的函数，如字符串处理、文件操作和内存管理等。除了标准库，C还支持自定义库函数的编写，使得开发者能够根据自己的需求实现特定的功能。 C的性能优异，它的代码可以高效地编译和执行。C语言的程序可以直接转换为机器码，并且对系统资源的利用非常高效。这使得C成为了编写高性能和底层系统软件的首选语言。 同时，C的跨平台性也是它的优点之一。由于C语言的标准库在各个平台上都有实现，因此可以在不同的操作系统上编写和运行C程序，大大提高了程序的移植性。 总之，C语言具有简洁灵活的语法、强大的功能、高性能和跨平台性等优点，使得它成为了软件开发领域中非常重要的一门语言。无论是开发底层系统软件还是移动应用，C语言都能够提供高效、可靠和灵活的解决方案。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值