×
Featured image of post 换个姿势学C语言第9章

换个姿势学C语言第9章

换个姿势学C语言 第9章 显示图形和文本元素

0. 说明

《换个姿势学C语言》由何旭辉 著,清华大学出版社2022年出版。感谢何老师!

Snipaste_2024-03-10_14-51-10.png

这是一本非常不错的书!

9. 显示图形和文本元素

学习了绘制点、线和填充颜色,我们还需要学习如何显示图像。

现在我们将学习如何显示采用BMP格式的图像文件。EasyX其实提供了显示图片的函数:

Snipaste_2026-08-22_20-48-17.png

但我们还是先自己实现它。

本章相关知识:

  • 常见的位图文件格式。
  • 显示24位.bmp图像的方法(国旗和行政区旗)。
  • 显示不同字体的方法。
  • 控制屏幕分辨率和全屏显示窗口。

在完成本章后,外汇牌价看板程序所需的技术预研工作就完成了!

外汇牌价看板的运行效果图:

Snipaste_2024-03-10_00-12-26.png

很多国旗或行政区区旗,每一面旗帜对应一个图形文件,文件名与倾向代码相同,例如英镑就是GBP.bmp。

Snipaste_2026-08-22_21-03-53.png

9.1 常见的位图文件格式

第8章介绍过图像传感器感应每一个像素点上的光并以R、G、B三种颜色分量描述像素点的颜色,一幅图像由多个像素组成,这种用像素表达图像的图形被称为位图。

9.1.1 常见的位图格式

针对不同的场景和应用需求,位图目前存在多种格式,其中较常用的格式有JPG和PNG。各种图形格式的特点和相互关系如下:

  • RAW格式,原始图像文件,是数码相机从图像传感器上获取的未经压缩的原始数据,会记录相应拍摄所产生的一些原始数据,如快门设置、光圈值等信息,图像细节丰富,但占用空间较大。
  • JPG格式,使用最广泛的照片格式,在日常生活中,手机、数码相机拍摄的都是JPG格式的,其进行了压缩,虽然压缩会对图像质量进行破坏,但人眼难以分辨。
  • GIF格式,只支持256种颜色,文件较小,如常见的动图就是GIF格式。但由于专利限制,后来很快被PNG格式取代。
  • PNG格式,便携式网络图形,是一种无损压缩的位图图形格式。广泛用于互联网。
  • BMP格式,位图,是一种不压缩像素数据的文件格式。它逐个地描述每个像素点的颜色,这一点和RAW格式类似,但比RAW格式保存的信息少,文件占用空间较RAW小,但比JPG、PNG大。BMP文件支持不同的颜色位数,本章只讲解24位真彩色模式的BMP图像的显示,以降低程序复杂度。
9.1.2 BMP文件基本结构

BMP文件都遵循统一的文件格式规范,BMP文件的主要内容是像素数据,但除此之外BMP文件中还包含必备的图片信息,例如图片的宽度和高度,这些信息一般放在文件的开始部分,被称为文件头。

Snipaste_2026-08-22_22-23-43.png

  • 文件头的大小一般是固定的,例如BMP文件的文件头为固定的54个字节(在只讨论24位真彩色、无压缩、标准40字节信息头模式的BMP图像的前提下),文件头里面除了存储图像的宽度、高度。还包含其他一些信息,如文件大小、像素数据的起始位置和颜色数等。
  • 在文件头之后是图片的像素数据,像素数据的多少取决于图片的大小和颜色模式,图片越大、包含的颜色数越多,像素数据就越多。

接下来以显示24位BMP图像为例,逐步了解BMP文件的文件格式,并在程序中读取和显示BMP图像!

9.2 显示24位BMP图像

在目录D:\BC101\Resources\L09下有一个640_480_RED.bmp文件,它是一个宽度为640像素、高度为480像素、全部像素为红色(RGB值为255,0,0)的BMP文件,全部像素为红色是为了便于在调试程序时观察文件中的数据。

Snipaste_2026-08-22_22-53-59.png

我们用python读取一下BMP的头文件信息,看看和书上是不是一致的:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
import struct

file1 = r'D:\\BC101\\Resources\\L09\\640_480_RED.bmp'


def parse_bmp_header(path):
    with open(path, 'rb') as f:
        header = f.read(54)
    print(f"\n==== {path} ====")
    print("原始54字节:", header)
    # 小端解析 BITMAPFILEHEADER + BITMAPINFOHEADER
    (sig, file_size, reserved, data_offset,
     ih_size, w, h, planes,
     bitcnt, comp, img_size, xppm,
     yppm, clrused, clrimp) = struct.unpack(
        '<2sI4sIIiiHHIIIIII', header)
    print(f"签名:{sig}, 文件大小:{file_size},像素偏移:{data_offset}")
    print(f"宽={w},高={h},位深={bitcnt},压缩={comp},像素区大小={img_size}")


parse_bmp_header(file1)

运行程序输出如下:

1
2
3
4
==== D:\\BC101\\Resources\\L09\\640_480_RED.bmp ====
原始54字节: b'BM6\x10\x0e\x00\x00\x00\x00\x006\x00\x00\x00(\x00\x00\x00\x80\x02\x00\x00\xe0\x01\x00\x00\x01\x00\x18\x00\x00\x00\x00\x00\x00\x10\x0e\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00'
签名:b'BM', 文件大小:921654,像素偏移:54
宽=640,高=480,位深=24,压缩=0,像素区大小=921600

Snipaste_2026-08-22_22-56-13.png

可以看到通过python程序获取到的像素高度、宽度、文件大小、位深等信息都和查看文件属性里面的信息是对得上的!

通过notepad++打开这个文件,并使用HEX插件查看,其内容如下:

Snipaste_2026-08-23_12-54-37.png

我们的目标不是查看文件的内容,而是要在程序中将它显示出来。

9.2.1 打开BMP文件并读取文件头

要在程序中显示BMP文件,首先要打开文件并从文件头中获取一些有用的信息(图片的宽度、高度和允许的颜色数等),BMP文件的文件头占用文件开始的54个字节,这54字节又分为三个部分。

Snipaste_2026-08-23_13-04-13.png

  • BMP文件标识(2字节),第1-2字节是BMP文件的特殊标识,分别是字节B和M,如果一个文件的第1、2字节不是这两个字母,则可以认为不是一个BMP文件,可以放弃下一步读取。
  • 位图文件头(12字节),第3-14字节被称为位图文件头,其中主要包含两项信息:BMP文件的大小和像素数据在文件中的起始位置。
  • 位图详细信息(40字节),第15-54字节包含位图文件的详细信息,其中我们关心的信息包括位图宽度(像素)和位图高度(像素)。

知道了BMP文件头的基本组成后,就可以打开BMP文件并读取文件头。

使用AI协助,读取文件头信息:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
/// L09_01_READ_BMP_FILE.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

int main()
{
    FILE *bmpfile = fopen("D:/BC101/Resources/L09/640_480_RED.bmp", "rb");
    if (bmpfile == NULL)
    {
        printf("打开BMP文件失败\n");
        return 1;
    }
    printf("打开BMP文件成功\n");
    // 获取标识信息
    char tag[2];
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(tag, 2, 1, bmpfile);
    if (ret_1 != 1)
    {
        printf("读取BMP标识失败,文件过短或损坏\n");
        fclose(bmpfile);
        return 2;
    }
    char first = tag[0];
    char second = tag[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M')
    {
        printf("打开的文件不是BMP文件格式\n");
        fclose(bmpfile);
        return 3;
    }
    printf("读取BMP文件标识成功\n");

    // 开始处理位图文件图信息
    // 第1-4字节,整型, BMP文件大小
    unsigned int fileSize = 0;
    size_t ret_2 = fread(&fileSize, 4, 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP文件大小异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", fileSize);

    // 第5-8字节,保留区, 9-12字节,像素偏移量
    unsigned int reserved = 0;
    unsigned int offBits = 0;
    size_t ret_3 = fread(&reserved, 4, 1, bmpfile);
    size_t ret_4 = fread(&offBits, 4, 1, bmpfile);
    if (ret_3 != 1 || ret_4 != 1)
    {
        printf("读取文件头保留/偏移失败\n");
        fclose(bmpfile);
        return 5;
    }
    printf("像素偏移量: %u\n", offBits);

    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int infoHeaderSize; // 信息头结构体长度,标准BMP为40
    int width;                   // 图像宽度,像素
    int height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short planes;       // 色彩平面数,BMP固定等于1
    unsigned short bitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int compression;    // 压缩方式;0=不压缩
    unsigned int imageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int xPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int yPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int clrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int clrImportant;   // 重要颜色数量,一般为0

    size_t ret;

    ret = fread(&infoHeaderSize, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读infoHeaderSize失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&width, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读width失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&height, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读height失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&planes, 2, 1, bmpfile);
    if (ret != 1)
    {
        printf("读planes失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&bitCount, 2, 1, bmpfile);
    if (ret != 1)
    {
        printf("读bitCount失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&compression, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读compression失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&imageSize, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读imageSize失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&xPelsPerMeter, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读xPelsPerMeter失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&yPelsPerMeter, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读yPelsPerMeter失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&clrUsed, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读clrUsed失败\n");
        fclose(bmpfile);
        return 6;
    }

    ret = fread(&clrImportant, 4, 1, bmpfile);
    if (ret != 1)
    {
        printf("读clrImportant失败\n");
        fclose(bmpfile);
        return 6;
    }

    printf("==== BITMAPINFOHEADER ====\n");
    printf("信息头大小: %u\n", infoHeaderSize);
    printf("图像宽: %d\n", width);
    printf("图像高: %d\n", height);
    printf("色彩平面: %u\n", planes);
    printf("位深: %u\n", bitCount);
    printf("压缩方式: %u (0=无压缩)\n", compression);
    printf("像素数据总大小(含padding): %u\n", imageSize);
    printf("X分辨率(每米像素): %u\n", xPelsPerMeter);
    printf("Y分辨率(每米像素): %u\n", yPelsPerMeter);
    printf("调色板颜色数量: %u\n", clrUsed);
    printf("重要颜色数量: %u\n", clrImportant);

    int bytes_per_pixel = bitCount / 8;                  // 每个像素占多少字节,24位就是3字节
    int line_raw_bytes = width * bytes_per_pixel;        // 一行原始像素字节,不含padding填充
    int line_padded_bytes = (line_raw_bytes + 3) & (~3); // 4字节对齐后的真实一行大小,包含padding
    printf("每行原始字节:%d, 对齐后实际行大小:%d\n", line_raw_bytes, line_padded_bytes);

    //跳到像素数据真正起始位置,不要硬编码54
    fseek(bmpfile, offBits, SEEK_SET);
    printf("已经fseek跳到像素偏移:%u\n", offBits);

    fclose(bmpfile);

    return 0;
}

运行程序输出如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
打开BMP文件成功
BM
读取BMP文件标识成功
BMP文件大小: 921654
像素偏移量: 54
==== BITMAPINFOHEADER ====
信息头大小: 40
图像宽: 640
图像高: 480
色彩平面: 1
位深: 24
压缩方式: 0 (0=无压缩)
像素数据总大小(含padding): 921600
X分辨率(每米像素): 0
Y分辨率(每米像素): 0
调色板颜色数量: 0
重要颜色数量: 0
每行原始字节:1920, 对齐后实际行大小:1920
已经fseek跳到像素偏移:54

可以看到,上面我们定义了非常多的变量来存储BMP文件头中的信息,但这样显得很麻烦,这个时候就可以使用之前学过的结构体!

针对第3-14字节的位图文件头,可以使用结构体来存储:

1
2
3
4
5
6
7
8
9
struct BITMAP_HEADER
{
    unsigned int Size;        // 第1-4字节,无符号整型, BMP文件大小
    unsigned short Reserved1; // 第5-6字节,无符号短整型,保留区1
    unsigned short Reserved2; // 第7-8字节,无符号短整型,保留区2
    unsigned int OffBits;     // 第9-12字节,无符号整型, 像素偏移量
};

typedef struct BITMAP_HEADER BitmapHeader;

然后针对位图文件头的处理就可以这样了:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    // 开始处理位图文件图信息
    BitmapHeader bmpHeader;

    size_t ret_2 = fread(&bmpHeader, sizeof(bmpHeader), 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP位图文件头异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", bmpHeader.Size);
    printf("像素偏移量: %u\n", bmpHeader.OffBits);

注意,以上都只是从代码里面复制的片段,不能直接运行!

位图详细信息就可以像下面这样定义:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
// 位图详细信息
struct BITMAP_INFORMATION
{
    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int InfoHeaderSize; // 信息头结构体长度,标准BMP为40
    int Width;                   // 图像宽度,像素
    int Height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short Planes;       // 色彩平面数,BMP固定等于1
    unsigned short BitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int Compression;    // 压缩方式;0=不压缩
    unsigned int ImageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int XPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int YPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int ClrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int ClrImportant;   // 重要颜色数量,一般为0
};
typedef struct BITMAP_INFORMATION bitmapInfomation;

然后优化代码,读取位图文件头和位图详细信息的代码就变成下面这样:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
/// L09_01_READ_BMP_FILE.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

// 位图文件头
struct BITMAP_HEADER
{
    unsigned int Size;        // 第1-4字节,无符号整型, BMP文件大小
    unsigned short Reserved1; // 第5-6字节,无符号短整型,保留区1
    unsigned short Reserved2; // 第7-8字节,无符号短整型,保留区2
    unsigned int OffBits;     // 第9-12字节,无符号整型, 像素偏移量
};

typedef struct BITMAP_HEADER BitmapHeader;

// 位图详细信息
struct BITMAP_INFORMATION
{
    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int InfoHeaderSize; // 信息头结构体长度,标准BMP为40
    int Width;                   // 图像宽度,像素
    int Height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short Planes;       // 色彩平面数,BMP固定等于1
    unsigned short BitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int Compression;    // 压缩方式;0=不压缩
    unsigned int ImageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int XPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int YPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int ClrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int ClrImportant;   // 重要颜色数量,一般为0
};
typedef struct BITMAP_INFORMATION bitmapInfomation;

int main()
{
    FILE *bmpfile = fopen("D:/BC101/Resources/L09/640_480_RED.bmp", "rb");
    if (bmpfile == NULL)
    {
        printf("打开BMP文件失败\n");
        return 1;
    }
    printf("打开BMP文件成功\n");
    // 获取标识信息
    char tag[2];
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(tag, 2, 1, bmpfile);
    if (ret_1 != 1)
    {
        printf("读取BMP标识失败,文件过短或损坏\n");
        fclose(bmpfile);
        return 2;
    }
    char first = tag[0];
    char second = tag[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M')
    {
        printf("打开的文件不是BMP文件格式\n");
        fclose(bmpfile);
        return 3;
    }
    printf("读取BMP文件标识成功\n");

    // 开始处理位图文件图信息
    BitmapHeader bmpHeader;

    size_t ret_2 = fread(&bmpHeader, sizeof(bmpHeader), 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP位图文件头异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", bmpHeader.Size);
    printf("像素偏移量: %u\n", bmpHeader.OffBits);

    // 开始处理位图详情信息
    bitmapInfomation bitInfo;
    size_t ret_3 = fread(&bitInfo, sizeof(bitInfo), 1, bmpfile);
    if (ret_3 != 1)
    {
        printf("读取位图详情信息失败\n");
        fclose(bmpfile);
        return 5;
    }

    printf("==== BITMAPINFOHEADER ====\n");
    printf("信息头大小: %u\n", bitInfo.InfoHeaderSize);
    printf("图像宽: %d\n", bitInfo.Width);
    printf("图像高: %d\n", bitInfo.Height);
    printf("色彩平面: %u\n", bitInfo.Planes);
    printf("位深: %u\n", bitInfo.BitCount);
    printf("压缩方式: %u (0=无压缩)\n", bitInfo.Compression);
    printf("像素数据总大小(含padding): %u\n", bitInfo.ImageSize);
    printf("X分辨率(每米像素): %u\n", bitInfo.XPelsPerMeter);
    printf("Y分辨率(每米像素): %u\n", bitInfo.YPelsPerMeter);
    printf("调色板颜色数量: %u\n", bitInfo.ClrUsed);
    printf("重要颜色数量: %u\n", bitInfo.ClrImportant);

    int bytes_per_pixel = bitInfo.BitCount / 8;           // 每个像素占多少字节,24位就是3字节
    int line_raw_bytes = bitInfo.Width * bytes_per_pixel; // 一行原始像素字节,不含padding填充
    int line_padded_bytes = (line_raw_bytes + 3) & (~3);  // 4字节对齐后的真实一行大小,包含padding
    printf("每行原始字节:%d, 对齐后实际行大小:%d\n", line_raw_bytes, line_padded_bytes);

    // 跳到像素数据真正起始位置,不要硬编码54
    fseek(bmpfile, bmpHeader.OffBits, SEEK_SET);
    printf("已经fseek跳到像素偏移:%u\n", bmpHeader.OffBits);

    printf("sizeof(BitmapHeader)=%zu\n", sizeof(bmpHeader));
    printf("sizeof(bitmapInformation)=%zu\n", sizeof(bitInfo));

    fclose(bmpfile);

    return 0;
}

运行输出:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
打开BMP文件成功
BM
读取BMP文件标识成功
BMP文件大小: 921654
像素偏移量: 54
==== BITMAPINFOHEADER ====
信息头大小: 40
图像宽: 640
图像高: 480
色彩平面: 1
位深: 24
压缩方式: 0 (0=无压缩)
像素数据总大小(含padding): 921600
X分辨率(每米像素): 0
Y分辨率(每米像素): 0
调色板颜色数量: 0
重要颜色数量: 0
每行原始字节:1920, 对齐后实际行大小:1920
已经fseek跳到像素偏移:54
sizeof(BitmapHeader)=12
sizeof(bitmapInformation)=40

可以看到获取的关键信息与之前通过一个个的参数读取是一样的,但这样读取方式更加快捷简便!

为什么不定义一个结构体包含全部文件头的内容,然后一次性读入54个字节呢?

是由于在结构体进行内存分配时存在“内存对齐”因素,把BMP文件头的全部内容定义成一个结构体会导致从文件中读入的数据与结构体元素发生错位!

因此没有采用定义1个结构体存储所有文件头信息的方法。读取BMP文件头的主要目的是为了获取图片的关键信息,如宽度、高度和颜色数。在文件头读取完毕后,从第55个字节开始的内容会因为文件格式不同而分为两种情况:

  • 对于单色(1位)、16色(4位)、256色(8位)位图,接下来是调色板数据;
  • 对于16位、24位真彩色位图,接下来是像素数据。

为了减少程序的复杂度,我们只考虑24位位图的情况:

  • 从第55字节开始就是像素数据;
  • 1个像素的颜色使用3个字节来描述。
9.2.2 从文件中获取第1个像素的颜色

24位BMP文件每个像素占用3个字节,分别存储R/G/B颜色分量。

📝 注意
在BMP文件中,R、G、B颜色分量存储的次序是B、G、R,而不是我们习惯的次序-R、G、B。刚好是反的!

Snipaste_2026-08-23_20-51-47.png

可以看到从第55字节开始的像素数据是00、00、 ff,表示这个像素的颜色分量值是0(B)、0(G)、255(R)。

为了便于存储读取的像素颜色,我们可以定义一个名为_24BIT_PIXEL的结构体,专门存储这种24位像素数据(之所以要在结构体和数据类型前面加下划线是因为C语言不支持以数字开始的结构体和数据类型名)。这个结构体使用3个unsigned char类型的成员变量(1字节)依次存储B、G、R三种颜色分量的值。

1
2
3
4
5
6
7
8
// 24位像素数据
struct _24BIT_PIXEL
{
    unsigned char Blue;
    unsigned char Green;
    unsigned char Red;
};
typedef struct _24BIT_PIXEL _24BitPixel;

在程序中定义了结构体后就可以从文件中读取一个像素的数据。

然后在上一节的程序结尾加上以下程序代码块:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    // 开始读取像素信息
    _24BitPixel pixel;
    size_t ret_4 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
    if (ret_4 != 1)
    {
        printf("读取位图第1个像素信息失败\n");
        fclose(bmpfile);
        return 5;
    }
    printf("第1个像素的颜色分量Red:%d\n", pixel.Red);
    printf("第1个像素的颜色分量Green:%d\n", pixel.Green);
    printf("第1个像素的颜色分量Blue:%d\n", pixel.Blue);

然后运行输出:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
打开BMP文件成功
BM
读取BMP文件标识成功       
BMP文件大小: 921654       
像素偏移量: 54
==== BITMAPINFOHEADER ====
信息头大小: 40
图像宽: 640
图像高: 480
色彩平面: 1
位深: 24
压缩方式: 0 (0=无压缩)    
像素数据总大小(含padding): 921600
X分辨率(每米像素): 0
Y分辨率(每米像素): 0
调色板颜色数量: 0
重要颜色数量: 0
每行原始字节:1920, 对齐后实际行大小:1920
已经fseek跳到像素偏移:54
sizeof(BitmapHeader)=12
sizeof(bitmapInformation)=40
第1个像素的颜色分量Red:255
第1个像素的颜色分量Green:0
第1个像素的颜色分量Blue:0

可以看到,第1个像素的颜色分量是Red(255)、Green(0)、Blue(0),毫无疑问,它就是红色!如果你继续读取,将会依次获取每一个像素的颜色。

9.2.3 绘制每一个像素

现在我们就可以使用putpixel函数逐个显示每个像素了。首先需要调用initgraph函数初始化图形窗口!

图形窗口的大小可以和图片大小一致,图片的宽和高之前已经读取到结构体变量bmpInfo中,可以用它们来初始化窗口。

1
2
// 初始化窗口
initgraph(bitInfo.Width, bitInfo.Height);

接下来需要依次取得每个像素的颜色并使用putpixel函数逐个显示每个像素,这是两个任务:

  • 依次读取每一个像素的颜色;
  • 在指定的位置显示获取的像素颜色。

不要试图一次解决两个问题,我们可以先来完成第一个任务,依次读取每一个像素的颜色,之前已经成功获取一个像素的颜色并显示了它的R、G、B的值,要读取全部像素的颜色就需要多次读取,那么要读取多少次呢?

这取决于图片的宽度和高度,以下循环读取图片第1行的全部像素:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
    for (int x = 0; x <= bitInfo.Width - 1; x++)
    {
        size_t ret_5 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
        if (ret_5 != 1)
        {
            printf("读取位图像素信息失败\n");
            fclose(bmpfile);
            return 5;
        }
    }

在上述代码中,控制变量x的初始是0,终值是bitInfo.Width - 1,以宽度640像素为例,就是0到639,循环执行640次。

只读取一行的640个像素是不够的,因为这个图片有480行,所以读取行的循环应该被执行480次,因此还要加上垂直方向的循环控制,然后可以使用之前的rgb函数转换成RGBColor类型,然后最终的代码如下:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
/// L09_02_DISPLAY_BMP.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

typedef unsigned long RGBColor;

// rbg格式转换
RGBColor rgb(unsigned char red, unsigned char green, unsigned char blue);

// 位图文件头
struct BITMAP_HEADER
{
    unsigned int Size;        // 第1-4字节,无符号整型, BMP文件大小
    unsigned short Reserved1; // 第5-6字节,无符号短整型,保留区1
    unsigned short Reserved2; // 第7-8字节,无符号短整型,保留区2
    unsigned int OffBits;     // 第9-12字节,无符号整型, 像素偏移量
};

typedef struct BITMAP_HEADER BitmapHeader;

// 位图详细信息
struct BITMAP_INFORMATION
{
    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int InfoHeaderSize; // 信息头结构体长度,标准BMP为40
    int Width;                   // 图像宽度,像素
    int Height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short Planes;       // 色彩平面数,BMP固定等于1
    unsigned short BitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int Compression;    // 压缩方式;0=不压缩
    unsigned int ImageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int XPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int YPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int ClrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int ClrImportant;   // 重要颜色数量,一般为0
};
typedef struct BITMAP_INFORMATION bitmapInfomation;

// 24位像素数据
struct _24BIT_PIXEL
{
    unsigned char Blue;
    unsigned char Green;
    unsigned char Red;
};
typedef struct _24BIT_PIXEL _24BitPixel;

int main()
{
    FILE *bmpfile = fopen("D:/BC101/Resources/L09/640_480_RED.bmp", "rb");
    if (bmpfile == NULL)
    {
        printf("打开BMP文件失败\n");
        return 1;
    }
    printf("打开BMP文件成功\n");
    // 获取标识信息
    char tag[2];
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(tag, 2, 1, bmpfile);
    if (ret_1 != 1)
    {
        printf("读取BMP标识失败,文件过短或损坏\n");
        fclose(bmpfile);
        return 2;
    }
    char first = tag[0];
    char second = tag[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M')
    {
        printf("打开的文件不是BMP文件格式\n");
        fclose(bmpfile);
        return 3;
    }
    printf("读取BMP文件标识成功\n");

    // 开始处理位图文件图信息
    BitmapHeader bmpHeader;

    size_t ret_2 = fread(&bmpHeader, sizeof(bmpHeader), 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP位图文件头异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", bmpHeader.Size);
    printf("像素偏移量: %u\n", bmpHeader.OffBits);

    // 开始处理位图详情信息
    bitmapInfomation bitInfo;
    size_t ret_3 = fread(&bitInfo, sizeof(bitInfo), 1, bmpfile);
    if (ret_3 != 1)
    {
        printf("读取位图详情信息失败\n");
        fclose(bmpfile);
        return 5;
    }

    printf("==== BITMAPINFOHEADER ====\n");
    printf("信息头大小: %u\n", bitInfo.InfoHeaderSize);
    printf("图像宽: %d\n", bitInfo.Width);
    printf("图像高: %d\n", bitInfo.Height);
    printf("色彩平面: %u\n", bitInfo.Planes);
    printf("位深: %u\n", bitInfo.BitCount);
    printf("压缩方式: %u (0=无压缩)\n", bitInfo.Compression);
    printf("像素数据总大小(含padding): %u\n", bitInfo.ImageSize);
    printf("X分辨率(每米像素): %u\n", bitInfo.XPelsPerMeter);
    printf("Y分辨率(每米像素): %u\n", bitInfo.YPelsPerMeter);
    printf("调色板颜色数量: %u\n", bitInfo.ClrUsed);
    printf("重要颜色数量: %u\n", bitInfo.ClrImportant);

    int bytes_per_pixel = bitInfo.BitCount / 8;           // 每个像素占多少字节,24位就是3字节
    int line_raw_bytes = bitInfo.Width * bytes_per_pixel; // 一行原始像素字节,不含padding填充
    int line_padded_bytes = (line_raw_bytes + 3) & (~3);  // 4字节对齐后的真实一行大小,包含padding
    printf("每行原始字节:%d, 对齐后实际行大小:%d\n", line_raw_bytes, line_padded_bytes);

    // 跳到像素数据真正起始位置,不要硬编码54
    fseek(bmpfile, bmpHeader.OffBits, SEEK_SET);
    printf("已经fseek跳到像素偏移:%u\n", bmpHeader.OffBits);

    printf("sizeof(BitmapHeader)=%zu\n", sizeof(bmpHeader));
    printf("sizeof(bitmapInformation)=%zu\n", sizeof(bitInfo));

    // 开始读取像素信息
    // _24BitPixel pixel;
    // size_t ret_4 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
    // if (ret_4 != 1)
    // {
    //     printf("读取位图第1个像素信息失败\n");
    //     fclose(bmpfile);
    //     return 5;
    // }
    // printf("第1个像素的颜色分量Red:%d\n", pixel.Red);
    // printf("第1个像素的颜色分量Green:%d\n", pixel.Green);
    // printf("第1个像素的颜色分量Blue:%d\n", pixel.Blue);

    // 初始化窗口
    initgraph(bitInfo.Width, bitInfo.Height);

    for (int y = 0; y <= bitInfo.Height - 1; y++)
    {
        for (int x = 0; x <= bitInfo.Width - 1; x++)
        {
            _24BitPixel pixel;
            size_t ret_5 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
            if (ret_5 != 1)
            {
                printf("读取位图像素信息失败\n");
                fclose(bmpfile);
                return 5;
            }
            putpixel(x, y, rgb(pixel.Red, pixel.Green, pixel.Blue));
        }
    }

    _getch();
    closegraph();
    fclose(bmpfile);

    return 0;
}

RGBColor rgb(unsigned char red, unsigned char green, unsigned char blue)
{
    return (RGBColor)red |
           ((RGBColor)green << 8) |
           ((RGBColor)blue << 16);
}

运行效果图如下:

Snipaste_2026-08-25_21-57-18.png

只显示一个纯色BMP不能证明程序是正确的,在同一个文件夹中有另一个名为"640_480_TEST_CARD.bmp"的文件,将程序中文件路径"D:/BC101/Resources/L09/640_480_RED.bmp"替换成"D:/BC101/Resources/L09/640_480_TEST_CARD.bmp",再次运行程序,可以看到效果如下图所示:

Snipaste_2026-08-29_15-01-11.png

可以看到,图片是上下颠倒的!

这是因为之前没有讲过BMP文件中存储的像素数据次序是“从下到上、从左到右”的,这是BMP文件格式的定义者规定的,我们只能遵守它。换句话说,我们读取的第1行像素数据,实际上是图片最底部的一行,我们的程序将图像最底部的一行像素绘制到最上方,因此图形就颠倒了。要解决这个问题也很简单,只需要将putpixel(x, y, rgb(pixel.Red, pixel.Green, pixel.Blue));优化一下为:

1
putpixel(x, bitInfo.Height - 1 - y, rgb(pixel.Red, pixel.Green, pixel.Blue));

这样一来就是从底部开始从下到上地绘制像素,解决了图片显示上下颠倒的问题,再次运行效果如下:

Snipaste_2026-08-29_15-09-06.png

需要注意y = 0 时, bitInfo.Height - y为480像素,此时就会越界,超出画布,像素直接丢失,因此绘制垂直方向需要减1。

9.3 优化BMP图像显示程序

虽然使用L09_02_DISPLAY_BMP.cpp程序已经能显示出BMP图片了,但这个程序仅用于说明BMP图片显示的原理,而不能用于外汇牌价看板程序的,它存在很多问题:

  • 显示图片的代码全部位于main函数中,无法复用。
  • 只能显示一张图片,且图片填充了整个窗口,在外汇牌价看板中,我们需要显示多张旗帜的图片,而且需要图片显示在窗口的任意位置,而不是用图片填充整个窗口。
  • 一个文件分多次读取,显示速度较慢。多次使用fread函数从文件中读取数据,甚至像素数据都慢逐个读取的,这影响了程序的性能。

为了解决上面的问题,我们需要对程序进行优化,优化的手段包括:

  • 新增displayBMP函数,以支持代码复用并可以在指定位置显示图片;
  • 对显示BMP文件的代码进行重构,提高读取文件的效率。
9.3.1 重新组织代码结构

在main函数中写大量代码是一种恶习,在main函数所以的main.cpp文件中包含很多其他函数的代码也不是一个好习惯。

之前介绍过组织函数库代码的原则:

  • 如果一个函数库中包含多种用途的函数,应该将其按功能进行分类,分种类别的函数源代码应该独立放在一个源代码文件(.cpp文件或.c文件中。
  • 单独使用一个头文件(.h文件)对类型、函数等进行声明。这个头文件的文件名通常与函数定义的源代码文件相同(扩展名不同)。

这两个原则同样适用于普通应用程序。它所带来的好处是显而易见的:将程序划分成多个文件、多个模块,为多人协作完成一个项目提供可能;未来如果需要将其独立做成函数库,代码也更容易分离。

在开始之前,我们先将与颜色相关的数据类型、函数从main.cpp中独立出来。

为了不影响之前的项目代码,复制L09_02_DISPLAY_BMP文件夹,为L09_03_DISPLAY_BMP,并调整里面的文件名称以及launch.json和tasks.json配置,此处不展开。

9.3.1.1 新增颜色类模块

新增color.h头文件:

1
2
3
4
5
6
7
/// color.h
// 颜色相关文件头
#pragma once
typedef unsigned long RGBColor;

// rbg格式转换
RGBColor rgb(unsigned char red, unsigned char green, unsigned char blue);

这个文件包括了数据类型RGBColor的定义和rgb函数的声明。

新增color.cpp函数实现文件:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
/// color.cpp
// 颜色相关实现

#include "color.h"

RGBColor rgb(unsigned char red, unsigned char green, unsigned char blue)
{
    return (RGBColor)red |
           ((RGBColor)green << 8) |
           ((RGBColor)blue << 16);
}

这个文件里面包含了头文件color.h以及rgb函数的实现代码,然后在L09_03_DISPLAY_BMP.cpp中引入\#include "color.h",并删除移动到color.h和color.cpp文件中的代码:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
/// L09_03_DISPLAY_BMP.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

#include "color.h"

// 位图文件头
struct BITMAP_HEADER
{
    unsigned int Size;        // 第1-4字节,无符号整型, BMP文件大小
    unsigned short Reserved1; // 第5-6字节,无符号短整型,保留区1
    unsigned short Reserved2; // 第7-8字节,无符号短整型,保留区2
    unsigned int OffBits;     // 第9-12字节,无符号整型, 像素偏移量
};

typedef struct BITMAP_HEADER BitmapHeader;

// 位图详细信息
struct BITMAP_INFORMATION
{
    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int InfoHeaderSize; // 信息头结构体长度,标准BMP为40
    int Width;                   // 图像宽度,像素
    int Height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short Planes;       // 色彩平面数,BMP固定等于1
    unsigned short BitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int Compression;    // 压缩方式;0=不压缩
    unsigned int ImageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int XPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int YPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int ClrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int ClrImportant;   // 重要颜色数量,一般为0
};
typedef struct BITMAP_INFORMATION bitmapInfomation;

// 24位像素数据
struct _24BIT_PIXEL
{
    unsigned char Blue;
    unsigned char Green;
    unsigned char Red;
};
typedef struct _24BIT_PIXEL _24BitPixel;

int main()
{
    FILE *bmpfile = fopen("D:/BC101/Resources/L09/640_480_TEST_CARD.bmp", "rb");
    if (bmpfile == NULL)
    {
        printf("打开BMP文件失败\n");
        return 1;
    }
    printf("打开BMP文件成功\n");
    // 获取标识信息
    char tag[2];
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(tag, 2, 1, bmpfile);
    if (ret_1 != 1)
    {
        printf("读取BMP标识失败,文件过短或损坏\n");
        fclose(bmpfile);
        return 2;
    }
    char first = tag[0];
    char second = tag[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M')
    {
        printf("打开的文件不是BMP文件格式\n");
        fclose(bmpfile);
        return 3;
    }
    printf("读取BMP文件标识成功\n");

    // 开始处理位图文件图信息
    BitmapHeader bmpHeader;

    size_t ret_2 = fread(&bmpHeader, sizeof(bmpHeader), 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP位图文件头异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", bmpHeader.Size);
    printf("像素偏移量: %u\n", bmpHeader.OffBits);

    // 开始处理位图详情信息
    bitmapInfomation bitInfo;
    size_t ret_3 = fread(&bitInfo, sizeof(bitInfo), 1, bmpfile);
    if (ret_3 != 1)
    {
        printf("读取位图详情信息失败\n");
        fclose(bmpfile);
        return 5;
    }

    printf("==== BITMAPINFOHEADER ====\n");
    printf("信息头大小: %u\n", bitInfo.InfoHeaderSize);
    printf("图像宽: %d\n", bitInfo.Width);
    printf("图像高: %d\n", bitInfo.Height);
    printf("色彩平面: %u\n", bitInfo.Planes);
    printf("位深: %u\n", bitInfo.BitCount);
    printf("压缩方式: %u (0=无压缩)\n", bitInfo.Compression);
    printf("像素数据总大小(含padding): %u\n", bitInfo.ImageSize);
    printf("X分辨率(每米像素): %u\n", bitInfo.XPelsPerMeter);
    printf("Y分辨率(每米像素): %u\n", bitInfo.YPelsPerMeter);
    printf("调色板颜色数量: %u\n", bitInfo.ClrUsed);
    printf("重要颜色数量: %u\n", bitInfo.ClrImportant);

    int bytes_per_pixel = bitInfo.BitCount / 8;           // 每个像素占多少字节,24位就是3字节
    int line_raw_bytes = bitInfo.Width * bytes_per_pixel; // 一行原始像素字节,不含padding填充
    int line_padded_bytes = (line_raw_bytes + 3) & (~3);  // 4字节对齐后的真实一行大小,包含padding
    printf("每行原始字节:%d, 对齐后实际行大小:%d\n", line_raw_bytes, line_padded_bytes);

    // 跳到像素数据真正起始位置,不要硬编码54
    fseek(bmpfile, bmpHeader.OffBits, SEEK_SET);
    printf("已经fseek跳到像素偏移:%u\n", bmpHeader.OffBits);

    printf("sizeof(BitmapHeader)=%zu\n", sizeof(bmpHeader));
    printf("sizeof(bitmapInformation)=%zu\n", sizeof(bitInfo));

    // 开始读取像素信息
    // _24BitPixel pixel;
    // size_t ret_4 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
    // if (ret_4 != 1)
    // {
    //     printf("读取位图第1个像素信息失败\n");
    //     fclose(bmpfile);
    //     return 5;
    // }
    // printf("第1个像素的颜色分量Red:%d\n", pixel.Red);
    // printf("第1个像素的颜色分量Green:%d\n", pixel.Green);
    // printf("第1个像素的颜色分量Blue:%d\n", pixel.Blue);

    // 初始化窗口
    initgraph(bitInfo.Width, bitInfo.Height);

    for (int y = 0; y <= bitInfo.Height - 1; y++)
    {
        for (int x = 0; x <= bitInfo.Width - 1; x++)
        {
            _24BitPixel pixel;
            size_t ret_5 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
            if (ret_5 != 1)
            {
                printf("读取位图像素信息失败\n");
                fclose(bmpfile);
                return 5;
            }
            putpixel(x, bitInfo.Height - 1 - y, rgb(pixel.Red, pixel.Green, pixel.Blue));
        }
    }

    _getch();
    closegraph();
    fclose(bmpfile);

    return 0;
}

运行代码,此时会提示以下异常:

1
2
D:\BC101\Examples\L09\L09_03_DISPLAY_BMP/L09_03_DISPLAY_BMP.cpp:159: undefined reference to `rgb(unsigned char, unsigned char, unsigned char)'      
collect2.exe: error: ld returned 1 exit status

问题的根源是color.cpp 没有参与编译链接,这是 VSCode + MinGW 多文件项目最经典的坑。

#include "color.h" 只是让编译器看到函数声明,但函数的实现代码在 color.cpp 里。如果你的 tasks.json 编译命令只编译了当前打开的 L09_03_DISPLAY_BMP.cpp 这一个文件,链接器就找不到 rgb 函数的实体,报 “未定义”。因此需要修改tasks.json配置:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build_easyx",
            "type": "process",
            "command": "D:\\ProgramFiles\\mingw-w64\\bin\\g++.exe",
            "args": [
                "-g",
                "L09_03_DISPLAY_BMP.cpp",
                "color.cpp",
                "-lEasyX",
                "-lgdi32",
                "-limm32",
                "-lole32",
                "-luuid",
                "-o",
                "D:\\BC101\\Examples\\Debug\\L09_03_DISPLAY_BMP.exe"
            ],
            "options": {
                "cwd": "D:\\BC101\\Examples\\L09\\L09_03_DISPLAY_BMP"
            },
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "problemMatcher": "$gcc"
        }
    ]
}

增加11行的"color.cpp",表示color.cpp也一起参与编译,再次运行代码,可以看到程序能正常编译运行,说明重新组织颜色类代码是正常的!

9.3.1.2 新增BMP处理类模块

我们可以将与BMP文件相关的结构体、数据类型和函数作为一个模块,分成bmp.h和bmp.cpp两个文件中。

创建bmp.h文件,直接将L09_03_DISPLAY_BMP.cpp中跟BMP文件相关的定义和声明移动过去:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
/// bmp.h
// BMP相关文件头

// 位图文件头
struct BITMAP_HEADER
{
    unsigned int Size;        // 第1-4字节,无符号整型, BMP文件大小
    unsigned short Reserved1; // 第5-6字节,无符号短整型,保留区1
    unsigned short Reserved2; // 第7-8字节,无符号短整型,保留区2
    unsigned int OffBits;     // 第9-12字节,无符号整型, 像素偏移量
};

typedef struct BITMAP_HEADER BitmapHeader;

// 位图详细信息
struct BITMAP_INFORMATION
{
    // ========== BITMAPINFOHEADER 信息头 ==========
    unsigned int InfoHeaderSize; // 信息头结构体长度,标准BMP为40
    int Width;                   // 图像宽度,像素
    int Height;                  // 图像高度,像素;>0像素行倒存,<0正向存储
    unsigned short Planes;       // 色彩平面数,BMP固定等于1
    unsigned short BitCount;     // 每个像素位深;24代表24位真彩色
    unsigned int Compression;    // 压缩方式;0=不压缩
    unsigned int ImageSize;      // 像素数据总字节(包含行padding填充,可为0)
    unsigned int XPelsPerMeter;  // 水平分辨率:每米多少像素
    unsigned int YPelsPerMeter;  // 垂直分辨率:每米多少像素
    unsigned int ClrUsed;        // 使用的调色板颜色数量,24位真彩色为0
    unsigned int ClrImportant;   // 重要颜色数量,一般为0
};
typedef struct BITMAP_INFORMATION bitmapInfomation;

// 24位像素数据
struct _24BIT_PIXEL
{
    unsigned char Blue;
    unsigned char Green;
    unsigned char Red;
};
typedef struct _24BIT_PIXEL _24BitPixel;

然后在L09_03_DISPLAY_BMP.cpp中引入bmp.h头文件,就变成了下面这样:

  1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
/// L09_03_DISPLAY_BMP.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

#include "color.h"
#include "bmp.h"

int main()
{
    FILE *bmpfile = fopen("D:/BC101/Resources/L09/640_480_TEST_CARD.bmp", "rb");
    if (bmpfile == NULL)
    {
        printf("打开BMP文件失败\n");
        return 1;
    }
    printf("打开BMP文件成功\n");
    // 获取标识信息
    char tag[2];
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(tag, 2, 1, bmpfile);
    if (ret_1 != 1)
    {
        printf("读取BMP标识失败,文件过短或损坏\n");
        fclose(bmpfile);
        return 2;
    }
    char first = tag[0];
    char second = tag[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M')
    {
        printf("打开的文件不是BMP文件格式\n");
        fclose(bmpfile);
        return 3;
    }
    printf("读取BMP文件标识成功\n");

    // 开始处理位图文件图信息
    BitmapHeader bmpHeader;

    size_t ret_2 = fread(&bmpHeader, sizeof(bmpHeader), 1, bmpfile);
    if (ret_2 != 1)
    {
        printf("读取BMP位图文件头异常\n");
        fclose(bmpfile);
        return 4;
    }
    printf("BMP文件大小: %u\n", bmpHeader.Size);
    printf("像素偏移量: %u\n", bmpHeader.OffBits);

    // 开始处理位图详情信息
    bitmapInfomation bitInfo;
    size_t ret_3 = fread(&bitInfo, sizeof(bitInfo), 1, bmpfile);
    if (ret_3 != 1)
    {
        printf("读取位图详情信息失败\n");
        fclose(bmpfile);
        return 5;
    }

    printf("==== BITMAPINFOHEADER ====\n");
    printf("信息头大小: %u\n", bitInfo.InfoHeaderSize);
    printf("图像宽: %d\n", bitInfo.Width);
    printf("图像高: %d\n", bitInfo.Height);
    printf("色彩平面: %u\n", bitInfo.Planes);
    printf("位深: %u\n", bitInfo.BitCount);
    printf("压缩方式: %u (0=无压缩)\n", bitInfo.Compression);
    printf("像素数据总大小(含padding): %u\n", bitInfo.ImageSize);
    printf("X分辨率(每米像素): %u\n", bitInfo.XPelsPerMeter);
    printf("Y分辨率(每米像素): %u\n", bitInfo.YPelsPerMeter);
    printf("调色板颜色数量: %u\n", bitInfo.ClrUsed);
    printf("重要颜色数量: %u\n", bitInfo.ClrImportant);

    int bytes_per_pixel = bitInfo.BitCount / 8;           // 每个像素占多少字节,24位就是3字节
    int line_raw_bytes = bitInfo.Width * bytes_per_pixel; // 一行原始像素字节,不含padding填充
    int line_padded_bytes = (line_raw_bytes + 3) & (~3);  // 4字节对齐后的真实一行大小,包含padding
    printf("每行原始字节:%d, 对齐后实际行大小:%d\n", line_raw_bytes, line_padded_bytes);

    // 跳到像素数据真正起始位置,不要硬编码54
    fseek(bmpfile, bmpHeader.OffBits, SEEK_SET);
    printf("已经fseek跳到像素偏移:%u\n", bmpHeader.OffBits);

    printf("sizeof(BitmapHeader)=%zu\n", sizeof(bmpHeader));
    printf("sizeof(bitmapInformation)=%zu\n", sizeof(bitInfo));

    // 开始读取像素信息
    // _24BitPixel pixel;
    // size_t ret_4 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
    // if (ret_4 != 1)
    // {
    //     printf("读取位图第1个像素信息失败\n");
    //     fclose(bmpfile);
    //     return 5;
    // }
    // printf("第1个像素的颜色分量Red:%d\n", pixel.Red);
    // printf("第1个像素的颜色分量Green:%d\n", pixel.Green);
    // printf("第1个像素的颜色分量Blue:%d\n", pixel.Blue);

    // 初始化窗口
    initgraph(bitInfo.Width, bitInfo.Height);

    for (int y = 0; y <= bitInfo.Height - 1; y++)
    {
        for (int x = 0; x <= bitInfo.Width - 1; x++)
        {
            _24BitPixel pixel;
            size_t ret_5 = fread(&pixel, sizeof(_24BitPixel), 1, bmpfile);
            if (ret_5 != 1)
            {
                printf("读取位图像素信息失败\n");
                fclose(bmpfile);
                return 5;
            }
            putpixel(x, bitInfo.Height - 1 - y, rgb(pixel.Red, pixel.Green, pixel.Blue));
        }
    }

    _getch();
    closegraph();
    fclose(bmpfile);

    return 0;
}

这个文件包括读取24位BMP文件的结构体声明和类型定义,未来还会在此文件中增加displayBMP函数声明,目前displayBMP函数虽尚未创建,但也应该创建一个空的bmp.cpp文件,然后在其中加入#include指令包含bmp.h文件:

1
2
3
/// bmp.cpp
// BMP文件相关实现
#include "bmp.h";

此时,重新编译代码,可以正常编译,说明bmp.h头文件起作用了!但还有大段的代码在main函数中,需要将其移动到bmp.cpp中,实现代码复用!

因此,计划增加函数displayBMP,并放到bmp.cpp文件中。

9.3.2 函数displayBMP的设计与实现

我们现在来设计函数displayBMP,用于在指定位置显示BMP图片,它的声明被加入bmp.h文件中,它的实现代码将被加入到bmp.cpp中。

9.3.2.1 displayBMP函数的设计

在设计displayBMP之前需要考虑如下问题:

  • 函数的功能是什么? 在指定位置显示24位真彩色图片。
  • 函数的名字是什么? displayBMP。
  • 函数需要传入哪些参数? BMP图片的完整路径、图片要显示的位置,如top像素和left像素。
  • 函数是否需要返回值?返回何种类型的值?
    • 需要返回值,因为显示图片不一定都会成功,根据不同的失败原因约定返回值如下表所示。
返回值意义
0显示图片成功
-1打开文件失败(文件不存在或权限不足)
-2内存分配失败(可能是文件过大)
-3打开的文件不是BMP文件

于是displayBMP函数的原型为:

1
2
// 显示bmp文件
int displayBMP(const char* filename, int top, int left);

然后就可以在bmp.cpp中加入这个函数的基础代码,函数的功能实现可以后面再处理。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
/// bmp.cpp
// BMP文件相关实现
#include "bmp.h"

// 显示bmp文件
int displayBMP(const char* filename, int top, int left)
{
    printf("你调用了displayBMP函数");
    return 0;
}

然后修改 L09_03_DISPLAY_BMP.cpp代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
/// L09_03_DISPLAY_BMP.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include <stdio.h>
#include <conio.h>
#include <graphics.h>

#include "color.h"
#include "bmp.h"

int main()
{
    displayBMP("D:/BC101/Resources/L09/640_480_TEST_CARD.bmp", 0, 0);
    return 0;
}

然后,此时也要改一下tasks.json,将bmp.cpp文件加入到编译中:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
{
    "version": "2.0.0",
    "tasks": [
        {
            "label": "build_easyx",
            "type": "process",
            "command": "D:\\ProgramFiles\\mingw-w64\\bin\\g++.exe",
            "args": [
                "-g",
                "L09_03_DISPLAY_BMP.cpp",
                "color.cpp",
                "bmp.cpp",
                "-lEasyX",
                "-lgdi32",
                "-limm32",
                "-lole32",
                "-luuid",
                "-o",
                "D:\\BC101\\Examples\\Debug\\L09_03_DISPLAY_BMP.exe"
            ],
            "options": {
                "cwd": "D:\\BC101\\Examples\\L09\\L09_03_DISPLAY_BMP"
            },
            "group": {
                "kind": "build",
                "isDefault": true
            },
            "problemMatcher": "$gcc"
        }
    ]
}

然后再运行程序:

Snipaste_2026-08-29_21-12-29.png

正常输出了调用了displayBMP函数,说明函数调用没有问题!

达成这个目标后,就可以专注bmp.cpp中displayBMP函数的实现了!

9.3.2.2 displayBMP函数的实现

displayBMP的原型是:

1
2
// 显示bmp文件
int displayBMP(const char* filename, int top, int left);

第1个参数const char* filename用于传入要显示的BMP文件名,它是字符串常量的指针,第2、3个参数表示位图显示的位置,此处的top和left表示图片的左上角在窗口中的坐标。

以上是调用的displayBMP函数的例子:

1
displayBMP("D:/BC101/Resources/L09/640_480_TEST_CARD.bmp", 0, 0);

1)一次性读入图片文件

分多次用fread函数读取同一个磁盘文件不是一个好习惯!因为磁盘文件位于外部存储设备,访问速度比内存慢很多。对于机构硬盘来说每次读取都需要运动磁头,而机械运行是需要耗费较长时间的。即使有文件缓冲区存在或者使用固态硬盘,多次读取的性能仍比一次读取全部内容要低。此外,如果一次性读入了文件的全部内容,接下来你就可以马上关闭文件避免对文件长时间占用。

但也有例外,如果文件的大小超过了计算机的物理内存,操作系统就不得不动用磁盘上的虚拟内存来存储读入的文件内容,这种情况下性能提升非常有限。好在一般的BMP图形文件相对于现在使用的计算机内存而言都非常小,所以可以通过displayBMP函数一次性能入图片文件的全部内容到内存中。

如何一次性读取整个图片文件呢?需要首先知道文件的大小,然后根据文件的大小分配内存,再将文件读入其中。

之前打开文件后,使用fileno和filelength函数获取文件的大小(字节数),这两个文件也可以用于图片文件。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// 显示bmp文件
int displayBMP(const char* filename, int top, int left) {
    printf("你调用了displayBMP函数");
    FILE* bmpfile = fopen(filename, "rb");
    if (bmpfile == NULL) {
        printf("打开BMP文件失败\n");
        return -1;
    }
    printf("打开BMP文件成功\n");
    // io.h:  filelength 获取文件长度
    long fileSize = filelength(fileno(bmpfile));
    printf("文件总大小 = %ld 字节\n", fileSize);
    // stdlib.h:  malloc 动态分配内存
    void* fileData = malloc(fileSize);
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(fileData, 1, fileSize, bmpfile);
    if (ret_1 != fileSize) {
        printf("读取BMP文件失败,文件过短或损坏\n");
        fclose(bmpfile);
        free(fileData);
        return -2;
    }
    fclose(bmpfile);
    // 以下省略
}

这段代码中,使用fopen打开BMP文件,然后使用filelength(fileno(bmpfile))获取文件的长度,确定文件的长度字节数后,就可以使用malloc(fileSize)来动态分配内存。

以前使用malloc分配内存,我们总是将函数返回的指针转换成某种特定类型的指标。而这次情况发生了变化,因为没有一种确定的数据类型对应于即将读入的文件内容,所以malloc函数返回的“无类型指针”无需进行转换。将其直接赋值给无类型的指针变量void* fileData,让这个指针指向所分配内存空间的起始处即可。

然后使用size_t ret_1 = fread(fileData, 1, fileSize, bmpfile);读取BMP文件的内容,此处与课本上面有差异,课本上面是size_t ret_1 = fread(fileData, fileSize, 1, bmpfile);是一次性读取fileSize个字节,而size_t ret_1 = fread(fileData, 1, fileSize, bmpfile);是一次读1个字节,共读取fileSize个字节,课本那样会存在一个问题, 如果文件只剩下一部分数据,不够 fileSize 个字节。 fread 不会返回读到的残缺字节,返回 0。 你永远不知道到底读了多少字节,残缺的数据不会拷贝进缓冲区。

读取完文件后,一定要使用 fclose(bmpfile);关闭文件!另外如果读取异常时,除了要关闭文件,也要使用free(fileData);释放刚才动态分配的内存!

2) 使用字符指针变量取出文件标识

数据已经读入到内存中并且已经知道这个内存区块的首地址(fileData),通过简单的计算就可以得出每一块数据的起始位置,例如位图文件标识就位于该内存区块的第1、2字节,由于文件标识是字符型数据,因此可以定义一个字符指针tags指向它们,将指针fileData的值直接赋值给指针tags就可以了:

1
const char* tags = (char*)fileData;

需要注意的是,因为指针fileData是无类型的指针,此处需要将其转换成字符指针,同时我们不会改变此处的内容,使用const char*类型的指针即可。

然后就可以使用以下代码确认文件标识:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
    // 上面的代码省略
    const char* tags = (char*)fileData;
    char first = tags[0];
    char second = tags[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M') {
        printf("打开的文件不是BMP文件格式\n");
        free(fileData);
        return -3;
    }
    printf("读取BMP文件标识成功\n");
   // 下面的代码省略

注意char first = tags[0];可以换成char first = *tags:

1
2
3
4
    // char first = tags[0];
    // char second = tags[1];
    char first = *tags;
    char second = *(tags+1);

转换后是等价的!

  • tags[0] tags[1],数组下标,可读性高,适合人阅读调试,日常写代码推荐你这种。
  • 指针写法 *tags *(tags+1):偏底层书上风格,代码更短,但肉眼容易看错偏移。

C 语言语法规则:a[i] 语法糖本质就是 *(a + i)。

  • tags[0] → *(tags + 0) → *tags
  • tags[1] → *(tags + 1)

日常业务、调试、自己写项目:优先下标 tags[0] tags[1] 。

3) 使用结构体指针取出位图文件头和位图详细信息

紧随其后的位图文件头、位图详细信息是使用结构体保存的。可以使用结构体指针指向它们在内存中的位置,但语句较复杂一些!

1
2
    // 文件头,跳过前2字节的BM标识
    BitmapHeader* bmpHeader = (BitmapHeader*)((char*)fileData + 2);

这里定义了一个指针bmpHeader,类型为BitmapHeader*,用于指向BitmapHeader结构体,它应该指向指针fileData之后的第3个字节,但指针fileData是“无类型指针”,它无法进行算术运行,如果像下面这样试图对fileData + 2:

1
    BitmapHeader* bmpHeader = (BitmapHeader*)(fileData + 2);

此时编译时提示了警告:

1
2
3
bmp.cpp: In function 'int displayBMP(const char*, int, int)':
bmp.cpp:43:56: warning: pointer of type 'void *' used in arithmetic [-Wpointer-arith]
     BitmapHeader* bmpHeader = (BitmapHeader*)(fileData + 2);

C/C++ 标准:void* 是无类型指针,不知道指向元素多大,不允许直接做加减偏移运算 fileData + 2。

修复方案:先把 fileData 转成字节指针(char*),做完偏移,再强转结构体指针。

即,先将fileData指针强制转换成字符型指针再进行运算,转换成字符型指针是因为字符型数据占用1个字节,之前我们提过“指针变量的值进行加、减运算时,加减的值并不等于算术值,而是会根据指针变量的类型进行加减,加减的算术值取决于所指向的数据类型的大小”,而对字符型指针进行算术运算时是以1字节为单位的,下面的表达式会计算出fileData指向的位置以后第3个字节的地址:

1
(char*)fileData + 2

然后再将运算后的结果进行强制类型转换,转换为指向BitmapHeader的结构体指针。

1
	 BitmapHeader* bmpHeader = (BitmapHeader*)((char*)fileData + 2);

这样一来,就可以读取位图文件头中的内容了。需要说明的是,当使用结构体指针访问结构体成员时,可以使用下面的方式之一:

1
2
3
    (*bmpHeader).Size;
    // 或者
    bmpHeader->Size;

位图详细信息也采用同样的方法获取,先偏移,再强转结构体指针:

1
2
    // 信息头:文件头占14字节,偏移14
    bitmapInfomation* bitInfo = (bitmapInfomation*)((char*)fileData + 2 + 12);

这样一来,结构体指针bmpHeader和bitInfo就分别指向了文件数据中位图文件头和位图详细信息所在的内存位置!

Snipaste_2026-09-06_22-17-07.png

4) 使用结构体指针取出像素颜色

对于24位BMP图片,从第55个字节开始就是像素数据,每3个字节描述1个像素产颜色。_24BitPixel结构体,对应着BMP文件的像素数据。我们仍然逐个绘制每个像素,因为需要定义一个结构体_24BitPixel的指针,让它指向文件中第1个像素数据的位置:

1
2
3
4
5
    // 像素数据区的起始内存地址:文件缓冲区首地址 + 像素偏移OffBits
    char* pixelStartAddr = (char*)fileData + bmpHeader->OffBits;
    // 像素游走指针,起点指向像素缓冲区最开头。
    // 放在循环外面!全程单向往后移动,读完一行、跳过填充字节再读下一行
    _24BitPixel* pixelData = (_24BitPixel*)pixelStartAddr;

使用文件起始位置的fileData加上bmpHeader->OffBits就可以简单地算出像素数据所在的地址,因为bmpHeader->OffBits存储着像素数据相对于文件头的偏移量。

5)编制每个像素

下面的代码将绘制图像文件的每个像素:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
    // BMP图像像素原点在左下角,所以y从图像最底部一行向上循环绘制
    for (int y = top + bitInfo->Height - 1; y >= top; y--) {
        // x循环:绘制当前一行里面,从左到右所有像素点
        for (int x = left; x <= left + bitInfo->Width - 1; x++) {
            // EasyX绘制像素点
            putpixel(x, y, rgb(pixelData->Red, pixelData->Green, pixelData->Blue));
            // 像素指针向后移动,指向下一个像素
            pixelData++;
        }
        // ======================两层for循环之间处理padding======================
        // 读完一行所有像素,跳过本行末尾多余的填充字节,指针跳到下一行像素起点
        if (padding != 0) {
            pixelData = (_24BitPixel*)((char*)pixelData + padding);
        }
    }

由于BMP在每行数据后面有可能存在padding。 BMP 格式规定:每行像素数据的字节长度必须是 4 的倍数。如果实际一行像素字节数不是 4 的倍数,就在行尾补 0 凑齐,这些补齐的字节就是 padding。 核心原因:4 字节对齐,提高内存访问效率 。

BMP 格式设计于 1980 年代,当时的 CPU(8086/80386)从内存读取数据时,如果数据起始地址是 4 的倍数,读取速度最快。如果不对齐,CPU 可能需要分两次读取一个像素的数据,性能下降。

虽然现代 CPU 已经不强制要求对齐,但 BMP 格式保留了这个历史规则,所有 BMP 文件都遵循 4 字节对齐。

举例说明

24 位 BMP,每行 3 个字节 / 像素:

宽度一行实际字节是否 4 的倍数需要补 padding
640640×3 = 19201920÷4=480,整除0 字节
641641×3 = 19231923÷4 余 3补 1 字节
642642×3 = 19261926÷4 余 2补 2 字节
643643×3 = 19291929÷4 余 1补 3 字节

padding的计算公式:

1
2
3
4
5
6
7
   // 一行纯像素占用字节数,24位图像一个像素占3字节(B/G/R)
    int rowBytes = bitInfo->Width * 3;
    printf("一行像素 %d 字节\n", rowBytes);
    // BMP强制每行总字节必须是4的整数倍,padding=行尾补齐的多余填充字节
    // (4‑余数)%4 解决刚好整除4时padding等于0
    int padding = (4 - (rowBytes % 4)) % 4;
    printf("padding %d \n", padding);

由于存在padding,因此在编制像素内循环里面使用了以下判断:

1
2
3
4
        // 读完一行所有像素,跳过本行末尾多余的填充字节,指针跳到下一行像素起点
        if (padding != 0) {
            pixelData = (_24BitPixel*)((char*)pixelData + padding);
        }

最终bmp.cpp的完整代码:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
/// bmp.cpp
// BMP文件相关实现

#include "bmp.h"
#include "color.h"

// 显示bmp文件
int displayBMP(const char* filename, int top, int left) {
    printf("你调用了displayBMP函数");
    FILE* bmpfile = fopen(filename, "rb");
    if (bmpfile == NULL) {
        printf("打开BMP文件失败\n");
        return -1;
    }
    printf("打开BMP文件成功\n");
    // io.h:  filelength 获取文件长度
    long fileSize = filelength(fileno(bmpfile));
    printf("文件总大小 = %ld 字节\n", fileSize);
    // stdlib.h:  malloc 动态分配内存
    void* fileData = malloc(fileSize);
    if (fileData == NULL) {
        printf("文件太大,内存分区异常\n");
        return -2;
    }
    // fread(缓冲区,每个元素大小,元素数量,文件)
    size_t ret_1 = fread(fileData, 1, fileSize, bmpfile);
    if (ret_1 != fileSize) {
        printf("读取BMP文件失败,文件过短或损坏\n");
        fclose(bmpfile);
        free(fileData);
        return -3;
    }
    fclose(bmpfile);

    const char* tags = (char*)fileData;
    char first = tags[0];
    char second = tags[1];
    printf("%c%c\n", first, second);
    if (first != 'B' || second != 'M') {
        printf("打开的文件不是BMP文件格式\n");
        free(fileData);
        return -4;
    }
    printf("读取BMP文件标识成功\n");
    // 文件头,跳过前2字节的BM标识
    BitmapHeader* bmpHeader = (BitmapHeader*)((char*)fileData + 2);
    // 信息头:文件头占14字节,偏移14
    bitmapInfomation* bitInfo = (bitmapInfomation*)((char*)fileData + 2 + 12);
    // ============ 下面这4行写在循环外面的原因:整张图只需要计算一次 ============
    // 一行纯像素占用字节数,24位图像一个像素占3字节(B/G/R)
    int rowBytes = bitInfo->Width * 3;
    printf("一行像素 %d 字节\n", rowBytes);
    // BMP强制每行总字节必须是4的整数倍,padding=行尾补齐的多余填充字节
    // (4‑余数)%4 解决刚好整除4时padding等于0
    int padding = (4 - (rowBytes % 4)) % 4;
    printf("padding %d \n", padding);
    printf("像素区大小 %d \n", bitInfo->ImageSize);
    // 像素数据区的起始内存地址:文件缓冲区首地址 + 像素偏移OffBits
    char* pixelStartAddr = (char*)fileData + bmpHeader->OffBits;
    // 像素游走指针,起点指向像素缓冲区最开头。
    // 放在循环外面!全程单向往后移动,读完一行、跳过填充字节再读下一行
    _24BitPixel* pixelData = (_24BitPixel*)pixelStartAddr;

    // BMP图像像素原点在左下角,所以y从图像最底部一行向上循环绘制
    for (int y = top + bitInfo->Height - 1; y >= top; y--) {
        // x循环:绘制当前一行里面,从左到右所有像素点
        for (int x = left; x <= left + bitInfo->Width - 1; x++) {
            // EasyX绘制像素点
            putpixel(x, y, rgb(pixelData->Red, pixelData->Green, pixelData->Blue));
            // 像素指针向后移动,指向下一个像素
            pixelData++;
        }
        // ======================两层for循环之间处理padding======================
        // 读完一行所有像素,跳过本行末尾多余的填充字节,指针跳到下一行像素起点
        if (padding != 0) {
            pixelData = (_24BitPixel*)((char*)pixelData + padding);
        }
    }
    // 释放之前malloc开辟的内存,防止内存泄漏
    free(fileData);
    return 0;
}

主函数main.cpp代码如下:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
/// L09_03_DISPLAY_BMP.cpp
#ifdef _MSC_VER
// VS 环境生效
#define _CRT_SECURE_NO_WARNINGS
#pragma warning(disable : 6031)
#pragma comment(lib, "EasyXw.lib")
#endif

#include "bmp.h"
#include <conio.h>

int main() {

    // 初始化窗口
    initgraph(640, 480);

    // displayBMP("D:/BC101/Resources/L09/640_480_TEST_CARD.bmp", 0, 0);
    // 641的会出现绘制越界问题
    // displayBMP("D:/BC101/Resources/L09/641_480_TEST_CARD.bmp", 0, 0);
    int result = displayBMP("D:/BC101/Resources/L09/639_480_TEST_CARD.bmp", 0, 0);
    switch (result) {
    case 0:
        _getch();     // 暂停
        closegraph(); // 关闭图像显示
        printf("图片显示成功\n");
        break;
    case -1:
        printf("打开BMP文件失败(文件不存在或权限不足)\n");
        break;
    case -2:
        printf("文件太大,内存分区异常\n");
        break;
    case -3:
        printf("读取BMP文件失败,文件过短或损坏\n");
        break;
    case -4:
        printf("打开的文件不是BMP文件格式\n");
        break;
    }

    return 0;
}

运行调试输出如下图所示:

Snipaste_2026-09-18_21-54-37.png

Licensed under the GNU General Public License v3.0
最后更新于 2026年11月15日 19:21