windows SDK chapter 4 设备无关代码

绘制和重绘

为什么需要重绘?

在控制台编程时,输出均以纯文本打印到终端,终端会永远保存输出,自然不需要重绘

但是窗口编程的时候,一个窗口可能被移动到屏幕边界之外或者被其他窗口遮盖,此时这个窗口上的文字就消失了,

系统不会一直记着(操作系统有可能临时记住)窗口上画过什么,在哪里画的.当用户再次将这个窗口置于顶层的时候,操作系统就要求程序,将刚才抹去的文字重新打印.这个过程当然也是在消息循环中处理的.

操作系统怎么发出重绘的要求呢?

使用WM_PAINT消息

WM_PAINT

操作系统什么时候会发出这个WM_PAINT要求呢?

用户移动窗口,导致原来被遮盖的部分暴露,或者关闭了覆盖该窗口的对话框

用户调整窗口大小

滚动条滚动

程序自己显式调用InvalidateRect或者InvalidateRgn,生成WM_PAINT消息

下拉菜单后收回

只要是程序需要更新客户区的时候,应该自动或者强制发出WM_PAINT消息,绕一个弯集中从事件函数中处理

操作系统不能记住被覆盖的部分吗?

少数情况下可以,比如鼠标指针造成的小面积覆盖或者在客户区内拖动图表

有效矩形和无效矩形

需要重新绘制的部分成为无效矩形

什么部分需要重新绘制?先前被遮盖现在需要至于顶层的窗口部分,或者先前移出屏幕现在移入屏幕的部分

windows操作系统会为每个打开的窗口维护一个数据结构,该数据结构用来记录该窗口的最小无效区域范围,如果在该窗口重绘之前,在其上又有新的无效矩形则windows取所有无效区域的最小覆盖.如果原来该窗口进程的消息队列中没有有WM_PAINT消息,则发送一条该消息.如果已经有过WM_PAINT则只需要更新操作系统维护的数据结构

什么数据结构?目前未知,需要学习核心编程后获得原理

立刻重绘

各种WM消息是有优先级之分的

WM_PAINT重绘消息的优先级就比较低,WM_VSCROLL垂直滚动条消息就比较高

即使消息队列中已经存在了WM_PAINT消息,后来加入一个WM_VSCROLL消息,这个WM_VSCROLL消息也会先被处理.如此优先队列有个好处是,WM_PAINT消息只会存在一条,多次改变之后重绘和每次改变后的重绘,对于人类来说几乎观察不出来,因此WM_PAINT不需要太多

这就有可能导致,程序一直在忙活高优先级的消息处理,WM_PAINT这个消息一直不处理,比如一个有上亿行的数据库,不停拖动滚动条改变垂直视角的时候程序可能一直忙于处理WM_VSCROLL.那么我们看到的窗口就会迟滞.

但是有那种关系户性质的WM_PAINT消息,它不用排队等待被处理,而是被操作系统亲自安排给程序"给我立刻处理WM_PAINT"

调用UpdateWindow(hwnd)函数即可做到这一点

如果调用UpdateWindow函数时,整个客户区都是有效的,那么调用了一个寂寞

否则,即客户区存在无效矩形,UpdateWindow让窗口立刻收到WM_PAINT,由windows操作系统调用窗口过程WndProc函数

当WM_PAINT处理完后,UpdateWindow将控制还给调用者

这就解释了为啥在主函数创建窗口实例,ShowWindow之后,进入消息循环之前,有一次UpdateWindow

1
2

ShowWindow(hwnd, iCmdShow);
UpdateWindow(hwnd);

即使这里不写UpdateWindow(hwnd),通常也能立刻显式窗口.但是就怕WM_PAINT一直排队的情况

GDI

graphics device interface,图形设备接口,负责系统与绘图程序的信息交换

图形设备,如打印机,屏幕

GDI负责封装硬件设备,并且向上层提供接口,在代码层面如果需要和图形设备交互,只需要调用接口.

类似于系统调用接口,GDI也允许程序直接访问物理硬件,只能通过"设备环境"抽象接口访问硬件

举一个GDI的例子

1 2	WINGDIAPI WINBOOL WINAPI TextOutA(HDC hdc,int x,int y,LPCSTR lpString,int c); WINGDIAPI WINBOOL WINAPI TextOutW(HDC hdc,int x,int y,LPCWSTR lpString,int c);

TextOut函数的作用是向窗口客户区输出一个字符串,

参数	意义
hdc	设备环境句柄,几乎所有的GDI函数都以hdc作为第一个参数
x	开始绘制的客户区相对横坐标
y	--纵坐标
lpString	需要输出到客户区的字符串
c	lpString的长度

设备环境

设备环境DC是内核维护的数据结构

一个设备环境与一个特定你的显式设备相关联

设备环境的属性包括文本颜色,文本背景色,字体等等

GDI函数可以根据相对于设备环境分成两类,一类是使用HDC真正绘图的函数,另一类是修改HDC的函数

如果以在纸上画画类比的话,

设备环境就相当于图纸,画笔,图纸下面的桌子,灯光,以及谁来画(决定字体)

真正输出的内容相当于这个特定的人主观画出的东西

设备环境是一个大结构体,怎么引用他呢?使用指针?不是,使用HDC类型的句柄.

实际上这个句柄也是一个整数,可能是内核维护的设备环境表的下标,反正一个设备环境对应唯一的一个编号,作为句柄索引该设备环境

获取设备环境句柄

BeginPaint/EndPaint

这一对只应用于处理WM_PAINT消息

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

  PAINTSTRUCT ps;
  RECT rect;
  HDC hdc;
  static TCHAR szBuffer[128] = TEXT("default");
  switch (message)
  {
...
  case WM_PAINT:
      hdc = BeginPaint(hwnd, &ps);//获取设备环境hdc,并且第二个参数ps中也有相同的hdc
      GetClientRect(hwnd, &rect);//获取当前客户区矩形范围,通过第二个参数返回
      DrawText(hdc, szBuffer, -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
          //使用hdc设备环境,向rect矩形范围内绘制一个单行上下左右都居中的字符串"default"
      EndPaint(hwnd, &ps);//释放ps中保存的hdc(也就是BeginPaint创建的hdc)
      return 0;
      ...
  }

1
2
3
4
5
6
7
8
9

HDC BeginPaint(
  [in]  HWND          hWnd,		//窗口实例句柄
  [out] LPPAINTSTRUCT lpPaint	//
);

BOOL EndPaint(
  [in] HWND              hWnd,
  [in] const LPPAINTSTRUCT lpPaint
);

两个函数的第一个参数均为HWND窗口句柄

hwnd是啥?

1 2 3 4 5 6 7 8 9 10 11 12 13

hwnd = CreateWindow(classType1, TEXT("first class first instance"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL); ShowWindow(hwnd, iCmdShow);

窗口实例的句柄

第二个参数均为LPPAINTSTRUCT类型

struct PAINTSTRUCT

1 2 3 4 5 6 7 8

typedef struct tagPAINTSTRUCT { HDC hdc; //设备环境句柄 WINBOOL fErase; //表明背景是否应该被擦除,0为是 RECT rcPaint; //指明需要绘制的矩形区域 WINBOOL fRestore; //尚未使用,保留 WINBOOL fIncUpdate; //尚未使用 BYTE rgbReserved[32]; //尚未使用 } PAINTSTRUCT,*PPAINTSTRUCT,*NPPAINTSTRUCT,*LPPAINTSTRUCT;

第一个成员就是hdc,这和BeginPaint返回的hdc是同一个值,实际上相当于BeginPaint以通过引用返回了一个包含ps的结构体,然后又单独通过返回值返回了hdc句柄.多此一举,只是为了用起来方便

第二个成员表明Windows在返回该结构体的BeginPaint中,是否擦除了无效区域背景,如果擦除了则fErase=0.默认情况下是会自动擦除的.自定以擦除过程可以处理WM_ERASEBKGND消息

注册窗口类WNDCLASS时指定了一个画刷wndclass.hbrBackground=(HBRUSH)GetStockObject(WHITE_BRUSH),windows将会使用这里指定的画刷擦除无效背景

第三个参数rcPaint定义了无效矩形边界,以像素为单位,相对于客户区左上角的距离

该矩形区域就是需要重绘的区域,也就是调用BeginPaint之后重绘的区域

BeginPaint如果调用成功则返回HDC句

EndPaint释放一个HDC句柄,调用成功则返回TRUE

绘图GDI函数的调用要夹在两个函数之间

如果只写这两个函数

1
2
3

  	PAINTSTRUCT ps;        
hdc = BeginPaint(hwnd, &ps);//获取设备环境hdc,并且第二个参数ps中也有相同的hdc
      EndPaint(hwnd, &ps);//释放ps中保存的hdc(也就是BeginPaint创建的hdc)

BeginPaint只会重绘无效矩形部分,也就是第二个参数ps中rcPaint指定的矩形

考虑到客户区有可能是一个圆形或者其他非矩形形状,一般不管三七二十一将整个客户区重绘一遍.

这就需要先调用InvalidateRect使得整个客户区失效,然后再调用BeingPaint重绘

1 2 3 4 5

BOOL InvalidateRect( [in] HWND hWnd, [in] const RECT *lpRect, [in] BOOL bErase );

第一个参数是窗口句柄

第二个参数是需要无效化的矩形范围,如果是NULL则表示整个客户区

第三个参数决定BeginPaint是否擦除原背景,当bErase=TRUE则擦除原有背景.否则不擦除

GetDC/ReleaseDC

处理非WM_PAINT消息时,如果需要绘制客户区,就要调用这一对.

或者只是需要设备环境信息,不需要绘图时,可以调用这一对.

1
2
3
4
5
6
7
8

HDC GetDC(
  [in] HWND hWnd		//窗口实例句柄
);

int ReleaseDC(
  [in] HWND hWnd,		
  [in] HDC  hDC		//需要释放的hDC句柄,一定是最近的GetDC获取的那个句柄,两个函数配套使用
);

两个函数的使用一定是在处理同一条消息时配对完成的

GetDC返回的设备句柄可以在整个客户区绘制,但是BeginPaint只允许在失效矩形绘制

GetDC不会将无效矩形有效化.如有需要,显式调用ValidateRect(hwnd,rect),当rect为NULL则表示整个客户区

GetWindowDC/ReleaseWindowDC

GetDC绘制的只有客户区,对于窗口标题栏这种非客户区无能为力

GetWindowDC则可以绘制包括客户区,非客户区在内该窗口的所有区域

相应的消息是WM_NCPAINT

GDI绘制函数

TEXTOUT

1
2
3
4
5
6
7

BOOL TextOutA(
  [in] HDC    hdc,//GetDC或者BeginPaint返回的hdc句柄
  [in] int    x,//输出在客户区的起始水平位置
  [in] int    y,
  [in] LPCSTR lpString,//需要输出的字符串
  [in] int    c//输出字符串长度
);

关于x,y坐标

GetTextMatrics获取字体尺寸

系统字体取决于分辨率和字号大小,不能假设字体大小,而是调用函数获取信息,编写设备无关代码

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

  typedef struct tagTEXTMETRICA {
    LONG tmHeight;//字体总高度
    LONG tmAscent;//字体基线以上高度
    LONG tmDescent;//字体基线以下高度
    LONG tmInternalLeading;//字体重音符号高度
    LONG tmExternalLeading;//行间距
    LONG tmAveCharWidth;//消息字符加权宽度
    LONG tmMaxCharWidth;//最宽字符宽度
    LONG tmWeight;//字体粗细
    LONG tmOverhang;//为字符串加粗或者斜体额外宽度
    LONG tmDigitizedAspectX;
    LONG tmDigitizedAspectY;
    BYTE tmFirstChar;该字体第一个字符的编号
    BYTE tmLastChar;
    BYTE tmDefaultChar;
    BYTE tmBreakChar;
    BYTE tmItalic;
    BYTE tmUnderlined;
    BYTE tmStruckOut;
    BYTE tmPitchAndFamily;//决定字体是否是等宽字体,最低位为1则变宽,为0则等宽
    BYTE tmCharSet;
  } TEXTMETRICA,*PTEXTMETRICA,*NPTEXTMETRICA,*LPTEXTMETRICA;

BOOL GetTextMetricsW(
  [in]  HDC           hdc,
  [out] LPTEXTMETRICW lptm
);

GetTextMetricsW第一个参数是一个hdc设备环境句柄,该函数就是返回该hdc设备环境中的字体属性

第二个参数是一个TEXTMETRICA类型的引用,用来承载返回值

该结构体类型有20个成员,成员意义:

文本格式化

GetTextMetrics应该什么时候调用呢?

windows运行时,系统字体不会改变,因此GetTextMetircs只需要调用一次,保存下字体属性,一劳永逸

那么啥时候办这个"一劳"呢?在处理WM_CREATE消息时.

为啥在这个时候?WM_CREATE一定是窗口收到的第一条消息,此时窗口还没有输出到桌面,文字都还没打印.机不可失

1 2 3 4 5 6 7 8 9 10 11

hwnd = CreateWindow(classType1, TEXT("first class first instance"), WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, NULL, NULL, hInstance, NULL);

在创建窗口实例时就会发送WM_CREATE消息

举个例子,假如要打印多行字符,需要设置好字间距和行间距

字间距好说,就是tmAveCharWidth

行间距(这里的行间距指的是上一行字体的顶和下一行字体的顶的距离,包括纯空白的高度)麻烦点,需要tmHeight+tmExternalLeading

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

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{

    HDC hdc;//设备环境句柄
    PAINTSTRUCT ps;
    RECT rect;
    TEXTMETRICA tm;//字体属性结构
    static int cxChar,cyChar;
    static TCHAR szBuffer[128] = TEXT("default");
    switch (message)
    {
    case WM_CREATE:
        
        hdc=GetDC(hwnd);
        GetTextMetrics(hdc,&tm);//获取当前系统字体属性,用tm承载
        cxChar=tm.tmAveCharWidth;//cxChar为平均小写字母宽度
        cyChar=tm.tmHeight+tm.tmExternalLeading;//cyChar为字体高度加上一个行间距
        ReleaseDC(hwnd,hdc);
        return 0;
	case ...
    return DefWindowProc(hwnd, message, wParam, lParam);
    }
}

wsprintf格式化字符串

不管是TextOut还是DrawText,决定往屏幕输出的参数都是字符串类型,不能是结构体或者整数或者浮点数

想要类似使用cout<<5这种直接打印整数到窗口是不可能的

那么怎么打印整数呢?用wsprintf先把要打印的所有东西,格式化到一个字符中,然后输出这个字符串

比如统计鼠标左键在客户区按下的次数

1
2
3
4
5
6
7
8
9
10

case WM_LBUTTONDOWN:
    static int cLBUTTONDOWN;//铁打的静态变量只会定义一次
    ++cLBUTTONDOWN;
    TCHAR szBuffer[100];//流水的局部变量
    wsprintf(szBuffer,TEXT("this is the %d time you click the left button"),cLBUTTONDOWN);//格式化字符串到szBuffer
    hdc = GetDC(hwnd);
    GetClientRect(hwnd, &rect);
    DrawText(hdc, szBuffer, -1, &rect, DT_SINGLELINE | DT_CENTER | DT_VCENTER);
    ReleaseDC(hwnd, hdc);
    return 0;

每次按下鼠标左键都会更新cLBUTTONDOWN这个统计数字

显式多行

windows32编程上给出的例子是打印SystemMetrics所有的系统参数

效果如图

已经有一个窗口程序的雏形了

使用GetSystemMetrics获取系统参数

1
2
3

int GetSystemMetrics(
  [in] int nIndex
);

该函数使用一个下标作为参数,意思是查询SystemMetrics表的第nIndex个元素

这个表啥样呢?

Value	Meaning
SM_ARRANGE56	The flags that specify how the system arranged minimized windows. For more information, see the Remarks section in this topic.
SM_CLEANBOOT67	The value that specifies how the system is started:0 Normal boot1 Fail-safe boot2 Fail-safe with network bootA fail-safe boot (also called SafeBoot, Safe Mode, or Clean Boot) bypasses the user startup files.
SM_CMONITORS80	The number of display monitors on a desktop. For more information, see the Remarks section in this topic.
....	...

Value为枚举类型的下标,从0开始编号,微软给出的文档并没有按照Value递增的顺序,而是按照枚举值字符串的字典序递增排列的SM_ARRANGE<SM_CLEANBOOT

为了方便观察,书上先建立了一个头文件sysmets.h,里面只有一个结构体数组struct sysmetrics[],每个结构体数组有三项,下标,枚举值字符串,意义.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

struct
{
	int Index;
	const TCHAR* szLabel;//此处需要用const修饰字符串常量,否则在virsual studio上会报告指针指向常量的错误
	const TCHAR* szDesc;
}sysmetrics[] =
{
 	SM_CXSCREEN, //初始化本结构体数组第一个元素的第一个成员
    TEXT("SM_CXSCREEN"),//sysmetrics[0].szLabel=TEXT("SM_CXSCREEN");
 	TEXT("Screen width in pixels"),//初始化本结构体数组第一个元素的第三个成员szDesc
    
SM_CYSCREEN, TEXT("SM_CYSCREEN"),
 TEXT("Screen height in pixels"),
    
    ...
}

GetSystemMetrics(Index)将会和systemtrics[Index]配套使用

然后主程序包含该头文件,相当于直接在主程序中定义了这么一个结构体数组

这个数组还有GetSystemMetrics函数在啥时候发挥的作用呢?

在WndProc消息处理函数中,下面炎鸠以下这个回调函数干了啥

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

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	static int cxChar, cxCaps, cyChar;//静态的小写,大写字体宽度,行间距
	HDC hdc;//设备环境句柄
	int i;//遍历sysmetrics数组时使用的循环变量i
	PAINTSTRUCT ps;//
	TCHAR szBuffer[10];//缓冲区,用于整合一行需要打印的字符
	TEXTMETRIC tm;//字体属性结构体,用于承载GetTextMetrics返回值
	switch (message)
	{
	case WM_CREATE:
		hdc = GetDC(hwnd);
		GetTextMetrics(hdc, &tm);//tm获取当前字体属性
		cxChar = tm.tmAveCharWidth;//获取小写字体宽度
		cxCaps = (tm.tmPitchAndFamily & 1 ? 3 : 2) * cxChar / 2;
            //获取大写字体宽度,变宽字体中,该值应该为小写字体宽度的1.5倍,等宽字体中大小写字母的宽度应该一样
            //由于的最低为是等宽变宽标志,因此与1按位与之后的结果,
            //如果为1说明字体变宽,cxCaps先等于三倍的cxChar然后除以2就是1.5倍的小写字母宽度
		cyChar = tm.tmHeight + tm.tmExternalLeading;//行间距,上一行字的本行字顶的距离
		ReleaseDC(hwnd, hdc);//释放设备环境
		return 0;
	case WM_PAINT:
		hdc = BeginPaint(hwnd, &ps);//重绘无效区,获得设备环境句柄
		for (i = 0; i < NUMLINES; i++)//SystemMetrics有NUMLINES项,因此下标遍历0到NUMLINES
		{
            //每行打印三项,枚举类型字符串,意义,参数值
			TextOut(hdc, 0, cyChar * i,//第二个参数中cyChar就起了作用,规定在哪里开始绘制,因为前面i行都已经绘制完毕,因此本行应该在第i+1行位置绘制
				sysmetrics[i].szLabel,
				lstrlen(sysmetrics[i].szLabel));
			TextOut(hdc, 22 * cxCaps, cyChar * i,//x坐标也有意义了,因为szLabel已经占用了从x=0开始的一些字节,因此szDesc从x=22开始绘制
				sysmetrics[i].szDesc,
				lstrlen(sysmetrics[i].szDesc));
			SetTextAlign(hdc, TA_RIGHT | TA_TOP);//设置文本右上角对齐,作用于hdc指向的设备环境
			TextOut(hdc, 22 * cxCaps + 40 * cxChar, cyChar * i, szBuffer,
				wsprintf(szBuffer, TEXT("%5d"),
                       
					GetSystemMetrics(sysmetrics[i].Index)));//此处压行了,szBuffer的构造放在了最后一个参数的求值中
			SetTextAlign(hdc, TA_LEFT | TA_TOP);//设置回左对齐,好借好还,再借不难
		}
		EndPaint(hwnd, &ps);//结束绘制,释放ps中的hdc设备环境
		return 0;
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}

打印不开问题

由于心胸狭隘

如果电脑屏幕比较小,那么可以显式的行数就少,可能一个屏幕没法全部打印出来.甚至屏幕窄了一行都显式不全,比如:

这是因为本程序没有考虑客户区的大小,它只管打印它的,不管人能不能看见

怎么获取客户区的大小呢?

GetClientRect

1
2
3
4

BOOL GetClientRect(
  [in]  HWND   hWnd,
  [out] LPRECT lpRect
);

第一个参数是设备环境句柄

第二个参数是返回值,用一个RECT结构体引用承载当前客户区信息

这个结构体啥样呢?

1
2
3
4
5
6

typedef struct tagRECT {
  LONG left;
  LONG top;
  LONG right;
  LONG bottom;
} RECT, *PRECT, *NPRECT, *LPRECT;

GetClientRect返回的矩形中,左和上坐标都是0,即以客户区的左上角为基准

右和下坐标是实际大小(像素)

处理WM_SIZE消息

更好的方法是处理WM_SIZE消息

每当窗口大小发生变化(位置变化不算),Windows就会向窗口过程发送一条WM_SIZE消息,此时传递给WndProc处理函数的lParam参数就有实际意义了,高16位是新的窗口高度,低16位是新的窗口宽度,可以使用两个静态变量来承载保存这个两个值,静态的好处是只会定义一次,那么在本次处理WM_SIZE消息时修改这两个值,就可以在处理下一条消息比如WM_PAINT时使用刚才保存的值

1
2
3
4
5
6
7
8
9
10
11
12

WndProc(...):
static int cxClient, cyClient;
...
switch (message) {
case ...
case WM_SIZE:
	cxClient = LOWORD(lParam);
	cyClient = HIWORD(lParam);

	return 0;
   case ...
   }

其中LOWORD和HIWORD是定义在WINDEF.H中的两个宏

1 2 3 4

#define LOWORD(l) ((WORD)(((DWORD_PTR)(l)) & 0xffff)) #define HIWORD(l) ((WORD)((((DWORD_PTR)(l)) >> 16) & 0xffff)) #define LOBYTE(w) ((BYTE)(((DWORD_PTR)(w)) & 0xff)) #define HIBYTE(w) ((BYTE)((((DWORD_PTR)(w)) >> 8) & 0xff))

LOWORD(l)就是不管l啥类型,对l取双字然后和0xFFFF全一的字按位与,即保留低字

在处理WM_SIZE消息时只负责计算出新的客户区宽高,重绘它是一点儿也不用管,因为一般WM_SIZE消息之后会有一个WM_PAINT消息接踵而至,重绘的工作在WM_PAINT中完成

这样看一切都合理了,处理WM_SIZE相当于为处理WM_PAINT预处理,计算客户区大小

但是窗口第一次显式出来的时候呢?WM_SIZE不是说得在窗口大小发生变化时才会收到吗?

事实上WM_CREATE之后不会立刻传递WM_PAINT进行绘制,而是会先传递WM_SIZE,可以理解为窗口从无到有也包含了客户区的尺寸变化

这样改进之后的WM_PAINT处理过程:

1
2
3
4
5
6
7
8
9

MAXLINES = cyClient / cyChar;
for (i = 0; i < min(NUMLINES,MAXLINES); ++i) {
	TextOut(hdc, 10, i * cyChar, sysmetrics[i].szLabel,lstrlen(sysmetrics[i].szLabel));
	TextOut(hdc, 40 * cxCaps, i * cyChar, sysmetrics[i].szDesc, lstrlen(sysmetrics[i].szDesc));
	wsprintf(szBuffer, TEXT("%5d"), GetSystemMetrics(sysmetrics[i].Index));
	SetTextAlign(hdc, TA_LEFT);
	TextOut(hdc, 80 * cxCaps, i * cyChar, szBuffer, lstrlen(szBuffer));
	SetTextAlign(hdc, TA_LEFT);
}	

首先MAXLINES计算得到当前客户区最大能够容纳的完整行数,然后下面打印的时候取现有行数和能够打印的最大完整行数最小值.

这样就不会在客户区最底下打印出短斤少两的半行了

但是这样没有解决不能显式完全的问题,甚至说只能解决边界上的显式好不好看问题,真是吹毛求疵

要用有限的屏幕空间浏览长于一个屏幕的信息,最好的方法就是添加一个滚动条,拖到下面看下面,拖到上面看上面,

比如任务管理器的滚动条

滚动条

滚动条的效果就类似拿着放大镜看一个巨大的报纸,但是放大镜固定不动,动的是报纸

下滑滚动条就是报纸往彼方移动,相当于放大镜往己方移动

与其说是放大镜,不如说是一张扣了个方框的不透明纸压在报纸上,透过这个方框看报纸

添加滚动条

滚动条属于窗口实例的风格,只需要在实例化窗口对象的时候往窗口对象风格标识符上按位与上滚动条特性WS_VSCROLL|WS_HSCROLL垂直滚动条|水平滚动条

比如:

1
2
3
4
5

hwnd = CreateWindow(szAppName, TEXT("Get System Metrics No. 1"),
	WS_OVERLAPPEDWINDOW| WS_VSCROLL | WS_HSCROLL,//此处加入滚动条属性
	CW_USEDEFAULT, CW_USEDEFAULT,
	CW_USEDEFAULT, CW_USEDEFAULT,
	NULL, NULL, hInstance, NULL);

之后的效果如图:

确实窗口右侧和下方都出现了滚动条

但是这时候拖动滚动条是没有效果的,它只是个摆设

Windows操作系统负责处理滚动条上的鼠标动作,但是不负责键盘接口.如果想要通过键盘控制滚动条,需要显式给出对应关系,但这是后话,目前的任务是给滚动条加上管理范围,让它不是摆设

Windows操作系统和应用程序

位置和范围

范围是一对整数,表明滚动条的最小值和最大值

位置是滑块实时在这个范围中的值,位置永远属于是范围这个整数集合

默认滚动条的范围是[0,100)

范围

可以调用setScrollRange修改其范围

1
2
3
4
5
6
7

BOOL SetScrollRange(
  [in] HWND hWnd,
  [in] int  nBar,
  [in] int  nMinPos,
  [in] int  nMaxPos,
  [in] BOOL bRedraw
);

设置滚动条范围

当滚动条范围是[0,NUMLINES-1],当滑块位置是0,此时第一条文本显示在客户区最上方,下面顺次是第2条文本,第3条...这样是合理的

当滑块位置是NUMLINES-1,此时最后一条文本显示在客户区最上方,下面全都是空白.显然着这不合理.

怎么样让滑块最远到达的位置,使得最后一条文本显示 在客户区的最下方?

假设客户区大小100,需要打印1000行,当滑块在0时可以显示第1到100行,当滑块在1时可以显示第2到101行,当滑块在900时,可以显示第901到1000行

因此只需要NUMLINES-cyClient就可以实现

啥时候更新滚动条范围呢?NUMLINES是一个常数,cyClient客户区垂直行数是一个变量,因此滚动条范围上界可以跟随cyClient变化

都在处理WM_SIZE时修改

1
2
3
4
5
6

case WM_SIZE:
	cxClient = LOWORD(lParam);
	cyClient = HIWORD(lParam);
	iVscrollMax = max(0, NUMLINES - cyClient / cyChar);//非负
	SetScrollRange(hwnd, SB_VERT, 0, iVscrollMax, TRUE);//修改范围
	return 0;

位置

滑块的位置是一个整数,比如当滚动条范围是[0,1024)

那么滑块的位置就有0,1,2,...,1022,1023,总共1024种情况

必须使用SetScrollPos函数修改滑块的位置

1

int SetScrollPos（HWN hWnd，int nBar，int nPos，BOOL bRedraw）;

程序和windows操作系统合作处理滚动条上的动作

windows操作系统:

处理滚动条中的所有鼠标信息,

当鼠标拖动滑块的时候高亮

当用户拖动滑块的时候,在滚动条内移动滑块

向拥有滚动条的窗口过程发送滚动条消息

程序:

初始化滚动条的范围和位置

处理传送给窗口过程的滚动条信息

更新滑块的位置

根据滚动条的变化更新客户区的内容

处理滚动条消息

单击滚动条或者拖动滑块会导致windows向窗口过程发送WM_VSCROLL或者WM_HSCROLL消息

此时wParam和lParam参数就有实际意义了.其中lParam用于滚动条是子窗口.wParam用于滚动条是窗口的一部分,目前只使用wParam就足够了

wParam是一个无符号32位双字

1
2

typedef _W64 unsigned int UINT_PTR, *PUINT_PTR;
typedef UINT_PTR            WPARAM;

其低位字代表了鼠标在滚动条的动作,又称为"通知码",低位字的枚举值在winuser.h中有定义

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

#define SB_LINEUP 0
#define SB_LINELEFT 0
#define SB_LINEDOWN 1
#define SB_LINERIGHT 1
#define SB_PAGEUP 2
#define SB_PAGELEFT 2
#define SB_PAGEDOWN 3
#define SB_PAGERIGHT 3
#define SB_THUMBPOSITION 4
#define SB_THUMBTRACK 5
#define SB_TOP 6
#define SB_LEFT 6
#define SB_BOTTOM 7
#define SB_RIGHT 7
#define SB_ENDSCROLL 8

各个枚举值的对应效果

wParam的高位字表示滑块位置

使用滚动条

加入滚动条处理的WndProc函数

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

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
	

	static int iVscrollPos;//记录滑块位置
	static int cxChar, cxCaps, cyChar;
	static int cxClient, cyClient;
	TEXTMETRIC tm;
	HDC hdc;
	PAINTSTRUCT ps;
	int i,y;
	TCHAR szBuffer[10];
	RECT rect;
	
	switch (message) {
	case WM_CREATE:
		hdc = GetDC(hwnd);
		GetTextMetrics(hdc, &tm);
		cxChar = tm.tmAveCharWidth;
		cxCaps = cxChar;
		if (tm.tmPitchAndFamily & 1) {
			cxCaps = cxChar * 3 / 2;
		}
		cyChar = tm.tmHeight + tm.tmExternalLeading;

		ReleaseDC(hwnd, hdc);
		return 0;
	case WM_SIZE:
		cxClient = LOWORD(lParam);
		cyClient = HIWORD(lParam);

		return 0;

	case WM_VSCROLL:
		switch (LOWORD(wParam)) {
		case SB_LINEUP://点击滚动条顶端的箭头导致滑块垂直位置上移一个单元
				iVscrollPos -= 1;
				break;
		case SB_LINEDOWN:
			iVscrollPos += 1;
			break;
		case SB_PAGEUP://点击滑块的滑道导致滑块垂直位移一页
			iVscrollPos -= cyClient / cyChar;
			break;
		case SB_PAGEDOWN:
			iVscrollPos += cyClient / cyChar;
			break;
		case SB_THUMBPOSITION://拖动滑块,其位置应该由wParam的高位字决定
			iVscrollPos = HIWORD(wParam);
			break;
		default:
			break;
		}
		iVscrollPos = max(0, min(iVscrollPos, NUMLINES - 1));//iVscrollPos不允许小于0,不允许比NUMLINES行大
		if (iVscrollPos != GetScrollPos(hwnd, SB_VERT)) {//测试一下本次滚动之后和上一次的位置是否相同,相同则不做修改
			SetScrollPos(hwnd, SB_VERT, iVscrollPos, TRUE);
			InvalidateRect(hwnd, NULL, TRUE);//本次滚动条动作处理完毕,整个窗口无效化,强制产生WM_PAINT消息,进行重绘处理
		}
		return 0;

	case WM_PAINT:
		hdc = BeginPaint(hwnd,&ps);
		for (i = 0; i < NUMLINES; ++i) {//i最大不能超过现有行数
			y = cyChar * (i - iVscrollPos);//原来的第i行应该在客户区的第i-iVescrollPos行打印
			TextOut(hdc, 10, y, sysmetrics[i].szLabel,lstrlen(sysmetrics[i].szLabel));
			TextOut(hdc, 40 * cxCaps, y, sysmetrics[i].szDesc, lstrlen(sysmetrics[i].szDesc));
			wsprintf(szBuffer, TEXT("%5d"), GetSystemMetrics(sysmetrics[i].Index));
			SetTextAlign(hdc, TA_LEFT);
			TextOut(hdc, 80 * cxCaps, y, szBuffer, lstrlen(szBuffer));
			SetTextAlign(hdc, TA_LEFT);
		}	
		EndPaint(hwnd, &ps);

		return 0;
	case WM_LBUTTONDOWN:
		GetClientRect(hwnd, &rect);
		wsprintf(szBuffer, TEXT("%d"),cxClient);
		MessageBox(NULL, szBuffer,TEXT("notice"), NULL);

		return 0;


	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;

	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}

关于绘图时的处理y = cyChar * (i - iVscrollPos);实际上干了一个将第i条作为客户区的第i-iVscrollPos行打印

立刻重绘

处理WM_VSCROLL时并没有立刻重绘客户区,而是调用InvalidateRect将这个皮球踢到下一次消息处理,WM_PAINT的处理.

WM_PAINT这个消息的优先级最低,当窗口过程的消息队列中有多种消息(比如多种对窗口有改动的消息)时,会首先处理其他消息,最后才会处理WM_PAINT消息.

这就好比市领导要求某中学视察,苦逼老师们提前一周就得造假材料,补完教案.等这一些都忙活完了,到领导视察当天,把所有材料一汇总,呈递给领导审阅

造材料就相当于处理其他消息

处理WM_PAINT就是呈递的临门一脚

如果要让WM_PAINT立刻被处理,需要在InvalidateRect之后立刻UpdateWindow

1
2
3
4
5

if (iVscrollPos != GetScrollPos(hwnd, SB_VERT)) {
	SetScrollPos(hwnd, SB_VERT, iVscrollPos, TRUE);
	InvalidateRect(hwnd, NULL, TRUE);
	UpdateWindow(hwnd);
}

Get/SetScrollInfo

先前的窗口中,滑块的大小是固定的,那么一小点都点不到.

而人家的滑块似乎是和总行数挂钩的,总行数越少滑块越大

确实如此,理论上可以得到一个公式 \[ \frac{滑块大小}{滚动条长度}=\frac{页面大小}{范围}=\frac{文档显示数量}{文档总大小} \]

我们先进的Set/GetScrollInfo函数已经超过了老式的Set/GetScrollRange,Set/GetScrollPos函数Set/GetScrollInfo就可以考虑这一点了

使用Set/GetScrollInfo完全可以做到先前的老式函数.

这俩函数可以设置/获得滚动条的所有信息

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

typedef struct tagSCROLLINFO {//SCROLLINFO结构体
  UINT cbSize;//sizeof(SCROLLINFO)
  UINT fMask;//要设置或者获取的值
  int  nMin;//范围最小值
  int  nMax;//范围最大值
  UINT nPage;//页面大小
  int  nPos;//当前位置
  int  nTrackPos;//当前追踪位置
} SCROLLINFO, *LPSCROLLINFO;


int SetScrollInfo(
  [in] HWND          hwnd,
  [in] int           nBar,//要么是SB_VERT,要么是SB_HORZ,作用是决定滑块是水平还是垂直的
  [in] LPCSCROLLINFO lpsi,//lpsi规定了ScrollInfo结构体应该被设置成什么状态
  [in] BOOL          redraw//表示是否重绘滚动条
);

BOOL GetScrollInfo(
  [in]      HWND         hwnd,
  [in]      int          nBar,
  [in, out] LPSCROLLINFO lpsi//返回值用引用承载
);

奇怪的是,结构体的第一个成员是自己的大小,这不随便用sizeof一算就有了吗?

windows程序设计给出的解释是,方便以后扩充结构使用

使用该结构体之前需要ixan将cbSize字段填充

1 2	SCROLLINFO si; si.cbSize=sizeof(SCROLLINFO);

真™抽象

fMask有效值:

1
2
3
4
5
6

#define SIF_RANGE 0x0001//范围掩码,获取SCROLLINFO.nMIn,.mMax
#define SIF_PAGE 0x0002//页面大小掩码,获取SCROLLINFO.nPage
#define SIF_POS 0x0004//滑块位置掩码,获取SCROLLINFO.nPos
#define SIF_DISABLENOSCROLL 0x0008
#define SIF_TRACKPOS 0x0010
#define SIF_ALL (SIF_RANGE | SIF_PAGE | SIF_POS | SIF_TRACKPOS)

不管是使用Set还是GetScrollInfo方法,引用传递的lpsi参数都要指定fMask这个成员

对于GetScrollInfo方法,指定了fMask=SIF_POS ,那么函数执行后lpsi引用的nPos就是有效值,其他成员无效

对于SetScrollInfo方法,指定了fMask=SIF_POS,那么函数根据lpsi的nPos值修改滚动条参数.其他成员不予理睬

修改滑块位置

使用SetScrollInfo改进的WM_CREATE处理函数

1
2
3
4
5
6
7
8
9

static SCROLLINFO si;
...
    
		if (iVscrollPos != GetScrollPos(hwnd, SB_VERT)) {
			si.fMask = SIF_POS;//设置掩码,只改变nPos参数
			SetScrollInfo(hwnd, SB_VERT, &si, FALSE);//不立刻重绘
			InvalidateRect(hwnd, NULL, TRUE);
			UpdateWindow(hwnd);
		}

设置滚动条范围

1
2
3
4
5
6
7
8
9
10
11

case WM_SIZE:
	cxClient = LOWORD(lParam);
	cyClient = HIWORD(lParam);
	si.fMask = SIF_RANGE | SIF_PAGE;
	si.nMin = 0;
	si.nMax = NUMLINES - 1;
	si.nPage = cyClient / cyChar;
	SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
	//iVscrollMax = max(0, NUMLINES - cyClient / cyChar);老方法
	//SetScrollRange(hwnd, SB_VERT, 0, iVscrollMax, TRUE);
	return 0;

虽然我们传递的si.nMax=NUMLINES-1但是Windows操作系统会自动将滚动条范围最大值设置为si.nMax-si.nPage+1,这就是SetScrollInfo函数相对于SetScrollRange的好处

更完善的滑动效果

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

LRESULT CALLBACK WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) {
	
	static int cxChar, cxCaps, cyChar, cxClient, cyClient, iMaxWidth;//字母宽度,大写字母宽度,行高度,客户区宽度,客户区高度,期望的最长宽度 //单位全是像素
	HDC hdc;
	int i, x, y, iVertPos, iHorzPos, iPaintBeg, iPaintEnd;//循环变量,绘制起点x,绘制起点y,竖直滑块位置,水平滑块位置,需要开始绘制的行号,需要结束绘制的行号
	PAINTSTRUCT ps;
	SCROLLINFO si;
	TCHAR szBuffer[10];
	TEXTMETRIC tm;
	RECT rect;

	switch (message) {
	case WM_CREATE:

		hdc = GetDC(hwnd);
		GetTextMetrics(hdc, &tm);//获取系统字体属性
		cxChar = tm.tmAveCharWidth;
		cxCaps = cxChar;
		if (tm.tmPitchAndFamily & 1) {
			cxCaps = cxChar * 3 / 2;
		}
		cyChar = tm.tmHeight + tm.tmExternalLeading;

		ReleaseDC(hwnd, hdc);
		iMaxWidth = 40 * cxChar + 22 * cxCaps;//初始化期望的最长宽度,以后就当作常数使用了
		return 0;
	case WM_SIZE:
		cxClient = LOWORD(lParam);//获取实时客户区宽度
		cyClient = HIWORD(lParam);//获取实时客户区高度


		//设置竖直滚动条属性
		si.cbSize = sizeof(si);//初始化si结构体
		si.fMask = SIF_RANGE | SIF_PAGE;//设置访问掩码
		si.nMin = 0;//设置滚动条范围上限为0
		si.nMax = NUMLINES - 1;//设置滚动条下限为NUMLINES-1
		si.nPage = cyClient / cyChar;//设置滚动条滚一页(一页=客户区一屏)的行数,客户区高度/一行的高度=客户区行数
		SetScrollInfo(hwnd, SB_VERT, &si, TRUE);//注册滚动条信息
		
		//设置水平滚动条属性
		si.cbSize = sizeof(si);//初始化si结构体
		si.fMask = SIF_RANGE | SIF_PAGE;//设置访问掩码
		si.nMin = 0;
		si.nMax = 2 + iMaxWidth / cxChar;//水平一页的宽度
		si.nPage = cxClient / cxChar;//客户区宽度➗字符宽度=一行可以有多少个字符
		SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
		return 0;

	case WM_VSCROLL:
		si.cbSize = sizeof(si);
		si.fMask = SIF_ALL;//设置访问掩码
		GetScrollInfo(hwnd, SB_VERT, &si);
		iVertPos = si.nPos;//iVertPos记录修改之前的si.nPos滑块位置
		switch (LOWORD(wParam)) {
		case SB_TOP:
			si.nPos = si.nMax;
			break;
		case SB_BOTTOM:
			si.nPos = si.nMin;
		case SB_LINEUP:
			si.nPos -= 1;
			break;
		case SB_LINEDOWN:
			si.nPos += 1;
			break;
		case SB_PAGEUP:
			si.nPos -= si.nPage;
			break;
		case SB_PAGEDOWN:
			si.nPos += si.nPage;
			break;
		case SB_THUMBTRACK://TRACK会一直跟踪鼠标位置
			si.nPos = si.nTrackPos;
			break;
		
		default:
			break;

		}
		si.fMask = SIF_POS;//设置访问掩码,修改滚动条的滑块位置信息
		SetScrollInfo(hwnd, SB_VERT, &si, TRUE);
		GetScrollInfo(hwnd, SB_VERT, &si);

		if (si.nPos != iVertPos) {//比较本次修改前后si.nPos是否发生了变化
			//如果发生了变化则立刻通知重绘
			ScrollWindow(hwnd, 0, cyChar * (iVertPos - si.nPos), NULL, NULL);
			UpdateWindow(hwnd);
		}
		return 0;

	case WM_HSCROLL:
		si.cbSize = sizeof(si);
		si.fMask = SIF_ALL;
		GetScrollInfo(hwnd, SB_HORZ, &si);
		iHorzPos = si.nPos;
		switch (LOWORD(wParam)) {
		case SB_LINERIGHT:
			si.nPos += 1;
			break;
		case SB_LINELEFT:
			si.nPos -= 1;
			break;
		case SB_PAGELEFT:
			si.nPos -= si.nPage;
			break;
		case SB_PAGERIGHT:
			si.nPos += si.nPage;
			break;
		case SB_THUMBPOSITION://POSITION只会在鼠标松开时才更新位置
			si.nPos = si.nTrackPos;
			break;

		default:
			break;
		}
		si.fMask = SIF_POS;
		SetScrollInfo(hwnd, SB_HORZ, &si, TRUE);
		GetScrollInfo(hwnd, SB_HORZ, &si);
		if (si.nPos != iHorzPos) {
			ScrollWindow(hwnd, cxChar * (iHorzPos - si.nPos), 0, NULL, NULL);
			UpdateWindow(hwnd);
		}



	case WM_PAINT:
		hdc = BeginPaint(hwnd,&ps);//ps包含了当前客户区信息
		si.cbSize = sizeof(si);
		si.fMask = SIF_POS;
		GetScrollInfo(hwnd, SB_VERT, &si);
		iVertPos = si.nPos;//获取当前滑块位置
		GetScrollInfo(hwnd, SB_HORZ, &si);
		iHorzPos = si.nPos;
		iPaintBeg = max(0, iVertPos + ps.rcPaint.top / cyChar);//计算绘制第几行
		iPaintEnd = min(NUMLINES - 1, iVertPos + ps.rcPaint.bottom / cyChar);
	
		for (i = iPaintBeg; i <= iPaintEnd; ++i) {
			
			x = cxChar * (1 - iHorzPos);
			y = cyChar * (i - iVertPos);
			TextOut(hdc, x, y, sysmetrics[i].szLabel, lstrlen(sysmetrics[i].szLabel));
			TextOut(hdc, x+22*cxCaps, y, sysmetrics[i].szDesc, lstrlen(sysmetrics[i].szDesc));
			
			
			SetTextAlign(hdc, TA_RIGHT | TA_TOP);
			wsprintf(szBuffer, TEXT("%5d"), GetSystemMetrics(sysmetrics[i].Index));
			TextOut(hdc, x + 22 * cxCaps+40*cxChar, y, szBuffer,lstrlen(szBuffer));
			SetTextAlign(hdc, TA_LEFT | TA_TOP);
		
		}
		EndPaint(hwnd, &ps);
		return 0;


	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;

	}
	return DefWindowProc(hwnd, message, wParam, lParam);
}

使用老式函数时拖动滑块只有当鼠标松开,才会重绘客户区

现在只要是鼠标拖着竖直滑块有动作,客户区实时更新

绷不住了

C++ reverse

windows x86 g++编译器生成的代码

以链栈类为例观察C++的反汇编长啥样

链栈类图

mermaid在typora上可以正常显式,但是放到网页上就不知道发生什么事了

代码实现

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

#include <iostream>
using namespace std;
class Stack
{
protected:
    int len;

public:
    Stack()
    {
        len = 0;
    }
    void push(const int &x);
    void pop();
    int top() const;
    int length() const
    {
        return len;
    }
    bool empty() const
    {
        return len == 0;
    }
};

class LinkedNode
{
protected:
    int value;
    LinkedNode *next;

public:
    LinkedNode(int v = 0, LinkedNode *n = NULL) : value(v), next(n) {}
    void setValue(int v = 0)
    {
        value = v;
    }
    int getValue() const
    {
        return value;
    }
    void setNext(LinkedNode *n = NULL)
    {
        next = n;
    }
    LinkedNode *getNext() const
    {
        return next;
    }

    friend ostream &operator<<(ostream &os, const LinkedNode &node)
    {
        os << node.value;
        return os;
    }
};
class LinkedStack : public Stack
{
protected:
    LinkedNode *head;

public:
    LinkedStack() : Stack()
    {
        head = new LinkedNode();
    }
    void push(const int &x)
    {
        LinkedNode *node = new LinkedNode(x, head->getNext());
        head->setNext(node);//头插
        ++len;
    }
    void pop()
    {
        if (empty())
            return;
        LinkedNode *p = head->getNext();
        head->setNext(p->getNext());
        delete p;
        --len;
    }
    int top() const
    {
        if (empty())
            return -1;
        return head->getNext()->getValue();
    }
};

int main()
{
    LinkedStack sta;
    for (int i = 1; i <= 10; ++i)
    {
        sta.push(i);//测试压栈功能
    }
    cout << sta.length() << endl;
    while (!sta.empty())
    {
        cout << sta.top() << " ";//测试取栈顶功能
        sta.pop();//测试退栈功能
    }
    return 0;
}

GCC编译链接

1

g++ main.cpp -O0 -o main -m32

thiscall调用约定

thiscall调用约定

唯一一个不能明确指明的函数修饰，因为thiscall不是关键字。他是C++类成员函数缺省的调用约定。由于成员函数调用还是一个this指针，所以thiscall是专为C++设计的调用方式。

1、参数从右往左入栈

2、如果参数个数确定，this指针通过通过ecx传递给被调用者；如果参数个数不确定，this指针在所有参数压栈后被压入堆栈

3、对参数个数不定的，调用者清理堆栈，否则函数自己清理

main函数反汇编

main函数开端

main遵守cdecl调用约定,只有成员函数才遵守thiscall调用约定

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

.text:00401530 ; Attributes: bp-based frame fuzzy-sp
.text:00401530
.text:00401530 ; int __cdecl main(int argc, const char **argv, const char **envp)
.text:00401530                 public _main
.text:00401530 _main           proc near               ; CODE XREF: ___tmainCRTStartup+221↑p
.text:00401530
.text:00401530 var_14          = dword ptr -14h
.text:00401530 var_10          = byte ptr -10h
.text:00401530 var_4           = dword ptr -4
.text:00401530 argc            = dword ptr  8
.text:00401530 argv            = dword ptr  0Ch
.text:00401530 envp            = dword ptr  10h
.text:00401530
.text:00401530                 lea     ecx, [esp+4]
.text:00401534                 and     esp, 0FFFFFFF0h
.text:00401537                 push    dword ptr [ecx-4]
.text:0040153A                 push    ebp
.text:0040153B                 mov     ebp, esp
.text:0040153D                 push    ecx
.text:0040153E                 sub     esp, 24h

main函数刚开始时,esp指向0077FEDC,用OD观察这个位置,是主线程的堆栈

主线程的堆栈起于0x77E000,大小是0x2000即8K

由于堆栈倒着生长,因此栈底在0x780000,此时栈顶在0x0077FEDC,方向是0x780000->0x77E000

距离栈底0x780000-0x77FEDC=0x124即292字节

但是这时候主函数才是刚开始啊,也只有主函数的三个参数压栈了啊,怎么就已经使用了292个字节这么大呢?

主函数不是程序的入口点,在主函数执行前还有其他函数要执行,也可能占用线程栈

PE头->NT头->可选头->AddressOfEntryPoint

其RVA是0x14C0

而ImageBase是0x400000

加起来得到入口点的虚拟地址为0x4014C0

lea ecx, [esp+4]

将要执行此条指令时,esp=0x77FEDC,

此时栈中是啥呢?

1
2
3
4
5

0077FEDC  00401386  ___tmainCRTStartup+226
0077FEE0  00000001  
0077FEE4  00CA1650  debug034:00CA1650
0077FEE8  00CA22B8  debug034:00CA22B8
...

栈顶0077FEDC存放的是主函数的返回地址,这个地址在___tmainCRTStartu函数中

1 2 3 4 5 6 7

.text:0040136C mov [esp+90h+lpreserved], eax ; envp .text:00401370 mov eax, ds:_argv .text:00401375 mov [esp+90h+dwReason], eax ; argv .text:00401379 mov eax, ds:_argc .text:0040137E mov [esp+90h+dwMilliseconds], eax ; argc .text:00401381 call _main .text:00401386 mov ecx, ds:_managedapp

显然这个返回地址是call _main函数压入栈中的

栈顶再往下四个字节,0077FEE0上是1,是main函数的第一个参数int argc,4个字节

再往下四个字节0077FEE4上是main函数的第二个参数,命令行参数字符串数组const char **argv的基地址,4个字节

再往下四个字节0077FEE8上市main函数的第三个参数,环境变量字符串数组const char **envp的基地址,4个字节

esp+4显然就指向main函数的第一个参数int argc

加载有效地址将该参数的地址交给ecx

and esp, 0FFFFFFF0h

esp低4位置零,高28位保持不变,意思是16字节对齐

此举只能导致esp不增,要么esp本来低位有数现在降到0,要么本来esp就是16字节对齐了,不用降为0.

又栈是倒着生长的,因此不用担心此举将会导致新的压栈覆盖三个参数

对齐的目的应该是追求效率

此步执行后的栈帧

1
2
3
4

0077FED0  00000002  
0077FED4  00DB1618  debug035:00DB1618
0077FED8  00DB1670  debug035:00DB1670
0077FEDC  00401386  ___tmainCRTStartup+226

push dword ptr [ecx-4]

ecx在本函数的第一条指令时被置为第一个参数的地址

现在将ecx-4又退到main函数的返回地址

这里又把返回地址压栈

1
2
3
4
5
6
7
8
9

0077FECC  00401386  ___tmainCRTStarup+226
0077FED0  00000002  
0077FED4  00DA1618  debug035:00DA16
0077FED8  00DA1670  debug035:00DA16
0077FEDC  00401386  ___tmainCRTStarup+226
0077FEE0  00000004  
0077FEE4  00DA1660  debug035:00DA16
0077FEE8  00DA22B8  debug035:00DA22
0077FEEC  00000000  

好像把返回值和参数压了两次栈,第一次是调用者___tmainCRTStarup做的,第二次是main函数做的

为啥要搞重复建设呢?

推测是因为调用约定不同导致的,___tmainCRTStarup这个函数不是cdecl调用约定的,而是stdcall约定的

push ebp

调用者函数的帧指针ebp压栈保存,方便ebp为现在的函数服务

mov ebp, esp

ebp获得当前main函数栈顶指针拷贝

当前栈顶指向二次压栈的返回值地址

push ecx

ecx存放的是第一个参数的地址,现在又把他压栈,相当于这个值前后一共压栈3次

推测这里是保存ecx寄存器值后来再还给他

sub esp, 24h

栈顶下移0x24h个字节,为main函数申请栈帧空间,一次性申请全

到此函数开端完毕

main初始化

call ___main

这个函数进行了一些初始化,它先判断是否已经初始化过了,如果初始化过了则返回

否则记录一下已经初始化过了,然后执行___do_global_ctors这个函数,推测是对全局位置的对象实例化调用构造函数

奇怪的是,调用函数应该使用call指令,但是____main中调用___do_global_ctors使用的是jmp short跳转指令,使用jmp不会参数压栈,可以认为___do_global_ctors不需要参数,但是返回地址也没有压栈,___do_global_ctors执行完毕之后,控制应该交给谁呢?

___main函数如果jz跳转实现,再loc_40BC70中也是没有返回值的,但是___main在调用的时候已经把返回到__main的地址压栈,因此可以推测,___do_global_ctors相当于___main的延续,它将会返回到___main栈帧一开始压入的返回地址

这个__do_global_ctors干了啥呢?

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

void __do_global_ctors()
{
  func_ptr v0; // ebx
  func_ptr v1; // eax

  v0 = __CTOR_LIST__[0];
  if ( __CTOR_LIST__[0] == (func_ptr)-1 )//func_ptr是指针类型,(func_ptr)-1是将-1强制转换为指针类型,需要结合 __CTOR_LIST__[0] 来立即这里的判断条件
  {
    v1 = 0;
    do
    {
      v0 = v1;//v0指向上一个函数指针
      v1 = (func_ptr)((char *)v1 + 1);//v1后移一个单位
    }
    while ( __CTOR_LIST__[(_DWORD)v1] );//当v1遍历完整个函数指针表时,最后一项为全0,此时while条件不满足,跳出循环
  }
  for ( ; v0; v0 = (func_ptr)((char *)v0 - 1) )//v0逆序遍历整个函数指针表
    __CTOR_LIST__[(_DWORD)v0]();//后面加了小括号意思是当作函数执行了
  atexit(__do_global_dtors);//注册函数,当程序正常终止的时候,执行__do_global_dtors函数.
    //当程序执行到此时并不会执行执行__do_global_dtors函数,而是当整个exe程序执行完毕才会执行__do_global_dtors函数
    //atexit只是起到注册作用
}

__CTOR_LIST__表是一个函数指针表

第零个函数指针__CTOR_LIST__[0]的值为0xFFFFFFFFh=-1,这个值总是-1,表征函数指针表的开始,并且填了第0个元素的空,使得真正的函数指针下标从1开始

1
2
3
4
5
6
7
8
9
10
11
12
13
14

.text:004CA335 90 90 90 90 90 90 90 90 90 90+                align 10h
.text:004CA340                                               public ___CTOR_LIST__
.text:004CA340                               ; func_ptr __CTOR_LIST__[]
.text:004CA340 FF FF FF FF                   ___CTOR_LIST__  dd 0FFFFFFFFh           ; DATA XREF: ___do_global_ctors+4↑r
.text:004CA340                                                                       ; ___do_global_ctors:loc_40BC18↑r ...
.text:004CA344 3C 16 40 00                                   dd offset __GLOBAL__sub_I_main
.text:004CA348 00 96 4C 00                                   dd offset __GLOBAL__sub_I__ZNSt12ctype_bynameIcEC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEj
.text:004CA34C 90 96 4C 00                                   dd offset __GLOBAL__sub_I__ZNSt12ctype_bynameIwEC2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEEj
.text:004CA350 60 9D 4C 00                                   dd offset __GLOBAL__sub_I__ZNSt12ctype_bynameIcEC2ERKSsj
.text:004CA354 30 9E 4C 00                                   dd offset __GLOBAL__sub_I__ZNSt12ctype_bynameIwEC2ERKSsj
.text:004CA358 00 9F 4C 00                                   dd offset __GLOBAL__sub_I__ZN9__gnu_cxx9__freeresEv
.text:004CA35C 50 A2 4C 00                                   dd offset __GLOBAL__sub_I__ZSt20__throw_system_errori
.text:004CA360 30 A3 4C 00                                   dd offset _register_frame_ctor
.text:004CA364 00 00 00 00                                   align 8

__do_global_dtors干了啥呢?

推测是遍历了析构函数表,挨个执行每个函数指针

1
2
3
4
5
6
7
8
9
10

void __cdecl __do_global_dtors()
{
  void (*i)(void); // eax

  for ( i = *p_63984; i; ++p_63984 )
  {
    i();
    i = p_63984[1];
  }
}

这个p_63984是指向全局析构函数表的指针

1

.data:004CD004 6C A3 4C 00                   _p_63984        dd offset dword_4CA36C  ; 

dword_4CA36C就是__DTOR_LIST_表的基地址

这个表很长,怎么运作的现在不想操心

现在回到main函数中

lea eax, [ebp+var_10]

将栈中var_10的地址放到eax中,这里var_10作用不是狠清晰,前面都没有提到var_10,

可以猜测一下,主函数下面就开了一个局部的LinkedStack对象,var_10会不会是该对象呢

联系后面调用LinkedStack构造函数,var_10十有八九是该对象

mov ecx, eax

再转手交给ecx

call __ZN11LinkedStackC1Ev

调用LinkedStack类的构造函数

跟踪一下这个函数

调用LinkedStack实例化一个链栈对象

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

.text:00422334 ; Attributes: bp-based frame
.text:00422334
.text:00422334 ; LinkedStack *LinkedStack::LinkedStack(LinkedStack *__hidden this)
.text:00422334 public __ZN11LinkedStackC1Ev
.text:00422334 __ZN11LinkedStackC1Ev proc near
.text:00422334
.text:00422334 var_C= dword ptr -0Ch
.text:00422334 var_4= dword ptr -4
.text:00422334 this= dword ptr  8
.text:00422334
.text:00422334 push    ebp
.text:00422335 mov     ebp, esp
.text:00422337 push    ebx
.text:00422338 sub     esp, 24h
.text:0042233B mov     [ebp+var_C], ecx
.text:0042233E mov     eax, [ebp+var_C]
.text:00422341 mov     ecx, eax
.text:00422343 call    __ZN5StackC2Ev  ; Stack::Stack(void)
.text:00422348 mov     dword ptr [esp], 8 ; size_t
.text:0042234F call    __Znwj          ; operator new(uint)
.text:00422354 mov     ebx, eax
.text:00422356 mov     dword ptr [esp+4], 0
.text:0042235E mov     dword ptr [esp], 0
.text:00422365 mov     ecx, ebx
.text:00422367 call    __ZN10LinkedNodeC1EiPS_ ; LinkedNode::LinkedNode(int,LinkedNode*)
.text:0042236C sub     esp, 8
.text:0042236F mov     eax, [ebp+var_C]
.text:00422372 mov     [eax+4], ebx
.text:00422375 nop
.text:00422376 mov     ebx, [ebp+var_4]
.text:00422379 leave
.text:0042237A retn
.text:0042237A __ZN11LinkedStackC1Ev endp

ecx->var_C->eax->ecx,兜兜转转还是ecx,这就很乖,为啥要用var_C捯饬?

再看后面的.text:00422343 call __ZN5StackC2Ev ; Stack::Stack(void)恍然大悟

又要使用当前对象调用父类构造函数了,那么ecx中啃腚还是要存放当前对象

只不过编译器没有优化这件事了

跟踪一下父类构造函数Stack()

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

.text:00422910 ; Attributes: bp-based frame
.text:00422910
.text:00422910 ; Stack *Stack::Stack(Stack *__hidden this)
.text:00422910 public __ZN5StackC2Ev
.text:00422910 __ZN5StackC2Ev proc near
.text:00422910
.text:00422910 var_4= dword ptr -4
.text:00422910 this= dword ptr  8
.text:00422910
.text:00422910 push    ebp
.text:00422911 mov     ebp, esp
.text:00422913 sub     esp, 4
.text:00422916 mov     [ebp+var_4], ecx
.text:00422919 mov     eax, [ebp+var_4]
.text:0042291C mov     dword ptr [eax], 0
.text:00422922 nop
.text:00422923 leave
.text:00422924 retn
.text:00422924 __ZN5StackC2Ev endp

当前对象的栈中地址->ecx->var_4->eax

0->[eax]=当前对象=当前对象的第一个成员

也就是当前对象的第一个双字置0,而Stack对象的第一个成员正好是一个双字的int len

因此这就做了len = 0;这么一件事

为啥要费六条汇编指令呢?这是调用约定固定的结构

ecx传递的当前对象的栈中地址必须先压入栈中然后eax从栈中获得该对象的地址,

后面使用eax寄存器相对寻址对栈上的对象进行内存读写

这样看直接从ecx交给eax不行吗?不需要压栈中转啊

显然是可以的,但是没有开启编译优化就得这样来

回到LinkedStack()

mov dword ptr [esp], 8 ; size_t

栈顶上放一个8,貌似要调用函数了,但是很奇怪的是,后面要调用的是operator new,它怎么会有参数呢?

还有就是,LinkedStack()构造函数中只有一个句柄head,没有一个int类型的局部变量,为啥现在要再栈上放一个8?

联系后文可知,这个8将作为new开辟空间的大小Size

8临时占用了head句柄的位置,后面开出对象来之后再写回这个位置,节省了空间

LinkedNode就两个成员变量并且都是4个字节,那么一个LinkedNode实例的大小也就是sizeof(LinkedNode)=8

1
2

int value;
LinkedNode *next;

因此这里把8临时放到head的位置

call __Znwj ; operator new(uint)

调用new运算符(_Znwj这名字是真tm抽象)

根据源代码的逻辑,此处应该是new一个LinkedNode类实例作为链栈的附加头节点head

这个new干了啥呢?

ebx是被调用者保存寄存器,也就是Znwj要维护其值前后不变

ebx压栈保存后被赋予新值1,然后申请了18h=24字节的栈帧空间

mov eax, [esp+1Ch+arg_0]

这里esp=77fe50,arg_0=4

加起来指向77fe70,栈中这个位置

1
2

0077FE6C  00422354  LinkedStack::LinkedStack(void)+20
0077FE70  00000008  

这个位置是LinkedStack函数局部变量的起始位置

也就是刚才mov dword ptr [esp], 8 ; size_t这条指令的目的位置

1
2
3
4

LinkedStack() : Stack()
{
    head = new LinkedNode();
}

而LinkedStack的局部变量只有一个head

那么这里eax将会是head这个句柄的值,刚才已经被临时置为8表征对象大小,因此现在用ebx保存这个大小,为head的真值让路

再往下到log_4C7F12中,

上来就把ebx放到栈上作为Size,准备调用malloc,而ebx经过前面的分析可以得知,就是LinkedNode的大小

这是循环的开始,可以看到循环调用了_malloc函数,推测是,如果堆上申请空间失败则一直重复申请,直到申请成功

怎么判断的?

malloc的返回值用eax承载,如果申请成功则eax承载的是堆上地址,否则eax=0

当eax不为0则jz short loc_4C7F23跳转失败,执行

1
2
3

.text:004C7F1E add     esp, 18h
.text:004C7F21 pop     ebx
.text:004C7F22 retn

函数就返回了,eax承载返回值

当eax为0则jz short loc_4C7F23后面继续循环

继续循环并没有立刻重新调用malloc函数,而是做了一些手续,具体干了啥呢?

下到loc_4C7F23中,首先调用了一个无参函数get_new_handler

这个函数就干了一个事mov eax, __ZN12_GLOBAL__N_113__new_handlerE ;其中__ZN12_GLOBAL__N_113__new_handlerE =0

new_handler是我们应当人为设置的函数,即使用set_new_handler设置的函数,作用是在operator new中,malloc开不出堆空间时,应该执行的函数

显然我们之前并没有使用set_new_handler设置这么一个纠错函数,这种情况下get_new_handler将返回NULL

显然__ZN12_GLOBAL__N_113__new_handlerE这个值应该存放的是一个函数地址,我们没有设置set_new_handler当然这个位置存放的是0,这也就是get_new_handler返回NULL的原因

说他是一个函数地址,还可以在后文看出,使用get_new_handler之后eax理论上承载的是函数地址,程序先检查一下eax是否有效,如果有效(即非零)则直接call eax说明eax中就是函数地址,即__ZN12_GLOBAL__N_113__new_handlerE理应存放函数地址

如果我们调用set_new_handler设置过处理函数,则直接跳转loc_4C7F12重新调用malloc

这可以做一个实验

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17

#include <iostream> using namespace std; void flag(){ cout<<"flag{dustball}"; exit(0); } const int maxn=10000000; int main() { set_new_handler(flag); while(true){ int *p=new int[maxn]; } return 0; }

如果堆爆了,开不出来,理应执行flag函数,而主函数中我们丧心病狂地一直索取堆空间,必然会导致堆满

1 2 3

PS C:\Users\86135\Desktop\test> g++ test.cpp -O0 -o test -m32 PS C:\Users\86135\Desktop\test> ./test flag{dustball}

可以看到确实执行了set_new_handler设置的flag函数

如果把main中的死循环去掉,只索要一个1e7的int数组,显然不会爆堆,此时就不会执行flag函数

至于堆空间有多大呢?

这个在PE头->NT头->附加头->SizeOfHeapReserve

用010editor打开main.exe观察这个位置

发现给堆预留的空间是100000h=1MB

如果我们没有设置过处理函数,则执行loc_4C7F30缺省处理过程.该处理过程干了啥呢?

1
2
3
4
5
6
7
8
9
10

.text:004C7F30
.text:004C7F30 loc_4C7F30:             ; thrown_size
.text:004C7F30 mov     [esp+1Ch+Size], 4
.text:004C7F37 call    ___cxa_allocate_exception
.text:004C7F3C mov     dword ptr [eax], offset off_4D8C80
.text:004C7F42 mov     [esp+1Ch+var_14], offset __ZNSt9bad_allocD1Ev ; void (__cdecl *)(void *)
.text:004C7F4A mov     [esp+1Ch+lptinfo], offset __ZTISt9bad_alloc ; lptinfo
.text:004C7F52 mov     [esp+1Ch+Size], eax ; void *
.text:004C7F55 call    ___cxa_throw
.text:004C7F55 __Znwj endp

这个结构并没有返回到loc_4C7F12重新尝试malloc,

一开始调用了___cxa_allocate_exception

发生了什么事呢?先看结局,

要么左下GE,函数返回了,其效果就相当于malloc一开始就开出来然后返回了

要么右下BE,还是开不出来,直接调用了terminate()终止了程序

GE结局有两种达成情况,一个是___cxa_allocate_exception又尝试了一次malloc,这次开出来了,直接GE

另一种达成清空是,这次又没开出来,两次malloc都没开出来,这时候进入了loc_4C805C,关键调用了一个__ZN12_GLOBAL__N_14pool8allocateEj_constprop_0

反汇编这个函数看看吧,好家伙都用到了互斥锁,涉及进程安全性了,上网搜一下pool_allocate吧,说是内存池之类的东西.

这就需要学了CSAPP实现malloc和STL源码剖析再说了

本次对operator new的炎鸠就到此位置吧

回到LinkedStack()函数中

mov ebx, eax

如果能回来,说明new没有寄,那么eax中就是new在堆上开辟的对象的地址

这里eax将堆上对象的地址交给了ebx

mov dword ptr [esp+4], 0

本条指令以及后面的mov dword ptr [esp], 0参数压栈,马上要调用函数了

mov ecx, ebx

ebx将堆上对象的地址交给ecx,

可是不应该放在栈上head的地方吗?为啥要给ecx呢?

之前我们已经知道,ecx是用来存放当前对象的,其作用也就是this指针

那么后面啃腚要调用一个作用于当前对象的函数

刚才我们从new的逻辑中只能看到分配了空间,可是这片对空间并没有初始化,而head = new LinkedNode();这里调用了构造函数.

那么可以推测,马上就要调用LinkedNode的构造函数了

call __ZN10LinkedNodeC1EiPS_ ; LinkedNode::LinkedNode(int,LinkedNode*)

果然如此,调用了LinkedNode构造函数,他有两个参数,都是4字节类型

并且我们没有在源代码显式地给他传参,而是使用的缺省参数(默认为0)

1

head = new LinkedNode();

这也就解释了刚才压栈两个0是为啥了

跟踪一下LinkedNode()干了啥

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

.text:00421FE8 ; Attributes: bp-based frame
.text:00421FE8
.text:00421FE8 ; LinkedNode::LinkedNode(int, LinkedNode*)
.text:00421FE8 public __ZN10LinkedNodeC1EiPS_
.text:00421FE8 __ZN10LinkedNodeC1EiPS_ proc near
.text:00421FE8
.text:00421FE8 var_4= dword ptr -4
.text:00421FE8 arg_0= dword ptr  8
.text:00421FE8 arg_4= dword ptr  0Ch
.text:00421FE8
.text:00421FE8 push    ebp
.text:00421FE9 mov     ebp, esp
.text:00421FEB sub     esp, 4
.text:00421FEE mov     [ebp+var_4], ecx
.text:00421FF1 mov     eax, [ebp+var_4]
.text:00421FF4 mov     edx, [ebp+arg_0]
.text:00421FF7 mov     [eax], edx
.text:00421FF9 mov     eax, [ebp+var_4]
.text:00421FFC mov     edx, [ebp+arg_4]
.text:00421FFF mov     [eax+4], edx
.text:00422002 nop
.text:00422003 leave
.text:00422004 retn    8
.text:00422004 __ZN10LinkedNodeC1EiPS_ endp

esp-4在栈上申请了4字节空间,然后存放ecx中的对象地址,然后过继给eax

arg_0是左边第一个参数,经过edx中转放到[eax]上,这个寄存器寻址,也就是对象的起始位置,也就是int value的位置

arg_4,第二个参数,经过edx中转放到[eax+4],也就是对象起始地址偏上4个字节,即第二个成员LinkedNode *next的地址

retn 8相当于

1
2

add esp, 8h
ret

即函数尾声

函数的局部变量就一个当前对象地址的拷贝,4个字节,这里为啥要退栈8字节呢?

退栈之前的栈帧状态:

1 2 3 4 5 6 7

LinkedStack的栈帧 ... 参数2 参数1 LinkedNode()的栈帧 返回值地址<-ebp 局部变量

退栈后

1 2

参数2 参数1

显然是合理的,调用者LinkedStack清理参数

也就是说LinkedNode()将堆上LinkedNode对象两个成员都置零

回到LinkedStack中

sub esp, 8

又申请了8字节的空间

eax, [ebp+var_C]

var_C是存放的LinkedStack对象的堆地址

这里将它交给eax,看来是马上对他读写了

[eax+4], ebx

ebx是LinkedNode对象的堆地址,[eax+4]寄存器相对寻址,解引用之后是LinkedStack对象的第二个成员,即LinkedNode *head

这里就是将head句柄落实了,让他指向了堆上的一片空间

mov ebx, [ebp+var_4]

var_4是函数开端时被调用者保存的上级函数的ebx值

见函数开端

1
2
3

.text:00422334 push    ebp
.text:00422335 mov     ebp, esp
.text:00422337 push    ebx

现在本函数进入尾声了,要归还上级函数的ebx寄存器了,于是从栈里把他弹出来

leave

栈顶指针退回到本函数的帧指针处,帧指针重新指向上级函数的帧底

1
2

movq esp, ebp    # 使 rsp 和 rbp 指向同一位置，即子栈帧的起始处
popq ebp	#弹出开端时压栈保存的上级函数帧指针

retn

相当于

1
2

add esp, 0h
ret

函数返回了

从LinkedStack()回到main()

从LinkedStack回来时标绿的部分执行完毕

loc_401557

1
2
3
4

.text:00401557 loc_401557:
.text:00401557 mov     eax, [ebp+var_14]
.text:0040155A cmp     eax, 0Ah
.text:0040155D jg      short loc_40157D

这里做了一个判断var_14是否为10

如果var_14>10则跳转loc_40157D

也就是右侧

否则执行左侧循环

左侧循环体中,var_14每次+1,显然是作为循环变量用的

对应到源代码是

1
2
3
4

for (int i = 1; i <= 10; ++i)
{
    sta.push(i);
}

这里var_14就是i,判断条件就是10

循环体

1
2
3
4
5
6
7
8
9
10

.text:0040155F lea     eax, [ebp+var_10]
.text:00401562 lea     edx, [ebp+var_14]
.text:00401565 mov     [esp], edx      ; this
.text:00401568 mov     ecx, eax
.text:0040156A call    __ZN11LinkedStack4pushERKi ; LinkedStack::push(int const&)
.text:0040156F sub     esp, 4
.text:00401572 mov     eax, [ebp+var_14]
.text:00401575 add     eax, 1
.text:00401578 mov     [ebp+var_14], eax
.text:0040157B jmp     short loc_401557

var_10的地址放到eax中,var_10中存放的是什么,在调用LinkedStack()之前该值被作为唯一的参数传递给LinkedStack,显然是this指针,那么var_10存放的就是LinkedStack对象的首地址

var_14的地址放到edx中,var_14是循环变量,也是每次循环时将要被压入LinkedStack的值

mov [esp], edx将要压入LinkedStack的值先放到栈顶,作为参数传递

ecx, eax用ecx承载LinkedStack对象地址,这是调用约定,马上就要调用成员函数了

call __ZN11LinkedStack4pushERKi ; LinkedStack::push(int const&)

该函数的唯一一个参数已经被刚才mov [esp], edx放到栈顶了

该函数的细节就不需要步入跟踪了,放一张截图,反汇编写的已经很明白了

跳出循环体

当var_14也就是i=11,超过10的时候,跳出了循环

进入loc_40157D

这里面大多数逻辑或者类似逻辑都已经炎鸠过了还差一个cout<<这个玩意儿

下面炎鸠一下这个怎么实现的

std::cout

源代码

1

cout << sta.length() << endl;

反汇编

1
2
3
4
5
6

.text:0040157D lea     eax, [ebp+var_10]	;var_10,LinkedStack对象
.text:00401580 mov     ecx, eax				;var_10经过eax中转放到ecx,为了遵守调用约定
.text:00401582 call    __ZNK5Stack6lengthEv ; Stack::length(void)
.text:00401587 mov     [esp], eax
.text:0040158A mov     ecx, offset __ZSt4cout ; std::cout
.text:0040158F call    __ZNSolsEi      ; std::ostream::operator<<(int)

length函数的返回值放在eax中然后放到栈顶,准备参数

然后把__ZSt4cout的地址放到ecx中,显然作为对象传递

然后调用了__ZNSolsEi,即operator<<函数,打印了length

本函数执行之后,终端上已经打印出10了

可是后来貌似还打印了一些东西

1
2
3
4

.text:00401594 sub     esp, 4
.text:00401597 mov     dword ptr [esp], offset __ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_ ; this
.text:0040159E mov     ecx, eax
.text:004015A0 call    __ZNSolsEPFRSoS_E ; std::ostream::operator<<(std::ostream & (*)(std::ostream &))

又压栈了一个__ZSt4endlIcSt11char_traitsIcEERSt13basic_ostreamIT_T0_ES6_的地址作为参数

这是个啥呢?跟踪它,IDA给出的注释是

1

std::ostream *__cdecl std::endl<char,std::char_traits<char>>(std::ostream *__os)

原来是endl,它原来是个函数(函数模板)

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

std::ostream *__cdecl std::endl<char,std::char_traits<char>>(std::ostream *__os)
{
  int v1; // eax
  _BYTE *v2; // ebx
  int v3; // eax
  int (__stdcall *v5)(char); // edx
  char v6; // [esp+4h] [ebp-18h]

  v1 = *(_DWORD *)(*(_DWORD *)__os - 12);
  v2 = *(_BYTE **)((char *)__os + v1 + 124);
  if ( !v2 )
    std::__throw_bad_cast();
  if ( v2[28] )
  {
    v3 = (char)v2[39];
  }
  else
  {
    std::ctype<char>::_M_widen_init(*(_DWORD *)((char *)__os + v1 + 124));
    v5 = *(int (__stdcall **)(char))(*(_DWORD *)v2 + 24);
    v3 = 10;
    if ( v5 != std::ctype<char>::do_widen )
      v3 = ((char (__thiscall *)(_BYTE *, int))v5)(v2, 10);
  }
  std::ostream::put((std::ostream *)v3, v6);
  return std::ostream::flush(__os);
}

该函数的参数类型为std::ostream *__os,此os不是操作系统的缩写,而是ostream唯一的一个标准输出对象cout

至于cout,endl,ostream都长啥样,干了啥,现在不做炎鸠,留作后话吧

C++中endl的本质是什么_xiaofei0859的博客-CSDN博客_c++ endl

为啥可以cout.operator<<(endl);这样调用,endl不是一个函数吗?

显然ostream类中有对operator<<(endl)的重载函数,咋重载的现在不想了解

总结

调用约定

参数使用栈传递,从右向左压栈,栈顶是最左的参数

this指针使用ecx寄存器传递,成员函数的其他参数使用栈传递

成员函数返回值使用eax传递

成员函数的 调用和普通函数几乎没有区别,就多一个一个ecx传递对象指针

new和构造函数的关系

它俩不存在谁调用谁的关系,调用者函数首先调用operator new函数在堆上申请空间,然后调用者接着调用构造函数初始化这片空间

new的工作细节

在operator new执行之前,调用者会把new应当申请多大空间,写到栈上,这个位置后来还得存放new返回的句柄

new不需要知道开辟空间是为了干什么,只需要一个大小参数

new会调用malloc函数,如果malloc开不出来则尝试调用get_new_handle即用户自定义的处理函数.

如果用户没有定义该函数则走默认的流程,

这个默认的流程还没有全炎鸠明白

构造函数的工作细节

反汇编视角下的构造函数和普通的成员函数没有区别,都是使用ecx表示当前对象地址,或者说new在堆上开出的地址

构造函数通过ecx拿到堆上的一片地址后,构造函数就认为这里就是我要进行初始化的对象,构造函数才不会管这片空间够不够大

因此

1
2
3
4
5
6
7
8
9

class Test{
    int x;
    int y;
};
int main()
{
    Test *a=(Test*)new int;
    return 0;
}

这种代码也是可以通过编译的,但是new只在堆上开了一个int的大小即4字节,显然放不开一个8字节的Test

但是编译器不知道,程序运行的时候也不知道,这就发生了类似数组访问越界的行为.Test.y成员写到堆上的位置是没有申请的空间,下一次申请堆空间就会覆盖掉这个地址

MRCTF2020-EzCPP

main函数

ida给出的反编译伪代码真的是老太太的裹脚--又臭又长

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

int __cdecl main(int argc, const char **argv, const char **envp)
{
  __int64 v3; // rax
  __int64 v4; // rbx
  __int64 v5; // rax
  bool v6; // bl
  __int64 v7; // rax
  __int64 v8; // rax
  __int64 v9; // rax
  __int64 v10; // rax
  __int64 v11; // rax
  __int64 v12; // rax
  char v14[40]; // [rsp+0h] [rbp-140h] BYREF
  __int64 v15; // [rsp+28h] [rbp-118h] BYREF
  __int64 v16; // [rsp+30h] [rbp-110h] BYREF
  int v17; // [rsp+3Ch] [rbp-104h] BYREF
  char v18[32]; // [rsp+40h] [rbp-100h] BYREF
  char v19[48]; // [rsp+60h] [rbp-E0h] BYREF
  char v20[31]; // [rsp+90h] [rbp-B0h] BYREF
  char v21; // [rsp+AFh] [rbp-91h] BYREF
  char v22[47]; // [rsp+B0h] [rbp-90h] BYREF
  char v23; // [rsp+DFh] [rbp-61h] BYREF
  char v24[36]; // [rsp+E0h] [rbp-60h] BYREF
  int v25; // [rsp+104h] [rbp-3Ch]
  char *v26; // [rsp+108h] [rbp-38h]
  int *v27; // [rsp+110h] [rbp-30h]
  _DWORD *v28; // [rsp+118h] [rbp-28h]
  int *v29; // [rsp+120h] [rbp-20h]
  int i; // [rsp+128h] [rbp-18h]
  int v31; // [rsp+12Ch] [rbp-14h]

  v31 = 0;
  std::vector<int>::vector(v20, argv, envp);
  std::vector<bool>::vector(v19);
  std::allocator<char>::allocator(&v21);
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v18, &unk_500E, &v21);
  std::allocator<char>::~allocator(&v21);
  v3 = std::operator<<<std::char_traits<char>>(&std::cout, "give me your key!");
  std::ostream::operator<<(v3, &std::endl<char,std::char_traits<char>>);
  for ( i = 0; i <= 8; ++i )
  {
    std::istream::operator>>(&std::cin, &keys[i]);
    std::__cxx11::to_string((std::__cxx11 *)v22, keys[i]);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::operator+=(v18, v22);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v22);
  }
  v28 = keys;
  v29 = keys;
  v27 = (int *)&unk_83E4;
  while ( v29 != v27 )
  {
    v17 = *v29;
    std::vector<int>::push_back(v20, &v17);
    ++v29;
  }
  v4 = std::vector<std::shared_ptr<SQLStorage::AddUpdateTable>>::end(v20);
  v5 = fmt::v6::internal::get_container<fmt::v6::internal::buffer<char>>(v20);
  std::for_each<__gnu_cxx::__normal_iterator<char *,std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>>,boost::unit_test::output::s_replace_chars>(
    v5,
    v4);
  v26 = v20;
  v16 = fmt::v6::internal::get_container<fmt::v6::internal::buffer<char>>(v20);
  v15 = std::vector<std::shared_ptr<SQLStorage::AddUpdateTable>>::end(v26);
  while ( __gnu_cxx::operator!=<spdlog::details::log_msg_buffer const*,std::vector<spdlog::details::log_msg_buffer>>(
            (const __gnu_cxx::__normal_iterator<const std::shared_ptr<sio::message>*,std::vector<std::shared_ptr<sio::message>> > *)&v16,
            (const __gnu_cxx::__normal_iterator<const std::shared_ptr<sio::message>*,std::vector<std::shared_ptr<sio::message>> > *)&v15) )
  {
    v25 = *(_DWORD *)__gnu_cxx::__normal_iterator<int *,std::vector<int>>::operator*(&v16);
    std::allocator<char>::allocator(&v23);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v14, &unk_500E, &v23);
    std::allocator<char>::~allocator(&v23);
    depart(v25, (__int64)v14);
    {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>> &)#1}::operator()(
      (__int64)&func,
      (__int64)v14);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string(v24, v14);
    v6 = !{lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>,int)#2}::operator()(
            (__int64)&check,
            (__int64)v24,
            v31);
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v24);
    if ( v6 )
    {
      v7 = std::operator<<<std::char_traits<char>>(&std::cout, "Wrong password!");
      std::ostream::operator<<(v7, &std::endl<char,std::char_traits<char>>);
      system("pause");
      exit(0);
    }
    ++v31;
    std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v14);
    __gnu_cxx::__normal_iterator<unsigned int *,std::vector<unsigned int>>::operator++(&v16);
  }
  v8 = std::operator<<<std::char_traits<char>>(&std::cout, "right!");
  std::ostream::operator<<(v8, &std::endl<char,std::char_traits<char>>);
  v9 = std::operator<<<std::char_traits<char>>(&std::cout, "flag:MRCTF{md5(");
  v10 = std::operator<<<char>(v9, v18);
  v11 = std::operator<<<std::char_traits<char>>(v10, ")}");
  std::ostream::operator<<(v11, &std::endl<char,std::char_traits<char>>);
  v12 = std::operator<<<std::char_traits<char>>(
          &std::cout,
          "md5()->{32/upper case/put the string into the function and transform into md5 hash}");
  std::ostream::operator<<(v12, &std::endl<char,std::char_traits<char>>);
  system("pause");
  std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::~basic_string(v18);
  std::vector<bool>::~vector(v19);
  std::__cxx1998::vector<double,std::allocator<double>>::~vector((std::vector<std::shared_ptr<sio::message>> *const)v20);
  return 0;
}

其中甚至都有分配器allocator实例的创建,还有析构函数的调用,真的是废话

ida有时候为同一对象创建了好多副本,但是实际上都是只读访问的副本,根本没有必要创建

甚至有的副本创建了根本不访问

为啥ida有时候显得很呆?

他只是刻板地按照堆栈中存在过的局部变量,决定创建或者不创建一个对象,它没法确定后来有没有使用这个对象,或者是否只是只读访问这个对象

main翻译成人话

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

int main()
{
    vector<int> v;
    string final;
    cout << "give me your key!" << endl;
    for (int i = 0; i <= 8; ++i)
    {
        cin >> keys[i];
        final += to_string(keys[i]);
        v.push_back(keys[i] ^ 1);//放到向量v里面的是输入与1的按位异或
    }
    for (int i = 0; i < v.length(); ++i)
    {
        string temp;
        depart(v[i], temp);

        将temp中的一些字符换掉

            if (temp和ans[i] 字符串不相同)
        {
            cout << "wrong password!" << endl;
            system("pause");
            exit(0);
        }
    }

    cout << "right!" << endl;
    cout << "flag:MRCTF{md5(" << final << ")}" << endl;
    cout << "md5()->{32/upper case/put the string into the function and transform into md5 hash}" << endl;
    system("pause");

    return 0;
}

关键点在于三个lambda和一个depart

第一个lambda已经翻译成人话了,就是一个keys[i]^1

第二个lambda已经翻译成汉字了,"将temp中的一些字符换掉"

具体的更换规则

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

__int64 __fastcall {lambda(std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>> &)#1}::operator()(__int64 a1, __int64 a2) { 将a2中的原数->新数 48->79 0->O 49->108 1->l 50->122 2->z 51->69 3->E 52->65 4->A 53->115 5->s 54->71 6->G 55->84 7->T 56->66 8->B 57->113 9->q 32->61 空格->等号= }

第三个lambda也翻译成汉字了"temp和ans[i]字符串不相同",这个就是判断条件

ans[i]是程序每次都会自动初始化好的,应该是全局位置的string数组,

这个数组的初始化在哪里看呢?

跟踪这个lambda表达式

继续跟踪这个ans数组

发现他在bss段,按下ctrl+x观察交叉引用,发现有一个__static_initialization_and_destruction_0函数引用过该数组,追踪该函数,其中有:

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

std::ios_base::Init::Init((std::ios_base::Init *)&std::__ioinit); __cxa_atexit((void (__fastcall *)(void *))&std::ios_base::Init::~Init, &std::__ioinit, &_dso_handle); std::allocator<char>::allocator(&v3); std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string( &ans[abi:cxx11], "=zqE=z=z=z", &v3); std::allocator<char>::~allocator(&v3); std::allocator<char>::allocator(&v4); std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string( (char *)&ans[abi:cxx11] + 32, "=lzzE", &v4) std::allocator<char>::~allocator(&v4); std::allocator<char>::allocator(&v5); std::__cxx11::basic_string<char,std::char_traits<char>,std::allocator<char>>::basic_string( (char *)&ans[abi:cxx11] + 64, "=ll=T=s=s=E", &v5); ...

相当于

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

string ans[9] = { "=zqE=z=z=z", "=lzzE", "=ll=T=s=s=E", "=zATT", "=s=s=s=E=E=E", "=EOll=E", "=lE=T=E=E=E", "=EsE=s=z", "=AT=lE=ll" };

于是就得到了ans数组,后面的工作就是从ans数组开始反回去

depart(v[i], temp);

depart函数干了啥事呢?将v[i]分解质因数,然后按照从大到小的顺序,放到temp字符串里

1
2
3
4
5
6
7
8
9
10
11
12

void depart(int a1, string &s)
{
    for (int i = 2; sqrt(a1) >= i; ++i) // i从2根号a1,遍历求a1的乘法因子
    {
        if ((a1 % i) == 0)
        {                      //当a1%i能够除开则i是a1的除法因子
            depart(a1 / i, s); // a1中去掉刚刚找到的乘法因子i,然后继续寻找剩下的乘法银子
            break;
        }
    }
    s = s + " " + to_string(v6); //由于最深处的递归函数首先执行本行,因此,最大的因子最先添加到a2上
}

解密脚本

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

#include <iostream>
#include <vector>
#include <string>
using namespace std;
string ans[11] = {
    "=zqE=z=z=z",

    "=lzzE",

    "=ll=T=s=s=E",

    "=zATT",

    "=s=s=s=E=E=E",

    "=EOll=E",

    "=lE=T=E=E=E",

    "=EsE=s=z",

    "=AT=lE=ll"
};
void change(string &str)
{
    for (int i = 0; i < str.length(); ++i)
    {
        switch (str[i])
        {
        case 'O':
            str[i] = '0';
            break;
        case 'l':
            str[i] = '1';
            break;
        case 'z':
            str[i] = '2';
            break;
        case 'E':
            str[i] = '3';
            break;
        case 'A':
            str[i] = '4';
            break;
        case 's':
            str[i] = '5';
            break;
        case 'G':
            str[i] = '6';
            break;
        case 'T':
            str[i] = '7';
            break;

        case 'B':
            str[i] = '8';
            break;
        case 'q':
            str[i] = '9';
            break;
        case '=':
            str[i] = ' ';
            break;
        }
    }
}
int calc(const string &str){
    string temp;
    int ans=1;
    for(int i=1;i<str.length();++i){
        if(str[i]==' '){
            ans*=stoi(temp);
            temp="";
        }
        else{
            temp+=str[i];
        }
    }
    ans*=stoi(temp);
    return ans;
}
int main(int argc, char **argv, char **envp)
{
    for (int i = 0; i < 11; ++i)
    {
        change(ans[i]);
        cout<<(calc(ans[i])^1)<<endl;
    }
    return 0;
}

运行结果

1
2
3
4
5
6
7
8
9
10

PS C:\Users\86135\Desktop\MRCTF2020\EzCPP> ./test
2345
1222
5774
2476
3374
9032
2456
3531
6720

Linux虚拟机或者wsl上运行EasyCPP然后把keys乎进去

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16