参考http://www.cnblogs.com/MikeZhang/archive/2012/02/10/nppRunGo.html

最近google的go语言流行程度越来越大了，学着别人写的内容自己在windows下搭建了一个简单的开发环境，记录在这里，如果需要参考的可以借鉴。

一、        下载编译器

下载go语言的开发工具可以到http://code.google.com/p/gomingw/downloads/list去下载，这里列出了当前最新的版本。

我选择下载http://gomingw.googlecode.com/files/gowin386_release.r60.3.zip

下载完毕之后，就是一个压缩包，我们把它解压缩，最终解压缩后的目录以go命名。

二、        配置环境变量

编译工具下载之后解压缩，就是一个目录，后期我们需要在命令行或者工具中调用编译程序，所以需要把编译工具的路径以及相关属性配置进系统环境变量。

需要设定的环境变量如下：

其中go目录全路径是我们前面解压缩后的以go命名的目录，我们这里假设为c:\go

1、在xp环境下：

在桌面我的电脑右键，查看属性，弹出系统属性对话框，如下：

新建环境变量：

在vista和win环境下：

在桌面计算机右键，查看属性，打开系统信息窗口，再点击“高级系统设置”，弹出系统属性对话框，对话框与XP类似，具体设置参考XP系统设置部分。

三、        配置开发工具

开发工具，我这里推荐两张，一种是Notepad++，一种是集成开发环境LiteIDE。

1．Notepad++

Notepad++的主页为http://notepad-plus-plus.org/，大家可以上去自己下最新的版本。

程序的安装与普通程序没有区别，安装完毕之后就可以打开notepad++。

默认情况下，notepad是不带go语言的代码解释器的，也不带便捷编译功能。所以我们需要下载安装go语言的代码解释器，并进行适当配置。

操作步骤如下：

（1）下载语言解析模板

go语言解析模板：http://notepad-plus.sourceforge.net/commun/userDefinedLang/go.zip   

下载之后，解压缩，里面有“go.xml”，“userDefineLang_Go.xml”，“README”三个文件，我们重点关注前面两个文件。

（2）将文件userDefineLang_Go.xml内容copy至Application Data下Notepad++目录的userDefineLang.xml中，如果没有该文件，则直接userDefineLang_Go.xml文件名改成userDefineLang.xml复制过去。
　　XP: C:\Documents and Settings\[username]\Application Data\Notepad++
　　Vista/Win7 : C:\Users\[username]\AppData\Roaming\Notepad++

 拷贝过去之后，打开userDefineLang.xml文件，把文件前面与最后的“<!-- <NotepadPlus> -->”和“<!-- </NotepadPlus> -->”分别改成“<NotepadPlus>”和“</NotepadPlus>”,改完保存之后

（3）将go.xml文件copy至notepad++安装目录下的plugins\APIs目录（例如：D:\Program Files\Notepad++\plugins\APIs）；

（4）重启notepad++程序，在语言菜单下可以看见go。

（5）设定快捷编译命令。

打开Notepad++程序之后，运行F5命令

在弹出的对话框中输入以下内容：“cmd /k 8g.exe -o tmp.8 "$(FULL_CURRENT_PATH)" & 8l.exe -o tmp.exe tmp.8 & del tmp.8 & tmp.exe & PAUSE & del tmp.exe & EXIT”。
   保存为"Run Go"，并设置Ctrl+F6为快捷键。

（6）测试编译

我们使用notepad++新建一个hello.go文件，在其中输入以下代码。

再按“Ctrl+F6”快捷键。

弹出窗口显示，证明环境配置完毕。

我们也可以在dos命令窗口中执行编译运行命令。

2．LiteIDE

LiteIDE是go语言开发一个集成环境，可以到

http://code.google.com/p/golangide/downloads/list去查看最新版本。

我们这里下载LiteIDE12.2_windows版本。

这个工具的配置在下载处有文档说明，这里就不详细介绍了。

希望写的内容对大家有帮助。

一、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

Broadcom NetXtrem II网卡Linux安装指南

 

适用机型:

所有BladeCenter HS21; 所有BladeCenter LS21; 所有BladeCenter LS41; 所有System x3550; 所有System x3650; 所有System x3655; 所有System x3755

文档内容：

Broadcom NetXtreme II GbE网卡驱动有两种格式：source RPM 和tar格式。文件名分别为bnx2-<version>.src.rpm 和 bnx2-<version>.tar.gz
下载地址：http://www-1.ibm.com/support/docview.wss?uid=psg1MIGR-64538

Source RPM 驱动包的安装步骤
=============================
1. 安装source RPM包：
rpm -ivh bnx2-<version>.src.rpm

2. 进入/usr/src路径并编译
cd /usr/src/{redhat,OpenLinux,turbo,packages,rpm ..}
rpm -bb SPECS/bnx2.spec
或者
rpmbuild -bb SPECS/bnx2.spec (针对RPM version 4.x.x)
注意：不同内核的linux版本，其rpm路径不同

3. 安装刚刚编译好的包
rpm -ivh RPMS/i386/bnx2-<version>.i386.rpm
驱动被安装到如下路径

对于2.4.x kernels:
/lib/modules/<kernel_version>/kernel/drivers/net/bnx2.o
对于2.6.0 kernels:
/lib/modules/<kernel_version>/kernel/drivers/net/bnx2.ko

4. 加载驱动:
insmod bnx2.o
或
insmod bnx2.ko (在 2.6.x kernels)
或
modprobe bnx2
5. 配置网卡地址、网关等等

TAR驱动包的安装步骤
=============================
1. 创建一个目录并将文件解包
tar xvzf bnx2-<version>.tar.gz

2. 编译驱动bnx2.o (或bnx2.ko)，生成可加载的模块
cd src
make

3. 通过加载模块对其进行测试
insmod bnx2.o
或
insmod bnx2.ko (在2.6.x kernels)
或
insmod bnx2

4. 安装驱动
make install
驱动被安装的位置与RPM方式安装的位置一样

5. 配置网卡地址、网关等等