关于结构体字对齐—BMP文件图像处理程序

最近用C写了个关于BMP文件图像处理的简单程序，结果算法写了不用1个小时搞定，而次要的文件输入输出搞了我半天才搞定。

主要问题有两点：

第一，在读取BMP文件的文件头信息放入结构体时，发现中间会漏了2个字节，原因是结构体字对齐，结果导致整体的错位，一个输入66K的图片，输出有178MB。

解决办法：不将结构体整个一起read、write，而是将其中的每个成员一个一个地read、write。当然，牺牲了效率。

第二，之前以为BMP灰度图的颜色表信息是没用的，后来查了资料才发现，只有24位深的BMP图才没有颜色表项，对于其他的1、4、8位深还是有用的。

解决办法：将颜色表项读入内存，然后再写入新图像文件中。对于8bit的BMP灰度图，颜色表就是0 0 0 0 ~ 255 255 255 0的灰度值

/*********************************以下是关于BMP文件图像处理程序源代码***************************/

//*********************image.h****************

#ifndef IMAGE_H
#define IMAGE_H
void image_info(FILE* file);
void image_save(FILE *file);
void image_smooth(); //图像平滑
void image_Roberts_sharpen(); //Roberts算法的图像锐化
void image_Roberts_enhance(); //Roberts算法的图像增强
void image_median_filter(); //中值滤波
typedef struct BMP //其实BMP文件头、位图信息头、颜色信息的结构体在<windows.h>头文件中有
{
unsigned short bfType; //文件标识 2字节必须为BM
unsigned int bfSize; //文件大小 4字节
unsigned short bfReserved1; //保留，每字节以"00"填写 2字节
unsigned short bfReserved2; //同上 2字节
unsigned int bfOffBits; //记录图像数据区的起始位置(图象数据相对于文件头字节的偏移量)。 4字节

//40字节
unsigned int biSize; //表示本结构的大小 4字节
int biWidth; //位图的宽度 4字节
int biHeight; //位图的高度 4字节
unsigned short biPlanes; //永远为1 , 2字节
unsigned short biBitCount; //位图的位数分为1 4 8 16 24 32 2字节
unsigned int biCompression; //压缩说明 4字节
unsigned int biSizeImage; //表示位图数据区域的大小以字节为单位 4字节
int biXPelsPerMeter; //用象素/米表示的水平分辨率 4字节
int biYPelsPerMeter; //用象素/米表示的垂直分辨率 4字节
unsigned int biClrUsed; //位图使用的颜色索引数 4字节
unsigned int biClrImportant; //对图象显示有重要影响的颜色索引的数目 4字节

} BMP;

int color_table_length; //颜色表项数
int line_byte;
unsigned char *imagedata;
unsigned char *temp;
extern BMP bmp;
unsigned char *pColorTable;//颜色表指针
extern unsigned char *pColorTable;//颜色表指针
extern int line_byte;
extern int color_table_length;
extern unsigned char *imagedata;
extern unsigned char *temp;
#endif

//****************image_rw***************

#include<stdio.h>
#include<stdlib.h>
//#include<windows.h>
#include"image.h"
void image_info(FILE *file)
{

//int times=3; //输入文件名次数。
char bmp_name[10]; //文件名

printf("\nplease enter a file name for reading:");
do
{
fflush(stdin);
gets(bmp_name);
file=fopen(bmp_name,"rb+"); //打开一个文件进行读写操作。
if (file==NULL)
{
printf("\nerror opening %s for reading! ",bmp_name);
}
else
{
break;
}
}
while(1);

//读取图像信息

fseek(file,0L,0); //读取图像文件类型
//fread(&bmp,sizeof(struct BMP),1,file);
fseek(file,0L,0); //图像文件类型
fread(&(bmp.bfType),sizeof(short),1,file);

fseek(file,2L,0); //图像文件大小
fread(&(bmp.bfSize),sizeof(int),1,file);

fseek(file,6L,0); //图像文件保留字1
fread(&(bmp.bfReserved1),sizeof(short),1,file);

fseek(file,8L,0); //图像文件保留字2
fread(&(bmp.bfReserved2),sizeof(short),1,file);

fseek(file,10L,0);//数据区的偏移量
fread(&(bmp.bfOffBits),sizeof(short),1,file);

fseek(file,14L,0);//文件头结构大小
fread(&(bmp.biSize),sizeof(int),1,file);

fseek(file,18L,0);//图像的宽度
fread(&(bmp.biWidth),sizeof(int),1,file);

fseek(file,22L,0);//图像的高度
fread(&(bmp.biHeight),sizeof(int),1,file);

fseek(file,26L,0);//图像的面数
fread(&(bmp.biPlanes),sizeof(short),1,file);

fseek(file,28L,0);//图像一个像素的字节数
fread(&(bmp.biBitCount),sizeof(short),1,file);

fseek(file,30L,0);//图像压缩信息
fread(&(bmp.biCompression),sizeof(short),1,file);

fseek(file,34L,0);//图像数据区的大小
fread(&(bmp.biSizeImage),sizeof(int),1,file);

fseek(file,38L,0);//水平分辨率
fread(&(bmp.biXPelsPerMeter),sizeof(int),1,file);

fseek(file,42L,0);//垂直分辨率
fread(&(bmp.biYPelsPerMeter),sizeof(int),1,file);

fseek(file,46L,0);//颜色索引数
fread(&(bmp.biClrUsed),sizeof(int),1,file);

fseek(file,50L,0);//重要颜色索引数
fread(&(bmp.biClrImportant),sizeof(int),1,file);

printf("\n bmp tpye: %x",bmp.bfType);
printf("\n bmp size: %u",bmp.bfSize);
printf("\n bmp reserved1: %u",bmp.bfReserved1);
printf("\n bmp reserved2: %u",bmp.bfReserved2);
printf("\n bmp offBits: %u",bmp.bfOffBits);

printf("\n bmp bisize: %u",bmp.biSize);
printf("\n bmp biWidth: %d",bmp.biWidth);
printf("\n bmp biHeight: %d",bmp.biHeight);
printf("\n bmp biplans: %u",bmp.biPlanes);
printf("\n bmp biBitCount: %u",bmp.biBitCount);
printf("\n bmp biCompression: %u",bmp.biCompression);
printf("\n bmp biSizeImage: %u",bmp.biSizeImage);
printf("\n bmp biXPelsPerMeter: %d",bmp.biXPelsPerMeter);
printf("\n bmp biYPelsPerMeter: %d",bmp.biYPelsPerMeter);
printf("\n bmp biClrUsed: %u",bmp.biClrUsed);
printf("\n bmp biClrImportant: %u\n",bmp.biClrImportant);

switch(bmp.biBitCount)
{
case 1:
color_table_length = 2;
break;
case 4:
color_table_length = 16;
break;
case 8:
color_table_length = 256;
break;
case 24:
color_table_length = 0;
break;
default:
color_table_length = 0;
printf("\n wrong biBitCount!");
}

line_byte=(( bmp.biWidth*bmp.biBitCount + 31) / 8);//获得图像数据每行的数据个数,Windows规定一个扫描行所占的字节数必须是4的倍数（即以long为单位），不足的以0填充，

imagedata=( unsigned char* )malloc( bmp.biSizeImage );
temp=( unsigned char* )malloc( bmp.biSizeImage );
pColorTable=(unsigned char*)malloc( color_table_length * 4 );
fseek(file, 54L, 0);
fread(pColorTable, sizeof(unsigned char), color_table_length * 4, file);
fseek(file, (long)bmp.bfOffBits, 0);
fread(imagedata, sizeof(unsigned char), bmp.biSizeImage, file);
fseek(file, (long)bmp.bfOffBits, 0);
fread(temp, sizeof(unsigned char), bmp.biSizeImage, file);

fclose(file);
}

//保存图像
void image_save(FILE *file)
{
//int times=3; //输入文件名次数。
char bmp_name[10]; //文件名
//int i; //记录数据区个数

printf("\nplease enter a file name for writeing:");
do
{
fflush(stdin);
gets(bmp_name);
file=fopen(bmp_name,"wb+"); //打开一个文件进行读写操作。
if (file==NULL)
{
printf("\nerror opening %s for writing",bmp_name);
}
else
{
break;
}
}
while(1);

//写文件头
printf("\n%s",bmp_name);
fseek(file,0L,0); //图像文件类型
fwrite(&(bmp.bfType),sizeof(short),1,file);
printf("\n bmp tpye: %x",bmp.bfType);

fseek(file,2L,0); //图像文件大小
fwrite(&(bmp.bfSize),sizeof(int),1,file);
printf("\n bmp size: %d",bmp.bfSize);

fseek(file,6L,0); //图像文件保留字1
fwrite(&(bmp.bfReserved1),sizeof(short),1,file);
printf("\n bmp reserved1: %d",bmp.bfReserved1);

fseek(file,8L,0); //图像文件保留字2
fwrite(&(bmp.bfReserved2),sizeof(short),1,file);
printf("\n bmp reserved2: %d",bmp.bfReserved2);

fseek(file,10L,0);//数据区的偏移量
fwrite(&(bmp.bfOffBits),sizeof(short),1,file);
printf("\n bmp offBits: %d",bmp.bfOffBits);

fseek(file,14L,0);//文件头结构大小
fwrite(&(bmp.biSize),sizeof(int),1,file);
printf("\n bmp bisize: %d",bmp.biSize);

fseek(file,18L,0);//图像的宽度
fwrite(&(bmp.biWidth),sizeof(int),1,file);
printf("\n bmp biWidth: %d",bmp.biWidth);

fseek(file,22L,0);//图像的高度
fwrite(&(bmp.biHeight),sizeof(int),1,file);
printf("\n bmp biHeight: %d",bmp.biHeight);

fseek(file,26L,0);//图像的面数
fwrite(&(bmp.biPlanes),sizeof(short),1,file);
printf("\n bmp biplans: %d",bmp.biPlanes);

fseek(file,28L,0);//图像一个像素的字节数
fwrite(&(bmp.biBitCount),sizeof(short),1,file);
printf("\n bmp biBitCount: %d",bmp.biBitCount);

fseek(file,30L,0);//图像压缩信息
fwrite(&(bmp.biCompression),sizeof(short),1,file);
printf("\n bmp biCompression: %d",bmp.biCompression);

fseek(file,34L,0);//图像数据区的大小
fwrite(&(bmp.biSizeImage),sizeof(int),1,file);
printf("\n bmp biSizeImage: %d",bmp.biSizeImage);

fseek(file,38L,0);//水平分辨率
fwrite(&(bmp.biXPelsPerMeter),sizeof(int),1,file);
printf("\n bmp biXPelsPerMeter: %d",bmp.biXPelsPerMeter);

fseek(file,42L,0);//垂直分辨率
fwrite(&(bmp.biYPelsPerMeter),sizeof(int),1,file);
printf("\n bmp biYPelsPerMeter: %d",bmp.biYPelsPerMeter);

fseek(file,46L,0);//颜色索引数
fwrite(&(bmp.biClrUsed),sizeof(int),1,file);
printf("\n bmp biClrUsed: %d",bmp.biClrUsed);

fseek(file,50L,0);//重要颜色索引数
fwrite(&(bmp.biClrImportant),sizeof(int),1,file);
printf("\n bmp biClrImportant: %d\n",bmp.biClrImportant);

fseek(file, 54L, 0);
fwrite(pColorTable, sizeof(unsigned char), color_table_length * 4, file);

fseek(file,(long)(bmp.bfOffBits),0);
fwrite(imagedata,sizeof(unsigned char),bmp.biSizeImage,file);

fclose(file);
}

//*****************pixprocess.c***************

#include<stdio.h>
#include<stdlib.h>
#include<math.h>
#include"image.h"

//************************homework**********************
void image_smooth()
{
int i,j,tmp;
for (i=1;i<bmp.biHeight-1;i++)
{
for (j=1;j<bmp.biWidth-1;j++)
{
tmp = 0;
tmp += temp[(i-1)*bmp.biWidth + j-1];
tmp += temp[(i-1)*bmp.biWidth + j];
tmp += temp[(i-1)*bmp.biWidth + j+1];
tmp += temp[ i*bmp.biWidth + j-1];
tmp += temp[ i*bmp.biWidth + j+1];
tmp += temp[(i+1)*bmp.biWidth + j-1];
tmp += temp[(i+1)*bmp.biWidth + j];
tmp += temp[(i+1)*bmp.biWidth + j+1];
tmp = tmp/9;
imagedata[ i*bmp.biWidth + j ] =tmp;
}
}
}

void image_Roberts_sharpen()
{
int i,j,tmp;
for (i=1;i<bmp.biHeight-1;i++)
{
for (j=1;j<bmp.biWidth-1;j++)
{
tmp = 0;
tmp += abs( temp[(i+1)*bmp.biWidth + j-1] + 2*temp[(i+1)*bmp.biWidth + j] + temp[(i+1)*bmp.biWidth + j+1] - temp[(i-1)*bmp.biWidth + j-1] - 2*temp[(i-1)*bmp.biWidth + j] - temp[(i-1)*bmp.biWidth + j+1] );
tmp += abs( temp[(i-1)*bmp.biWidth + j+1] + 2*temp[ i*bmp.biWidth + j+1] + temp[(i+1)*bmp.biWidth + j+1] - temp[(i-1)*bmp.biWidth + j-1] - 2*temp[ i*bmp.biWidth + j-1] - temp[(i+1)*bmp.biWidth + j-1] );
imagedata[ i*bmp.biWidth + j ] =tmp;
}
}
}

void image_Roberts_enhance()
{
int i,j,tmp;
for (i=1;i<bmp.biHeight-1;i++)
{
for (j=1;j<bmp.biWidth-1;j++)
{
tmp = 0;
tmp += abs( temp[(i+1)*bmp.biWidth + j-1] + 2*temp[(i+1)*bmp.biWidth + j] + temp[(i+1)*bmp.biWidth + j+1] - temp[(i-1)*bmp.biWidth + j-1] - 2*temp[(i-1)*bmp.biWidth + j] - temp[(i-1)*bmp.biWidth + j+1] );
tmp += abs( temp[(i-1)*bmp.biWidth + j+1] + 2*temp[ i*bmp.biWidth + j+1] + temp[(i+1)*bmp.biWidth + j+1] - temp[(i-1)*bmp.biWidth + j-1] - 2*temp[ i*bmp.biWidth + j-1] - temp[(i+1)*bmp.biWidth + j-1] );
imagedata[ i*bmp.biWidth + j ] +=tmp;
}
}
}

void image_median_filter()
{
int i,j,k,m;
unsigned char tmp[9];
unsigned char change;
for (i=1;i<bmp.biHeight-1;i++)
{
for (j=1;j<bmp.biWidth-1;j++)
{
tmp[0] = temp[(i-1)*bmp.biWidth + j-1];
tmp[1] = temp[(i-1)*bmp.biWidth + j];
tmp[2] = temp[(i-1)*bmp.biWidth + j+1];
tmp[3] = temp[ i*bmp.biWidth + j-1];
tmp[4] = temp[ i*bmp.biWidth + j+1];
tmp[5] = temp[(i+1)*bmp.biWidth + j-1];
tmp[6] = temp[(i+1)*bmp.biWidth + j];
tmp[7] = temp[(i+1)*bmp.biWidth + j+1];
tmp[8] = temp[ i *bmp.biWidth + j];
for(k=0; k<9; k++)
{
for(m=k; m<9; m++)
{
if(tmp[k] > tmp[m])
{
change = tmp[k];
tmp[k] = tmp[m];
tmp[m] =change;
}
}
}
imagedata[ i*bmp.biWidth + j ] = tmp[4];
}
}
}

//***************main.c******************

#include<stdio.h>
#include<stdlib.h>
#include<string.h>
#include<conio.h>
//#include<windows.h>
#include"image.h"

//RGBQUADUAD *pColorTable;//颜色表指针
BMP bmp;

int main()
{
FILE *file=NULL;
int choose;
char go_on;
do
{
image_info(file); //imagedata已经分配了动态内存，但是没有释放

printf("\n 1.image_smooth");
printf("\n 2.image_Roberts_sharpen");
printf("\n 3.image_Roberts_enhance");
printf("\n 4.image_median_filter");
printf("\n 5.do nothing");
//printf("7.image_opposite");

printf("\nchoose your options:");
fflush(stdin);
scanf("%d",&choose);
switch(choose)
{
case 1:
image_smooth();
image_save(file);
case 2:
image_Roberts_sharpen();
image_save(file);
break;
case 3:
image_Roberts_enhance();
image_save(file);
break;
case 4:
image_median_filter();
image_save(file);
case 5:
image_save(file);
break;
default:
printf("\n wrong choose!");

}
free(imagedata);
free(temp);
free(pColorTable);
printf("\nlet's go on?(y/n):");
fflush(stdin);
scanf("%c",&go_on);
if (go_on=='n')
{
printf("\nbye bye!");
break;
}
}
while(1);

return 0;
}

/*********************************以下是关于BMP文件结构的内容【百度百科来的】***************************/

组成

　　典型的BMP图像文件由四部分组成：

　　1：位图头文件数据结构，它包含BMP图像文件的类型、显示内容等信息；

　　2：位图信息数据结构，它包含有BMP图像的宽、高、压缩方法，以及定义颜色等信息；

　　3：调色板，这个部分是可选的，有些位图需要调色板，有些位图，比如真彩色图（24位的BMP）就不需要调色板；

　　4：位图数据，这部分的内容根据BMP位图使用的位数不同而不同，在24位图中直接使用RGB，而其他的小于24位的使用调色板中颜色索引值。

对应的数据结构

　　1：BMP文件组成

　　BMP文件由文件头、位图信息头、颜色信息和图形数据四部分组成。

　　2：BMP文件头（14字节）

　　BMP文件头数据结构含有BMP文件的类型、文件大小和位图起始位置等信息。

　　其结构定义如下：

　　typedef struct tagBITMAPFILEHEADER

　　{

　　WORD bfType; // 位图文件的类型，必须为BM(0-1字节）

　　DWORD bfSize; // 位图文件的大小，以字节为单位（2-5字节）

　　WORD bfReserved1; // 位图文件保留字，必须为0(6-7字节）

　　WORD bfReserved2; // 位图文件保留字，必须为0(8-9字节）

　　DWORD bfOffBits; // 位图数据的起始位置，以相对于位图（10-13字节）

　　// 文件头的偏移量表示，以字节为单位

　　} BITMAPFILEHEADER;

　　3：位图信息头（40字节）

　　BMP位图信息头数据用于说明位图的尺寸等信息。

　　typedef struct tagBITMAPINFOHEADER{

　　DWORD biSize; // 本结构所占用字节数（14-17字节）

　　LONG biWidth; // 位图的宽度，以像素为单位（18-21字节）

　　LONG biHeight; // 位图的高度，以像素为单位（22-25字节）

　　WORD biPlanes; // 目标设备的级别，必须为1(26-27字节）

　　WORD biBitCount;// 每个像素所需的位数，必须是1（双色），（28-29字节）

　　// 4(16色），8(256色）或24（真彩色）之一

　　DWORD biCompression; // 位图压缩类型，必须是 0（不压缩），（30-33字节）

　　// 1(BI_RLE8压缩类型）或2(BI_RLE4压缩类型）之一

　　DWORD biSizeImage; // 位图的大小，以字节为单位（34-37字节）

　　LONG biXPelsPerMeter; // 位图水平分辨率，每米像素数（38-41字节）

　　LONG biYPelsPerMeter; // 位图垂直分辨率，每米像素数（42-45字节)

　　DWORD biClrUsed;// 位图实际使用的颜色表中的颜色数（46-49字节）

　　DWORD biClrImportant;// 位图显示过程中重要的颜色数（50-53字节）

　　} BITMAPINFOHEADER;

　　4：颜色表

　　颜色表用于说明位图中的颜色，它有若干个表项，每一个表项是一个RGBQUAD类型的结构，定义一种颜色。RGBQUAD结构的定义如下：

　　typedef struct tagRGBQUAD {

　　BYTE rgbBlue;// 蓝色的亮度（值范围为0-255)

　　BYTE rgbGreen; // 绿色的亮度（值范围为0-255)

　　BYTE rgbRed; // 红色的亮度（值范围为0-255)

　　BYTE rgbReserved;// 保留，必须为0

　　} RGBQUAD;

　　颜色表中RGBQUAD结构数据的个数有biBitCount来确定：

　　当biBitCount=1,4,8时，分别有2,16,256个表项；

　　当biBitCount=24时，没有颜色表项。

　　位图信息头和颜色表组成位图信息，BITMAPINFO结构定义如下：

　　typedef struct tagBITMAPINFO {

　　BITMAPINFOHEADER bmiHeader; // 位图信息头

　　RGBQUAD bmiColors[1]; // 颜色表

　　} BITMAPINFO;

　　5：位图数据

　　位图数据记录了位图的每一个像素值，记录顺序是在扫描行内是从左到右，扫描行之间是从下到上。位图的一个像素值所占的字节数：

　　当biBitCount=1时，8个像素占1个字节；

　　当biBitCount=4时，2个像素占1个字节；

　　当biBitCount=8时，1个像素占1个字节；

　　当biBitCount=24时，1个像素占3个字节；

　　Windows规定一个扫描行所占的字节数必须是

　　4的倍数（即以long为单位），不足的以0填充，

　　biSizeImage = ((((bi.biWidth * bi.biBitCount) + 31) & ~31) / 8) * bi.biHeight;

　　具体数据举例：

　　如某BMP文件开头：

　　424D 4690 0000 0000 0000 4600 0000 2800 0000 8000 0000 9000 0000 0100*1000 0300 0000 0090 0000 A00F 0000 A00F 0000 0000 0000 0000 0000*00F8 E007 1F00 0000*02F1 84F1 04F1 84F1 84F1 06F2 84F1 06F2 04F2 86F2 06F2 86F2 86F2 .... ....

　　BMP文件可分为四个部分：位图文件头、位图信息头、彩色板、图像数据阵列，在上图中已用*分隔。

图像文件头

　　1）1：(这里的数字代表的是"字",即两个字节，下同）图像文件头。0x424D=’BM’，表示是Windows支持的BMP格式。

　　2）2-3：整个文件大小。4690 0000，为00009046h=36934。

　　3）4-5：保留，必须设置为0。

　　4）6-7：从文件开始到位图数据之间的偏移量。4600 0000，为00000046h=70，上面的文件头就是35字=70字节。

位图信息头

　　5）8-9：位图图信息头长度。

　　6）10-11：位图宽度，以像素为单位。8000 0000，为00000080h=128。

　　7）12-13：位图高度，以像素为单位。9000 0000，为00000090h=144。

　　8）14：位图的位面数，该值总是1。0100，为0001h=1。

　　9）15：每个像素的位数。有1（单色），4（16色），8（256色），16（64K色，高彩色），24（16M色，真彩色），32（4096M色，增强型真彩色）。1000为0010h=16。

　　10）16-17：压缩说明：有0（不压缩），1（RLE 8，8位RLE压缩），2（RLE 4，4位RLE压缩，3（Bitfields，位域存放）。RLE简单地说是采用像素数+像素值的方式进行压缩。T408采用的是位域存放方式，用两个字节表示一个像素，位域分配为r5b6g5。图中0300 0000为00000003h=3。

　　11）18-19：用字节数表示的位图数据的大小，该数必须是4的倍数，数值上等于（≥位图宽度的最小的4的倍数）×位图高度×每个像素位数。0090 0000为00009000h=80×90×2h=36864。

　　12）20-21：用象素/米表示的水平分辨率。A00F 0000为0000 0FA0h=4000。

　　13）22-23：用象素/米表示的垂直分辨率。A00F 0000为0000 0FA0h=4000。

　　14）24-25：位图使用的颜色索引数。设为0的话，则说明使用所有调色板项。

　　15）26-27：对图象显示有重要影响的颜色索引的数目。如果是0，表示都重要。

彩色板

　　16）28-....（不确定）：彩色板规范。对于调色板中的每个表项，用下述方法来描述RGB的值：

　　1字节用于蓝色分量

　　1字节用于绿色分量

　　1字节用于红色分量

　　1字节用于填充符（设置为0)

　　对于24-位真彩色图像就不使用彩色板，因为位图中的RGB值就代表了每个象素的颜色。

/**********************************以下是关于结构体对齐的内容【转载来的】*******************************/

(1)什么是字节对齐

　　一个变量占用 n 个字节，则该变量的起始地址必须能够被 n 整除，即: 存放起始地址 % n = 0，对于结构体而言，这个 n 取其成员种的数据类型占空间的值最大的那个。

(2)为什么要字节对齐

　　内存空间是按照字节来划分的，从理论上说对内存空间的访问可以从任何地址开始，但是在实际上不同架构的CPU为了提高访问内存的速度，就规定了对于某些类型的数据只能从特定的起始位置开始访问。这样就决定了各种数据类型只能按照相应的规则在内存空间中存放，而不能一个接一个的顺序排列。

　　举个例子，比如有些平台访问内存地址都从偶数地址开始，对于一个int型(假设32位系统)，如果从偶数地址开始的地方存放，这样一个读周期就可以读出这个int数据，但是如果从奇数地址开始的地址存放，就需要两个读周期，并对两次读出的结果的高低字节进行拼凑才能得到这个int数据，这样明显降低了读取的效率。

(3)如何进行字节对齐

　　每个成员按其类型的对齐参数(通常是这个类型的大小)和指定对齐参数(不指定则取默认值)中较小的一个对齐，并且结构的长度必须为所用过的所有对齐参数的整数倍,不够就补空字节。

　　这个规则有点苦涩，可以把这个规则分解一下，前半句的意思先获得对齐值后与指定对齐值进行比较,其中对齐值获得方式如下：

　　1. 数据类型的自身对齐值为：对于char型数据，其自身对齐值为1，对于short型为2，对于int, long, float类型，其自身对齐值为4，对于 double 类型其自身对齐值为8，单位为字节。

　　2.结构体自身对齐值：其成员中自身对齐值最大的那个值。

　　其中指定对齐值获得方式如下：

　　#pragma pack (value)时的指定对齐值value。

　　未指定则取默认值。

　　后半句的意思是主要是针对于结构体的长度而言，因为针对数据类型的成员，它仅有一个对齐参数，其本身的长度、于这个对齐参数，即1倍。对于结构体而言，它可能使用了多种数据类型，那么这句话翻译成对齐规则：每个成员的起始地址 % 自身对齐值 = 0，如果不等于 0 则先补空字节直至这个表达式成立。

换句话说，对于结构体而言，结构体在在内存的存放顺序用如下规则即可映射出来：

　　(一)每个成员的起始地址 % 每个成员的自身对齐值 = 0，如果不等于 0 则先补空字节直至这个表达式成立；

　　(二)结构体的长度必须为结构体的自身对齐值的整数倍,不够就补空字节。

　　举个例子：

#pragmapack(8)
structA{
　　chara;
　　longb;
};
structB{
　　chara;
　　structAb;
　　longc;
};

　　对于 struct A 来说，对于char型数据，其自身对齐值为1，对于long类型，其自身对齐值为4, 结构体的自身对齐值取其成员最大的对齐值，即大小4。那么struct A 在内存中的顺序步骤为：

　　(1) char a, 地址范围为0x0000~0x0000,起始地址为0x0000,满足 0x0000 % 1 = 0，这个成员字节对齐了。

　　(2) long b, 地址起始位置不能从0x00001开始，因为 0x0001 % 4 != 0,　所以先补空字节，直到0x00003结束，即补3个字节的空字节，从0x00004开始存放b,其地址范围为0x00004~0x0007.

　　(3)此时成员都存放结束，结构体长度为8，为结构体自身对齐值的2倍，符合条件(二).

　　此时满足条件(一)和条件(二)，struct A 中各成员在内存中的位置为：a*** b ,sizeof(struct A) = 8。(每个星号代表一位，成员各自代表自己所占的位，比如a占一位，b占四位)

　　对于struct B，里面有个类型为struct A的成员b自身对齐值为4，对于long类型，其自身对齐值为4. 故struct B的自身对齐值为4。那么structB 在内存中的顺序步骤为：

　　(1) char a, 地址范围为0x0000~0x0000,起始地址为0x0000,满足 0x0000 % 1 = 0，这个成员字节对齐了。

　　(2) struct A b, 地址起始位置不能从0x00001开始，因为 0x0001 % 4 != 0,　所以先补空字节，直到0x00003结束，即补3个字节的空字节，从0x00004开始存放b,其地址范围为0x00004~0x00011.

　　(3) long c，地址起始位置从0x000012开始，因为 0x0012 % 4 = 0，其地址范围为0x00012~0x0015.

　　(4)此时成员都存放结束，结构体长度为16，为结构体自身对齐值的4倍，符合条件(二).

　　此时满足条件(一)和条件(二)，struct B 中各成员在内存中的位置为：a*** b c ,sizeof(struct C) = 24。(每个星号代表一位，成员各自代表自己所占的位，比如a占一位，b占八位，c占四位)

posted @ 2012-03-24 23:06 maliqian 阅读(2486) 评论(0) 编辑收藏举报

刷新页面返回顶部

maliqian

关于结构体字对齐—BMP文件图像处理程序

对应的数据结构

图像文件头

位图信息头

彩色板

公告