99re66热这里只有精品4,蜜臀久久99精品久久久久久9,在线中文字幕一区

�~�译报错�Q?lib/../lib64/crt1.o�Q�在函数‘_start’中(.text+0x20)对‘main’未定义的引�?collect2: error: ld returned 1exit status

��王 — Tue, 05 Mar 2024 04:18:00 GMT

不用怀疑，把main()函数�q�没了，下次仔细��查一下吧�Q�尼玛！

��王 2024-03-05 12:18 发表评论

��王 — Thu, 20 Oct 2022 07:34:00 GMT

��数点后保留2位数�Q?br />
float x = 100.1234;

char buf[8] = { 0 };

::sprintf(buf, "%0.2lf", x);

��王 2022-10-20 15:34 发表评论

CMake报错�Q?STREQUAL" "x86_64" Unknown arguments specified

��王 — Wed, 22 Dec 2021 08:24:00 GMT

使用CMake时报错：(x��)

"STREQUAL" "x86_64" Unknown arguments specified
解决�Q?br />
if($ENV(COMPILING_TYPE) STREQUAL "x86_64")
改�ؓ(f��)�Q?/span>
if(($ENV(COMPILING_TYPE)) STREQUAL "x86_64")

O了！

��王 2021-12-22 16:24 发表评论

��王 — Fri, 10 Jan 2020 07:11:00 GMT

make_unique是包含在C++14中的�Q�gcc版本�q�低�Q�安装新版本gcc�Q�比�?.x
1、安装centos-release-scl
sudo yum install centos-release-scl
2、安装devtoolset
sudo yum install devtoolset-9-gcc*
�Q�如果想安装7.*版本的，��改成devtoolset-7-gcc*�Q?
3、激�z�d��应的devtoolset�Q�所以你可以一�ơ安装多个版本的devtoolset�Q?br />需要的时候用下面以下命��o(h��)切换到对应的版本
scl enable devtoolset-9 bash
4、查看gcc版本 gcc -v 昄��?.x O了！

��王 2020-01-10 15:11 发表评论

��王 — Mon, 13 Sep 2010 16:24:00 GMT

double pow(double x double k);
�q�回x的k�ơ方�Q�可以另k=1/n,则函数返回的是x的n�ơ方�?

��王 2010-09-14 00:24 发表评论

代码自动生成-宏带来的奇技淫��y

��王 — Tue, 22 Jun 2010 15:54:00 GMT

摘要: 阅读全文

��王 2010-06-22 23:54 发表评论

VS2005/2008 warning C4251 needs to have dll-interface

��王 — Wed, 07 Apr 2010 00:57:00 GMT

   �E�序中消除warning有两�U�方法：(x��)消极一点不�ȝ��他，反正不是error:-)�Q�积极一点，则想办法��L��。去掉又用两�U�方法：(x��)一�U��?pragma warning(disable: xxxx)�Q�眼不见�Q�心不烦�Q�另外就是找��决问题的办法了�?br> 今天做dll库时�Q�在struct中用��C��stl�Q?br> class CLASS_TEST
{
    ...
private:
    std::vector m_structs;
}
但是�~�译�Ӟ��vs2005�l�出了warning C4251: 'CLASS_TEST::m_structs' : class 'std::vector<_Ty>' needs to have dll-interface to be used by clients of class ‘CLASS_TEST’的警告信息。费了很大的劲才解决掉，记录下来�?/p>

在头文�g中，定义�?br>#ifdef MYDLL_EXPORTS
#define MYDLL_API __declspec(dllexport)
#else
#define MYDLL_API __declspec(dllimport)
#endif

现在�Q�在变量m_structs前，��d��Q?br>template class MYDLL_API std::allocator;
template class MYDLL_API std::vector >;
�q�样�Q�即可以了�?/p>

��王 2010-04-07 08:57 发表评论

字节寚w��详解

��王 — Wed, 17 Mar 2010 07:55:00 GMT

http://blog.csdn.net/jszj/archive/2009/02/20/3915328.aspx

一.什么是字节寚w��,��Z��么要寚w��?
��C��计算��Z��内存�I�间都是按照byte划分的，从理��Z��讲似乎对��M��c�d��的变量的讉K��可以从�Q何地址开始，但实际情冉|��在访问特定类型变量的时候经常在�?定的内存地址讉K��Q�这��需要各�U�类型数据按照一定的规则在空间上排列�Q�而不是顺序的一个接一个的排放�Q�这��是寚w��?br> 寚w��的作用和原因�Q�各个硬件��^台对存储�I�间的处理上有很大的不同。一些��^台对某些特定�c�d��的数据只能从某些特定地址开始存取。比如有些架构的CPU在访�?一个没有进行对齐的变量的时候会(x��)发生错误,那么在这�U�架构下�~�程必须保证字节寚w��.其他�q�_��可能没有�q�种情况�Q�但是最常见的是如果不按照适合其��^台要求对数据存放�q�行寚w��Q�会(x��)在存取效率上带来损失。比如有些��^台每�ơ读都是从偶地址开始，如果一个int型（假设�?2位系�l�）如果存放在偶地址开始的地方�Q�那么一个读周期��可以读��32bit�Q�而如果存攑֜�奇地址开始的地方�Q�就需�?个读周期�Q��ƈ对两�ơ读出的�l�果的高低字节进行拼凑才能得到该32bit�?据。显然在��d��效率上下降很多�?/p>

�?字节寚w��对程序的影响:
    先让我们看几个例子吧(32bit,x86环境,gcc�~�译�?:
讄��构体如下定义�Q?br>struct A
{
    int a;
    char b;
    short c;
};
struct B
{
    char b;
    int a;
    short c;
};
现在已知32位机器上各种数据�c�d��的长度如�?
char:1(有符��h��W�号�?
short:2(有符��h��W�号�?
int:4(有符��h��W�号�?
long:4(有符��h��W�号�?
float:4    double:8
那么上面两个�l�构大小如何�?
�l�果�?
sizeof(strcut A)��gؓ(f��)8
sizeof(struct B)的值却�?2

�l�构体A中包含了4字节长度的int一个，1字节长度的char一个和2字节长度的short型数据一�?B也一�?按理说A,B大小应该都是7字节�?br>之所以出��C��面的�l�果是因为编译器要对数据成员在空间上�q�行寚w��。上面是按照�~�译器的默认讄��q�行寚w��的结�?那么我们是不是可以改变编译器的这�U�默认对齐设�|�呢,当然可以.例如:
#pragma pack (2) /*指定�?字节寚w��*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定寚w��Q�恢复缺省对�?/
sizeof(struct C)值是8�?br>修改寚w��gؓ(f��)1�Q?br>#pragma pack (1) /*指定�?字节寚w��*/
struct D
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定寚w��Q�恢复缺省对�?/
sizeof(struct D)��gؓ(f��)7�?br>后面我们再讲�?pragma pack()的作�?

�?�~�译器是按照什么样的原则进行对齐的?
    先让我们看四个重要的基本概念�Q?br>1.数据�c�d��自��n的对齐��|��(x��)
对于char型数据，其自�w�对齐��gؓ(f��)1�Q�对于short型�ؓ(f��)2�Q�对于int,float,double�c�d��Q�其自��n寚w��gؓ(f��)4�Q�单位字节�?br>2.�l�构体或者类的自�w�对齐��|��(x��)其成员中自��n寚w��值最大的那个倹{�?br>3.指定寚w��|��(x��)#pragma pack (value)时的指定寚w��值value�?br>4.数据成员、结构体和类的有效对齐��|��(x��)自��n寚w��值和指定寚w��g��的那个倹{�?br>�?了这些��|��我们��可以很方便的来讨论具体数据�l�构的成员和其自�w�的寚w��方式。有效对齐值N是最�l�用来决定数据存攑֜�址方式的��|��最重要。有效对齐N�Q�就�?表示“寚w��在N�?#8221;�Q�也��是说该数据�?存放起始地址%N=0".而数据结构中的数据变量都是按定义的先后顺序来排放的。第一个数据变量的起始地址��是�?据结构的起始地址。结构体的成员变量要寚w��排放�Q�结构体本��n也要�Ҏ(gu��)��自��n的有效对齐值圆�?��是�l�构体成员变量占用总长度需要是对结构体有效寚w��值的整数倍，�l�合下面例子理解)。这样就不能理解上面的几个例子的��g��?br>例子分析�Q?br>分析例子B�Q?br>struct B
{
    char b;
    int a;
    short c;
};
�?设B从地址�I�间0x0000开始排放。该例子中没有定义指定对齐��|��在笔者环境下�Q�该值默认�ؓ(f��)4。第一个成员变量b的自�w�对齐值是1�Q�比指定或者默认指�?寚w��?��，所以其有效寚w��gؓ(f��)1�Q�所以其存放地址0x0000�W�合0x0000%1=0.�W�二个成员变量a�Q�其自��n寚w��gؓ(f��)4�Q�所以有效对齐��g��?�Q?所以只能存攑֜�起始地址�?x0004�?x0007�q�四个连�l�的字节�I�间中，复核0x0004%4=0,且紧靠第一个变量。第三个变量c,自��n寚w��gؓ(f��) 2�Q�所以有效对齐��g��?�Q�可以存攑֜�0x0008�?x0009�q�两个字节空间中�Q�符�?x0008%2=0。所以从0x0000�?x0009存放�?都是B内容。再看数据结构B的自�w�对齐��gؓ(f��)其变量中最大对齐�?�q�里是b�Q�所以就�?�Q�所以结构体的有效对齐��g��?。根据结构体圆整的要求， 0x0009�?x0000=10字节�Q�（10�Q?�Q�％4�Q?。所�?x0000A�?x000B也�ؓ(f��)�l�构体B所占用。故B�?x0000�?x000B 共有12个字�?sizeof(struct B)=12;其实如果��p��一个就来说它已��满��_��节对齐了, 因�ؓ(f��)它的起始地址�?,因此肯定是对齐的,之所以在后面补充2个字�?是因为编译器��Z��实现�l�构数组的存取效�?试想如果我们定义了一个结构B的数�l?�?么第一个结构�v始地址�?没有问题,但是�W�二个结构呢?按照数组的定�?数组中所有元素都是紧挨着�?如果我们不把�l�构的大��补充�ؓ(f��)4的整数�?那么下一个结构的起始地址��是0x0000A,�q�显然不能满��结构的地址寚w��?因此我们要把�l�构补充成有效对齐大��的整数�?其实诸如:对于char型数据，�?自��n寚w��gؓ(f��)1�Q�对于short型�ؓ(f��)2�Q�对于int,float,double�c�d��Q�其自��n寚w��gؓ(f��)4�Q�这些已有类型的自��n寚w��g��是基于数�l�考虑�?�?是因��些类型的长度已知�?所以他们的自��n寚w��g��已知了.
同理,分析上面例子C�Q?br>#pragma pack (2) /*指定�?字节寚w��*/
struct C
{
    char b;
    int a;
    short c;
};
#pragma pack () /*取消指定寚w��Q�恢复缺省对�?/
�W?一个变量b的自�w�对齐��gؓ(f��)1�Q�指定对齐��gؓ(f��)2�Q�所以，其有效对齐��gؓ(f��)1�Q�假设C�?x0000开始，那么b存放�?x0000�Q�符�?x0000%1= 0;�W�二个变量，自��n寚w��gؓ(f��)4�Q�指定对齐��gؓ(f��)2�Q�所以有效对齐��gؓ(f��)2�Q�所以顺序存攑֜�0x0002�?x0003�?x0004�?x0005四个�q�箋字节中，�W�合0x0002%2=0。第三个变量c的自�w�对齐��gؓ(f��)2�Q�所以有效对齐��gؓ(f��)2�Q�顺序存�?br>�?x0006�?x0007中，�W�合 0x0006%2=0。所以从0x0000�?x00007共八字节存放的是C的变量。又C的自�w�对齐��gؓ(f��)4�Q�所以C的有效对齐��gؓ(f��)2。又8%2=0,C 只占�?x0000�?x0007的八个字节。所以sizeof(struct C)=8.

�?如何修改�~�译器的默认寚w��?
1.在VC IDE中，可以�q�样修改�Q�[Project]|[Settings],c/c++选项卡Category的Code Generation选项的Struct Member Alignment中修改，默认�?字节�?br>2.在编码时�Q�可以这样动态修改：(x��)#pragma pack .注意:是pragma而不是progma.

�?针对字节寚w��,我们在编�E�中如何考虑?

    如果在编�E�的时候要考虑节约�I�间的话,那么我们只需要假定结构的首地址�?,然后各个变量按照上面的原则进行排列即�?基本的原则就是把�l�构中的变量按照 �c�d��大小从小到大声明,��量减少中间的填补空�?�q�有一�U�就是�ؓ(f��)了以�I�间换取旉��的效�?我们昄��的进行填补空间进行对�?比如:有一�U��用空间换旉��?法是昑ּ�的插入reserved成员�Q?br>         struct A{
           char a;
           char reserved[3];//使用�I�间换时�?br>           int b;
}

reserved成员�Ҏ(gu��)��们的�E�序没有什么意�?它只是�v到填补空间以辑ֈ�字节寚w��的目�?当然即��不加�q�个成员通常�~�译器也�?x��)给我们自动填补寚w��,我们自己加上它只是�v到显式的提醒作用.

�?字节寚w��可能带来的隐�(zh��n)?
代码中关于对齐的隐�?zh��n)��Q�很多是隐式的。比如在强制�c�d��转换的时候。例如：(x��)
unsigned int i = 0x12345678;
unsigned char *p=NULL;
unsigned short *p1=NULL;

p=&i;
*p=0x00;
p1=(unsigned short *)(p+1);
*p1=0x0000;
最后两句代码，从奇数边界去讉K��unsignedshort型变量，昄��不符合对齐的规定�?br>在x86上，�c�M��的操作只�?x��)媄响效率，但是在MIPS或者sparc上，可能��是一个error,因�ؓ(f��)它们要求必须字节寚w��.

�?如何查找与字节对齐方面的问题:
如果出现寚w��或者赋值问题首先查�?br>1. �~�译器的big little端设�|?br>2. 看这�U�体�p�L��w�是否支持非寚w��讉K��
3. 如果支持看设�|�了寚w��与否,如果没有则看讉K��旉��要加某些�Ҏ(gu��)��的修饰来标志其特�D�访问操作�?/p>

ARM下的寚w��处理
from DUI0067D_ADS1_2_CompLib

3.13 type qulifiers

有部分摘自ARM�~�译器文档对齐部�?/p>

寚w��的��?
1.__align(num)
   �q�个用于修改最高��别对象的字节边界。在汇编中��用LDRD或者STRD�?br>   ��p��用到此命令__align(8)�q�行修饰限制。来保证数据对象是相应对齐�?br>   �q�个修饰对象的命令最大是8个字节限�?可以�?字节的对象进�?字节
   寚w��,但是不能�?字节的对�?字节寚w��?br>   __align是存储类修改,他只修饰最高��c�d��对象不能用于�l�构或者函数对象�?br>
2.__packed
__packed是进行一字节寚w��
1.不能对packed的对象进行对�?br> 2.所有对象的��d��讉K��都进行非寚w��讉K��
3.float�?qi��ng)包含float的结构联合及(qi��ng)未用__packed的对象将不能字节寚w��
4.__packed对局部整形变量无影响
5.强制由unpacked对象向packed对象转化是未定义,整�Ş指针可以合法�?br> 义�ؓ(f��)packed�?br>     __packed int* p; //__packed int 则没有意�?br> 6.寚w��或非寚w��d��讉K��带来问题
__packed struct STRUCT_TEST
{
char a;
int b;
char c;
} ;    //定义如下�l�构此时b的�v始地址一定是不对齐的
         //在栈中访问b可能有问�?因�ؓ(f��)栈上数据肯定是对齐访问[from CL]
//��下面变量定义成全局静态不在栈�?
static char* p;
static struct STRUCT_TEST a;
void Main()
{
__packed int* q; //此时定义成__packed来修饰当前q指向为非寚w��的数据地址下面的访问则可以

p = (char*)&a;
q = (int*)(p+1);

*q = 0x87654321;
/*
得到赋值的汇编指��o(h��)很清�?br>ldr      r5,0x20001590 ; = #0x12345678
[0xe1a00005]   mov      r0,r5
[0xeb0000b0]   bl       __rt_uwrite4 //在此处调用一个写4byte的操作函�?

[0xe5c10000]   strb     r0,[r1,#0]   //函数�q�行4�ơstrb操作然后�q�回保证了数据正��的讉K��
[0xe1a02420]   mov      r2,r0,lsr #8
[0xe5c12001]   strb     r2,[r1,#1]
[0xe1a02820]   mov      r2,r0,lsr #16
[0xe5c12002]   strb     r2,[r1,#2]
[0xe1a02c20]   mov      r2,r0,lsr #24
[0xe5c12003]   strb     r2,[r1,#3]
[0xe1a0f00e]   mov      pc,r14
*/

/*
如果q没有加__packed修饰则汇�~�出来指令是�q�样直接�?x��)导致奇地址处访问失�?br>[0xe59f2018] ldr r2,0x20001594 ; = #0x87654321
[0xe5812000] str r2,[r1,#0]
*/

//�q�样可以很清楚的看到非对齐访问是如何产生错误�?br>//以及(qi��ng)如何消除非对齐访问带来问�?br>//也可以看到非寚w��讉K��和对齐访问的指��o(h��)差异��D��效率问题
}

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/jszj/archive/2009/02/20/3915328.aspx

��王 2010-03-17 15:55 发表评论

��王 — Mon, 15 Mar 2010 10:25:00 GMT

转：(x��)http://blog.csdn.net/yincheng01/archive/2010/03/11/5367032.aspx

微��Y卛_��?010�q?�?2日发布VS2010的正式版�Q�对于c++语言做了修改�Q��之更加符合c++标准�?/p>

下面对于微��Y对于c++语言的修改做一下分析！

Lambda表达�?/p>

很多�~�程�~�程语言都支持匿名函�?anonymous function)。所谓匿名函敎ͼ��是�q�个函数只有函数体，而没有函数名。Lambda表达式就是实现匿名函数的一�U�编�E�技巧，它�ؓ(f��)�~�写匿名函数提供了简明的函数式的句法。同��h��Visual Studio中的开发语�a��Q�Visual Basic和Visual C#早就实现了对Lambda表达式的支持�Q�终于Visual C++�q�次也不甘落后，在Visual Studio 2010中添加了对Lambda表达式的支持�?br> Lambda表达式��得函数可以在使用的地方定义，�q�且可以在Lambda函数中��用Lambda函数之外的数据。这��׃ؓ(f��)针对集合操作带来了很大的便利。在作用上，Lambda表达式类��g��函数指针和函数对象，Lambda表达式很好地兼顾了函数指针和函数对象的优点，却没有它们的�~�点。相对于函数指针或是函数对象复杂的语法�Ş式，Lambda表达式��用非常简单的语法��可以实现同��L(f��ng)��功能�Q�降低了Lambda表达式的学习(f��n)隑ֺ��Q�避免了使用复杂的函数对象或是函数指针所带来的错误。我们可以看一个实际的例子�Q?/p>

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#include "stdafx.h"
#include
#include
#include
#include

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    vector v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }
         for_each(v.begin(), v.end(), [] (int n) {
        cout << n;
        if (n % 2 == 0) {
            cout << " even ";
        } else {
            cout << " odd ";
        }
    });
    cout << endl;

    return 0;
}
#include "stdafx.h"
#include
#include
#include
#include

using namespace std;

int _tmain(int argc, _TCHAR* argv[])
{
    vector v;
    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }
         for_each(v.begin(), v.end(), [] (int n) {
        cout << n;
        if (n % 2 == 0) {
            cout << " even ";
        } else {
            cout << " odd ";
        }
    });
    cout << endl;

return 0;
}

�q�段代码循环遍历输出vector中的每一个数�Q��ƈ判断�q�个数是奇数�q�是偶数。我们可以随时修改Lambda表达式而改变这个匿名函数的实现�Q�修改对集合的操作。在�q�段代码中，C++使用一对中括号“[]”来表�C�Lambda表达式的开始，其后�?#8221;(int n)”表示Lambda表达式的参数。这些参数将在Lambda表达式中使用到。�ؓ(f��)了体�?x��)Lambda表达式的��z�，我们来看看同��L(f��ng)��功能�Q�如何��用函数对象实玎ͼ�(x��)

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#include "stdafx.h"
#include
#include
#include
#include
using namespace std;

struct LambdaFunctor {
    void operator()(int n) const {
        cout << n << " ";
        if (n % 2 == 0) {
            cout << " even ";
        } else {
            cout << " odd ";
        }

    }
};

int _tmain(int argc, _TCHAR* argv[])
{
    vector v;

    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }

    for_each(v.begin(), v.end(), LambdaFunctor());
    cout << endl;

    return 0;
}
#include "stdafx.h"
#include
#include
#include
#include
using namespace std;

struct LambdaFunctor {
    void operator()(int n) const {
        cout << n << " ";
        if (n % 2 == 0) {
            cout << " even ";
        } else {
            cout << " odd ";
        }

}
};

int _tmain(int argc, _TCHAR* argv[])
{
vector v;

    for (int i = 0; i < 10; ++i) {
        v.push_back(i);
    }

for_each(v.begin(), v.end(), LambdaFunctor());
cout << endl;

return 0;
}

通过比较我们��可以发玎ͼ�Lambda表达式的语法更加��z�，使用��h��更加��单高�?/p>

静态断�a�static_assert

在之前的C++标准C++03中，我们可以使用两种断言�Q?br> • 使用预处理中的条件编译和#error指��o(h��)�Q�可以在预处理阶�D�|��查一些编译条�?br> • 可以使用宏assert来进行运行时��查，以确保程序逻辑的正��?/p>

但��?error�Ҏ(gu��)��是非常烦琐的�Q��ƈ且不能够�Ҏ(gu��)��板参数进行检查，因�ؓ(f��)模板实例化是在编译时�q�行�Q��?error�Ҏ(gu��)��是在预处理阶�D�进行的。而assert宏是在运行时�q�行��查。不隑֏�玎ͼ�我们�~�少了一样东西，那就是可用于在编译时��查的工具。于是，静态断�a�应运而生�?/p>

在新的C++标准C++0x中，加入了对静态断�a�的支持，引入了新的关键字static_assert来表�C�静态断�a�。��用静态断�a��Q�我们可以在�E�序的编译时期检��一些条件是否成立，�q�个�Ҏ(gu��)��在调试模板函数的模板参数时特别有用。在�~�译的时候，模板函数实例化，�q�时我们��可以��用静态断�a��L��试模板函数的参数是否按照我们的设计拥有合适的倹{��例如下面这�D�代码：(x��)

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
template struct Kitten {
    static_assert(N < 2, "Kitten requires N < 2.");
};

int main() {
    Kitten<1> peppermint;
    Kitten<3> jazz;

   return 0;
}
template struct Kitten {
    static_assert(N < 2, "Kitten requires N < 2.");
};

int main() {
Kitten<1> peppermint;
Kitten<3> jazz;

return 0;
}

当我们在��d��C��使用“1”��d��例化Kitten�q�个�l�构体时�Q�在�~�译的时候，静态断�a�static_assert�?x��)测试参数N的��|��当N的值小�?时就�?x��)��生一个断�a�错误�Q��ƈ��相应的调试帮助信息输出�?#8220;Error List”�H�口中，�q�样�E�序员就可以寚w��题快速定位，解决问题��更加方便了�?br>

�? static_assert断言�?qi��ng)其输�?/p>

另外�Q�静态断�a��q�带来很多其他的优势。例如静态断�a�在编译时�q�行处理�Q�不�?x��)��生�Q何运行时�ȝ��间和旉��上的开销�Q�这��׃��得它比assert宏具有更好的效率。另外比较重要的一个特性是如果断言��p�|�Q�它�?x��)��生有意义且充分的诊断信息�Q�帮助程序员快速解决问题�?/p>

auto关键�?/p>

在C++0x中，auto关键字的意义发生了改变。从Visual C++ 2010开始，auto关键字将用于指引�~�译器根据变量的初始值来军_��变量的数据类型。换句话��_(d��)��我们可以把auto当成一�U�新的数据类型，它可�?#8220;从初始化�?initialize)中推导出所代表的变量的真正�c�d��”。这�U�对auto关键字的使用方式可以大大消除当前替代方式所��D��的冗长和易出错的代码。我们看一个实际的例子�Q?/p>

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#include
#include
#include
#include
#include
using namespace std;
using namespace std::tr1;

int main() {
    map m;

    const regex r("(\\w+) (\\w+)");

    for (string s; getline(cin, s); ) {
        smatch results;
        if (regex_match(s, results, r)) {
            m[results[1]] = results[2];
        }
    }
    for (auto i = m.begin(); i != m.end(); ++i) {
        cout << i->second << " are " << i->first << endl;
    }

    return 0;
}
#include
#include
#include
#include
#include
using namespace std;
using namespace std::tr1;

int main() {
map m;

const regex r("(\\w+) (\\w+)");

    for (string s; getline(cin, s); ) {
        smatch results;
        if (regex_match(s, results, r)) {
            m[results[1]] = results[2];
        }
    }
    for (auto i = m.begin(); i != m.end(); ++i) {
        cout << i->second << " are " << i->first << endl;
    }

return 0;
}

在这�D�代码中�Q�我们��用auto关键字来代替了真正的数据�c�d��map::iterator�Q�这使得整个代码自然而简�z��?/p>

另外�Q�跟其他数据�c�d��一��P��我们也可以对auto关键字进行修饎ͼ�例如��d��const�Q�指�?*)�Q�左值引�?&)�Q�右值引�?&&)�{�等�Q�编译器�?x��)根据a(ch��n)uto�c�d��所代表的真正的数据来决定这些修饰的具体含义�?/p>

��Z��兼容一些旧有的C++代码�Q�我们可以��?Zc:auto�q�个�~�译器选项�Q�来告诉�~�译器是采用auto关键字的原有定义�q�是在新标准C++0x中的定义�?/p>

叛_��引�?/p>

作�ؓ(f��)最重要的一��语�a��Ҏ(gu��)��，叛_��引�?rvalue references)被引入到 C++0x中。我们可以通过操作�W?#8220;&&”来声明一个右值引用，原先在C++中��?#8220;&”操作�W�声明的引用现在被称为左值引用�?

int a;
int& a_lvref = a; // 左值引�?/p>

int b;
int&& b_rvref = b; // 叛_��应�?br> 左值引用和叛_��引用的表现行�ؓ(f��)基本一��_(d��)��它们唯一的差别就是右值引用可以绑定到一个��(f��)时对�?叛_�?上，而左值引用不可以。例如：(x��)

int& a_lvref = int(); // error C2440: 'initializing' : cannot convert from 'int' to 'int &'
int&& b_rvref = int(); // OK!
在第一行代码中�Q�我们将一个��(f��)时对象int()�l�定��C��个左值引用，��生一个编译错误。而在�W�二行中�Q�我们将临时对象�l�定到右值引用，��可以顺利通过�~�译�?/p>

叛_��是无名的数据，例如函数的返回��g��般说来就是右倹{��当对右��D��行操作的时候，叛_��本�w�往往没有必要保留�Q�因此在某些情况下可以直�?#8220;�U�d��”之。通过叛_��引用，�E�序可以明确的区分出传入的参数是否�ؓ(f��)叛_��|��从而避免了不必要的拯��Q�程序的效率也就得到了提高。我们考虑一个简单的数据交换的小�E�序�Q�从中来体会(x��)叛_��引用所带来的效率提升。我们可以写一个函数swap来实��C��个变量值的交换�Q?/p>

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
template swap(T& a, T& b)
{
    T tmp(a);   // tmp对象创徏后，我们��拥有了a的两份拷�?nbsp;
    a = b;      // 现在我们拥有b的两份拷�?nbsp;
    b = tmp;    // 现在我们拥有a的两份拷�?nbsp;
}
template swap(T& a, T& b)
{
    T tmp(a);   // tmp对象创徏后，我们��拥有了a的两份拷�?br>    a = b;      // 现在我们拥有b的两份拷�?br>    b = tmp;    // 现在我们拥有a的两份拷�?br>}
在这�D�代码中�Q�虽然我们只是�ؓ(f��)了进行简单的数据交换�Q�但是却执行了多�ơ对象拷贝。这些对象的拯��操作�Q�特别是当这些对象比较大的时候，无疑�?x��)媄响程序的效率�?/p>

那么�Q�如果��用右值引用如何实现呢�Q?/p>

view plaincopy to clipboardprint?
·········10········20········30········40········50········60········70········80········90········100·······110·······120·······130·······140·······150
#include "stdafx.h"

template
T&& move(T&& a)
{
    return a;
}

template void swap(T& a, T& b)
{
    T tmp(move(a)); // 对象a被移动到对象tmp�Q�a被清�I?nbsp;
    a = move(b);    // 对象b被移动到对象a�Q�b被清�I?nbsp;
    b = move(tmp); // 对象tmp被移动到对象b
}

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 1;
    int b = 2;
    swap(a, b);

   return 0;
}
#include "stdafx.h"

template
T&& move(T&& a)
{
return a;
}

template void swap(T& a, T& b)
{
T tmp(move(a)); // 对象a被移动到对象tmp�Q�a被清�I?br> a = move(b); // 对象b被移动到对象a�Q�b被清�I?br> b = move(tmp); // 对象tmp被移动到对象b
}

int _tmain(int argc, _TCHAR* argv[])
{
    int a = 1;
    int b = 2;
    swap(a, b);

return 0;
}

在这�D�重新实现的代码中，我们使用了一个move()函数来代替对象的赋值操作符“=”,move()只是��单地接受一个右值引用或者左值引用作为参敎ͼ�然后直接�q�回相应对象的右值引用。这一�q�程不会(x��)产生拯��(Copy)操作�Q�而只�?x��)将源对象移�?Move)到目标对象�?/p>

正是拯��(Copy)和移�?Move)的差别，使得叛_��引用成为C++0x中最�Ȁ动�h心的新特性之一。从实践角度�Ԍ��它能够完��是解决C++中长久以来�ؓ(f��)人所诟病的��(f��)时对象的效率问题。从语言本��n�Ԍ��它健全了C++中的引用�c�d��在左值右值方面的�~�陷。从库设计者的角度�Ԍ��它给库设计者又带来了一把利器。而对于广大的库��用者而言�Q�不动一兵一卒便能够获得“免费�?#8221;效率提升�?/p>

在Visual Studio 2010中，因�ؓ(f��)有了对这些C++0x新特性的支持�Q�重新点燃了�E�序员们对C++的热情。C++重振雄风�Q�指日可待！

本文来自CSDN博客�Q��{载请标明出处�Q?a >http://blog.csdn.net/yincheng01/archive/2010/03/11/5367032.aspx

��王 2010-03-15 18:25 发表评论

��王 — Thu, 21 Jan 2010 15:43:00 GMT

比如我们有这样一个C函数
#include
long test(int a,int b)
{
    a = a + 1;
    b = b + 100;
    return a + b;
}

写成32位汇�~�就是这�?br />;//////////////////////////////////////////////////////////////////////////////////////////////////////
.386
.module flat,stdcall           ;�q�里我们用stdcall ��是函数参数压栈的时候从最后一个开始压�Q�和被调用函数负责清�?br />option casemap:none            ;区分大小�?br />
includelib msvcrt.lib          ;�q�里是引入类�?#160;相当�?#160;#include�?#160;
printf  PROTO C:DWORD,:VARARG  ;�q�个��是声明一下我们要用的函数��_(d��)��到时�?#160;汇编�E�序�?x��)自动到msvcrt.lib里面扄��?#160;
                                ;:VARARG 表后面的参数不确�?#160;因�ؓ(f��)C��是�q�样的printf(const char *, ...);
                               ;�q�样的函数要注意不是被调用函数负责清�?#160;因�ؓ(f��)它本�w�不知道有多��个参数
                               ;而是有调用者负责清�?#160; 下面�?x��)详�l�说�?br />.data
szTextFmt  BYTE '%d',0        ;�q�个是用来类型�{换的�Q�跟C的一�?字符用字节类�?br />a          dword 1000         ;假设
b          dword 2000         ;处理数值都用双�?#160;没有int 跟long 的区�?br />
;/////////////////////////////////////////////////////////////////////////////////////////
.code

_test proc A:DWORD,B:DWORD
      push ebp
      mov  ebp,esp
      mov  eax,dword ptr ss:[ebp+8]
      add  eax,1
      mov  edx,dword ptr ss:[ebp+0Ch]
      add  edx,100
      add  eax,edx
      pop  ebp
      retn 8
_test endp

_main proc
      push dword ptr ds:b       ;反汇�~�我们看到的b��׃��是b了而是一个[*****]数字 dword ptr ��是我们在ds(数据�D?把[*****]
                                ;开始的一个双字长数值取出来
      push dword ptr ds:a       ;跟她对应的还�?#160;byte ptr ****��是取一个字节出�?#160;比如�q�样 mov  al,byte ptr ds:szTextFmt
                                ;��把 % 取出�?#160;而不包括 d
      call _test
      push eax                  ;假设push eax的地址�?#215;××××
      push offset szTextFmt
      call printf
      add  esp,8
      ret
_main endp
end  _main

;////////////////////////////////////////////////////////////// 下面介绍堆栈的变�?br />首先要明白的�?#160;操作堆栈�D?#160;ss 只能�?#160;esp或ebp寄存�?#160;其他的寄存器eax ebx edx�{�都不能够用 �?#160;esp永远指向堆栈栈顶 ebp用来在堆栈段

里面��d��
push 指��o(h��)是压�?#160;ESP=ESP-4
pop  指��o(h��)是出�?#160;ESP=ESP+4
我们假设main函数一开始堆栈定�?#160;ESP=400
push dword ptr ds:b                 ;ESP-4=396 ->里面的值就�?#160;2000 ��是b的数�?br />push dword ptr ds:a                 ;ESP-4=392 ->里面的值就�?#160;1000 ��是a的数�?br />call test                           ;ESP-4=388�Q?gt;里面的数值是什么？�q�个太重要了 ��是我们用来找游戏函数的原理所在�?br />                                                 里面的数值就是call test 指��o(h��)下一条指令的地址�Q?gt;即push eax的地址×××××

��C��test函数里面

push ebp                           ;ESP-4=384->里面保存了当前ebp的�?#160;而不是把ebp清零
mov  ebp,esp                       ;�q�里ESP�Q?84��没变化了，但是 ebp=esp=384,��Z��么要�q�样做呢因�ؓ(f��)我们要用ebp到堆栈里面找参数
mov  eax,dword ptr ss:[ebp+8]      ;反汇�~�是�q�样�?#160;��x��Z��么a��是[ebp+8]�?br />                                   ;我们往上看看堆栈里地址392处就保存着a的�?#160;�q�里ebp=384 加上8正好��是392�?br />                                   ;�q�样��把传递过来的1000拿了出来eax=1000
add  eax,1                         ;相当�?#160;a+1�?#160;eax=1001
mov  edx,dword ptr ss:[ebp+0Ch]    ; 0Ch=12 一样道理这里指向堆栈的地址�?84+12=396 ��是2000�?#160;edx=2000
add  edx,100                       ;相当�?#160;b+100 edx=2100
add  eax,edx                       ;eax=eax+edx�Q?001�Q?100�Q?101 �q�里eax已经保存了最�l�的�l�果�?#160;
                                   ;因�ؓ(f��)win32汇编一般用eax�q�回�l�果所以如果最�l�结果不是在eax里面的话 �q�要把它攑ֈ�eax
                                   ;比如假设我的�l�果保存在变量nRet里面最后还是要�q�样 mov eax,dword ptr nRet
pop  ebp                           ;ESP=384+4=388 而保存在栈顶384的�?#160;保存�?#160;ebp�?#160;��x��复ebp原来的�?#160;
                                   ;因�ؓ(f��)一开始我们就把ebp的值压栈了�Q�mov ebp,esp已经改变了ebp的��|��q�里恢复��是保证了堆栈��^�?br />retn  8                            ;ESP+8->396 �q�里retn是由�pȝ��调用�?#160;我们不用��?#160;�pȝ��?x��)自动把EIP指针指向原来的call的下一条指�?br />                                   ;�׃��是系�l�自动恢复了call那里的压栈所�?#160;真正�q�回到的时候ESP+4��是恢复了call压栈的堆�?br />                                   ;��C��q�个时�?#160;ESP=400 ��是函数调用开始的堆栈�Q�就是说函数调用前跟函数调用后的堆栈是一��L(f��ng)��
                                   ;�q�就是堆栈��^�?#160;
�׃��我们用stdcall上面retn 8��是被调用者负责恢复堆栈的意思了�Q�函数test是被调用者，所以负责把堆栈�?,call 那里是系�l�自动恢复的

push eax                ;ESP-4=396->里面保存了eax的�?101
                        ;上面已经看到了eax保存着�q�回��|��我们要把它传�l�printf也是通过堆栈传�?#160;
push offset szTextFmt   ;ESP-4=392->里面保存了szTextFmt的地址也就是C里面的指�?#160;实际上没有什么把字符串传递的�Q�我们传的都是地址
                        ;无论是在汇编或C 所以在汇编里没有什么字�W�串�c�d�� 用最多的��是DWORD。嘿嘿游戏里面传递参�?#160;��单多�?br />call printf             ;ESP-4=388->里面保存了下一条指令的地址
add  esp,8              ;ESP+8=400 恢复了调用printf前的堆栈状�?br />                        ;上面说了�׃��printf后面参数�?VARARG �q�样的类型是有调用者恢复堆栈的所以printf里面没有retn 8之类的指�?br />                        ;�q�是��p��用者负责清�?#160;main是调用�?#160;所以下面一句就�?#160;add esp,8 把堆栈恢复到调用printf之前
                        ;而call printf那里的压�?#160;是由�pȝ��做的恢复的工作也是系�l�完�?#160;我们不用�?#160;只是知道里面保存是返回地址��够

                      ;�?br />ret                     ;main 函数�q�回其他的事情是�pȝ��自动搞定我们不用�?#160;��d��完成

��王 2010-01-21 23:43 发表评论

最快速度扑ֈ�内存泄漏

��王 — Thu, 21 Jan 2010 15:14:00 GMT

原帖�Q?a >http://blog.csdn.net/i_like_cpp/archive/2007/06/28/1669962.aspx
作者：(x��)许式�?2006�q?1月某�?/font>

内存��理是C++�E�序员的痛。我的《内存管理变革》系列就是试图讨论更为有效的内存��理方式�Q�以杜绝�Q�或减少�Q�内存泄漏，减轻C++�E�序员的负担。由于工作忙的缘故，�q�个�p�d��目前未完�Q�暂停�?br />
�q�篇短文我想换个方式�Q�讨��Z��下如何以最快的速度扑ֈ�内存泄漏�?br />
��认是否存在内存泄漏
我们知道�Q�MFC�E�序如果��到存在内存泄漏�Q�退出程序的时候会(x��)在调试窗口提醒内存泄漏。例如：(x��)

class CMyApp : public CWinApp
{
public:
   BOOL InitApplication()
   {
       int* leak = new int[10];
       return TRUE;
   }
};
产生的内存泄漏报告大体如下：(x��)

Detected memory leaks!
Dumping objects ->
c:\work\test.cpp(186) : {52} normal block at 0x003C4410, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
�q�挺好。问题是�Q�如果我们不喜欢MFC�Q�那么难道就没有办法�Q�或者自己做�Q?

呵呵�Q�这不需要。其实，MFC也没有自己做。内存泄漏检��的工作是VC++的C�q�行库做的。也��是��_(d��)��只要你是VC++�E�序员，都可以很方便地检��内存泄漏。我们还是给个样例：(x��)

#include

inline void EnableMemLeakCheck()
{
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

void main()
{
EnableMemLeakCheck();
int* leak = new int[10];
}
�q�行�Q�提醒：(x��)不要按Ctrl+F5�Q�按F5�Q�，你将发现�Q��生的内存泄漏报告与MFC�c�M��Q�但有细节不同，如下�Q?/font>

Detected memory leaks!
Dumping objects ->
{52} normal block at 0x003C4410, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
��Z��么呢�Q�看下面�?/font>

定位内存泄漏�׃��哪一句话引�v�?br />你已�l�发现程序存在内存泄漏。现在的问题是，我们要找泄漏的根源�?/font>

一般我们首先确定内存泄漏是�׃��哪一句引赗��在MFC中，�q�一点很�Ҏ(gu��)��。你双击内存泄漏报告的文字，或者在Debug�H�口中按F4�Q�IDE��帮你定位到甌��该内存块的地斏V��对于上例，也就是这一句：(x��)

int* leak = new int[10];

�q�多多少��对你分析内存泄漏有点帮助。特别地�Q�如果这个new仅对应一条delete�Q�或者你把delete漏写�Q�，�q�将很快可以��认问题的症�l��?

我们前面已经看到�Q�不使用MFC的时候，生成的内存泄漏报告与MFC不同�Q�而且你立��d��现按F4不灵。那么难道MFC做了什么手脚？

其实不是�Q�我们来模拟下MFC做的事情。看下例�Q?

inline void EnableMemLeakCheck()
{
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

#ifdef _DEBUG
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

void main()
{
EnableMemLeakCheck();
int* leak = new int[10];
}

再运行这个样例，你惊喜地发现�Q�现在内存泄漏报告和MFC没有��M��分别了�?/font>

快速找到内存泄�?br />单确定了内存泄漏发生在哪一行，有时候�ƈ不��够。特别是同一个new对应有多处释攄��情�Ş。在实际的工�E�中�Q�以下两�U�情况很典型�Q?

创徏对象的地�Ҏ(gu��)��一个类工厂�Q�ClassFactory�Q�模式。很多甚臛_��部类实例由同一个new创徏。对于此�Q�定位到了new出对象的所在行基本没有多大帮助�?

COM对象。我们知道COM对象采用Reference Count�l�护生命周期。也��是��_(d��)��对象new的地方只有一个，但是Release的地方很多，你要一个个排除�?
那么�Q�有什么好办法�Q�可以迅速定位内存泄漏？

�{�：(x��)有�?/font>

在内存泄漏情况复杂的时候，你可以用以下�Ҏ(gu��)��定位内存泄漏。这是我个�h认�ؓ(f��)通用的内存泄漏追�t�方法中最有效的手�D�c�?/font>

我们再回头看看crtdbg生成的内存泄漏报告：(x��)

Detected memory leaks!
Dumping objects ->
c:\work\test.cpp(186) : {52} normal block at 0x003C4410, 40 bytes long.
Data: < > CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD CD
Object dump complete.
除了产生该内存泄漏的内存分配语句所在的文�g名、行号�ؓ(f��)�Q�我们注意到有一个比较陌生的信息�Q�{52}。这个整数��g��表了什么意思呢�Q?/font>

其实�Q�它代表了第几次内存分配操作。象�q�个例子�Q�{52}代表了第52�ơ内存分配操作发生了泄漏。你可能要说�Q�我只new�q�一�ơ，怎么�?x��)是�W?2�ơ？�q�很�Ҏ(gu��)��理解�Q�其他的内存甌��操作在C的初始化�q�程调用的呗�?)

有没有可能，我们让程序运行到�W?2�ơ内存分配操作的时候，自动停下来，�q�入调试状态？所�q�，crtdbg��实提供了这��L(f��ng)��函数�Q�即 long _CrtSetBreakAlloc(long nAllocID)。我们加上它�Q?/font>

inline void EnableMemLeakCheck()
{
_CrtSetDbgFlag(_CrtSetDbgFlag(_CRTDBG_REPORT_FLAG) | _CRTDBG_LEAK_CHECK_DF);
}

#ifdef _DEBUG
#define new new(_NORMAL_BLOCK, __FILE__, __LINE__)
#endif

void main()
{
   EnableMemLeakCheck();
   _CrtSetBreakAlloc(52);
   int* leak = new int[10];
}
你发玎ͼ��E�序�q�行�?int* leak = new int[10]; 一句时�Q�自动停下来�q�入调试状态。细�l�体�?x��)一下，你可以发玎ͼ��q�种方式你获得的信息�q�比在程序退出时获得文�g名及(qi��ng)行号有�h(hu��n)值得多。因为报告泄漏文件名�?qi��ng)行��P��你获得的只是静态的信息�Q�然而_CrtSetBreakAlloc则是把整个现场恢复，你可以通过对函数调用栈分析�Q�我发现很多��Z��?f��n)惯看函数调用栈�Q�如果你属于�q�种情况�Q�我强烈推荐你去补上�q�一课，因�ؓ(f��)它太重要了）以及(qi��ng)其他在线调试技巧，来分析��生内存泄漏的原因。通常情况下，�q�种分析�Ҏ(gu��)��可以�?分钟内找到肇事者�?/font>

当然�Q�_CrtSetBreakAlloc要求你的�E�序执行�q�程是可�q�原的（多次执行�q�程的内存分配顺序不�?x��)发生变化）。这个假讑֜�多数情况下成立。不�q�，在多�U�程的情况下�Q�这一�Ҏ(gu��)��旉��以保证�?/font>

附加说明�Q?br />对“内存管理”相关的技术感兴趣�Q�这里可以看到我的所有关于内存管理的文章�?/font>

本文来自CSDN博客�Q��{载请标明出处�Q?/font> http://blog.csdn.net/i_like_cpp/archive/2007/06/28/1669962.aspx

��王 2010-01-21 23:14 发表评论