from c++0x/c++2011standard.
|
typename |
g++4.5-32bit |
g++4.5-64bit |
vc10.0-32bit |
vc10.0-64bit |
|
char |
1 |
1 |
1 |
1 |
|
char16_t |
2 |
2 |
2 |
2 |
|
char32_t |
4 |
4 |
4 |
4 |
|
wchar_t |
4 |
4 |
2 |
2 |
|
short |
2 |
2 |
2 |
2 |
|
int |
4 |
4 |
4 |
4 |
|
long |
4 |
8 |
4 |
4 |
|
long long |
8 |
8 |
8 |
8 |
|
float |
4 |
4 |
4 |
4 |
|
double |
8 |
8 |
8 |
8 |
|
long double |
12 |
16 |
8 |
8 |
|
派生成员函数指针(单继承) |
8 |
16 |
4 |
8 |
|
派生成员函数指针(多继承) |
8 |
16 |
8 |
16 |
|
派生成员函数指针(虚继承) |
8 |
16 |
12 |
16 |
#ifdef __linux__
#define __stdcall __attribute__((__stdcall__))
#define __thiscall __attribute__((__thiscall__))
#define __cdecl __attribute__((__cdecl__))
#define __fastcall __attribute__(__fastcall__))
#endif
RetType call_convFuncName(ParamType param);
example: RecursiveCall
int __cdeclcalc_sum(int sum, inti)
{
if( 0 == i )
{
return sum;
}
sum += i;
return calc_sum(sum, --i);
}
if( cond1)
{
statement1;
}
else if(cond2 )
{
statement2;
}
else
{
statement3;
}
switch(flg )
{
case 1:
statement1;
break;
case 2:
statement2;
break;
default:
statement3;
}
while(condition )
{
statements;
}
do {
statements;
} while( condition );
for( ;condition; )
{
statements;
}
loop:
statements;
if( condition )
{
goto loop;
}
(1)thinking:
int i =1;
int j =(++i) + (i++) + (++i);
VC6.0/GNUgcc/g++: i = 4, j = 7
VS2005/2008/2010: i = 4, j = 9;
(2)thedifference of following statements:
char* lpszStr1 = "hello world";
const char* lpszStr2 = "helloworld";
char lpszStr3[] = "helloworld";
(3)thedifferent of pointer and reference
int i=0;
int& j=i;
int* k=&i;// int* k=&j;
ref,alias(the same entity) pointer,address(addressof entity)
In fact, the implement of pointer and referenceby assembly is the same. Such as following:
int i = 5;
int* pi = &i;
int ri = i;
The corresponding assembly code:
mov dword [i], 5
lea eax, [i]
mov dword ptr[pi], eax;
lea eax, dword ptr[i]
mov dword ptr[ri], eax
(4) enumtype
4 bytessigned in 32bit-program
8 bytes signed in 64bit-program
(5) macro
#define parse_to_string(macro_arg) #macro_arg
#define contact(arg1, arg2) arg1##arg2
(6)templatespecialization in class.
VisualStudio support explicit and implicit specialization
GCC just support implicit specialization.
vs2010 introduce:
1.lambda expression
genericsyntax:
[](ParaType para) ->RetType//->RetType: specific return type
{
statements;
}
[] : lambdaexpr prefix
othersyntax:
(1)
int local= 0;
int result= [&](void) ->int
{
return ++local;
}();
or
int result= [&local](void) ->int
{
return ++local;
}();
(2)
int local= 0;
int result= [=](void) mutable ->int
{
return ++local;
}();
or
int result= [local](void) mutable->int
{
return ++local;
}();
2.static_assert
example:
template<typename _Ty, typename _Tx>
_Typointer_cast(_Tx sptr)
{
static_assert(std::tr1::is_pointer<_Tx>::value&&
std::tr1::is_pointer<_Ty>::value,
“the type of src and dstoperand must be pointer”);
union {
_Txs_ptr;
_Tyd_ptr;
} uData;
uData.s_ptr = sptr;
return uData.d_ptr;
}
3.support new means for keyword: auto, type deduction.
example:
auto i =3; // be similar to var in C#
4.rvalue, it can bind on a temporary.
example:
template<typename T>
class Integer
{
public:
Integer(void)
{
this->data = T();
}
Integer(const T&data)
{
this->data = data;
}
Integer(const Integer&integer)
{
this->data = integer.data;
}
bool operator==(const Integer&integer)
{
return this->data == integer.data;
}
bool operator==(const Integer&&integer)
{
return *this == integer;
}
private:
T data;
};
5.decltype usage:
auto i =1;
auto j =1.0f;
typedef decltype(j) JType;
gcc 4.5 ext support
6.new keywords: char16_t, char32_t
example:
char16_t f[]= u”hello world!”;
char32_t e[]= U”hello world!”;
Win32vc6.0, 8.0, 9.0, 10.0
int a = 3, b = 0;
__asm moveax, a;
__asm movb, eax;
Linux32
int a =3, b = 0;
__asm__ [__volatile__](“movl %1, %0” : “=r”(b) : “m” (a));
or
asm [volatile](“movl%1, %0” : “=r”(b) : “m”(a));
example:
template<typename bchar>
__declspec(naked)
int __cdecl _strlen(const bchar*)
{
__asm
{
movesi, dword ptr[esp + 4];
moveax, -1;
cmpesi, 0;
jzend__;
label:
movcl, byte ptr [esi];
incesi;
inceax;
cmpcl, 0;
jnzlabel;
end__:
ret;
}
}
template<typename wchar>
__declspec(naked)
int __cdecl _wcslen(const wchar*)
{
__asm
{
movesi, dword ptr[esp + 4];
moveax, -1;
cmpesi, 0;
jzend;
label:
movcx, word ptr [esi];
incesi;
inceax;
cmpcx, 0;
jnzlabel;
end:
ret;
}
}
template<typename bchar>
__declspec(naked)
char* __cdecl_strcpy(bchar*, const bchar*, int)
{
__asm
{
movecx, dword ptr[esp + 12]
movesi, dword ptr[esp + 8];
movedi, dword ptr[esp + 4];
incecx;
repmovsb;
moveax, edi;
subeax, dword ptr[esp + 12];
deceax;
ret;
}
}
template<typename wchar>
__declspec(naked)
wchar_t* __cdecl_wcscpy(wchar*, const wchar*, int)
{
__asm
{
movecx, dword ptr[esp + 12]
movesi, dword ptr[esp + 8];
movedi, dword ptr[esp + 4];
incecx;
repmovsw;
moveax, edi;
subeax, dword ptr[esp + 12];
subeax, dword ptr[esp + 12];
subeax, 2;
ret;
}
}
template<typename bchar>
__declspec(naked)
char* __cdecl_strcat(bchar*, int, constbchar*, int)
{
__asm
{
movecx, dword ptr[esp + 16];
movesi, dword ptr[esp + 12];
movedx, dword ptr[esp + 8];
movedi, dword ptr[esp + 4];
addedi, edx;
repmovsb;
movbyte ptr[edi], 0;
moveax, edi;
subeax, dword ptr[esp + 16];
subeax, edx;
ret;
}
}
template<typename wchar>
__declspec(naked)
wchar_t* __cdecl_wcscat(wchar*, int, constwchar*, int)
{
__asm
{
movecx, dword ptr[esp + 16];
movesi, dword ptr[esp + 12];
movedx, dword ptr[esp + 8];
addedx, dword ptr[esp + 8];
movedi, dword ptr[esp + 4];
addedi, edx;
repmovsw;
movword ptr[edi], 0;
moveax, edi;
subeax, dword ptr[esp + 16];
subeax, dword ptr[esp + 16];
subeax, edx;
ret;
}
}
原文地址：http://blog.csdn.net/xseekerj/article/details/25697183
