1、CString to char*
经过类型强制转换，可以将CString类型转换成char*，例如：CString cStr = "Hello,world!";
char* zStr = (char*)(LPCTSTR)cStr;
2、char* to CString
char*类型可以直接给CString，完成自动转换，例如：
char* zStr = "Hello,world!";
CString cStr = zStr;
3、CString to LPCSTR
将CString转换成LPCSTR，需要获得CString的长度，例如：CString cStr = _T("Hello,world!");
int nLen = cStr.GetLength();
LPCSTR lpszBuf = cStr.GetBuffer(nLen);
4、CString to LPSTR
这个和第3个技巧是一样的，例如：
CString cStr = _T("Hello,world!");
int nLen = str.GetLength();
LPSTR lpszBuf = str.GetBuffer(nLen);
5、Char[] to int
将字符串类型转换成整数型，可以使用atoi函数，例如：
char c[10];
int n;
n = atoi?;
6、Char[] to float
和第5个技巧一样，使用atof()函数可以转换成float型，例如：char c[10];
float f;
f = atof?;
7、Char* to int
和第5个技巧完全一样，例如：
char *str = "100";
int i;
i = atoi(str);
一、其它数据类型转换为字符串
短整型(int)
itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制itoa(i,temp,2); ///按二进制方式转换
长整型(long)
ltoa(l,temp,10);
二、从其它包含字符串的变量中获取指向该字符串的指针
CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;
BSTR类型的_variant_t变量
v1 = (_bstr_t)"程序员";
buf = _com_util::ConvertBSTRToString((_bstr_t)v1);
三、字符串转换为其它数据类型
strcpy(temp,"123");
短整型(int)
i = atoi(temp);
长整型(long)
l = atol(temp);
浮点(double)
d = atof(temp);
四、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:
整数(int)
str.Format("%d",i);
浮点数(float)
str.Format("%f",i);
字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值str = username;
五、BSTR、_bstr_t与CComBSTR
CComBSTR、_bstr_t是对BSTR的封装,BSTR是指向字符串的32位指针。
char *转换到BSTR可以这样: BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上头文件comutil.h
反之可以使用char *p=_com_util::ConvertBSTRToString(b);
六、VARIANT 、_variant_t 与 COleVariant
VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值
对于不马上赋值的VARIANT，最好先用Void VariantInit(VARIANTARG FAR* pvarg);进行初始化,其本质是将vt设置为VT_EMPTY,下表我们列举vt与常用数据的对应关系:
unsigned char bVal; VT_UI1
short iVal; VT_I2
long lVal; VT_I4
float fltVal; VT_R4
double dblVal; VT_R8
VARIANT_BOOL boolVal; VT_BOOL
SCODE scode; VT_ERROR
CY cyVal; VT_CY
DATE date; VT_DATE
BSTR bstrVal; VT_BSTR
IUnknown FAR* punkVal; VT_UNKNOWN
IDispatch FAR* pdispVal; VT_DISPATCH
SAFEARRAY FAR* parray; VT_ARRAY|*
unsigned char FAR* pbVal; VT_BYREF|VT_UI1
short FAR* piVal; VT_BYREF|VT_I2
long FAR* plVal; VT_BYREF|VT_I4
float FAR* pfltVal; VT_BYREF|VT_R4
double FAR* pdblVal; VT_BYREF|VT_R8
VARIANT_BOOL FAR* pboolVal; VT_BYREF|VT_BOOL
SCODE FAR* pscode; VT_BYREF|VT_ERROR
CY FAR* pcyVal; VT_BYREF|VT_CY
DATE FAR* pdate; VT_BYREF|VT_DATE
BSTR FAR* pbstrVal; VT_BYREF|VT_BSTR
IUnknown FAR* FAR* ppunkVal; VT_BYREF|VT_UNKNOWN
IDispatch FAR* FAR* ppdispVal; VT_BYREF|VT_DISPATCH
SAFEARRAY FAR* FAR* pparray; VT_ARRAY|*
VARIANT FAR* pvarVal; VT_BYREF|VT_VARIANT
void FAR* byref; VT_BYREF
_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数
会自动处理这些数据类型。
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;
COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;
七、其它
对消息的处理中我们经常需要将WPARAM或LPARAM等32位数据(DWORD)分解成两个16位数据(WORD),例如：
LPARAM lParam;
WORD loValue = LOWORD(lParam);///取低16位
WORD hiValue = HIWORD(lParam);///取高16位
对于16位的数据(WORD)我们可以用同样的方法分解成高低两个8位数据(BYTE),例如:
WORD wValue;
BYTE loValue = LOBYTE(wValue);///取低8位
BYTE hiValue = HIBYTE(wValue);///取高8位
后记：本文匆匆写成，错误之处在所难免，欢迎来信指正。
int ->str itoa,atoi
double- str ftoa,atof
_bstr_t,_variant_t,CString,long 等等看看下面:
我给你点详细的例子，看下面
先看懂_variant_t与_bstr_t这两个类的构造函数和 operator=
里面有重载了很多情况，
其他类型向_variant_t 赋值:
_variant_t( ) throw( );
_variant_t( const VARIANT& varSrc ) throw( _com_error );
_variant_t( const VARIANT* pVarSrc ) throw( _com_error );
_variant_t( const _variant_t& var_t_Src ) throw( _com_error );
_variant_t( VARIANT& varSrc, bool fCopy ) throw( _com_error );
_variant_t( short sSrc, VARTYPE vtSrc = VT_I2 ) throw( _com_error ); _variant_t( long lSrc, VARTYPE vtSrc = VT_I4 ) throw( _com_error ); _variant_t( float fltSrc ) throw( );
_variant_t( double dblSrc, VARTYPE vtSrc = VT_R8 ) throw( _com_error ); _variant_t( const CY& cySrc ) throw( );
_variant_t( const _bstr_t& bstrSrc ) throw( _com_error );
_variant_t( const wchar_t *wstrSrc ) throw( _com_error );
_variant_t( const char* strSrc ) throw( _com_error );
_variant_t( bool bSrc ) throw( );
_variant_t( IUnknown* pIUknownSrc, bool fAddRef = true ) throw( );
_variant_t( IDispatch* pDispSrc, bool fAddRef = true ) throw( );
_variant_t( const DECIMAL& decSrc ) throw( );
_variant_t( BYTE bSrc ) throw( );
operator=的重载形式:
_variant_t& operator=( const VARIANT& varSrc ) throw( _com_error );
_variant_t& operator=( const VARIANT* pVarSrc ) throw( _com_error ); _variant_t& operator=( const _variant_t& var_t_Src ) throw( _com_error ); _variant_t& operator=( short sSrc ) throw( _com_error );
_variant_t& operator=( long lSrc ) throw( _com_error );
_variant_t& operator=( float fltSrc ) throw( _com_error );
_variant_t& operator=( double dblSrc ) throw( _com_error );
_variant_t& operator=( const CY& cySrc ) throw( _com_error );
_variant_t& operator=( const _bstr_t& bstrSrc ) throw( _com_error ); _variant_t& operator=( const wchar_t* wstrSrc ) throw( _com_error ); _variant_t& operator=( const char* strSrc ) throw( _com_error );
_variant_t& operator=( IDispatch* pDispSrc ) throw( _com_error );
_variant_t& operator=( bool bSrc ) throw( _com_error );
_variant_t& operator=( IUnknown* pSrc ) throw( _com_error );
_variant_t& operator=( const DECIMAL& decSrc ) throw( _com_error );
_variant_t& operator=( BYTE bSrc ) throw( _com_error );
有了以上两个函数,举个例子：
double f=1.0
_variant_t v;
v=f; //是合法的看看operator=的重载形式就知道了
CString str="ddd"
_variant_t v;
v=str.AllocSysString() 或者v=(_bstr_t)(char*)str;
即可
_variant_t转换成别的形式
你首先必须确定你要转化成什么样的形式
double f;
_variant_t v
f=v.dblVal 即可或者f=(double)v;也可以
附：_variant_t的操作符
operator short( ) const throw( _com_error );
operator long( ) const throw( _com_error);
operator float( ) const throw( _com_error ); operator double( ) const throw( _com_error ); operator CY( ) const throw( _com_error ); operator bool( ) const throw( _com_error ); operator DECIMAL( ) const throw( _com_error ); operator BYTE( ) const throw( _com_error ); operator _bstr_t( ) const throw( _com_error ); operator IDispatch*( ) const throw( _com_error ); operator IUnknown*( ) const throw( _com_error );
二：
CString－>TCHAR*的转化可以用函数GetBuff()
函数原型为：LPTSTR GetBuffer( int nMinBufLength ); CString str("CString");
TCHAR* szMsg = new TCHAR[100];
//其参数为CString字符串的长度
szMsg = str.GetBuffer(str.GetLength());
str.ReleaseBuffer();
delete []szMsg;
szMsg = NULL;
TCHAR*－>CString的转化
TCHAR szTchar[18] = L"TCHAR";
CString str;
str.Format(_T("%s"),szTchar);
CString和string的互相转换
CString->std::string 例子：
CString strMfc="test";
std::string strStl;
strStl=strMfc.GetBuffer(0);
std::string->CString 例子：
CString strMfc；
std::string strStl="test";
strMfc=strStl.c_str();
对有关数据类型转换的整理
int i = 100;
long l = 2001;
float f=300.2;
double d=12345.119;
char username[]="程佩君";
char temp[200];
char *buf;
CString str;
_variant_t v1;
_bstr_t v2;
一、其它数据类型转换为字符串
?短整型(int)
itoa(i,temp,10);///将i转换为字符串放入temp中,最后一个数字表示十进制
itoa(i,temp,2); ///按二进制方式转换
?长整型(long)
ltoa(l,temp,10);
?浮点数(float,double)
用fcvt可以完成转换,这是MSDN中的例子:
int decimal, sign;
char *buffer;
double source = 3.1415926535;
buffer = _fcvt( source, 7, &decimal, &sign );
运行结果:source: 3.1415926535 buffer: '31415927' decimal: 1 sign: 0
decimal表示小数点的位置,sign表示符号:0为正数，1为负数?CString变量
str = "2008北京奥运";
buf = (LPSTR)(LPCTSTR)str;
?BSTR变量
BSTR bstrValue = ::SysAllocString(L"程序员");
char * buf = _com_util::ConvertBSTRToString(bstrValue);
SysFreeString(bstrValue);
AfxMessageBox(buf);
delete(buf);
?CComBSTR变量
CComBSTR bstrVar("test");
char *buf = _com_util::ConvertBSTRToString(bstrVar.m_str);
AfxMessageBox(buf);
delete(buf);
?_bstr_t变量
_bstr_t类型是对BSTR的封装，因为已经重载了=操作符，所以很容易使
用
_bstr_t bstrVar("test");
const char *buf = bstrVar;///不要修改buf中的内容
AfxMessageBox(buf);
?通用方法(针对非COM数据类型)
用sprintf完成转换
?char buffer[200]; char c = '1'; int i = 35; long j = 1000; float
f = 1.7320534f; sprintf( buffer, "%c",c); sprintf( buffer, "%d",i);
sprintf( buffer, "%d",j); sprintf( buffer, "%f",f);
二、字符串转换为其它数据类型
strcpy(temp,"123");
?短整型(int)
i = atoi(temp);
?长整型(long)
l = atol(temp);
?浮点(double)
d = atof(temp);
?CString变量
CString name = temp;
?BSTR变量
BSTR bstrValue = ::SysAllocString(L"程序员");
...///完成对bstrValue的使用
SysFreeString(bstrValue);
?CComBSTR变量
CComBSTR类型变量可以直接赋值
CComBSTR bstrVar1("test");
CComBSTR bstrVar2(temp);
?_bstr_t变量
_bstr_t类型的变量可以直接赋值
_bstr_t bstrVar1("test");
_bstr_t bstrVar2(temp);
三、其它数据类型转换到CString
使用CString的成员函数Format来转换,例如:
?整数(int)
str.Format("%d",i);
?浮点数(float)
str.Format("%f",i);
?字符串指针(char *)等已经被CString构造函数支持的数据类型可以直接赋值
str = username;
?对于Format所不支持的数据类型，可以通过上面所说的关于其它数据类型转化到char *的方法先转到char *，然后赋值给CString变量。
四、BSTR、_bstr_t与CComBSTR
?CComBSTR 是ATL对BSTR的封装，_bstr_t是C++对BSTR的封装,BSTR是32位指针,但并不直接指向字串的缓冲区。
char *转换到BSTR可以这样:
BSTR b=_com_util::ConvertStringToBSTR("数据");///使用前需要加上comutil.h和comsupp.lib
SysFreeString(bstrValue);
反之可以使用
char *p=_com_util::ConvertBSTRToString(b);
delete p;
具体可以参考一，二段落里的具体说明。
CComBSTR与_bstr_t对大量的操作符进行了重载，可以直接进行=,!=,==等操作，所以使用非常方便。
特别是_bstr_t,建议大家使用它。
五、VARIANT 、_variant_t 与 COleVariant
?VARIANT的结构可以参考头文件VC98\Include\OAIDL.H中关于结构体tagVARIANT的定义。
对于VARIANT变量的赋值：首先给vt成员赋值，指明数据类型，再对联合结构中相同数据类型的变量赋值，举个例子：
VARIANT va;
int a=2001;
va.vt=VT_I4;///指明整型数据
va.lVal=a; ///赋值
?_variant_t是VARIANT的封装类，其赋值可以使用强制类型转换，其构造函数会自动处理这些数据类型。
使用时需加上#include
例如：
long l=222;
ing i=100;
_variant_t lVal(l);
lVal = (long)i;
?
COleVariant的使用与_variant_t的方法基本一样，请参考如下例子：COleVariant v3 = "字符串", v4 = (long)1999;
CString str =(BSTR)v3.pbstrVal;
long i = v4.lVal;
////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////// //////////////
?本主题演示如何将各种 C++ 字符串类型转换为其他字符串。可以转换的字符串类型包括 char *、wchar_t*、_bstr_t、CComBSTR、CString、basic_string 和System.String。在所有情况下，在将字符串转换为新类型时，都会创建字符串的副本。对新字符串进行的任何更改都不会影响原始字符串，反之亦然。
从 char * 转换
示例
说明
此示例演示如何从 char * 转换为上面列出的其他字符串类型。
// convert_from_char.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
char *orig = "Hello, World!";
cout << orig << " (char *)" << endl;
// Convert to a wchar_t*
size_t origsize = strlen(orig) + 1;
const size_t newsize = 100;
size_t convertedChars = 0;
wchar_t wcstring[newsize];
mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE);
wcscat_s(wcstring, L" (wchar_t *)");
wcout << wcstring << endl;
// Convert to a _bstr_t
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert to a CComBSTR
CComBSTR ccombstr(orig);
if (ccombstr.Append(L" (CComBSTR)") == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a CString
CString cstring(orig);
cstring += " (CString)";
cout << cstring << endl;
// Convert to a basic_string
string basicstring(orig);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
输出
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)
从 wchar_t * 转换
示例
说明
此示例演示如何从 wchar_t * 转换为上面列出的其他字符串类型。// convert_from_wchar_t.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
wchar_t *orig = L"Hello, World!";
wcout << orig << L" (wchar_t *)" << endl;
// Convert to a char*
size_t origsize = wcslen(orig) + 1;
const size_t newsize = 100;
size_t convertedChars = 0;
char nstring[newsize];
wcstombs_s(&convertedChars, nstring, origsize, orig, _TRUNCATE);
strcat_s(nstring, " (char *)");
cout << nstring << endl;
// Convert to a _bstr_t
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert to a CComBSTR
CComBSTR ccombstr(orig);
if (ccombstr.Append(L" (CComBSTR)") == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a CString
CString cstring(orig);
cstring += " (CString)";
cout << cstring << endl;
// Convert to a basic_string
wstring basicstring(orig);
basicstring += L" (basic_string)";
wcout << basicstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
输出
Hello, World! (wchar_t *)
Hello, World! (char *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)
从 _bstr_t 转换
示例
说明
此示例演示如何从 _bstr_t 转换为上面列出的其他字符串类型。
// convert_from_bstr_t.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
_bstr_t orig("Hello, World!");
wcout << orig << " (_bstr_t)" << endl;
// Convert to a char*
const size_t newsize = 100;
char nstring[newsize];
strcpy_s(nstring, (char *)orig);
strcat_s(nstring, " (char *)");
cout << nstring << endl;
// Convert to a wchar_t*
wchar_t wcstring[newsize];
wcscpy_s(wcstring, (wchar_t *)orig);
wcscat_s(wcstring, L" (wchar_t *)");
wcout << wcstring << endl;
// Convert to a CComBSTR
CComBSTR ccombstr((char *)orig);
if (ccombstr.Append(L" (CComBSTR)") == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a CString
CString cstring((char *)orig);
cstring += " (CString)";
cout << cstring << endl;
// Convert to a basic_string
string basicstring((char *)orig);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String((char *)orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
输出
Hello, World! (_bstr_t)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (CComBSTR)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)
从 CComBSTR 转换
示例
说明
此示例演示如何从 CComBSTR 转换为上面列出的其他字符串类型。
// convert_from_ccombstr.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
#include "vcclr.h"
using namespace std;
using namespace System;
using namespace System::Runtime::InteropServices;
int main()
{
CComBSTR orig("Hello, World!");
CW2A printstr(orig);
cout << printstr << " (CComBSTR)" << endl;
// Convert to a char*
const size_t newsize = 100;
char nstring[newsize];
CW2A tmpstr1(orig);
strcpy_s(nstring, tmpstr1);
strcat_s(nstring, " (char *)");
cout << nstring << endl;
// Convert to a wchar_t*
wchar_t wcstring[newsize];
wcscpy_s(wcstring, orig);
wcscat_s(wcstring, L" (wchar_t *)");
wcout << wcstring << endl;
// Convert to a _bstr_t
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert to a CString
CString cstring(orig);
cstring += " (CString)";
cout << cstring << endl;
// Convert to a basic_string
wstring basicstring(orig);
basicstring += L" (basic_string)";
wcout << basicstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
输出
Hello, World! (CComBSTR)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CString)
Hello, World! (basic_string)
Hello, World! (System::String)
从 CString 转换
示例
说明
此示例演示如何从 CString 转换为上面列出的其他字符串类型。
// convert_from_cstring.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
CString orig("Hello, World!");
wcout << orig << " (CString)" << endl;
// Convert to a char*
const size_t newsize = 100;
char nstring[newsize];
strcpy_s(nstring, orig);
strcat_s(nstring, " (char *)");
cout << nstring << endl;
// Convert to a wchar_t*
// You must first convert to a char * for this to work. size_t origsize = strlen(orig) + 1;
size_t convertedChars = 0;
wchar_t wcstring[newsize];
mbstowcs_s(&convertedChars, wcstring, origsize, orig, _TRUNCATE);
wcscat_s(wcstring, L" (wchar_t *)");
wcout << wcstring << endl;
// Convert to a _bstr_t
_bstr_t bstrt(orig);
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert to a CComBSTR
CComBSTR ccombstr(orig);
if (ccombstr.Append(L" (CComBSTR)") == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a basic_string
string basicstring(orig);
basicstring += " (basic_string)";
cout << basicstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String(orig);
systemstring += " (System::String)";
Console::WriteLine("{0}", systemstring);
delete systemstring;
}
输出
Hello, World! (CString)
Hello, World! (char *)
Hello, World! (wchar_t *)
Hello, World! (_bstr_t)
Hello, World! (CComBSTR)
Hello, World! (basic_string)
Hello, World! (System::String)
从 basic_string 转换
示例
说明
此示例演示如何从 basic_string 转换为上面列出的其他字符串类型。
// convert_from_basic_string.cpp
// compile with /clr /link comsuppw.lib
#include
#include
#include
#include "atlbase.h"
#include "atlstr.h"
#include "comutil.h"
using namespace std;
using namespace System;
int main()
{
string orig("Hello, World!");
cout << orig << " (basic_string)" << endl;
// Convert to a char*
const size_t newsize = 100;
char nstring[newsize];
strcpy_s(nstring, orig.c_str());
strcat_s(nstring, " (char *)");
cout << nstring << endl;
// Convert to a wchar_t*
// You must first convert to a char * for this to work.
size_t origsize = strlen(orig.c_str()) + 1;
size_t convertedChars = 0;
wchar_t wcstring[newsize];
mbstowcs_s(&convertedChars, wcstring, origsize, orig.c_str(), _TRUNCATE);
wcscat_s(wcstring, L" (wchar_t *)");
wcout << wcstring << endl;
// Convert to a _bstr_t
_bstr_t bstrt(orig.c_str());
bstrt += " (_bstr_t)";
cout << bstrt << endl;
// Convert to a CComBSTR
CComBSTR ccombstr(orig.c_str());
if (ccombstr.Append(L" (CComBSTR)") == S_OK)
{
CW2A printstr(ccombstr);
cout << printstr << endl;
}
// Convert to a CString
CString cstring(orig.c_str());
cstring += " (CString)";
cout << cstring << endl;
// Convert to a System::String
String ^systemstring = gcnew String(orig.c_str());
systemstring += " (System::String)";
词性转换总结与归纳 动词变名词 announce—announcement通知 equip 装备---equipment 装备，器材(不可名) settle—settlement定居，安定 achieve---achievement 成就 amuse--amusement 娱乐 manage---management 经营管理 advertise--- advertisement广告 agree— agreement同意disgree—disagreement不同意 argue---argument争吵commit—commitment奉献 develop---development发展 govern 统治—government 政府 describe—description描写，描绘erupt—eruption爆发 affect—affection影响 satisfy—satisfaction满意，满足select—selection挑选，选择
permit—permission允许admit—admission承认，允许invite—invitation 邀请，请帖devote—devotion献身，专注apply—application申请，申请书produce—production生产，产品protect—protection保护 educate-----education教育consider—consideration考虑attract—attraction 吸引力，吸引instruct—instruction 指导，介绍discuss—discussion 讨论appreciate—appreciation感激，欣赏recognize—recognition认出conclude—conclusion 结论 decide----decision 决定compete—competition比赛 express 表达----expression 词语；表达方式graduate 毕业—graduation operate—operation操作，动手术organize----organization 组织imagine—imagination 想象力
第二章常用数据类型 【学习目标】 本章将学习一些基本的程序概念，如程序结构、标识符、章的学习要 关键字和注释等。本点包括如下几点： （1）了解C语言的基本结构。 （2）分号、块和空白的使用。 （3）标识符的约束规则。 （4）C关键字。 （5 ）直接量的认识。 （6）注释的使用。 【学习导航】 本章的在整个课程中的位置如图2-1所示。 图2-1 本章学习导航
2.1 C语言基本程序结构 任何一种程序设计语言都具有特定的语法规则和规定的表达方法。一个程序只有严格按 照语言规定的语法和表达方式编写，才能保证编写的程序在计算机中能正确地执行，同时也 便于阅读和理解。为了了解C语言的基本程序结构，请看【课堂案例2-1】。 【课堂案例2-1】在控制台输出“你好”。 【案例目标】会使用Xcode编辑器实现字符串输出 【案例知识要点】C语言的程序结构、基本输出语句 【案例程序代码】hello.c 1#i nclude
常见词形变化动词变名词 1.v+ ment 结尾 achieve---achievement 成就advertise--- advertisement// advertising agree— agreement appoint----appointment disappoint----disappointment disagree --- disagreement amuse----amusement 娱乐 argue---argument争吵commit—commitment奉献develop---development equip ---equipment 装备，器材govern 统治—government 政府manage---management 经营管理 2．V+ tion/sion 结尾 admit—admission承认attract—attraction 有吸引力的事或人； conclude—conclusion 结论compete—competition 竞争，比赛consider---consideration discuss—discussion 讨论 decide----decision describe—description描写，描绘direct---direction determine---determination educate-----education explain----explanation express ----expression graduate—graduation hesitate---hesitation invite—invitation imagine—imagination 想象力introduce—introduction 介绍instruct—instruction 指导，介绍invent—inventor / invention illustrate --illustration inspire---inspiration 灵感，鼓舞 人心的 impress—impression operate—operation organize----organization permit---permission pollute----pollution predict---prediction prepare---preparation pronounce ---pronunciation resolve -----resolution 决心 suggest --suggestion solve -----solution satisfy----satisfaction 3．V+ ance /ence结尾 allow—allowance 允许appear—appearance 外貌，出现disappear---disappearance 消失perform----performance --performer exist—existence 存在 4．V+ ing 结尾 bathe 洗澡---bathing end 结束----ending 结尾，结局train 训练---training mean ---- meaning 意义say-----saying 谚语 5．V+ 其他 able---ability---disable assist----assisitant analyze---analysis arrive-- arrival到达 beg(乞讨)—beggar 乞丐believe—belief 信仰 behave ----behavior die---dead----death employ--employer雇主--employee雇员 know---knowledge
1. MYSQL 5数据类型,长度范围 1.1数值类型 MySQL支持所有标准SQL数值数据类型.这些类型包括严格数值数据类型(INTEGER,SMALLINT,DECIMAL和NUMERIC),以及近似数值数据类型 (FLOAT,REAL 和DOUBLE PRECISION).关键字INT是INTEGER的同义词,关键字DEC是DECIMAL 的同义词. BIT 数据类型保存位字段值,并且支持MyISAM,MEMORY,InnoDB和BDB表.作为SQL标准的扩展,MySQL也支持整数类型 TINYINT,MEDIUMINT和BIGINT.下面的表显示了需要的每个整数类型的存储和范围. MySQL还支持选择在该类型关键字后面的括号内指定整数值的显示宽度(例 如,INT(4)).该可选显示宽度规定用于显示宽度小于指定的列宽度的值时从左侧填满宽度. 显示宽度并不限制可以在列内保存的值的范围,也不限制超过列的指定宽度的值的显示. 当结合可选扩展属性ZEROFILL使用时, 默认补充的空格用零代替.例如,对于声明为INT(5) ZEROFILL的列,值4检索为00004.请注意如果在整数列保存超过显示宽度的一个值,当MySQL为复杂联接生成临时表时会遇到问题,因为在这些情况下MySQL相信数据适合原列宽度. 所有整数类型可以有一个可选(非标准)属性UNSIGNED.当你想要在列内只允许 非负数和该列需要较大的上限数值范围时可以使用无符号值. 浮点和定点类型也可以为UNSIGNED.同数类型,该属性防止负值保存到列中.然而,与整数类型不同的是,列值的上范围保持不变. 如果为一个数值列指定ZEROFILL,MySQL自动为该列添加UNSIGNED属性. 对于浮点列类型,在MySQL中单精度值使用4个字节,双精度值使用8个字节. FLOAT类型用于表示近似数值数据类型.SQL标准允许在关键字FLOAT后面的括号内选择用位指定精度(但不能为指数范围).MySQL还支持可选的只用于确定存储大小的精度规定.0到23的精度对应FLOAT 列的4字节单精度.24到53的精度对应DOUBLE列的8字节双精度. MySQL允许使用非标准语法:FLOAT(M,D)或 REAL(M,D)或DOUBLE PRECISION(M,D).这里,"(M,D)"表示该值一共显示M位整数,其中D位位于小数点后面.例如,定义为FLOAT(7,4)的一个列可以显示为-999.9999.MySQL保存值时进行四舍五入,因此如果在FLOAT(7,4)列内插入999.00009,近似结果是999.0001.
(1) 整数型 整数包括bigint、int、smallint和tinyint，从标识符的含义就可以看出，它们的表示数范围逐渐缩小。 l bigint：大整数，数范围为-263 (-9223372036854775808)～263-1 (9223372036854775807) ，其精度为19，小数位数为0，长度为8字节。 l int：整数，数范围为-231 (-2,147,483,648) ～231 - 1 (2,147,483,647) ，其精度为10，小数位数为0，长度为4字节。 l smallint：短整数，数范围为-215 (-32768) ～215 - 1 (32767) ，其精度为5，小数位数为0，长度为2字节。 l tinyint：微短整数，数范围为0～255，长度为1字节，其精度为3，小数位数为0，长度为1字节。 (2) 精确整数型 精确整数型数据由整数部分和小数部分构成，其所有的数字都是有效位，能够以完整的精度存储十进制数。精确整数型包括decimal 和numeric两类。从功能上说两者完全等价，两者的唯一区别在于decimal不能用于带有identity关键字的列。 声明精确整数型数据的格式是numeric | decimal(p[,s])，其中p为精度，s为小数位数，s的缺省值为0。例如指定某列为精确整数型，精度为6，小数位数为3，即decimal(6,3)，那么若向某记录的该列赋值56.342689时，该列实际存储的是56.3427。 decimal和numeric可存储从-1038 +1 到1038 –1 的固定精度和小数位的数字数据，它们的存储长度随精度变化而变化，最少为5字节，最多为17字节。 l 精度为1～9时，存储字节长度为5； l 精度为10～19时，存储字节长度为9； l 精度为20～28时，存储字节长度为13； l 精度为29～38时，存储字节长度为17。 例如若有声明numeric(8,3)，则存储该类型数据需5字节，而若有声明numeric(22,5)，则存储该类型数据需13字节。 注意：声明精确整数型数据时，其小数位数必须小于精度；在给精确整数型数据赋值时，必须使所赋数据的整数部分位数不大于列的整数部分的长度。 (3) 浮点型 浮点型也称近似数值型。顾名思义，这种类型不能提供精确表示数据的精度，使用这种类型来存储某些数值时，有可能会损失一些精度，所以它可用于处理取值范围非常大且对精确度要求不是十分高的数值量，如一些统计量。
动词变名词1.v+ ment 结尾 achieve---achievement 成就advertise--- advertisement// advertising agree— agreement apartment 公寓 amusement 娱乐 argue---argument争吵 commit奉献—commitment compliment 称赞，恭维develop---development disgree—disagreement department 局，部 experiment 实验，试验 equip 装备---equipment 装备，器材govern 统治—government 政府manage---management 经营管理 2．V+ tion 结尾 admit 承认—admission attract吸引—attraction 有吸引力的事或人；令人向往的地方 conclude—conclusion 结论compete—competition 竞争，比赛discuss—discussion 讨论 educate-----education decide----decision describe—description描写，描绘express 表达----expression 词语；表达方式 graduate 毕业—graduation operate 操作，动手术—operation organize----organization imagine—imagination 想象力introduce—introduction 介绍instruct—instruction 指导，介绍invent—inventor / invention illustrate 阐明，举例说明--illustration invite—invitation inspire---inspiration 灵感，鼓舞人心的--- pollute----pollution 污染 predict---prediction 预言 pronounce ---pronunciation resolve 决心-----resolution 决心impress 给人印象—impression 印象permit 允许-----permission suggest-建议，暗示--suggestion solve解决-----solution 解决方法 3．V+ ance 结尾 allow—allowance 允许appear—appearance 外貌，出现perform----performance 演出exist—existance 存在 4．V+ ing 结尾 bathe 洗澡---bathing end 结束----ending 结尾，结局train 训练---training mean ---- meaning 意义say-----saying 谚语 5．V+ 其他 Beg(乞讨)—beggar 乞丐sit--seat 座位employ--employer 雇主，老板--employee雇员 believe—belief 信仰 behave 行为，举止----behavior know---knowledge fly—flight 飞行 heat 加热---heat 热量 hit 撞击------hit 轰动一时的人或物，碰撞mix 混合-----mixture 混合物 press 按，压—pressure 压力receive—receptionist 接待员serve—service 服务 succeed-- success tour 在-----旅游，在-----作巡回演出直接+地点tour China ---tour 旅游/
附件2： 中国航信标准数据格式
目录 中国航信标准数据使用说明 (3) 中国航信标准数据格式说明 (5) 中国航信标准数据格式 (7) 航班数据 (7) SCH数据 (8) 收益数据 (11) PNR数据（销售） (16) PNR数据（成行） (18) TCN数据 (20) CKI数据（详细） (33) CKI数据（汇总） (36) LDP数据 (38) BIDT数据 (41) MIDT数据 (43) 中国航信标准数据传输和保障流程 (45)
中国航信标准数据使用说明 中国航信作为国内航空公司共同发起设立的民航业IT服务公司，致力于为股东航空公司提供优质高效的民航业信息技术服务。为全力支持和配合航空公司针对本公司数据的一切合理使用的要求，辅助航空公司的日常运营和管理决策，中国航信整合三大业务系统数据，起草了《中国航信标准数据格式》。 《中国航信标准数据格式》是以中国航信的航班控制系统（ICS）、计算机分销系统（CRS）、离港系统（DCS）为依托，提取了包括收益、PNR、票面、值机、配载等信息在内的民航业常用数据，并参考国际通行数据标准，制定了中国航信标准的BIDT/MIDT数据格式。它是根据中国航信的实际情况和航空公司业务发展需要提出的，目的是通过规范数据格式的标准和提供方式，尽最大可能满足航空公司对数据的需求，调整和密切双方的合作关系，最大程度的保障航空公司的业务发展。 针对该数据格式的使用，特作如下说明： 1、该数据的提供对象为所有HOST在航信并与航信正式签署《航空公司服 务协议》的航空公司； 2、考虑到航空公司对数据的自主所有权，除MIDT数据外，其余数据均只 涉及本航空公司数据，不提供竞争数据； 3、该格式充分考虑了航空公司数据需求的多样性，在一段时间内保持稳定， 航信会定期进行标准数据格式的修改，主要是针对航空公司集中反映的 数据项予以调整，此调整将通报所有航空公司并在得到大部分航空公司 的书面认可后进行；
Excel中常用的数据类型 在Excel的单元格中可以输入多种类型的数据，如文本、数值、日期、时间等等。下面简单介绍这几种类型的数据。 1．字符型数据。在Excel中，字符型数据包括汉字、英文字母、空格等，每个单元格最多可容纳32000个字符。默认情况下，字符数据自动沿单元格左边对齐。当输入的字符串超出了当前单元格的宽度时，如果右边相邻单元格里没有数据，那么字符串会往右延伸；如果右边单元格有数据，超出的那部分数据就会隐藏起来，只有把单元格的宽度变大后才能显示出来。 如果要输入的字符串全部由数字组成，如邮政编码、电话号码、存折帐号等，为了避免Excel把它按数值型数据处理，在输入时可以先输一个单引号“'”(英文符号)，再接着输入具体的数字。例如，要在单元格中输入电话号码“64016633”，先连续输入“'64016633”，然后敲回车键，出现在单元格里的就是“64016633”，并自动左对齐。 2．数值型数据。在Excel中，数值型数据包括0~9中的数字以及含有正号、负号、货币符号、百分号等任一种符号的数据。默认情况下，数值自动沿单元格右边对齐。在输入过程中，有以下两种比较特殊的情况要注意。 (1)负数：在数值前加一个“”号或把数值放在括号里，都可以输入负数，例如要在单元格中输入“66”，可以连续输入“66”“(66)”，然后敲回车键都可以在单元格中出现“66”。 (2)分数：要在单元格中输入分数形式的数据，应先在编辑框中输入“0”和一个空格，然后再输入分数，否则Excel会把分数当作日期处理。例如，要在单元格中输入分数“2/3”，在编辑框中输入“0”和一个空格，然后接着输入“2/3”，敲一下回车键，单元格中就会出现分数“2/3”。 3．日期型数据和时间型数据。在人事管理中，经常需要录入一些日期型的数据，在录入过程中要注意以下几点： (1)输入日期时，年、月、日之间要用“/”号或“-”号隔开，如“2002-8-16”“2002/8/16”。 (2)输入时间时，时、分、秒之间要用冒号隔开，如“10:29:36”。 (3)若要在单元格中同时输入日期和时间，日期和时间之间应该用空格隔开。 （信息技术教育室供稿）
动词变名词 + ment 结尾 achieve---achievement 成就advertise--- advertisement词+ ed balance –balanced 平衡的 spot 斑点，地点----spotted 有斑点的talent-----talented 有天赋的organized 有组织的 distusted 厌恶的offended 生气的crowded 拥挤的polluted 被污染的pleased 高兴的 3．名词+ ful/less meaning—meaningful 有意义的care—careful/ careless 小心的；粗心的 help---helpful / helpless home—homeless 无家可归的 colour---colourful pain 疼痛---painful 痛苦的 use---useless/ useful thank—thankful 充满感激的 peace 和平---- peaceful 平静的，宁静的 playful 顽皮的，爱玩耍的 4．名词+ able adjustable 可调整的comfort---comfortable knowledge---knowledgeable suit 一套-----suitable 合适的 5.名词+ ous courage—courageous 勇敢的danger—dangerous mystery 神秘-----mysterious 神秘的变t confidence----confident difference---different dependence—dependent independence--independent 7. al 结尾 Addition—additional 附加的，额外的Class—classical 经典的 medicine 药----medical 医学的music---musical nature---natural 自然的 person---personal (私人的)nation—national 国家的 education---educational有教育意义的tradition----traditional 传统的 origin起源---original 新颖的；独创的grammar—grammatical 语法的globe—global 全球的 8．名词+ ly friend—friendly live---lively 活跃的，有生气的love—lovely 可爱的9.+ en 结尾wood—wooden 木制的wool—woolen 羊毛的 10. 其他 energy精力---energetic strategy—strategic 战略的 fool 傻子—foolish 愚蠢的freedom 自由—free 空的，免费的height 高度—high illness 疾病--- ill love—loving 慈爱的 death---dead pleasure---pleasant / pleased popularity 流行性—popular
任务型阅读常用词汇词性转换 动词变名词 1.v+ ment 结尾 achieve---achievement 成就 advertise--- advertisement// advertising agree— agreement apartment 公寓 amusement 娱乐 argue---argument争吵 commit奉献—commitment develop---development disgree—disagreement department 局，部 experiment 实验，试验 equip 装备---equipment 装备，器材 govern 统治—government 政府 manage---management 经营管理 2．V+ tion 结尾 admit 承认—admis sion attract吸引—attraction 有吸引力的事或人；令人向往的地方conclude—conclusion 结论 compete—competition 竞争，比赛 discuss—discussion 讨论 educate-----education decide----decision describe—description描写，描绘 express 表达----expression 词语；表达方式 graduate 毕业—graduation operate 操作，动手术—operation organize----organization imagine—imagination 想象力 introduce—introduction 介绍 instruct—instruction 指导，介绍 invent—inventor / invention invite—invitation pollute----pollution 污染 predict---prediction 预言 pronounce ---pronunciation impress 给人印象—impression 印象 permit 允许-----permission suggest-建议，暗示--suggestion solve解决-----solution 解决方法 3．V+ ance 结尾
刚接触编程地朋友往往对许多数据类型地转换感到迷惑不解，本文将介绍一些常用数据类型地使用. 我们先定义一些常见类型变量借以说明 ; ; ; ; []"程佩君"; []; *; ; ; ; 一、其它数据类型转换为字符串 短整型() ()将转换为字符串放入中,最后一个数字表示十进制 (); 按二进制方式转换 长整型() (); 浮点数() 用可以完成转换,这是中地例子: , ; *; ; ( , , , ); 运行结果: : '' : : 资料个人收集整理，勿做商业用途 表示小数点地位置表示符号为正数，为负数 变量 "北京奥运"; ()(); 变量 ("程序员"); * (); 资料个人收集整理，勿做商业用途 (); (); (); 变量 (""); * (); 资料个人收集整理，勿做商业用途 (); (); 变量 类型是对地封装，因为已经重载了操作符，所以很容易使用 ("");
* 不要修改中地内容 (); 通用方法(针对非数据类型) 用完成转换 []; ''; ; ; ; ( , ""); ( , ""); ( , ""); ( , ""); 二、字符串转换为其它数据类型 (,""); 短整型() (); 长整型() (); 浮点() (); 变量 ; 变量 ("程序员"); 完成对地使用 (); 变量 类型变量可以直接赋值 (""); (); 变量 类型地变量可以直接赋值 (""); (); 三、其它数据类型转换到 使用地成员函数来转换,例如: 整数() (""); 浮点数() (""); 字符串指针( *)等已经被构造函数支持地数据类型可以直接赋值 ; 对于所不支持地数据类型，可以通过上面所说地关于其它数据类型转化到*地方法先转到*，
V-N 1.v + ment achieve-achievement advertise-advertisement agree-agreement/advertising amuse-amusement argue-argument commit-commitment compliment- compliment develop-development disgree-disagreement depart-department experiment- experiment equip-equipment govern-government manage-management
2．V + tion admit-admission attract-attraction conclude-conclusion compete-competition discuss-discussion educate-education decide-decision describe-description express-expression graduate-graduation operate-operation organize-organization imagine-imagination introduce-introduction instruct-instruction invent-inventor / invention illustrate-illustration invite-invitation inspire-inspiration pollute-pollution predict-prediction pronounce-pronunciation resolve-resolution impress-impression permit-permission suggest-suggestion solve-solution
形容词变名词 efficient有效率的—efficiency 效率 patient—patience/impatience dependent—dependence依赖性 independent—independency 独立性 true—truth high—height wide—width long—length possible—possibility responsible—responsibility urgent—urgency 紧急 prosperous—prosperity 繁荣 accurate—accuracy 准确性 形容词变动词 modern—modernize social--socialize fast--fasten short/shorten long—lengthen—length(n.) wide--widen less--lessen strong—strengthen—strength(n.) large—enlarge 名词变动词 computer—computerize 名词---形容词—副词 beauty 美，美人—beautiful—beautifully care—careful—carefully
care—careless—carelessly difference---different---differently fortune—fortunate—fortunately/unfortunately happiness—happy—happily hunger—hungry--hungrily health—healthy—healthily luck—lucky—luckily noise—noisy—noisily pride—proud—proudly骄傲地 sadness—sad—sadly safety 安全；安全的地方—safe—safely silence—silent---silently 默默地 success—successful—successfully truth—true—truly unluck—unlucky—unluckily wonder 奇迹—wonderful—wonderfully 方位的词名词—形容词 East—eastern West—western South—southern North---northern In the west of China In the western part of China 四大洲名词-----形容词 Africa 非洲----- African Europe欧洲----- European America 美洲-----American Asia 亚洲–---- Asian
3.2C语言的基本数据类型及其表示 C语言的基本数据类型包括整型数据、实型数据和字符型数据，这些不同数据类型如何表示？如何使用？它们的数据范围是什么？下面我们分别进行介绍。 3.2.1常量与变量 1.常量 常量是指程序在运行时其值不能改变的量，它是Ｃ语言中使用的基本数据对 象之一。Ｃ语言提供的常量有： 以上是常量所具有的类型属性，这些类型决定了各种常量所占存储空间的大小和数的表示范围。在C程序中，常量是直接以自身的存在形式体现其值和类型，例如：123是一个整型常量，占两个存储字节，数的表示范围是-32768～32767；123.0是实型常量，占四个存储字节，数的表示范围是-3.410-38～3.41038。 需要注意的是，常量并不占内存，在程序运行时它作为操作对象直接出现在运算器的各种寄存器中。 2.符号常量 在C程序中，常量除了以自身的存在形式直接表示之外，还可以用标识符来表示常量。因为经常碰到这样的问题：常量本身是一个较长的字符序列，且在程序中重复出现，例如：取常数的值为3.1415927，如果在程序中多处出现，直接使用3.1415927的表示形式，势必会使编程工作显得繁琐，而且，当需要把的值修改为3.1415926536时，就必须逐个查找并修改，这样，会降低程序的可修改性和灵活性。因此，Ｃ语言中提供了一种符号常量，即用指定的标识符来表示某个常量，在程序中需要使用该常量时就可直接引用标识符。 Ｃ语言中用宏定义命令对符号常量进行定义，其定义形式如下： #define标识符常量 其中#define是宏定义命令的专用定义符，标识符是对常量的命名，常量可以是前面介绍的几种类型常量中的任何一种。该使指定的标识符来代表指定的常量，这个被指定的标识符就称为符号常量。例如，在C程序中，要用PAI代表实型常量3.1415927，用W代表字符串常量"Windows98"，可用下面两个宏定义命令： #define PAI3.1415927 #define W"Windows98" 宏定义的功能是：在编译预处理时，将程序中宏定义（关于编译预处理和宏定义的概念详见9.10节）命令之后出现的所有符号常量用宏定义命令中对应的常量一一替代。例如，对于以上两个宏定义命令，编译程序时，编译系统首先将程序中除这两个宏定义命令之外的所有PAI替换为3.1415927，所有W替换为Windows98。因此，符号常量通常也被称为宏替换名。 习惯上人们把符号常量名用大写字母表示，而把变量名用小写字母表示。例3-1是符号常量的一个简单的应用。其中，PI为定义的符号常量，程序编译时，用3.1416替换所有的PI。 例3-1：已知圆半径r，求圆周长c和圆面积s的值。
词汇转换大全 v. n. adj. appoint appointment appointed disable ability; disability able; unable;disabled absent absence absent absolute absorb absorbed accept acceptance acceptable access access accessible accident accidental; accomplish accomplishment accomplished achieve achievement achievable act action/actor/actress activity active addict addiction addicted add addition additional adjust adjustment adjustable admire admiration admirable admit admission advance advance advanced advantage advantage advantageous advertise advertisement advise advice age age aged agree agreement agreeable agriculture agricultural allow allowance allowable amaze amazement amazing / amazed ambition ambition ambitious amuse amusement amusing / amused analyze analysis analytic anger angry (angrily) announce announcement annoy annoyance annoying annual annual anxiety anxious apologize apology apologetic appear appearance apply applicant/applicatio n appreciate appreciation approve approval argue argument arrange arrangement arrive arrival
标准的数据类型 Standardization of sany group #QS8QHH-HHGX8Q8-GNHHJ8-HHMHGN#
附录C：CoDeSys中的数据类型 标准数据类型 数据类型 用户编程时可以使用标准和自定义数据类型。每个标识符与一种数据类型匹配。数据类型决定了存储内 存空间的大小以及它所存储的值的类型。 布尔变量(BOOL) 布尔类型变量的取值是TRUE(真) 和 FALSE(假). 它保留8 位的存储空间. 参照: BOOL 常量 参看章节 10，11, CoDeSys 中的操作数 , BOOL 常量 整数数据类型 BYTE, WORD, DWORD, SINT, USINT, INT, UINT, DINT, 和UDINT都是整型数据类型。每个不同的数据 类型包含一系列不同的值。下表列出了各整型数据类型的范围界限： 类型下限上限存储器空间 BYTE 0 255 8 位 WORD 0 65535 16 位 位 SINT: -128 127 8 位 USINT: 0 255 8 位 INT: -32768 32767 16 位
UINT: 0 65535 16 位 位 位 当大的数据类型转换成小的数据类型时，有可能导致信息丢失。 参照: 数字常数 也可参看10，11 章，CoDeSyS 中的操作数。 REAL / LREAL REAL 和 LREAL 就是所谓的浮点型类型。他们指代有理数。其中REAL 占32 位存储空间，LREAL 则占64。 REAL 存储范围：～ LREAL 存储范围：～ 也可参见章，REAL-/LREAL 常数 参照:REAL-/LREAL常数 字符串 10－附录 CoDeSys 10-31 字符串类型变量可包含任何一串字符。声明时变量的大小就决定为变量保留多大的存储空间。 此涉及字符串的字符数并可放入圆括号和方括号内。如果未给出变量的大小规格，默认大小 为80 个字符。 基本上，在CoDeSys 中，字符串的长度没有限制，但是字符串的功能仅可以处理1-255 个字符！ 35 个字符串声明的例子：
Java中几种常用的数据类型之间转换方法：1.短整型-->整型 如: short shortvar=0; int intvar=0; shortvar= (short) intvar 2.整型-->短整型 如: short shortvar=0; int intvar=0; intvar=shortvar; 3.整型->字符串型 如: int intvar=1; String stringvar; Stringvar=string.valueOf (intvar); 4.浮点型->字符串型 如: float floatvar=9.99f; String stringvar; Stringvar=String.valueOf (floatvar); 5.双精度型->字符串型 如： double doublevar=99999999.99; String stringvar; Stringvar=String.valueOf (doublevar); 6. 字符型->字符串型 如：char charvar=’a’; String stringvar;
Stringvar=String.valueOf (charvar); 7字符串型->整型、浮点型、长整型、双精度型如：String intstring=”10”; String floatstring=”10.1f”; String longstring=”99999999”; String doubleString=”99999999.9”; Int I=Integer.parseInt (intstring); Float f= Integer.parseInt (floatstring); Long lo=long. parseInt (longstring); Double d=double. parseInt (doublestring); 8字符串型->字节型、短整型 如：String s=”0”; Byte b=Integer.intValue(s); Short sh=Integer.intValue(s); 9字符串型->字符型 如： String s=”abc”; Char a=s.charAt(0); 10字符串型-->布尔型 String s=”true”; Boolean flag=Boolean.valueOf (“s”);