一、vc编译jpeglib库

1、下载源代码

下载地址：http://www.ijg.org/。注意：一定要下载win32 版本

2、编译源代码.

    A、解压源代码，修改源代码中jconfig.vc为jconfig.h；

    B、添加环境变量PATH，C:/Program Files/Microsoft Visual Studio/VC98/Bin ；

    C、修改makefile.vc，将 Pull in standard variable definitions下面的一行换为：!include <C:/Program Files/Microsoft Visual Studio/VC98/Include/win32.mak> ；

    D、进入命令提示环境下，输入：vcvars32 回车，这是一个用来设置VC路径环境的批处理；

    E、编译生成库文件 命令：nmake /f makefile.vc nodebug=1；

这样就OK了

3、jpeglib库VC下使用

对于库的使用只需要有相应的.lib文件和头文件就可以了。Vc中要添加libjpeg.lib库的连接

         将这几个文件拷贝到你的项目中：libjpeg.lib，jconfig.h，jmorecfg.h，jpeglib.h，在你需要进行压缩的文件中加入

extern "C" {

         #include "jpeglib.h"

         #include "jmorecfg.h"

         #include "jconfig.h"

}

参考：

http://blog.csdn.net/xingyu19871124/archive/2009/06/30/4310800.aspx

小知识：bmp文件的前54个字节是头，后面才是像素值。

二、使用jpeg库压缩

在源代码的文件夹下面有一个example.c的文件和libjpeg.txt，很有参考价值。

1、基本思路

首先调用截屏程序，将屏幕的位图信息存放在一个buffer里面，然后调用jpg压缩函数，在当前的目录下生成一个ok.jpg的文件。

2、出现的问题：

A、运行是总是报错：

我参考源代码的例子，也用JSAMPLE * image_buffer;来指向位图的像素的首地址，编译可以通过但是运行时就会报错，后来我用BYTE *image_buffer;来定义就可以正常运行了。

B、生成的jpg图像失真：

由于window的位图的像素格式是：BGRA，4个字节，jpeglib库使用的是RGB，3个字节的格式，所以需要将源像素去掉其透明字节，同时改变RGB的顺序。代码如下：

//RGB顺序调整

for (int i=0, int j=0; j < 1440*900*4; i+=3, j+=4)

{

    *(image_buffer+i)=*(image_buffer+j+2);

    *(image_buffer+i+1)=*(image_buffer+j+1);

    *(image_buffer+i+2)=*(image_buffer+j);

}

C、生成的jpg文件图像是倒的：

原因没有找到，后来修改了压缩函数的代码，生成了正确的jpg文件

while (cinfo.next_scanline < cinfo.image_height) {

         //这里我做过修改，由于jpg文件的图像是倒的，所以改了一下读的顺序

         //这是原代码：row_pointer[0] = & bits[cinfo.next_scanline * row_stride];

         row_pointer[0] = & bits[(cinfo.image_height - cinfo.next_scanline - 1) * row_stride];

    (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);

}

3、测试结果：

我编写了测试代码，连续截屏并生成jpg文件100次，大约花费7秒左右，也就是说1秒可以截屏13次左右。同时生成的jpg文件有100多K的样子。

三、代码：

 

#include "stdafx.h"
#include <atlbase.h>
#include <afxwin.h>
#include <WINDOWSX.H>
 
#define JPEG_QUALITY 50     //它的大小决定jpg的质量好坏
 
extern "C" {
    #include "jpeglib.h"
    #include "jmorecfg.h"
    #include "jconfig.h"
}
 
int savejpeg(char *filename, unsigned char *bits, int width, int height, int depth);
void CapScreen(char filename[]);
 
BYTE *image_buffer; //指向位图buffer的全局指针，window下像素格式: BGRA(4个字节)
 
int main(int argc, char* argv[])
{
 
    image_buffer = (BYTE *)malloc(1440 * 900 * 4);
 
    for(int i = 0; i < 100; i++){
        CapScreen("ok.bmp");   
        //RGB顺序调整
        for (int i=0, int j=0; j < 1440*900*4; i+=3, j+=4)
        {
            *(image_buffer+i)=*(image_buffer+j+2);
            *(image_buffer+i+1)=*(image_buffer+j+1);
            *(image_buffer+i+2)=*(image_buffer+j);
        }
        savejpeg("ok.jpg", image_buffer, 1440, 900, 3);
    }
 
    delete [] image_buffer;
    return 0;
}
 
 
/*===================================================================================
function:       jpeg压缩
input:          1:生成的文件名,2:bmp的指针,3:位图宽度,4:位图高度,5:颜色深度
return:         int
description:    bmp的像素格式为(RGB)
===================================================================================*/
int savejpeg(char *filename, unsigned char *bits, int width, int height, int depth)
{
        struct jpeg_compress_struct cinfo;
        struct jpeg_error_mgr jerr;
        FILE * outfile;                 /* target file */
        JSAMPROW row_pointer[1];        /* pointer to JSAMPLE row[s] */
        int     row_stride;             /* physical row width in image buffer */
 
        cinfo.err = jpeg_std_error(&jerr);
        jpeg_create_compress(&cinfo);
 
        if ((outfile = fopen(filename, "wb")) == NULL) {
                fprintf(stderr, "can't open %s/n", filename);
                return -1;
        }
        jpeg_stdio_dest(&cinfo, outfile);
 
        cinfo.image_width = width;      /* image width and height, in pixels */
        cinfo.image_height = height;
        cinfo.input_components = 3;         /* # of color components per pixel */
        cinfo.in_color_space = JCS_RGB;         /* colorspace of input image */
 
        jpeg_set_defaults(&cinfo);
        jpeg_set_quality(&cinfo, JPEG_QUALITY, TRUE /* limit to baseline-JPEG values */);
 
        jpeg_start_compress(&cinfo, TRUE);
 
        row_stride = width * depth; /* JSAMPLEs per row in image_buffer */
 
        while (cinfo.next_scanline < cinfo.image_height) {
            //这里我做过修改，由于jpg文件的图像是倒的，所以改了一下读的顺序
            //这是原代码：row_pointer[0] = & bits[cinfo.next_scanline * row_stride];
            row_pointer[0] = & bits[(cinfo.image_height - cinfo.next_scanline - 1) * row_stride];
            (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
        }
 
        jpeg_finish_compress(&cinfo);
        fclose(outfile);
 
        jpeg_destroy_compress(&cinfo);
        return 0;
}
 
 
void CapScreen(char filename[])
{
    CDC *pDC;
    pDC = CDC::FromHandle(GetDC(GetDesktopWindow()));
    if(pDC == NULL) return;
    int BitPerPixel = pDC->GetDeviceCaps(BITSPIXEL);
    int Width = pDC->GetDeviceCaps(HORZRES);
    int Height = pDC->GetDeviceCaps(VERTRES);
 
    CDC memDC;
    if(memDC.CreateCompatibleDC(pDC) == 0) return;
   
    CBitmap memBitmap, *oldmemBitmap;
    if(memBitmap.CreateCompatibleBitmap(pDC, Width, Height) == NULL) return;
 
    oldmemBitmap = memDC.SelectObject(&memBitmap);
    if(oldmemBitmap == NULL) return;
    if(memDC.BitBlt(0, 0, Width, Height, pDC, 0, 0, SRCCOPY) == 0) return;
 
    BITMAP bmp;
    memBitmap.GetBitmap(&bmp);
   
    //fp = fopen(filename, "w+b");
 
    BITMAPINFOHEADER bih = {0};
    bih.biBitCount = bmp.bmBitsPixel;
    bih.biCompression = BI_RGB;
    bih.biHeight = bmp.bmHeight;
    bih.biPlanes = 1;
    bih.biSize = sizeof(BITMAPINFOHEADER);
    bih.biSizeImage = bmp.bmWidthBytes * bmp.bmHeight;
    bih.biWidth = bmp.bmWidth;
   
    BITMAPFILEHEADER bfh = {0};
    bfh.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);
    bfh.bfSize = bfh.bfOffBits + bmp.bmWidthBytes * bmp.bmHeight;
    bfh.bfType = (WORD)0x4d42;
   
    //fwrite(&bfh, 1, sizeof(BITMAPFILEHEADER), fp);
    //fwrite(&bih, 1, sizeof(BITMAPINFOHEADER), fp);
   
    image_buffer = new BYTE[bmp.bmWidthBytes * bmp.bmHeight];
 
    GetDIBits(memDC.m_hDC,
        (HBITMAP) memBitmap.m_hObject,
     0,
     Height,
     image_buffer,
     (LPBITMAPINFO) &bih,
     DIB_RGB_COLORS);
    memDC.SelectObject(oldmemBitmap);
    //fwrite(p, 1, 1280 * 800 * 4, fp);
    //fclose(fp);
}
 

 

GDI Plus 描述：

    GDIPlus是微软出的一个C++面向对象库，它为windows的图形设备接口提供了更好的访问。与标准的windows GDI相比，二维绘图和图片使用得到很大改进。使用GDIPlus你可以绘制定制的对象，打开各种图片并以各种格式存储它们，使用多种字体和文本绘制轨迹 和各种调色板功能。

GDI Plus兼容性：

    GDIPlus最初是为MS Visual Studio 7开发的，但是因为这个产品的发布推迟了，所以微软就为Visual Studio 6发行了这个库的版本。如果你使用Visual Studio 6，可以从这里下载MFC GDI Plus库文件。http://www.codersource.net/samples/mfcgdiplus.zip

a）Visual Studio 7或者更新版本使用这个类库，只需要在你的工程里面包含<gdiplus.h>

b）早期版本的MSVS要使用这个类库，需要将下载的zip文件解压到一个文件夹，设其路径为your_path，然后将目录your_path\ gdiplus\includes加入到开发环境的包含路径中（Tools->Options->Directories-> Include files），然后在你的工程中你必须包含文件<gdiplus>，但是在那之前你必须定义define ULONG_PTR（这是GDIPlus中的一个定义，在老版本的VS中没有定义过）。也就是说，在StdAfx.h中你需要添加如下代码：

#define ULONG_PTR ULONG
include <gdiplus.h>

然后将目录your_path\gdiplus\lib包含到你的工程（Tools->Options->Directories->Library files），以使它们可以链接到你的程序。

【efivol补充：还必须在StdAfx.h中#include <gdiplus.h>之后加入这两句，不然有错。

using namespace Gdiplus;
#pragma comment(lib, "gdiplus.lib")

在编译完你的工程之后，将your_path\gdiplus\gdiplus.dll拷贝到生成的执行文件所在的文件夹（\Debug或者\Release）

使用GDI Plus类库：

要使用GDI Plus类库，你必须首先初始化类库。初始化是一个调用两个参数的函数，这两个参数是必须在整个GDIPlus会话中都存在的变量。在使用完GDIPlus之后，必须调用一个函数来关闭会话。

如果你使用MFC，一个好的方法是在你的CWinApp派生的类中（比如CYourProjectApp）添加变量：

private：
GdiplusStartupInput m_gdiplusStartupInput;
ULONG_PTR m_pGdiToken;

然后在app的InitInstance函数中的开始添加一行代码：

GdiplusStartup(&m_pGdiToken,&m_gdiplusStartupInput,NULL); //gdi+ init

然后重载ExitInstance函数（如果没有的话），在其中添加一行代码：

GdiplusShutdown(m_pGdiToken); //gdi+ end session

这些操作之后你就可以在你的程序中使用类库的功能了。

可以使用了么？不可以。我们新建一个单文档的工程，按上面的步骤做完，然后在View类的OnDraw（）函数里添加如下代码：

Graphics graphics(pDC->m_hDC);
Pen pen(Color(255, 0, 255));
graphics.DrawLine(&pen, 0, 0, 200, 100);

编译，出错。就这样还是被很多人转载，可恶吧。

错误提示为：
f:\includes\gdiplusenums.h(29) : error C2146: syntax error : missing ';' before identifier 'GraphicsState'
f:\includes\gdiplusenums.h(29) : fatal error C1004: unexpected end of file found

这个错误在网上百度一下有很多，问的人多，回答的人也多，但就是几乎没有人答对。解决方法是

在#include <gdiplus.h>之前加上#include <afxdtctl.h>

好了，一条线画出来了。为什么啊，这就不知道了，据说这个文件的作用是为IE4公共控件提供MFC支持。

柳暗花明之后，才发现这里有篇文章 Hints to get GDI+ running，是一个人写的建议。

里面说，要防止编译错误和问题，需要在#include <gdiplus.h>之前加上#include <afxwin.h>、<afxext.h>、<afxdisp.h>和<afxdtctl.h>。

{
　　float m[4][4]；
} MATRIX；
void XForm(float* res, const float* v, const float* m, int nNumVerts)
{
　　float dp；
　　int i；
　　　const VERTEX* vv = (VERTEX *)v；
　　　for (i = 0； i <； nNumVerts； i++)
　　{
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　　　// 写入转换了的 x
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　　// 写入转换了的 y
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 写入转换了的 z
　　　　dp = vv->；x * *m ++；
　　　　dp += vv->；y * *m ++；
　　　　dp += vv->；z * *m ++；
　　　　dp += vv->；w * *m ++；
　　　　*res ++ = dp；　　　　// 写入转换了的 w
　　　　vv ++；　　　　　　　 // 下一个矢量
　　　　m -= 16；
　　}
}
    推荐的代码 
typedef struct
{
　　float x,y,z,w；
} VERTEX；
typedef struct
{
　　float m[4][4]；
} MATRIX；
void XForm (float* res, const float* v, const float* m, int nNumVerts)
{
　　int i；
　　const VERTEX* vv = (VERTEX*)v；
　　const MATRIX* mm = (MATRIX*)m；
　　VERTEX* rr = (VERTEX*)res；
　　for (i = 0； i <； nNumVerts； i++)
　　{
　　　　rr->；x = vv->；x * mm->；m[0][0] + vv->；y * mm->；m[0][1]
　　　　　　　　+ vv->；z * mm->；m[0][2] + vv->；w * mm->；m[0][3]；
　　　　rr->；y = vv->；x * mm->；m[1][0] + vv->；y * mm->；m[1][1]
　　　　　　　　+ vv->；z * mm->；m[1][2] + vv->；w * mm->；m[1][3]；
　　　　rr->；z = vv->；x * mm->；m[2][0] + vv->；y * mm->；m[2][1]
　　　　　　　　+ vv->；z * mm->；m[2][2] + vv->；w * mm->；m[2][3]；
　　　　rr->；w = vv->；x * mm->；m[3][0] + vv->；y * mm->；m[3][1]
　　　　　　　　+ vv->；z * mm->；m[3][2] + vv->；w * mm->；m[3][3]；
　　}
} 
　　注意: 源代码的转化是与编译器的代码发生器相结合的。从源代码层次很难控制产生的机器码。依靠编译器和特殊的源代码，有可能指针型代码编译成的机器码比同等条件下的数组型代码运行速度更快。明智的做法是在源代码转化后检查性能是否真正提高了，再选择使用指针型还是数组型。 
6.充分分解小的循环 
　　要充分利用CPU的指令缓存，就要充分分解小的循环。特别是当循环体本身很小的时候，分解循环可以提高性能。BTW:很多编译器并不能自动分解循环。 
不好的代码 推荐的代码 
// 3D转化：把矢量 V 和 4x4 矩阵 M 相乘
for (i = 0； i <； 4； i ++)
{
　　r = 0；
　　for (j = 0； j <； 4； j ++)
　　{
　　　　r += M[j]*V[j]；
　　}
}
r[0] = M[0][0]*V[0] + M[1][0]*V[1] + M[2][0]*V[2] + M[3][0]*V[3]；
r[1] = M[0][1]*V[0] + M[1][1]*V[1] + M[2][1]*V[2] + M[3][1]*V[3]；
r[2] = M[0][2]*V[0] + M[1][2]*V[1] + M[2][2]*V[2] + M[3][2]*V[3]；
r[3] = M[0][3]*V[0] + M[1][3]*V[1] + M[2][3]*V[2] + M[3][3]*v[3]； 
7.避免没有必要的读写依赖 
　　当数据保存到内存时存在读写依赖，即数据必须在正确写入后才能再次读取。虽然AMD Athlon等CPU有加速读写依赖延迟的硬件，允许在要保存的数据被写入内存前读取出来，但是，如果避免了读写依赖并把数据保存在内部寄存器中，速度会更快。在一段很长的又互相依赖的代码链中，避免读写依赖显得尤其重要。如果读写依赖发生在操作数组时，许多编译器不能自动优化代码以避免读写依赖。所以推荐程序员手动去消除读写依赖，举例来说，引进一个可以保存在寄存器中的临时变量。这样可以有很大的性能提升。下面一段代码是一个例子： 
    不好的代码
float x[VECLEN], y[VECLEN], z[VECLEN]；
...... 
for (unsigned int k = 1； k <； VECLEN； k ++)
{
　　x[k] = x[k-1] + y[k]；
}
for (k = 1； k <； VECLEN； k++)
{
　　x[k] = z[k] * (y[k] - x[k-1])；
}
　　 推荐的代码 
float x[VECLEN], y[VECLEN], z[VECLEN]；
...... 
float t(x[0])；
for (unsigned int k = 1； k <； VECLEN； k ++)
{
　　t = t + y[k]；
　　x[k] = t；
}
t = x[0]；
for (k = 1； k <； VECLEN； k ++)
{
　　t = z[k] * (y[k] - t)；
　　x[k] = t；
} 
8.Switch 的用法 
　　Switch 可能转化成多种不同算法的代码。其中最常见的是跳转表和比较链/树。推荐对case的值依照发生的可能性进行排序，把最有可能的放在第一个，当switch用比较链的方式转化时，这样可以提高性能。此外，在case中推荐使用小的连续的整数，因为在这种情况下，所有的编译器都可以把switch 转化成跳转表。 
    不好的代码
int days_in_month, short_months, normal_months, long_months；
...... 
switch (days_in_month)
{
　　case 28:
　　case 29:
　　　　short_months ++；
　　　　break；
　　case 30:
　　　　normal_months ++；
　　　　break；
　　case 31:
　　　　long_months ++；
　　　　break；
　　default:
　　　　cout <；<； "；month has fewer than 28 or more than 31 days"； <；<； endl；
　　　　break；
}
    推荐的代码 
int days_in_month, short_months, normal_months, long_months；
...... 
switch (days_in_month)
{
　　case 31:
　　　　long_months ++；
　　　　break；
　　case 30:
　　　　normal_months ++；
　　　　break；
　　case 28:
　　case 29:
　　　　short_months ++； 
　　　　break；
　　default:
　　　　cout <；<； "；month has fewer than 28 or more than 31 days"； <；<； endl；
　　　　break；
} 
9.所有函数都应该有原型定义 
　　一般来说，所有函数都应该有原型定义。原型定义可以传达给编译器更多的可能用于优化的信息。 
　　尽可能使用常量(const)。C++ 标准规定，如果一个const声明的对象的地址不被获取，允许编译器不对它分配储存空间。这样可以使代码更有效率，而且可以生成更好的代码。 
10.提升循环的性能
　　要提升循环的性能，减少多余的常量计算非常有用（比如，不随循环变化的计算）。 
　　不好的代码(在for()中包含不变的if()) 推荐的代码 
for( i ... )
{
　　if( CONSTANT0 )
　　{
　　　　DoWork0( i )； // 假设这里不改变CONSTANT0的值
　　}
　　else
　　{
　　　　DoWork1( i )； // 假设这里不改变CONSTANT0的值
　　}
}
if( CONSTANT0 )
{
　　for( i ... )
　　{
　　　　DoWork0( i )；
　　}
}
else
{
　　for( i ... )
　　{
　　　　DoWork1( i )；
　　}
} 
　　如果已经知道if()的值，这样可以避免重复计算。虽然不好的代码中的分支可以简单地预测，但是由于推荐的代码在进入循环前分支已经确定，就可以减少对分支预测的依赖。 　　把本地函数声明为静态的(static) 
　　如果一个函数在实现它的文件外未被使用的话，把它声明为静态的(static)以强制使用内部连接。否则，默认的情况下会把函数定义为外部连接。这样可能会影响某些编译器的优化——比如，自动内联。 
11.考虑动态内存分配 
　　动态内存分配（C++中的"；new"；）可能总是为长的基本类型（四字对齐）返回一个已经对齐的指针。但是如果不能保证对齐，使用以下代码来实现四字对齐。这段代码假设指针可以映射到 long 型。 
　　例子 
　　double* p = (double*)new BYTE[sizeof(double) * number_of_doubles+7L]；
    double* np = (double*)((long(p) + 7L) &； –8L)； 
　　现在，你可以使用 np 代替 p 来访问数据。注意：释放储存空间时仍然应该用delete p。 
12.使用显式的并行代码 
　　尽可能把长的有依赖的代码链分解成几个可以在流水线执行单元中并行执行的没有依赖的代码链。因为浮点操作有很长的潜伏期，所以不管它被映射成 x87 或 3DNow! 指令，这都很重要。很多高级语言，包括C++，并不对产生的浮点表达式重新排序，因为那是一个相当复杂的过程。需要注意的是，重排序的代码和原来的代码在代数上一致并不等价于计算结果一致，因为浮点操作缺乏精确度。在一些情况下，这些优化可能导致意料之外的结果。幸运的是，在大部分情况下，最后结果可能只有最不重要的位（即最低位）是错误的。 
　　不好的代码
double a[100], sum；
int i；
sum = 0.0f；
for (i=0； i<；100； i++)
　　sum += a； 
    推荐的代码 
double a[100], sum1, sum2, sum3, sum4, sum；
int i；
sum1 = sum2 = sum3 = sum4 = 0.0；
for (i = 0； i <； 100； i += 4)
{
　　sum1 += a；
　　sum2 += a[i+1]；
　　sum3 += a[i+2]；
　　sum4 += a[i+3]；
}
sum = (sum4+sum3)+(sum1+sum2)； 
　　要注意的是：使用4 路分解是因为这样使用了4阶段流水线浮点加法，浮点加法的每一个阶段占用一个时钟周期，保证了最大的资源利用率。 
13.提出公共子表达式 
　　在某些情况下，C++编译器不能从浮点表达式中提出公共的子表达式，因为这意味着相当于对表达式重新排序。需要特别指出的是，编译器在提取公共子表达式前不能按照代数的等价关系重新安排表达式。这时，程序员要手动地提出公共的子表达式（在VC.net里有一项“全局优化”选项可以完成此工作，但效果就不得而知了）。 
推荐的代码 
float a, b, c, d, e, f；
...
e = b * c / d；
f = b / d * a；
float a, b, c, d, e, f；
...
const float t(b / d)；
e = c * t；
f = a * t； 
推荐的代码 
float a, b, c, e, f；
...
e = a / c；
f = b / c；
float a, b, c, e, f；
...
const float t(1.0f / c)；
e = a * t；
f = b * t； 
14.结构体成员的布局 
　　很多编译器有“使结构体字，双字或四字对齐”的选项。但是，还是需要改善结构体成员的对齐，有些编译器可能分配给结构体成员空间的顺序与他们声明的不同。但是，有些编译器并不提供这些功能，或者效果不好。所以，要在付出最少代价的情况下实现最好的结构体和结构体成员对齐，建议采取这些方法： 
　　A按类型长度排序 
　　把结构体的成员按照它们的类型长度排序，声明成员时把长的类型放在短的前面。 
　　把结构体填充成最长类型长度的整倍数 
　　把结构体填充成最长类型长度的整倍数。照这样，如果结构体的第一个成员对齐了，所有整个结构体自然也就对齐了。下面的例子演示了如何对结构体成员进行重新排序： 
　　不好的代码，普通顺序 推荐的代码，新的顺序并手动填充了几个字节
struct
{
　　char a[5]；
　　long k；
　　double x；
} baz；
struct
{
　　double x；
　　long k；
　　char a[5]；
char pad[7]；
} baz；

　　这个规则同样适用于类的成员的布局。 
　　B按数据类型的长度排序本地变量 
　　当编译器分配给本地变量空间时，它们的顺序和它们在源代码中声明的顺序一样，和上一条规则一样，应该把长的变量放在短的变量前面。如果第一个变量对齐了，其它变量就会连续的存放，而且不用填充字节自然就会对齐。有些编译器在分配变量时不会自动改变变量顺序，有些编译器不能产生4字节对齐的栈，所以4字节可能不对齐。下面这个例子演示了本地变量声明的重新排序： 
　　不好的代码，普通顺序 推荐的代码，改进的顺序 
short ga, gu, gi；
long foo, bar；
double x, y, z[3]；
char a, b；
float baz；
double z[3]；
double x, y；
long foo, bar；
float baz；
short ga, gu, gi； 
14.避免不必要的整数除法 
　　整数除法是整数运算中最慢的，所以应该尽可能避免。一种可能减少整数除法的地方是连除，这里除法可以由乘法代替。这个替换的副作用是有可能在算乘积时会溢出，所以只能在一定范围的除法中使用。 
　　不好的代码 推荐的代码 
int i, j, k, m；
m = i / j / k；
int i, j, k, m；
m = i / (j * k)； 
15.把频繁使用的指针型参数拷贝到本地变量 
　　避免在函数中频繁使用指针型参数指向的值。因为编译器不知道指针之间是否存在冲突，所以指针型参数往往不能被编译器优化。这样是数据不能被存放在寄存器中，而且明显地占用了内存带宽。注意，很多编译器有“假设不冲突”优化开关（在VC里必须手动添加编译器命令行/Oa或/Ow），这允许编译器假设两个不同的指针总是有不同的内容，这样就不用把指针型参数保存到本地变量。否则，请在函数一开始把指针指向的数据保存到本地变量。如果需要的话，在函数结束前拷贝回去。 　　
    不好的代码 
// 假设 q != r
void isqrt(unsigned long a, unsigned long* q, unsigned long* r)
{
　　*q = a；
　　if (a >； 0)
　　{
　　　　while (*q >； (*r = a / *q))
　　　　{
　　　　　　*q = (*q + *r) >；>； 1；
　　　　}
　　}
　　*r = a - *q * *q；
}
    推荐的代码
// 假设 q != r
void isqrt(unsigned long a, unsigned long* q, unsigned long* r)
{
　　unsigned long qq, rr；
　　qq = a；
　　if (a >； 0)
　　{
　　　　while (qq >； (rr = a / qq))
　　　　{
　　　　　　qq = (qq + rr) >；>； 1；
　　　　}
　　}
　　rr = a - qq * qq；
　　*q = qq；
　　*r = rr；
} 
16.赋值与初始化
先看看以下代码： 
class CInt
{
　　int m_i； 
public:
　　CInt(int a = 0):m_i(a) { cout <；<； "；CInt"； <；<； endl； }
　　~CInt() { cout <；<； "；~CInt"； <；<； endl； } 
　　CInt operator + (const CInt&； a) { return CInt(m_i + a.GetInt())； } 
　　void SetInt(const int i)　　{ m_i = i； }
　　int GetInt() const　　　　　　{ return m_i； }
}；
    不好的代码 
void main()
{
　　CInt a, b, c；
　　a.SetInt(1)；
　　b.SetInt(2)；
　　c = a + b；
}
    推荐的代码
void main()
{
　　CInt a(1), b(2)；
　　CInt c(a + b)；
} 
　　这两段代码所作的事都一样，但那一个更好呢？看看输出结果就会发现，不好的代码输出了四个"；CInt"；和四个"；~CInt"；，而推荐的代码只输出三个。也就是说，第二个例子比第一个例子少生成一次临时对象。Why? 请注意，第一个中的c用的是先声明再赋值的方法，第二个用的是初始化的方法，它们有本质的区别。第一个例子的"；c = a + b"；先生成一个临时对象用来保存a + b的值，再把该临时对象用位拷贝的方法给c赋值，然后临时对象被销毁。这个临时对象就是那个多出来的对象。第二个例子直接用拷贝构造函数的方法对c初始化，不产生临时对象。所以，尽量在需要使用一个对象时才声明，并用初始化的方法赋初值。 
17.尽量使用成员初始化列表 
　　在初始化类的成员时，尽量使用成员初始化列表而不是传统的赋值方式。 
　　不好的代码 
class CMyClass
{
　　string strName； 
public:
　　CMyClass(const string&； str)；
}； 
CMyClass::CMyClass(const string&； str)
{
　　strName = str；
}
    推荐的代码
class CMyClass
{
　　string strName；
　　int i；
public:
　　CMyClass(const string&； str)；
}； 
CMyClass::CMyClass(const string&；str)
   :strName(str)
{

} 
　　不好的例子用的是赋值的方式。这样，strName会先被建立（调用了string的默认构造函数），再由参数str赋值。而推荐的例子用的是成员初始化列表，strName直接构造为str，少调用一次默认构造函数，还少了一些安全隐患。zhuan

#ifdef __cplusplu*
**tern "C" {
#endif

//一段代码

#ifdef __cplusplus
}
#endif 

　　这样的代码到底是什么意思呢？首先，__cplusplus是cpp中的自定义宏，那么定义了这个宏的话表示这是一段cpp的代码，也就是说，上面的代码的含义是:如果这是一段cpp的代码，那么加入extern "C"{和}处理其中的代码。

　　要明白为何使用extern "C"，还得从cpp中对函数的重载处理开始说起。在c++中，为了支持重载机制，在编译生成的汇编码中，要对函数的名字进行一些处理，加入比如函数的返回类型等等.而在C中，只是简单的函数名字而已，不会加入其他的信息.也就是说:C++和C对产生的函数名字的处理是不一样的.

　　比如下面的一段简单的函数，我们看看加入和不加入extern "C"产生的汇编代码都有哪些变化:

int f(void)
{
return 1;
} 

　　在加入extern "C"的时候产生的汇编代码是:

.file "test.cxx"
.text
.align 2
.globl _f
.def _f; .scl 2; .type 32; .endef
_f:
pushl %ebp
movl %esp， %ebp
movl $1， %eax
popl %ebp
ret 

　　但是不加入了extern "C"之后

.file "test.cxx"
.text
.align 2
.globl __Z1fv
.def __Z1fv; .scl 2; .type 32; .endef
__Z1fv:
pushl %ebp
movl %esp， %ebp
movl $1， %eax
popl %ebp
ret 

　　两段汇编代码同样都是使用gcc -S命令产生的，所有的地方都是一样的，唯独是产生的函数名，一个是_f，一个是__Z1fv。

　　明白了加入与不加入extern "C"之后对函数名称产生的影响，我们继续我们的讨论:为什么需要使用extern "C"呢？C++之父在设计C++之时，考虑到当时已经存在了大量的C代码，为了支持原来的C代码和已经写好C库，需要在C++中尽可能的支持C，而extern "C"就是其中的一个策略。 
试想这样的情况:一个库文件已经用C写好了而且运行得很良好，这个时候我们需要使用这个库文件，但是我们需要使用C++来写这个新的代码。如果这个代码使用的是C++的方式链接这个C库文件的话，那么就会出现链接错误.我们来看一段代码:首先，我们使用C的处理方式来写一个函数，也就是说假设这个函数当时是用C写成的:

//f1.c
extern "C"
{
void f1()
{
return;
}
} 

　　编译命令是:gcc -c f1.c -o f1.o 产生了一个叫f1.o的库文件。再写一段代码调用这个f1函数:

// test.cxx
//这个extern表示f1函数在别的地方定义，这样可以通过
//编译，但是链接的时候还是需要
//链接上原来的库文件.
extern void f1();

int main()
{
f1();

return 0;
} 

　　通过gcc -c test.cxx -o test.o 产生一个叫test.o的文件。然后，我们使用gcc test.o f1.o来链接两个文件，可是出错了，错误的提示是:

test.o(.text + 0x1f):test.cxx: undefine reference to 'f1()' 

　　也就是说，在编译test.cxx的时候编译器是使用C++的方式来处理f1()函数的，但是实际上链接的库文件却是用C的方式来处理函数的，所以就会出现链接过不去的错误:因为链接器找不到函数。

　　因此，为了在C++代码中调用用C写成的库文件，就需要用extern "C"来告诉编译器:这是一个用C写成的库文件，请用C的方式来链接它们。

　　比如，现在我们有了一个C库文件，它的头文件是f.h，产生的lib文件是f.lib，那么我们如果要在C++中使用这个库文件，我们需要这样写:
extern "C"
{
＃i nclude "f.h"
} 

　　回到上面的问题，如果要改正链接错误，我们需要这样子改写test.cxx:

extern "C"
{
extern void f1();
}

int main()
{
f1();

return 0;
} 

　　重新编译并且链接就可以过去了.

　　总结

　　C和C++对函数的处理方式是不同的.extern "C"是使C++能够调用C写作的库文件的一个手段，如果要对编译器提示使用C的方式来处理函数的话，那么就要使用extern "C"来说明。
 

 
 
 
作者：宋宝华  e-mail:21cnbao@21cn.com　出处：太平洋电脑网

1.引言

C++语言的创建初衷是“a better C”，但是这并不意味着C++中类似C语言的全局变量和函数所采用的编译和连接方式与C语言完全相同。作为一种欲与C兼容的语言，C++保留了一部分过程式语言的特点（被世人称为“不彻底地面向对象”），因而它可以定义不属于任何类的全局变量和函数。但是，C++毕竟是一种面向对象的程序设计语言，为了支持函数的重载，C++对全局函数的处理方式与C有明显的不同。

2.从标准头文件说起

某企业曾经给出如下的一道面试题：

面试题

为什么标准头文件都有类似以下的结构？

   #ifndef __INCvxWorksh

   #define __INCvxWorksh

   #ifdef __cplusplus

   extern "C" {

   #endif

   /*...*/

   #ifdef __cplusplus

   }

   #endif

   #endif /* __INCvxWorksh */

分析

显然，头文件中的编译宏“#ifndef __INCvxWorksh、#define __INCvxWorksh、#endif” 的作用是防止该头文件被重复引用。

那么

   #ifdef __cplusplus

   extern "C" {

   #endif

  #ifdef __cplusplus

   }

   #endif

的作用又是什么呢？我们将在下文一一道来。

3.深层揭密extern "C"

extern "C" 包含双重含义，从字面上即可得到：首先，被它修饰的目标是“extern”的；其次，被它修饰的目标是“C”的。让我们来详细解读这两重含义。

（1）       被extern "C"限定的函数或变量是extern类型的；

extern是C/C++语言中表明函数和全局变量作用范围（可见性）的关键字，该关键字告诉编译器，其声明的函数和变量可以在本模块或其它模块中使用。记住，下列语句：

extern int a;

仅仅是一个变量的声明，其并不是在定义变量a，并未为a分配内存空间。变量a在所有模块中作为一种全局变量只能被定义一次，否则会出现连接错误。

通常，在模块的头文件中对本模块提供给其它模块引用的函数和全局变量以关键字extern声明。例如，如果模块B欲引用该模块A中定义的全局变量和函数时只需包含模块A的头文件即可。这样，模块B中调用模块A中的函数时，在编译阶段，模块B虽然找不到该函数，但是并不会报错；它会在连接阶段中从模块A编译生成的目标代码中找到此函数。

与extern对应的关键字是static，被它修饰的全局变量和函数只能在本模块中使用。因此，一个函数或变量只可能被本模块使用时，其不可能被extern “C”修饰。

（2）       被extern "C"修饰的变量和函数是按照C语言方式编译和连接的；

未加extern “C”声明时的编译方式

首先看看C++中对类似C的函数是怎样编译的。

作为一种面向对象的语言，C++支持函数重载，而过程式语言C则不支持。函数被C++编译后在符号库中的名字与C语言的不同。例如，假设某个函数的原型为：

void foo( int x, int y );

该函数被C编译器编译后在符号库中的名字为_foo，而C++编译器则会产生像_foo_int_int之类的名字（不同的编译器可能生成的名字不同，但是都采用了相同的机制，生成的新名字称为“mangled name”）。_foo_int_int这样的名字包含了函数名、函数参数数量及类型信息，C++就是靠这种机制来实现函数重载的。例如，在C++中，函数void foo( int x, int y )与void foo( int x, float y )编译生成的符号是不相同的，后者为_foo_int_float。

同样地，C++中的变量除支持局部变量外，还支持类成员变量和全局变量。用户所编写程序的类成员变量可能与全局变量同名，我们以"."来区分。而本质上，编译器在进行编译时，与函数的处理相似，也为类中的变量取了一个独一无二的名字，这个名字与用户程序中同名的全局变量名字不同。

未加extern "C"声明时的连接方式

假设在C++中，模块A的头文件如下：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

       #define MODULE_A_H

    int foo( int x, int y );

#endif

在模块B中引用该函数：

// 模块B实现文件　moduleB.cpp

＃i nclude "moduleA.h"

foo(2,3);

实际上，在连接阶段，连接器会从模块A生成的目标文件moduleA.obj中寻找_foo_int_int这样的符号！

加extern "C"声明后的编译和连接方式

加extern "C"声明后，模块A的头文件变为：

// 模块A头文件　moduleA.h

#ifndef MODULE_A_H

       #define MODULE_A_H

    extern "C" int foo( int x, int y );

#endif

在模块B的实现文件中仍然调用foo( 2,3 )，其结果是：

（1）模块A编译生成foo的目标代码时，没有对其名字进行特殊处理，采用了C语言的方式；

（2）连接器在为模块B的目标代码寻找foo(2,3)调用时，寻找的是未经修改的符号名_foo。

如果在模块A中函数声明了foo为extern "C"类型，而模块B中包含的是extern int foo( int x, int y ) ，则模块B找不到模块A中的函数；反之亦然。

所以，可以用一句话概括extern “C”这个声明的真实目的（任何语言中的任何语法特性的诞生都不是随意而为的，来源于真实世界的需求驱动。我们在思考问题时，不能只停留在这个语言是怎么做的，还要问一问它为什么要这么做，动机是什么，这样我们可以更深入地理解许多问题）：

实现C++与C及其它语言的混合编程。

明白了C++中extern "C"的设立动机，我们下面来具体分析extern "C"通常的使用技巧。

4.extern "C"的惯用法

（1）在C++中引用C语言中的函数和变量，在包含C语言头文件（假设为cExample.h）时，需进行下列处理：

extern "C"

{

＃i nclude "cExample.h"

}

而在C语言的头文件中，对其外部函数只能指定为extern类型，C语言中不支持extern "C"声明，在.c文件中包含了extern "C"时会出现编译语法错误。

笔者编写的C++引用C函数例子工程中包含的三个文件的源代码如下：

/* c语言头文件：cExample.h */

#ifndef C_EXAMPLE_H

#define C_EXAMPLE_H

extern int add(int x,int y);

#endif

/* c语言实现文件：cExample.c */

＃i nclude "cExample.h"

int add( int x, int y )

{

       return x + y;

}

// c++实现文件，调用add：cppFile.cpp

extern "C"

{

＃i nclude "cExample.h"

}

int main(int argc, char* argv[])

{

       add(2,3);

       return 0;

}

如果C++调用一个C语言编写的.DLL时，当包括.DLL的头文件或声明接口函数时，应加extern "C" {　}。

（2）在C中引用C++语言中的函数和变量时，C++的头文件需添加extern "C"，但是在C语言中不能直接引用声明了extern "C"的该头文件，应该仅将C文件中将C++中定义的extern "C"函数声明为extern类型。

笔者编写的C引用C++函数例子工程中包含的三个文件的源代码如下：

//C++头文件 cppExample.h

#ifndef CPP_EXAMPLE_H

#define CPP_EXAMPLE_H

extern "C" int add( int x, int y );

#endif

//C++实现文件 cppExample.cpp

＃i nclude "cppExample.h"

int add( int x, int y )

{

       return x + y;

}

/* C实现文件 cFile.c

/* 这样会编译出错：＃i nclude "cExample.h" */

extern int add( int x, int y );

int main( int argc, char* argv[] )

{

       add( 2, 3 );   

       return 0;

}

　　这个这个关键字用于声明变量的生存期为自动，即将不在任何类、结构、枚举、联合和函数中定义的变量视为全局变量，而在函数中定义的变量视为局部变量。这个关键字不怎么多写，因为所有的变量默认就是auto的。

(2)register

　　这个关键字命令编译器尽可能的将变量存在CPU内部寄存器中而不是通过内存寻址访问以提高效率。

(3)static

　　常见的两种用途:
　　　　1>统计函数被调用的次数;
　　　　2>减少局部数组建立和赋值的开销.变量的建立和赋值是需要一定的处理器开销的，特别是数组等含有较多元素的存储类型。在一些含有较多的变量并且被经常调用的函数中，可以将一些数组声明为static类型，以减少建立或者初始化这些变量的开销.

　　详细说明:
　　　　1>、变量会被放在程序的全局存储区中，这样可以在下一次调用的时候还可以保持原来的赋值。这一点是它与堆栈变量和堆变量的区别。
　　　　2>、变量用static告知编译器，自己仅仅在变量的作用范围内可见。这一点是它与全局变量的区别。
　　　　3>当static用来修饰全局变量时，它就改变了全局变量的作用域，使其不能被别的程序extern，限制在了当前文件里，但是没有改变其存放位置，还是在全局静态储存区。

　　使用注意:
　　　　1>若全局变量仅在单个C文件中访问，则可以将这个变量修改为静态全局变量，以降低模块间的耦合度；
　　　　2>若全局变量仅由单个函数访问，则可以将这个变量改为该函数的静态局部变量，以降低模块间的耦合度；
　　　　3>设计和使用访问动态全局变量、静态全局变量、静态局部变量的函数时，需要考虑重入问题(只要输入数据相同就应产生相同的输出)。

(4)const

　　被const修饰的东西都受到强制保护，可以预防意外的变动，能提高程序的健壮性。它可以修饰函数的参数、返回值，甚至函数的定义体。

　　作用:
　　　　1>修饰输入参数
　　　　　　a.对于非内部数据类型的输入参数，应该将“值传递”的方式改为“const引用传递”，目的是提高效率。例如将void Func(A a) 改为void Func(const A &a)。
　　　　　　b.对于内部数据类型的输入参数，不要将“值传递”的方式改为“const引用传递”。否则既达不到提高效率的目的，又降低了函数的可理解性。例如void Func(int x) 不应该改为void Func(const int &x)。
　　　　2>用const修饰函数的返回值
　　　　　　a.如果给以“指针传递”方式的函数返回值加const修饰，那么函数返回值（即指针）的内容不能被修改，该返回值只能被赋给加const修饰的同类型指针。
　　　　　　　如对于： const char * GetString(void);
　　　　　　　如下语句将出现编译错误：
　　　　　　 　char *str = GetString();//cannot convert from 'const char *' to 'char *'；
　　　　　　　正确的用法是：
　　　　　　　const char *str = GetString();
　　　　　　b.如果函数返回值采用“值传递方式”，由于函数会把返回值复制到外部临时的存储单元中，加const修饰没有任何价值。 如不要把函数int GetInt(void) 写成const int GetInt(void)。
　　　　3>const成员函数的声明中，const关键字只能放在函数声明的尾部,表示该类成员不修改对象.

　　　说明：
　　　　const type m; //修饰m为不可改变
　　　示例：
　　　　typedef char * pStr; //新的类型pStr;
　　　　char string[4] = "abc";
　　　　const char *p1 = string；
　　　　p1++; //正确，上边修饰的是*p1,p1可变
　　　　const pStr p2 = string;
　　　　p2++; //错误，上边修饰的是p2，p2不可变,*p2可变
　　　同理，const修饰指针时用此原则判断就不会混淆了。
　　　　const int *value; //*value不可变，value可变
　　　　int* const value; //value不可变，*value可变
　　　　const (int *) value; //(int *)是一种type,value不可变,*value可变
　　　　　　　　　　　　　　//逻辑上这样理解，编译不能通过，需要tydef int* NewType;
　　　　const int* const value;//*value,value都不可变

(5)volatile

　　表明某个变量的值可能在外部被改变，优化器在用到这个变量时必须每次都小心地重新读取这个变量的值，而不是使用保存在寄存器里的备份。它可以适用于基础类型如：int,char,long......也适用于C的结构和C++的类。当对结构或者类对象使用volatile修饰的时候，结构或者类的所有成员都会被视为volatile.
　　该关键字在多线程环境下经常使用，因为在编写多线程的程序时，同一个变量可能被多个线程修改，而程序通过该变量同步各个线程。
　　简单示例：
　　　DWORD __stdcall threadFunc(LPVOID signal)
　　　{
　　　　　int* intSignal=reinterpret_cast(signal);
　　　　　*intSignal=2;
　　　　　while(*intSignal!=1)
　　　　　sleep(1000);
　　　　　return 0;
　　　}
　　该线程启动时将intSignal 置为2，然后循环等待直到intSignal 为1 时退出。显然intSignal的值必须在外部被改变，否则该线程不会退出。但是实际运行的时候该线程却不会退出，即使在外部将它的值改为1，看一下对应的伪汇编代码就明白了：
　　　　　mov ax,signal
　　　　　label:
　　　　　if(ax!=1)
　　　　　goto label
　　对于C编译器来说，它并不知道这个值会被其他线程修改。自然就把它cache在寄存器里面。C 编译器是没有线程概念的,这时候就需要用到volatile。volatile 的本意是指：这个值可能会在当前线程外部被改变。也就是说，我们要在threadFunc中的intSignal前面加上volatile关键字，这时候，编译器知道该变量的值会在外部改变，因此每次访问该变量时会重新读取，所作的循环变为如下面伪码所示：
　　　　　label:
　　　　　mov ax,signal
　　　　　if(ax!=1)
　　　　　goto label

　　注意：一个参数既可以是const同时是volatile，是volatile因为它可能被意想不到地改变。它是const因为程序不应该试图去修改它。

(6)extern

　　extern 意为“外来的”···它的作用在于告诉编译器：有这个变量，它可能不存在当前的文件中，但它肯定要存在于工程中的某一个源文件中或者一个Dll的输出中。

   孙鑫老师的VC教学的视频在网上非常流行，我刚好看到网上有这个视频的学习笔记，这里把它贡献出来与大家分享。
下载
      孙鑫VC视频教学笔记

一 程序的设计

　　要避免错误，首先要从好的设计开始。对于程序的设计，需考虑到程序的两个特性：

　　1简单性

　　大多数常见的错误来源于程序设计中不必要的复杂成分。一个好的设计应该反映问题本身的要求，而不必为了刻意追求“满足将来的需要”而添加不必要的特性。实际上，简单优雅的设计比那些复杂的设计更能迎合未来的需求。

　　2 耦合性

　　耦合(decoupling)性用来衡量不同对象之间的依赖程度。松耦合的程序易于理解和实现，易于测试和维护，且这种程序包含错误的可能性小，错误也较容易发现和清除。
 

二 编程风格

　　编程风格是个人问题，有很大的随意性。一个好的编程风格不仅让代码易理解，也易于调试。好的编程风格包括：

　　1 清晰地书写代码

　　如果没有必要，尽量不要使用语言中的高级特性，因为这些特性不易于理解和调试。使用大多数程序员都能理解的语言成分来书写代码不易犯错且易于理解和维护。

　　2 编写结构良好的代码

　　当程序崩溃时所能得到的最基本的调试信息是源代码文件、问题所在行的行号和一个调用栈(call stack)。调用栈是调试程序时最有帮助的部分，它提供错误出现的上下文，也就是带参数的函数调用序列。你书写的代码结构越好，调用栈就能给你越多信息。

　　3 使用良好的标识符

　 　一个好名字能使你的代码更容易被理解和维护。流行的匈牙利命名法(Hungarian Notation)实际上是把标识符的意义和表示方法结合起来。 现在，匈牙利命名法表现出不少的局限性，匈牙利命名法过于看重前缀的作用，对一个变量的表达信息不完整，实际上并没有传递多少有用信息，它使代码难于阅 读，难以维护。一个好的命名传统是指示出变量的作用域以便在需要的时候检查它的定义，并明确地指出一个变量是全局的、局部的还是成员数据。依赖变量的定义 比依赖匈牙利前缀更加有用和可靠。

　　好的名字能够用平常的语言概括出该标识符所代表的实体的含义。在选择类、函数、变量的名字时可以考虑以下几个原则：

　　　　取简单的描述性名字，好的名字能简要地概括出这个标识符代表的含义。

　　　　避免简写，简写使标识符难于阅读和记忆，尽量使用混合大小写的完整的单词。

　　　　避免相似性的文字，避免混淆。

　　　　避免采用一般的或随机产生的名字，而应采用有实际意义的名字。如欲从按钮类派生位图按钮，取一个CBitmapButton，而不是CMyButton。

　　4 用简单的语句行

　　在VC中，一行可写多个语句。但调试是面向行的，过于复杂的行难于调试。因此，从调试的角度出发，每一个语句都应独自成行。

　　5 使用统一的排列

　　统一的排列方式使类、变量的定义和语句更加明显。

　　6 用括号使书写清晰

　　你不一定能都记住各种运算符的优先级和结合律，而使用多余的括号并不影响编译后的代码。因此，如果你不能确定是否需要括号时，请加上它。

　　7 使用好的注释

　　用好的注释能使你的代码不易出错，而且便于其他程序员阅读，便于理解和维护。

三 编写程序时应注意的问题

　　1 充分利用VC++的特性

　　可用下列技术来充分利用VC++的编译器的特性：

　　（1）用const代替#define来创建常量；

　　（2）用enum代替#define来创建常量集合；

　　（3）用内联(inline)函数代替#define；

　 　这三种技术用C++而不是C预处理。使用预处理的问题在于编译器对于预处理器所作的事情一无所知，因此无法用数据类型检查错误和不一致的地方。预处理的 名字不在符号表里，因此也不能用调试工具来检查预处理常量。相似地，预处理宏被编译进去，不能用调试工具跟踪。编译器能充分了解const、enum和 inline语句，从而能在编译的时候对出现的问题发出警告。

　　但预处理在很多调试代码中起重要作用。调试代码经常需要从非调试代码里面得到不同的行为，而最有效的办法就是让预处理为调试创建不同的代码。

　　（4）用new和delete代替malloc和free;

　　在创建对象、类型的安全性和灵活性方面。使用new/delete比malloc/free要好。另外，new可被重载，提供了更大的灵活性。

　　（5）用输入输出流(iostreams)代替stdio。

　 　使用C++输入输出流（<<和>>）而不使用C标准输入输出库（printf/sprintf和scanf/sscanf）， 有利于安全性和扩展性。从调试的角度来看，标准输入输出函数的最大问题在于编译器不能对控制流参数进行任何类型检测，而输入输出流的任何问题都能在编译时 检测出来。

　　2 使用头文件

　　要在头文件中声明所有共享的外部符号，而且保留函数原型中的参数名。把所有的共享定义放在头文件中，不要在.cpp文件里面看到extern关键字。

　　3 初始化变量

　 　在使用变量之前一定要把它们初始化。在初始化之前就使用变量肯定会产生错误。通常不需对对象进行初始化，对对数据成员应在构造函数中初始化。必须明确地 为在栈中和堆中分配的数组和数据结构进行初始化。对于对象，应该初始化每个需要初始化的数据成员。因为变量的使用是由优化器来检查的，所以检测未初始化的 本地变量，发布版本要比调试版本要做得好。

　　4 使用布尔表达式

C++的布尔类型：bool，值为true和false，大小为一个字节。

Windows程序通常用BOOL类型。定义如下：

1Typedef int BOOL;    
2  
3#define FALSE 0    
4  
5#define TRUE 1   

在C++中，一个布尔表达式如果为0则为假，其他则为真。因此，对布尔表达式应该检查是否问假而不是检查是否为真。

　　5 使用句柄和指针

　　初始化一个指针时，要么让其指向一个有效的内存地址，要么设为0（空指针），避免指针指向无效地址。回收指针所指对象时要重新初始化这个指针，并且在指针被释放前为空时就对其进行处理。对句柄的处理跟指针一样。

　　6 用引用而不是指针做参数

　　用指针做函数的参数可传递一个空指针，很灵活，但也很容易忘了对指针进行初始化。而引用是对象的别名，它必须和有效的对象相关联，不存在空的和没有初始化的引用。当在函数中收到一个引用参数时，可以肯定这是一个有效的对象。程序用引用做参数比用指针做参数更为健壮。

　　7 强制类型转换(cast)

　 　进行数据类型的强制类型转换时，将会调用相应的构造函数或转换函数来创建一个新类型的临时对象。对指针的正确类型转换可消除一个编译错误，但并没改变指 针。强制类型转换破坏了编译器进行类型检查的功能，而这正是编译器查找错误的最有效的机制。为了保证安全性，每一个强制类型转换都需要手工进行类型检查。 为尽量避免强制类型转换，你可以：避免使用多态数据类型；使用更加广泛的基类；提供特殊的存取函数；让编译器隐式处理类型转换等措施。

　　8 使用构造函数和析构函数

　 　构造函数需要分配内存，创建资源或者打开文件，这些运算并不总是成功。构造函数没有返回值，没有直接显示错误的方法。一个常见的方法（在很多MFC类中 使用）是把对象创建分为两步：第一步，让构造函数以一种不会出错的方式初始化对象；第二步，让某些初始化函数（如Init或Open）完成工作，这一步可 能出错。另一种方法是在构造函数中使用异常：第一步，以不会出错的方式初始化对象；第二步，用可能在try段内出错的代码初始化对象；第三步，在 catch代码里面处理异常。如果出现异常，就会在构造函数里清除分配的资源，并且再次抛出异常。

　　异常处理的一个关键细节就是在栈展 开的过程中抛出的异常会终止整个应用程序。在处理异常时经常要调用析构函数，因此析构函数很容易出错，一定要保证析构函数的异常在析构函数中得到处理。要 保证基类的析构函数是虚函数。这样，就算对象是一个指向基类的指针，也会调用派生类的析构函数。否则，就会引起资源泄漏(resource leak)。  

在VC程序中使用调试语句

为了更好地对程序调试，可以使用如下方法：使用断言、使用跟踪语句、使用异常和返回值。

一、断言

1、基本概念

　　断言是一种让错误在运行时候自我暴露的简单有效实用的技术。它们帮助你较早较轻易地发现错误，使得整个调试过程效率更高。

　　断言是布尔调试语句，用来检测在程序正常运行的时候某一个条件的值是否总为真，它能让错误在运行时刻暴露在程序员面前。使用断言的最大好处在于，能在更解决错误的发源地的地方发现错误。断言具有以下特征：

.断言是用来发现运行时刻错误的，发现的错误是关于程序实现方面的。

.断言中的布尔表达式显示的是某个对象或者状态的有效性而不是正确性。

.断言在条件编译后只存在于调试版本中，而不是发布版本里。

.断言不能包含程序代码。

.断言是为了给程序员而不是用户提供信息。

　 　使用断言最根本的好处是自动发现许多运行时产生的错误，但断言不能发现所有错误。断言检查的是程序的有效性而不是正确性，可通过断言把错误限制在一个有 限的范围内。当断言为假，激活调试器显示出错代码时，可用Call Stack命令，通过检查栈里的调用上下文、少量相关参数的值以及输出窗口中 Debug表的内容，通常能检查出导致断言失败的原因。_ASSERTE宏(属于C运行时间库)还能在断言失败时显示出失效断言。下面我们讨论一下MFC 库中的断言。

2、MFC库中的断言

(1) ASSERT(布尔表达式)

用MFC时最好选择ASSERT宏，它的优点是即使出现了WM_QUIT消息也能显示断言失效消息框。

(2) VERIFY(布尔表达式)

VERIFY 宏中的布尔表达式在发布版本中被保留下来。VERIFY宏简化了对函数返回值的检查，一般用来检查Windows API的返回值。由于 VERIFY宏里的布尔表达式在发布版本里保留了下来，因此最好尽量不要使用这个宏以实现程序代码和调试代码的完全分离。

(3 )ASSERT_VALID(指向CObject派生类对象的指针)

ASSERT_VALID宏通过调用重载的AssertValid函数来确定指向CObject派生类对象的指针是否有效。无论你什么时候从CObject派生类中得到一个对象，在对这个对象做任何操作之前都应该调用ASSERT_VALID宏。

(4) ASSERT_KINDOF(类名, 指向CObject派生类对象的指针)

这个宏用来验证指向CObject派生类对象的指针是否从某个特殊类中派生，在调用它之前先调用ASSERT_VALID宏。只有在很特殊的场合下才用得到，如检测编译器可能错过的对象类型问题。

此外，还有两个没有正式文件的ASSERT宏的变种：ASSERT_POINTER(指针,指针类型)，ASSERT_NULL_OR_POINTER(指针,指针类型)。

3、什么时候使用断言

　　把断言看作一种简单的制造栅栏的方法，这种栅栏能使错误在穿过自己时暴露。

.检查函数的输入

.检查函数的输出

.检查对象的当前状态

.坚持逻辑变量的合理性和一致性

.检查类中的不变量

公有成员函数比私有和保护的成员函数需要更全面的断言。

　　不正确地使用断言会导致错误。断言应该检测那些在程序正常运行的时候永远都不可能出现的状态。断言是用来揭示错误的，而不是用来纠正运行时刻错误的。

4、断言与防御性编程(Defensive Programming)

　 　断言在调试的时候向程序员揭示运行时刻错误（调试版本里），而防御性编程使用户在运行程序（发布版本里）时，当出现意外情况时程序仍能继续工作。实际 上，防御性的编程要求程序在检测到意外时返回一个“安全”的值（比如布尔函数返回false，指针和句柄返回空值），一个错误代码或者抛出一个异常来解决 问题。特定的防御性编程技术包括：处理无效函数参数和数据、出现问题的时候程序失败、检查临界函数返回的错误代码以及处理异常。需要防御性编程的标准问题 包括：错误的输入数据、内存或者硬盘空间不够、不能打开一个文件、外部设备不能访问、网络连接不上或者甚至在程序中还有错误，目的是保持程序的运行状态。 如果你的程序是防御性的，别忘了使用断言。如果你使用断言，也别忘了防御性编程。这两种技术最好结合在一起使用。

二、跟踪语句

1、基本概念

　 　跟踪语句(trace statements)可使程序执行，并使程序员可对可变值进行查看。它们提供了一个用于观察的程序，并且独立于一个交互式的调 试器，但是最具有特色的是它们常用于对调试器提供的信息进行补充。在VC中，跟踪消息通常输出到输出窗口中的Debug标签，也可以重新输出到一个文件 中。跟踪语句的特性如下：

.跟踪语句用于报告代码中重要的运行事件。

.跟踪语句的编译通常是有条件的，并只存在于调试版本中，而在发布版本中不被编译。

.跟踪语句不能包含程序代码或对程序代码有间接的影响作用。

.跟踪语句的目的是向程序员提供信息，而不是向用户。

跟踪语句也是调试语句，它可以执行程序，并且在运行中程序员可以查看变量。跟踪语句对于那些使用交互式调试器很难调试的程序是很有效的。

跟踪语句和断言的区别如下：

.跟踪语句是无条件的，断言是有条件的布尔语句。

.跟踪语句用于显示程序执行和变量值，不直接显示bug，断言用于显示出bug。

.跟踪语句将信息输出到调试窗口或文件中，可被随意地忽略，断言打断程序的执行。

2、MFC中的跟踪语句

　 　在MFC中，你可以使用TRACE和AfxOutputDebugString宏、CObject::Dump虚拟函数和AfxDumpStack函 数。TRACE宏由AfxDump实现，AfxDump由AfxOutputDebugString实现。AfxOutputDebugString宏和 AfxDumpStack函数可以在所有版本中编译，其他只能在调试版本中编译。


（1）TRACE宏有以下形式：

1_TRACE(reportType,format);    
2  
3_TRACE0(reportType,format,arg1);    
4  
5_TRACE1(reportType,format,arg1,arg2);    
6  
7_TRACE2(reportType,format,arg1,arg2,arg3);    
8  
9_TRACE3(reportType,format,arg1,arg2,arg3,arg4);

使用Visual C++调试器调试

一、调试版本与发布版本

　　有时程序能在调试版本运行但不能运行于发布版本，反之也有可能。一般说来，一个发布版本意味着某些类型的优化，而一个调试版本则没有优化。下面我们来看看它们的区别：

1、特别针对调试版本的编译选项

（1）/MDd,/MLd或者/MTd

　　调试版本的运行时刻库有调试符号，使用了调试堆，调试堆的目的是发现内存破坏和内存泄漏，并且向用户报告源代码的哪个地方出了问题。特性：

.调试版本的运行时刻库对内存的分配作了跟踪，允许用户检查内存泄漏。

.在刚分配的内存里写上0xCD的字节模式，用0xCD来填充刚分配的内存，有助于发现数据未被初始化的错误。

.在被释放的内存写上0xDD的字节模式，有助于发现已被释放的内存。

.在缓冲区的两边分配了四字节的保护数据，并用0xFD的字节模式作初始化，来检查写内存的上溢出和下溢出。

.在每个内存分配的地方对源代码文件名和行号作了记录，有助于用户在源代码中对内存分配进行定位。

（2）/Od

　 　这个选项用来关闭优化开关。因为未被优化的代码直接对应于源代码，所以比优化后的代码更容易读懂。未被优化的代码编译和链接会更快，会有更短的调试周 期。而由于优化，发布版本不见得会比调试版本运行得好，优化代码要求编译器做一些假设，去除冗余，但有时这个假设是错误的，并且去掉的冗余也有可能隐藏错 误。如发布版本的帧指针（EBP寄存器）省略（FPO）隐藏了函数原型不匹配的错误；在同步异常模式（只能由throw语句抛出，编译器默认，由/GX编 译选项设置）下，异常处理程序可能被优化掉，会阻止程序中的C++异常处理代码安全地捕获结构异常，在这种情况下，你必须使用异步异常模式（采取任何指令 都会产生异常的机制，由/Eha编译选项设置）。

（3）/D “_DEBUG”

　　打开条件编译调试代码开关。只有这个符号被定义，调试代码才会被编译，MFC使用_DEBUG符号来确定到底链接的是哪个版本的MFC类库。在调试版本中，内联默认情况下是被关闭的。

（4）/ZI

　 　创建编辑继续(Edit and Continue)的程序数据库。这个选项会打开/GF编译选项，/GF编译选项会消除重复字符串，并将字符串放到只 读内存。编辑继续功能需要获取存储在PDB文件里的特殊信息来使得代码的修改对调试器有效。如果被修改文件对应的信息不在PDB文件里，编辑继续功能就不 能进行，而且在调试过程中对代码的任何修改都会出现下面的提示信息 “One or more files are out of date or do not exist.”。

（5）/GZ

在调试版本中用来发现那些在发布版本里才发现的错误。其作用如下：

.用0xCC模式初始化自动（本地）变量。

.在通过函数指针调用函数时，检查栈指针，确认是否有调用规则不匹配。

.在函数最后检查栈指针是否被改变。

（6）/Gm

　　打开最小化重新链接开关，减少链接时间。

2、特别针对发布版本的编译选项

（1）/MD,/ML或者/MT

　　使用发布版本的运行时刻库。

（2）/O1或者/O2

　　打开优化开关，使得程序会最小或说速度会最快，优化器还可能发现代码中潜在的错误，而这些错误可能会被调试版本掩盖。

（3）/D “NDEBUG”

　　关闭条件编译调试代码开关。

（4）/GF

　　消除重复字符串并将它们放到只读内存中以避免被错误地修改。

（5）/Zi

创建包含调试符号的程序数据库。

　 　如果一个错误只发生在发布版本里，除非你是个汇编高手，否则你需要调试符号来提示你到底程序出现了什么问题，调试符号保存在程序的数据库文件（PDB） 中。Visual C++的AppWizard默认情况下没有为发布版本创建调试符号。为创建调试符号，打开工程设置对话框，选择 Win32 Release，在C/C++标签里选择Common类，在调试信息里，如果是发布版本选择Program Database，如果是调试版 本选择Program Database for Edit and Continue（编辑继续选项与优化链接不相容，不适于发布版本）。在Link标 签里选择Debug类，然后选择Debug Info和Microsoft format选项，最好不要选择Separate types选项，这样所有 的调试信息才会被合并到单独的一个PDB文件中。对于发布版本，选择Link标签，在Project options对话框的最后加上“/OPT: REF”，这个选项使得不被引用的函数和数据不会出现在可执行文件中，避免了文件的无谓增大。对于调试版本不要使用这个选项，它会关闭增量链接 (incremental linking)。

二、Visual C++编辑器的“设置”菜单

　　当你打开或新建一个包 含至少一个工程的Workspace后，Visual C++的Project菜单中的“Settings…”命令就变为有效，选择它或者按下热键Alt +F7后，便可调出工程设置对话框，这里面的选项将影响整个工程的建立和调试过程，因此很重要。

　　在这个对话框中，左上方的下拉列表框 用于选择一种工程配置，包括有Win32 Debug、Win32 Release和All Configurations（指前两种配置一起），某些选 项在不同的工程配置中有不同的缺省值。左边的树形视图给出了当前工程所有的文件及分类情况。下面我们就以Win32 Debug为例来看看与工程有关的的 四个主要选项卡的各自功能与含义（一共有十个选项卡）：

1、 General选项卡

　　这个选项卡比较简单，从上向下的 第一个选项用于更改使用MFC类库的方式： DLL的方式或是静态连接。我们可以在两种方式之间进行切换。第二个选项用于指定在编译连接过程中生成的中间 文件和输出文件的存放目录，对于调试版本来说，缺省的目录是工程下面的“Debug”子目录。第三个选项用于指定是否允许每种工程配置都有自己的文件依赖 关系（主要指头文件），由于绝大多数工程的调试版本和发布版本都具有相同的文件依赖关系，所以通常不需要更改该选项。

2、 Debug选项卡

　　Debug选项卡中是一些与调试有关的选项，由于选项比较多，它们被分成了几个类，我们可以从Category中选择不同的类别，选项卡就会切换显示出相应的选项。

　　在General类别中，可以指定要调试的可执行文件名。另外三个选项可以指定用于调试的工作目录，开始调试时给程序传送的命令行参数，以及进行远程调试时可执行文件的路径。

3、C/C++选项卡

　 　C/C++选项卡控制着Visual C++的编译器，其中的选项比较多。下面有一个Project Options编辑框，里面 列出的各种命令开关将会在开始编译时作为命令行参数传送给Visual C++的编译器。这些命令开关会跟随其它选项改变而改变。

　 　在General类别中，Warning level用于指定编译器显示警告的级别，如果选中了Warnings as errors，那么显示的每一 个警告都将会引起一个错误，这样在编译完毕后就无法启动连接器来进行连接。Optimizations用于设置代码优化方式，优化的目的主要有提高运行速 度和减小程序体积两种，但有时候这两种目的是相互矛盾的。另外，在极少数情况下，不进行优化，程序能正常运行，打开了优化措施之后，程序却会出现一些莫名 其妙的问题。其实这多半是程序中有潜在的错误，关闭优化措施往往只是暂时解决问题。Debug info用于指定编译器产生的调试信息的类型，为了使用 Visual C++的即编即调功能，必须在这里选择生成“Program Database for Edit and Continue”类型的调试 信息。Preprocessor definitions是一些预先定义的宏名。

　　C++ Language类别中的选项涉及到了C+ +语言的一些高级特性，包括有成员指针的表示方式、异常处理、运行时类型信息，一般情况下都不用改变它们。Code Generation类别中的选项涉 及如何生成目标代码，一般情况下保持缺省值即可。在Customize类别中，从上到下六个选项的含义分别为：是否禁止使用Microsoft对C++的 扩展；是否允许函数级别的连接；是否消除重复的字符串；是否允许进行最小化的重建；是否允许递增编译方式；是否允许编译器在开始运行时向Output窗口 中输出自己的版本信息。

　　在Listing Files类别中，我们可以指定编译器生成浏览信息和列表文件 （Listing file），前者可由浏览信息维护工具BSCMAKE生成浏览信息文件，后者则包含了C/C++源文件经过编译后对应的汇编指令。 Optimizations类别允许我们对优化措施进行更细微的控制，选择了Customize后，便可以选择进行哪几项优化，在 Inline function expansion中我们可以指定对内联函数的扩展方式。Precompiled Headers类别中是关于预编译头 文件的一些选项，一般情况下都不用更改。Preprocessor类别中是关于预处理的一些选择。

4、Link 选项卡

　 　Link选项卡控制着Visual C++的连接器。在General类别中，可以指定输出的文件名，以及一些在连接过程中需要使用的额外的库文件或目 标文件，下边五个选项的含义分别为：生成调试信息；忽略所有缺省的库文件；允许递增连接方式（这种方式可以加快连接的速度）；生成MAP文件；允许进行性 能分析。在Customize中选中Use program database允许使用程序数据库。在Debug类别中，我们可以指定调试信息的类别是 Microsoft的格式，还是COFF格式，或者两种都有，选中Separate types后连接器会把调试信息分开放在PDB文件中，这样连接起来 会更快一些，但调试时速度却会慢一些。Input类别中是一些与输入库文件有关的选项，我们可以在这里指定使用或不使用某些库文件或目标文件。 Output类别中则是一些与最终输出的可执行文件有关的选项，一般情况下都不用改变。

三、Visual C++调试工具

1、调试窗口

（1）观察窗口(Watch)

　　调试程序时，可使用观察窗口监视变量和表达式。

（2）快速查看窗口(Quick watch)

　　功能和观察窗口差不多。

（3）变量窗口(Variables)

　　变量窗口有三个标签：Auto标签显示了当前语句和前一条语句用到的变量，Locals标签显示当前函数的局部变量，this标签显示了this指针执行的对象。

（4）寄存器窗口(Register)

　　可以监视CPU的寄存器、标志值以及浮点堆栈

（5）内存窗口(Memory)

　　可显示从一特定地址开始的虚拟内存。Address框允许你指定从哪个虚拟内存地址开始显示。

（6）调用栈窗口(Call stack)

　　可显示引起当前源代码语句执行的一系列函数调用，当前函数在堆栈的顶端。

（7）反汇编窗口(Disassembly)

　　可查看编译器生成的对应于源代码的汇编指令。

2、调试符号

　 　程序数据库文件(.pdb)包含了Visual C++调试器所需的调试信息和程序信息。调试信息包含了变量的名字和类型、函数原型、源代码行号、类和 结构的布局、FPO调试信息（重建堆栈帧）以及进行增量链接所需的信息。对于设置了 Program Database for Edit and Continue选项的程序，PDB还要包含执行编辑继续功能所需的信息。

3、使用断点

　　断点(BreakPoint)是运行你向调试器描述环境，并让调试器设置好程序状态的一种机制。如果没有断点，只有在程序里一步一步跟踪使用调试器。在Visual C++中，你可以设置三种类型的断点：代码定位断点、数据断点和消息断点。

四、提高调试器的查错能力

　　尽量采用编译时刻检查而不是运行时刻检查。

1、使用最高的编译警告级别/W4

　 　象if(x=2)这样的语句，默认的警告级别为/W3时不显示任何信息，但改成最高警告级别/W4时则会出现“waning C4706: assignment within conditional expression”的警告。/W4能给出一些/W3所不能给的警告。

2、在调试版本中使用/GZ编译选项

　　/GZ选项用来发现那些在发布版本里才发现的错误，包括未被初始化的自动（局部）变量、堆栈错误、不正确的函数原型等。

3、使用#pragma warning编译器指示

　　你可以使用#pragma warning编译器指示来禁止整个程序、特定的头文件、特定的代码文件或是特定的某一行代码的特定警告，这看你把#pragma放在哪里。

4、使用没有警告的编译法则/WX

　　这个编译选项把所有的警告当成错误来对待，只有在假警告被消除之后才能应用。有时编译警告可能是合理的，处理编译警告的核心是要发现错误，而不是抑制警告本身。这个法则对于大的程序开发小组来说很有帮助。最终目标是消除错误，而不是消除警告。

五、内存空间与分配

1、内存分配错误

　　动态内存分配错误有两种基本类型：内存错误和内存泄漏。

（1）内存错误

　 　当一个指针或者该指针所指向的内存单元成为无效单元，或者内存中分配的数据结构被破坏时，就会造成内存错误。指针未被初始化，指针被初始化为一个无效地 址，指针被不小心错误地修改，在与指针相关联的内存区域被释放后使用该指针（这种指针被称为虚悬(dangling)指针），这些都会使指针变为无效指 针。当通过一个错误指针或者虚悬指针对内存进行写入，或者将指针强制转换为不匹配的数据结构，又或者是写数据越界，内存自身也会遭到破坏。删除未被初始化 的指针、删除非堆指针、多次删除同一指针或者覆盖一个指针的内部数据结构，都会造成内存分配系统错误。

（2）内存泄漏

　　内存泄漏在被动态分配的内存没有被释放时产生。有许多情况会导致内存泄漏，如没有在程序的全部执行路径中释放内存，没有在析构函数中释放所有的内存等。一个程序在崩溃之前可运行的时间越长，则导致崩溃的原因与内存泄漏的关系越大。

　 　Windows会在程序结束的时候将泄漏的内存收回，因此内存泄漏是个暂时性的问题。但为什么必须消除内存泄露呢？首先，内存泄漏往往会导致系统资源的 泄漏。动态分配内存往往不仅仅代表一块存储区域，还代表了某些类型的系统资源，如文件、窗口、设备上下文、GDI对象等。其次，高质量的程序和特定的服务 器程序必须能够无限地运行下去。最后，内存泄漏往往是其他程序错误或不良编程习惯的征兆。

　　导致内参泄漏的原因：忘记释放内存；构造函数失败；存在内存泄漏的析构函数；存在内存泄漏的异常处理程序；多个返回语句；使用错误形式的delete。

2、关于内存的初始化

　　在调试版本里，堆里未被初始化的内存被0xCD字节模式填充，堆里释放的内存被0xDD字节模式填充。堆栈里被初始化的内存被0xCC字节模式填充。调试版本和发布版本里，未被初始化的全局内存都被初始化为0。

3、内存虚拟地址空间

　　Windows使用一组固定的范围来分割进程的4GB虚拟地址空间，因此有时可通过查看指针的返回值来判断指针是否有效。

（1）Windows2000虚拟地址空间划分

0~0XFFFF(64KB)：不能用来检测空指针赋值（访问冲突）

0x10000(64KB)~0x7FFEFFFF(2GB-64KB)：Win32进程私有的（非保留的），用于程序代码和数据

0x7FFF0000(2GB-64KB)~0x7FFFFFFF(2GB)：不能用来防止覆盖OS分区（访问冲突）

0x800000000(2GB)~0xFFFFFFFF(4GB)：为操作系统保留，不可访问（访问冲突）

（2）Windows2000虚拟地址空间使用

0x00030000~0x0012FFFF：线程栈

0x00130000~0x003FFFFF：堆（有时堆位于此处）

0x00400000~0x005FFFFF：可执行代码

0x00600000~0x0FFFFFFF：堆（有时堆位于此处）

0x10000000~0x5FFFFFFF：App DLLs、Msvcrt.dll、Mfc42.dll

0x77000000~0xFFFFFFFF：Advapi32.dll、Comctl32.dll、Gdi32.dll、Kernel32.dll、Ntdll.dll、Rpcrt4.dll、Shell32.dll、User32.dll

其中，0x00400000是所有版本的Windows能使用的最低基地址。

六、一些调试技术

1、调试死循环

　　使用Debug菜单下的Break命令。在Windows2000中，如果程序有输入请求，可以使用F12键中断程序，然后检查窗口的调用栈，或单步跟踪代码找到死循环的发生原因。

2、用Spy++调试与消息有关的问题

　 　调试消息的最好方案是使用Visual C++提供的Spy++工具。Spy++允许程序员查看窗口、消息、进程和线程。Spy++默认的消息输出：第 一栏显示行号。第二栏显示接受消息的句柄。第三栏中的“S”表示消息是用SendMessage发出的，“P”代表消息是由PostMessage发出 的，“R”是消息句柄的返回值。第四栏给出解码后的消息名，消息参数或返回值。

3、非常规方法

（1）重新编连你的应用程序

　　当你的程序表现出异常的或意外的行为，或者Visual C++编译器因为一个内部编译器错误而失败时，最好删除工程中的Debug或Release文件夹，从头开始重新进行编连。

（2）重新启动Visual C++

　 　Visual C++有超强的能力，但编译器的某些特性也会引起奇怪的错误。如果你的程序表现得很奇怪，你可是试着清除所有的断点，关闭或隐藏观察窗 口，检查工程设置对话框看最近做了什么修改，直至重新启动Visual C++以便消除由于Visual C++环境引起的异常行为。

（3）重新启动Windows

　　当你发现Windows或者其他程序表现出异常的或出人意料的行为时，就应该重新启动Windows，以消除操作系统给调试带来的干扰。

         在我们的程序中，数据结构还有变量等等都需要占有内存，在很多系统中，它都要求内存分配的时候要对齐，这样做的好处就是可以提高访问内存的速度。


 我们还是先来看一段简单的程序：


                                程序一

      
      这段程序的功能很简单，就是定义了三个结构X1,X2,X3,这三个结构的主要区别就是内存数据摆放的顺序，其他都是一样的，另外程序输入了几种基本类型所占用的字节数，以及我们这里的三个结构所占用的字节数。

这段程序的运行结果为：

     结果的前面四行没有什么问题，但是我们在最后三行就可以看到三个结构占用的空间大小不一样，造成这个原因就是内部数据的摆放顺序，怎么会这样呢？

    下面就是我们需要讲的内存对齐了。

    内存是一个连续的块，我们可以用下面的图来表示,  它是以4个字节对一个对齐单位的：

                                                    图一

   让我们看看三个结构在内存中的布局：

   首先是 X1，如下图所示

    X1 中第一个是 Int类型，它占有4字节，所以前面4格就是满了，然后第二个是char类型，这中类型只占一个字节，所以它占有了第二个4字节组块中的第一格，第三个也是char类型，所以它也占用一个字节，它就排在了第二个组块的第二格，因为它们加在一起大小也不超过一个块，所以他们三个变量在内存中的结构就是这样的，因为有内存分块对齐，所以最后出来的结果是8，而不是6，因为后面两个格子其实也算是被用了。

    再次看看X2，如图所示

    X2中第一个类型是Char类型，它占用一个字节，所以它首先排在第一组块的第一个格子里面，第二个是Int类型，它占用4个字节，第一组块已经用掉一格，还剩3格，肯定是无法放下第二Int类型的，因为要考虑到对齐，所以不得不把它放到第二个组块，第三个类型是Char类型，跟第一个类似。所因为有内存分块对齐，我们的内存就不是8个格子了，而是12个了。


再看看X3，如下图所示：

   关于X3的说明其实跟X1是类似的，只不过它把两个1个字节的放到了前面，相信看了前面两种情况的说明这里也是很容易理解的。


   唉，写到这手都累了，关键是要画图，希望通过此文能让你理解内存对齐的基本概念，如果有问题，请留言。

此文完

首先我们来看两段简单的程序，如果你不进行编译运行 , 猜一猜结果分别是多少？

程序一

你猜出运行结果了么？现在我们就来揭示谜底，第一个程序的结果是1,第二个程序的运行结果是2。

哈哈，你或许会不解吧，这里就是我们需要讲的“三字符组”,也叫着“三字符序列”。

三字符序列不太常见，但C++标准允许把某些字符指定为三字符序列。三字符序列就是用于表示另一个字符的三个字符序列。以前为了表示键盘上没有的字符，这是必不可少的一种方法。

具体的三字符序列转义的对应关系如下表：

   我们在创建C＋＋类的时候，如果类中有const类型的变量，那么这个值的初始化就是一个问题，可以看下面一段代码：

      C++ 为我们提供了多态的功能，什么是多态呢，我的理解就是如果把指向派生类对象的指针赋值给基类指针，那么通过这个基类指针调用继承的函数的时候会根据指针指向的对象类型来动态的调用所需要的方法，这种特性就是多态了。(除了这个之外好像函数重载也是一种)

   可以先看下面一段程序：

程序代码
#include <iostream>
using namespace std;
class Shape
{
public:
    virtual void draw()
    {
        cout<<"Draw shape"<<endl;
    }
};

class Circle: public Shape
{
public:
    virtual void draw()
    {
        cout<<"Draw Circle"<<endl;
    }
};

class Triangle: public Shape
{
public:
    virtual void draw()
    {
        cout<<"Draw Triangle"<<endl;
    }
};
class Square: public Shape
{
public:
    virtual void draw()
    {
        cout<<"Draw Square"<<endl;
    }
};


int main()
{
    Shape *pShape = NULL;
    Circle aCircle;
    Triangle aTriangle;
    Square aSquare;

    pShape= &aCircle;
    pShape->draw();

    pShape= &aTriangle;
    pShape->draw();

    pShape=&aSquare;
    pShape->draw();
    return 0;
}

程序的运行结果是 :

Draw Circle

Draw Triangle

Draw Square

从结果可以可以看到，输出的结果并不是 Draw shape 。 这个就是多态的功效所在了。它直接根据指针实际指向的类型来动态调用了执行的函数。

要使用多态，必须把基类中需要使用多态功能的方法定义为 virtual ， 这样才能使用多态的强大功能。如果把基类的 draw 方法前面的 virtual 去掉，那么最后输出的结果将会是

Draw Shape

Draw Shape

Draw Shape

这说明没有使用多态,只是覆盖了。

多态的好处是显然的，开发者可以利用旧代码来调用新的方法，这样软件供应商可以在不透露技术秘密的情况下发现软件包，而开发者也可以根据继承机制从软件供应商提供的类库中派生出新类，且能和旧类库一起工作。

此文完。

C++给我们提供了一个换行的函数endl函数，不知道该不该叫函数，这个是在STLPort中的实现。

      下面是一个简单的程序，实现了比较简单的文本文件的复制。

运行的时候只要 copyFile  srcFile destFile 就可以了，这里 srcFile 是拷贝的源文件，

最近刚给我的VC6.0装上了Intel的9.0版本的编译器，觉得编译的时候好像速度比原来VC的稍微要慢一点， 于是我突然觉得无聊想用简单的方法比较一下编译器编译过的程序之间的运行速度。

我的机器上刚好有 DEV C++,VC6.0, 还有就是 Intel Complier9.0 了。

首先写了一个简单的程序：

   在没有对程序进行优化的情况下,三种编译器编译的程序运行时间如下（单位:毫秒）：

测试的环境是 Windows XP Pro+P3m 1.2G 512M SDR 。在进行测试的时候，我尽可能把其他无关的程序都关掉，让它们在相对比较稳定的环境下进行运算，但是这样并不能保证结果没有偏差，因为计算的次数有限，最后的结果很可能由于随机出现的情况而偏差。从上面结果来看，三者的性能差距不是太大。在优化之后，速度是 Intel Complier9.0>VC6.0>MinGW3.4.2 。

申明 : 以上测试存在很多不足的地方，仅仅使用了一种运算测试，其实我觉得要进行比较全面的测试才会得到比较可信的结果，本结果仅供参考。

首先让我们看下面一个例子

int a ＝ 100;

int *p=&a;

*p=200;

经过上面这三条语句之后，变量a的值就从100改为200了，这是很显然的，因为 *p 是解引用指针，其中变量p中存放的是变量a的地址，在这里是 0x0012ff78， 也就是说 * 操作符操作的是一个地址值，那么我们可以直接用 * 来操作地址值么？

*0x0012ff78 =300;

上面这条语句编译不过，因为指针解引用操作符 * 之后跟的不是一个指针类型，而是一个整型的值，这样是不行的，要想实现上面的功能，必须要把该整型值转化成指针类型。

我们可以这样处理

*(int *) 0x0012ff78=300; // 把整型强制转化成 int 类型的指针

这样 变量 a 的值就变成 300 了。

其实上面这种用法在一般的程序设计中是很少用的，因为编译器无法帮助你把某一个特定的变量放在一个内存中指定的位置，所以无法预知它的地址。小心使用这种方式不小心有就会误操作内存中的有用的数据。

上面这种用法其实一般都是用在操作硬件方面，在一些机器上面，要想与设备控制器的进行通信，就必须通过在某个特定的内存的地址来读取和写入值。这些地址是预先已经知道的，其实这些地址也就是与硬件通信的接口。

上面就是操作指定位置的内存的方法。

此文完。

我们在看书的时候，经常可以看到关于 左值(L-value) 和 右值(R-value) 的概念，那么到底什么是左值，什么是右值，它们之间的区别又是在哪里呢？

    通俗的讲，左值就是能够出现在赋值符号左面的东西，而右值就是那些可以出现在赋值符号右面的东西了。

举个很简单的例子：

a=b+100;

那么这里a就是左值，b+25就是一个右值。左值和右值之间是不一定都能互换的，上面的这个例子就是不能互换的，如果写成

b＋100＝a;

大家都能看出来这样写会不编译通过的，因为编译器无法判断b+100的内存地址，所以不能操作。

看了这个例子，可以做一个总结，左值必须应该是一个变量或者是表达式等，但是它的物理位置是可以确定的，而右值不一定,这也是它们两者之间的区别。

关于左值是表达式的例子有数组，还有指针这些都可以。

int array[10];

int a=5;

array[a+3]=10; //这里左值就是一个数组表达式了

此文完。

 另外：liotta朋友给了一些其他方面的提示 （左值右值翻译可能有些问题）

      如果要问你怎么样求一个字符串的长度，你估计会想到在string.h头文件中strlen(char *)函数，这个方法的确是很简单，但在这里，我们要自己写一个方法来实现，具体代码如下

在编程的时候，经常会遇到使用一个变量处理多种数据的情况，在这种情况下，如果我们不考虑使用类，那么就可以是struct（结构）和union（联合）来进行处理。那么，这两种结构之间到底有什么不同呢？

可以先看下面的一个小例子。

 1 #include  < iostream >
 2 using   namespace  std;
 3
 4 union U1 {
 5      char  c;
 6      int  i;
 7      double  d;
 8     } ;
 9 union U2 {
10      char  c;
11      // int i;
12      // double d;
13     } ;
14
15 union U3 {
16      char  c;
17      int  i;
18      // double d;
19     } ;
20
21 struct  S1 {
22      char  c;
23      int  i;
24      double  d;
25     } ;
26
27 struct  S2 {
28      char  c;
29      int  i;
30      // double d;
31     } ;
32
33 int  main() {
34     cout << " U1's size = " << sizeof (U1) << endl;
35     cout << " U2's size = " << sizeof (U2) << endl;
36     cout << " U3's size = " << sizeof (U3) << endl;
37     cout << endl;
38     cout << " -------------------------------- " << endl;
39     cout << " S1's size = " << sizeof (S1) << endl;
40     cout << " 其中 " << sizeof ( char ) << " + " << sizeof ( int ) << " + " << sizeof ( double ) << " = " << sizeof ( char ) + sizeof ( int ) + sizeof ( double ) << endl;
41     cout << " ---------- " << endl;
42     cout << " S2's size = " << sizeof (S2) << endl;
43     cout << " 其中 " << sizeof ( char ) << " + " << sizeof ( int ) << " = " << sizeof ( char ) + sizeof ( int ) << endl;
44     cout << " -------------------------------- " << endl;
45     S1 s;
46     s.c = ' A ' ;
47         cout << " 1 s.c =  " << s.c << endl;
48     s.d = 23.2132 ;
49         cout << " 1 s.d =  " << s.d << endl;
50
51         cout << " 2 s.c =  " << s.c << endl;
52         cout << " 2 s.d =  " << s.d << endl;
53         cout << " -----------------------  " << endl;
54     U1 u;
55         u.c = ' A ' ;
56         cout << " 1 u.c =  " << u.c << endl;
57     
58         u.i = 23322 ;
59         cout << " 1 u.i =  " << u.i << endl;
60
61         u.d = 23.2132 ;
62         cout << " 1 u.d =  " << u.d << endl;
63         cout << " 2 u.c =  " << u.c << endl;
64         cout << " 2 u.i =  " << u.i << endl;
65      return   0 ;
66 }
67

输出结果为：

U1's size =8

U2's size =1

U3's size =4

--------------------------------

S1's size =16

其中 1+4+8=13

----------

S2's size =8

其中 1+4=5

--------------------------------

1 s.c = A

1 s.d = 23.2132

2 s.c = A

2 s.d = 23.2132

-----------------------

1 u.c = A

1 u.i = 23322

1 u.d = 23.2132

2 u.c =

2 u.i = 1181975000

解释：

struct 类型的内存分配是结合内部的所有变量大小和相关的，但不是简单的相加，从上面的例子就可以看出来， struct 类型的分配的内存大小是应该内部最大数据类型的整数倍，不足一倍的部分会自动补全成一倍大小,应该是编译器为了数据整齐，处理速度会快些把。 union 类型的内存分配，只是和联合体内的最大的一个数据类型的大小相关，而且 union 内的所有数据都在一个单独的内存空间里面。这些就是上面程序出现这样的结果的原因。

   所以， u.c 的值是 A ，当给联合体内的其他变量赋值之后， u.c 的值就是一个无用的信息。同样， u.i 的值最初是 23322 ，当给 u.d 赋值 23.2132 之后， u.i 的值就变得无用了。

常量指针 和 指针常量

      在C＋＋的学习中，有人经常搞不清楚“常量指针”和“指针常量”这两个概念。其实简单一点讲，“常量指针”所指向的地址上的数据是常量，而“指针常量”所指向的地址是常量，地址上面的数据是可以变化的。


     下面看及格简单的例子，可以说明他们的区别:
            第一个

第二个

第三个

第四个

相信从上面四个简单的例子可以看出他们不一样的地方把，在这里要请大家注意一下的地方是：

指针常量的申明：const 放在* 和指针名之间 Type * const pointer ;

常量指针的申明：const放在类型说明符之前 const Type *pointer ;

整个代码如下:

 1#include <stdio.h>
 2#include <math.h>
 3
 4//using namespace std;
 5void printZB(){
 6    printf("-1.0                                0                       1.0\n");
 7    printf("------------------------------------|---------------------------------->\n");
 8    }
 9
10void printCos(float angle){
11    int blanks,postion;
12    postion = cos(angle)*35+35;
13    for(blanks=0;blanks<postion;blanks++)
14        printf(" ");
15        printf("*\n");
16
17    }
18
19int main()
20{
21    printZB();
22    float angle;
23    const float anglestep=0.22;
24    const float limit =9.42478;
25    for(angle=0.0;angle<limit;angle+=anglestep)
26        printCos(angle);
27    getchar();
28    return 0;
29}
30

   有两段程序，其实应该是一段程序，只是稍微有点不同。程序

的主要目的很简单，就是要输出1－25的平方根和平方。

   第一段在Dev-C++中编译通过的，就叫程序一：

 1#include <iostream>
 2#include <math.h>
 3using namespace std;
 4int main(){
 5    cout<<"N    平方根    平方"<<endl;
 6    for(int i=1;i<=25;i++){
 7        cout<<i<<"\t"<<sqrt(i)<<"\t"<<pow(i,2)<<endl;
 8        }
 9        getchar();
10        return 0;
11}
12

 1#include <iostream>
 2#include <math.h>
 3using namespace std;
 4int main(){
 5    cout<<"N    平方根        平方"<<endl;
 6    for(int i=1;i<=25;i++){
 7        cout<<i<<"\t"<<sqrt((double)i)<<"\t\t"<<pow((double)i,2)<<endl;
 8        }
 9        getchar();
10        return 0;
11}
12