尝试面向对象

最新推荐文章于 2024-05-20 15:29:54 发布
最新推荐文章于 2024-05-20 15:29:54 发布
阅读量73 收藏
点赞数
分类专栏： 我的 Windows 编程之旅 文章标签： c++ windows
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37435888/article/details/106604109
版权

尝试面向对象


在编写Win32窗口的时候, 创建两个及以上的窗口, 不可避免的需要初始化 WNDCLASS, 调用 CreateWindow来获取窗口, 重写 WNDPROC函数来实现特定的功能, 如果能将以面向对象的思想, 将窗口的共性通过类来表示就能一定程度上简化开发流程, 另外还有一些优势:

  1. 对一些变量限制访问, 一定程度上能减少对变量的错误操作, 也能实现对变量的访问限制
  2. 以成员函数的方式, 更能方便的拓展窗口的功能
  3. 进行一定的抽象, Win32程序的架构更加的清晰

尝试面向对象

窗口的Window Procedure

使用DefWindowProc函数

可以写出一个最简单的Window Procedure函数:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	return 0;
}

不过这样写并不能真正使用. 实际上, 这样做的后果就是CreateWindow1会返回一个NULL值, 在MSDN查阅CreateWindowExW函数, 可以看到:

This function typically fails for one of the following reasons:

  • an invalid parameter value
  • the system class was registered by a different module
  • The WH_CBT hook is installed and returns a failure code
  • if one of the controls in the dialog template is not registered, or its window window procedure fails
    WM_CREATE or WM_NCCREATE

其中最有可能的是第四条,窗口的Procedure函数处理WM_CREATE 或者 WM_NCCREATE消息失败了:

If an application processes this message, it should return zero to continue creation of the window.
If the application returns –1, the window is destroyed and the CreateWindowEx or CreateWindow
function returns a NULL handle. ------ WM_CREATE

If an application processes this message, it should return TRUE to continue creation of the window. If
the application returns FALSE, the CreateWindow or CreateWindowEx function will return a NULL
handle. ------ WM_NCCREATE

但是就算是将这两个消息单独拿出来处理, 仍然不能正确显示一个窗口:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	if (uMsg == WM_CREATE) return 0;
	if (uMsg == WM_NCCREATE) return TRUE;
	else return 0;
}

这样做CreateWindow不会返回NULL值了, 在任务栏上也能看到窗口, 但是仍然无法在屏幕上看到.任务栏上的窗口
一种编写方式是把每一种会接收到的Windows消息都进行处理, 这样自然不会有问题, 包括WM_CREATE, WM_NCCREATE, WM_ACTIVE, WM_TIMER, WM_PAINT, WM_ERASEBKGND, WM_CLOSE, WM_POWERBROADCAST等等, 很多消息都需要处理, 虽然有的很简单, 也许和WM_CREATE或者WM_NCCREATE一样, 返回一个值就能正常运行, 但对很多其实并不需要特殊处理的消息, 可以调用DefWindowProc, 这个函数已经提供了最基础的消息处理:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

或者在接收到WM_DESTROY消息时调用PostQuitMessage来结束消息循环, 退出程序:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	if(uMsg == WM_DESTROY) PostQuitMessage(0);
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

在Window Procedure中处理消息

在一个Window Procedure使用if-else语句时:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	if (uMsg == WM_DESTROY) {
		PostQuitMessage(0);
		return 0;
	}
	else if (uMsg == WM_CHAR) {
		//如果按下空格, ......
		if (wParam == ' ') {
			//......
			return 0;
		}

	}
	else if(uMsg == WM_PAINT){
		//绘制窗口
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hwnd, &ps);
		//......
		EndPaint(hwnd, &ps);
		return 0;
	}
	else if (uMsg == WM_CLOSE) {
		if (IDNO == MessageBox(hwnd, TEXT("Quit?"), TEXT("Quit"), MB_YESNO)) {
			return 0;
		}
	}
	//else if(......)......
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

或者使用switch语句:

LRESULT CALLBACK wnd_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	switch (uMsg) {
	case WM_DESTROY:
		PostQuitMessage(0);
		return 0;
	case WM_CHAR:
		//如果按下空格, ......
		if (wParam == ' ') {
			//......
			return 0;
		}
		break;
	case WM_PAINT: 
	{
		//绘制窗口
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(hwnd, &ps);
		//......
		EndPaint(hwnd, &ps); 
	}
		return 0;
	case WM_CLOSE:
		if (IDNO == MessageBox(hwnd, TEXT("Quit?"), TEXT("Quit"), MB_YESNO)) {
			return 0;
		}
		break;
		//case (......)......
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

当窗口功能很多时, 函数可能变得非常大而复杂, 如果能按照对象来调用函数, 使用起来会更简单一些:

LRESULT CALLBACK MyWin::Proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
	switch (uMsg) {
	case WM_DESTROY:
		return this->OnDestroy();
	case WM_CHAR:
		return this->OnChar(wParam);
	case WM_PAINT: 
		this->OnPaint();
		return 0;
	case WM_CLOSE:
		return this->OnClose();
	//case(......)......
	}
	return DefWindowProc(hwnd, uMsg, wParam, lParam);
}

使用CREATESTRUCT

CREATESTRUCT

在调用CreateWindow时, CreateWindow宏最终会展开为CreateWindowExA或者CreateWindowExW,2 而这两个函数区别不太, 所以这里就引用CreateWindowEx宏:

HWND WINAPI CreateWindowEx(
  _In_     DWORD     dwExStyle,
  _In_opt_ LPCTSTR   lpClassName,
  _In_opt_ LPCTSTR   lpWindowName,
  _In_     DWORD     dwStyle,
  _In_     int       x,
  _In_     int       y,
  _In_     int       nWidth,
  _In_     int       nHeight,
  _In_opt_ HWND      hWndParent,
  _In_opt_ HMENU     hMenu,
  _In_opt_ HINSTANCE hInstance,
  _In_opt_ LPVOID    lpParam
);

可以看到, 最后的一个形参lpParam, 它实际上对应WM_CREATE消息的LPARAM参数, 不过在WNDPROC函数中接收的并不是传入的lpParam, 而是另一个CREATESTRUCTA / CREATESTRUCTW的结构体的指针. CREATESTRUCTA 和 CREATESTRUCTW 同样除了字符串的编码方式之外区别不大, 所以这里引用 CREATESTRUCT 宏:

typedef struct tagCREATESTRUCT {
  LPVOID    lpCreateParams;
  HINSTANCE hInstance;
  HMENU     hMenu;
  HWND      hwndParent;
  int       cy;
  int       cx;
  int       y;
  int       x;
  LONG      style;
  LPCTSTR   lpszName;
  LPCTSTR   lpszClass;
  DWORD     dwExStyle;
} CREATESTRUCT, *LPCREATESTRUCT;

CREATESTRUCT中的lpCreateParams其实就是创建窗口时传入的lpParam参数.
lpParam参数是个LPVOID (void*) 类型, 传入的类型没有限制, 参考MSDN中的说明3, 可以在WNDPROC函数中获取该值, 也可以用它来储存状态, 而不必总在全局声明变量.

typedef struct {
	char key;
}StateInfo, *PStateInfo;
//......
StateInfo stateInfo = {' '};
hwnd = CreateWindowExW(
		0,
		g_wnd_classw.lpszClassName,
		L"Main Window",
		WS_OVERLAPPEDWINDOW,
		CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,
		NULL, NULL,
		g_hInst,
		(LPVOID)&stateInfo
	);
//.......
	case WM_CREATE: 
	{
		LPCREATESTRUCT pCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
		PStateInfo pStateInfo = reinterpret_cast<PStateInfo>(pCreateStruct->lpCreateParams);
		SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pStateInfo);
	}
	case WM_CHAR:
	{
		LONG_PTR ptr = GetWindowLongPtr(hwnd, GWLP_USERDATA);
		StateInfo *pStateInfo = reinterpret_cast<StateInfo*>(ptr);
		//如果按下key, 就直接退出
		if (pStateInfo->key == wParam) {
			//......
			DestroyWindow(hwnd);
			return 0;
		}
		break;
	}
//......

SetWindowLongPtr与GetWindowLongPtr

上述代码中还使用了SetWindowLongPtr4与GetWindowLongPtr这对函数, 它们的作用是将pStateInfo与hwnd所标识的窗口绑定, 并能以hwnd来唯一地取出pStateInfo.

LONG_PTR WINAPI SetWindowLongPtr(
  _In_ HWND     hWnd,
  _In_ int      nIndex,
  _In_ LONG_PTR dwNewLong
);

SetWindowLongPtr 将dwNewLong存入某个有偏移量nIndex的内存位置, 而这个位置在窗口额外空间中(extra window memory5).

通过pStateInfo来调用

pStateInfo可以接收LPVOID类型指针, 也就意味着可以实现一个窗口的类, 创建时将自己传入其中:

HINSTANCE g_hInstance;
LRESULT CALLBACK win_proc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam);
class MyWin {
public:
	MyWin() :m_hwnd(NULL) {}
	bool Create(
		PCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle = 0,
		int x = CW_USEDEFAULT, int y = CW_USEDEFAULT,
		int nWidth = CW_USEDEFAULT, int nHeight = CW_USEDEFAULT,
		HWND hWndParent = 0, HMENU hMenu = 0
	) {
		WNDCLASS wc = { 0 };

		wc.lpfnWndProc = win_proc;
		wc.hInstance = g_hInstance;
		wc.lpszClassName = L"MyWin Class";

		RegisterClass(&wc);

		m_hwnd = CreateWindowEx(
			dwExStyle, wc.lpszClassName, lpWindowName, dwStyle, x, y,
			nWidth, nHeight, hWndParent, hMenu, g_hInstance, this
		);

		return m_hwnd != NULL;
	}
public:
	HWND m_hwnd;

	LRESULT OnClose() {
		if (MessageBox(m_hwnd, L"Quit?", L"Quit", MB_YESNO) == IDYES) DestroyWindow(m_hwnd);
		return 0;
	}
	LRESULT OnDestroy() {
		PostQuitMessage(0);
		return 0;
	}
	LRESULT OnPaint() {
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(m_hwnd, &ps);
		RECT drawRect;
		GetClientRect(m_hwnd, &drawRect);
		DrawText(hdc, TEXT("HELLO WORLD"),-1, &drawRect,
			DT_SINGLELINE | DT_CENTER | DT_VCENTER);
		EndPaint(m_hwnd, &ps);
		return 0;
	}
	LRESULT OnCreate() {

	}
	BOOL Show(int nCmdShow) {
		return ShowWindow(m_hwnd, nCmdShow);
	}
};

函数指针问题

在编写面向对象的窗口类时, 我有一个一直无法解决的问题, 注册Window Class时需要给lpfnWndProc传入一个WNDPROC类型的函数指针, 但是它不能是成员(非静态的)函数, 也就是说:

LRESULT CALLBACK MyWin::WndProc(UINT uMsg, WPARAM wParam, LPARAM lParam) {
	//......
}

即使为lpfnWndProc设计了Window Procedure函数, 也无法传入:

wnd_class.lpfnWndProc = (WNDPROC)this->Proc; //错误, 无法完成对应指针的转换!

参考managing application state的示例实现, 提供了一个思路, 使用模板和静态成员函数, 通过代理的方式调用成员函数类型的Window Procedure.

Invoke
WM_CREATE/WM_NCCREATE
Other Message
Call Window Procedure
static WindowProc
SetWindowLongPtr
GetWindowLongPtr
pCaller is not NULL
unstatic HandleMessage
pCaller is NULL
DefWindowProc
Return 
template <class DERIVED_TYPE> 
class BaseWindow
{
public:
    static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
    {
        DERIVED_TYPE *pThis = NULL;

        if (uMsg == WM_NCCREATE)
        {
            CREATESTRUCT* pCreate = (CREATESTRUCT*)lParam;
            pThis = (DERIVED_TYPE*)pCreate->lpCreateParams;
            SetWindowLongPtr(hwnd, GWLP_USERDATA, (LONG_PTR)pThis);

            pThis->m_hwnd = hwnd;
        }
        else
        {
            pThis = (DERIVED_TYPE*)GetWindowLongPtr(hwnd, GWLP_USERDATA);
        }
        if (pThis)
        {
            return pThis->HandleMessage(uMsg, wParam, lParam);
        }
        else
        {
            return DefWindowProc(hwnd, uMsg, wParam, lParam);
        }
    }
    BOOL Create(
        PCWSTR lpWindowName,
        DWORD dwStyle,
        DWORD dwExStyle = 0,
        int x = CW_USEDEFAULT,
        int y = CW_USEDEFAULT,
        int nWidth = CW_USEDEFAULT,
        int nHeight = CW_USEDEFAULT,
        HWND hWndParent = 0,
        HMENU hMenu = 0
        )
    {
        WNDCLASS wc = {0};

        wc.lpfnWndProc   = DERIVED_TYPE::WindowProc;
        wc.hInstance     = GetModuleHandle(NULL);
        wc.lpszClassName = ClassName();
        //......
    }
    //......
};

(以上代码引用自managing application state, 删减了部分代码, 详见链接)
通过wc.lpfnWndProc = DERIVED_TYPE::WindowProc;将对应类型的静态Window Procedure函数DERIVED_TYPE::WindowProc赋值给lpfnWndProc变量, 然后在WindowProc中进行调用pThis->HandleMessage(uMsg, wParam, lParam);

完整代码实现

编写窗口基类

template<typename DerivedType>
class BaseWindow {
	typedef DerivedType* PDerivedType;
public:
	static LRESULT CALLBACK WindowProc(HWND hwnd, UINT uMsg, WPARAM wParam, LPARAM lParam) {
		PDerivedType pCaller = NULL;
		if (uMsg == WM_NCCREATE) {
			LPCREATESTRUCT lpCreateStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);
			pCaller = reinterpret_cast<PDerivedType>(lpCreateStruct->lpCreateParams);
			SetWindowLongPtr(hwnd, GWLP_USERDATA,(LONG_PTR) pCaller);
			pCaller->m_hwnd = hwnd;  //?
		}
		else {
			pCaller = reinterpret_cast<PDerivedType>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
		}
		if (pCaller) {
			switch (uMsg) {
			case WM_DESTROY: 
			{
				PAINTSTRUCT ps{};
				HDC hdc = ps.hdc;
				break; 
			}
			case WM_PAINT:
			{
				PAINTSTRUCT ps{};
				HDC hdc = ps.hdc;
				break;
			}
			}
			return pCaller->HandleMessage(uMsg, wParam, lParam);
		}
		else {
			return DefWindowProc(hwnd, uMsg, wParam, lParam); 
		}
	}
	BaseWindow() :m_hwnd(NULL) {}
	BOOL Create(
		PCWSTR lpWindowName, DWORD dwStyle, DWORD dwExStyle = 0,
		int x = CW_USEDEFAULT, int y = CW_USEDEFAULT,
		int nWidth = CW_USEDEFAULT, int nHeight = CW_USEDEFAULT,
		HWND hWndParent = 0, HMENU hMenu = 0
	) {
		WNDCLASS wc = { 0 };

		wc.lpfnWndProc = DerivedType::WindowProc;
		wc.hInstance = GetModuleHandle(NULL);
		wc.lpszClassName = CLASSNAME();

		RegisterClass(&wc);

		m_hwnd = CreateWindowEx(
			dwExStyle, wc.lpszClassName, lpWindowName, dwStyle, x, y,
			nWidth, nHeight, hWndParent, hMenu, GetModuleHandle(NULL), this
		);

		return m_hwnd != NULL ? TRUE:FALSE;
	}
	HWND GetWindow() { return m_hwnd; }
	BOOL ShowWnd(int nCmdShow) {
		return ShowWindow(m_hwnd, nCmdShow);
	}
	BOOL UpdateWnd() {
		return UpdateWindow(m_hwnd);
	}

protected:
	virtual LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) = 0;
	virtual PCWSTR CLASSNAME()const = 0;
	HWND m_hwnd;
};

简单的面向对象的Win32窗口实现

class SimpleWindow:public BaseWindow<SimpleWindow> {
public:
	LRESULT HandleMessage(UINT uMsg, WPARAM wParam, LPARAM lParam) {
		switch (uMsg) {
		case WM_DESTROY:
			PostQuitMessage(0);
			return 0;
		case WM_PAINT:
			OnPaint();
			return 0;
		case WM_CLOSE:
			return OnClose();
		}
		return DefWindowProc(m_hwnd, uMsg, wParam, lParam);
	}
	PCWSTR CLASSNAME()const { return L"simple window class"; };
protected:
	void OnPaint() {
		PAINTSTRUCT ps;
		HDC hdc = BeginPaint(m_hwnd, &ps);
		RECT rt;
		GetClientRect(m_hwnd, &rt);
		DrawText(hdc, L"Hello Window!", -1, &rt, DT_SINGLELINE | DT_CENTER | DT_VCENTER);

		EndPaint(m_hwnd, &ps);
	}
	LRESULT OnClose() {
		if (MessageBox(m_hwnd,
			L"It will quit the Window, Continue?", L"Quit Tip", MB_YESNO
		) == IDYES) {
			DestroyWindow(m_hwnd);
		}
		return 0;
	}
};

入口函数编写

int WINAPI wWinMain(HINSTANCE hInstance, HINSTANCE, LPWSTR lpCmdLine, int nCmdShow) {
	SimpleWindow smpWin;
	if (FALSE == smpWin.Create(L"Simple Window-A", WS_OVERLAPPEDWINDOW) ) return -1;
	
	smpWin.ShowWnd(nCmdShow);
	smpWin.UpdateWnd();

	MSG msg;

	while (GetMessage(&msg, NULL, 0, 0)) {
		TranslateMessage(&msg);
		DispatchMessage(&msg);
	}

	return 0;
}

  1. https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-createwindowexw ↩︎

  2. WinUser.h ↩︎

  3. https://docs.microsoft.com/en-us/windows/win32/learnwin32/managing-application-state- ↩︎

  4. https://docs.microsoft.com/zh-cn/windows/win32/api/winuser/nf-winuser-setwindowlongptra?redirectedfrom=MSDN ↩︎

  5. https://docs.microsoft.com/en-us/windows/win32/winmsg/about-window-classes#extra-class-memory ↩︎

qq_37435888
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
Python面向对象编程指南
03-22
Python是一种面向对象、解释型的程序设计语言，它已经被成功应用于科学计算、数据分析以及游戏开发等诸多领域。 Python面向对象编程指南深入介绍Python语言的面向对象特性，全书分3个部分共18章。第1部分讲述用特殊...
梳理面向对象的历史
weixin_44029038的博客
04-17 1211
面向对象的发展历史可以分为三个阶段： 雏形阶段、完善阶段和繁荣阶段
c语言如何实现面向对象编程
qq_27726651的博客
12-01 4513
一、简介 C语言是面向过程的一门语言，C++是面向对象，这个特性早已深入人心。但是嵌入式底层以及大型操作系统等却都是用C开发的。如果只用面向过程去开发这类大型软件，肯定行不通。 因此，C语言也可以用面向对象的思维去开发。例如现在的STM32的HAL库就在向着这个趋势进发。 二、 C语言实现封装 大部分使用 C 语言进行开发的工程师，在接触更高级的编程语言之前...
C# 面向对象
江江的博客
06-11 3046
/ 缴款 bool Withdraw(decimal amount);// 提，取（银行账户中的钱款） decimal Balance {get;} // 账户余额 } public class SaverAccount : IBankAccount {// 缴款 public bool Withdraw(decimal amount) // 提，取（银行账户中的钱款） {// 体现尝试失败 return false;
Golang 面向对象全解
Lejeune的博客
05-24 1770
Golang 面向对象全解     golang的面向对象是不完备的面向对象，大部分人员都是从java转换而来，造成了很多的坑，这一篇文章记录我已知的golang面向对象性质和坑，希望后来者注意。 基础          首先面向对象具有三大特性，封装、继承、多态，golang均不直接支持这三种特性，但都可以通过别的方式来实现这三种特性。 封装 golang中没有class只有struc
什么是面向对象
qq_45692431的博客
08-03 1644
面向对象! 最完整解释
OOP-RPG:这是我于2018年秋季在Java CS 1400类中首次尝试面向对象的编程
04-16
面向对象的角色扮演游戏 这是我于2018年秋季在Java CS 1400类中首次尝试面向对象的编程
Python 面向对象 编程指南
05-06
本书深入剖析Python，帮助读者全面掌握Python并构建出更好的应用程序，非常适合对Python语言有一定了解并想要深入学习Python的读者，也适合有一定开发经验并且想要尝试使用Python语言进行编程的IT从业人员。
面向对象框架技术及应用
02-22
北京火龙果软件工程技术中心 面向对象框架技术是软件重用的一种重要方式。本文以面向对象开发方法为基础，结合防空CI通信网仿真系统，介绍了开发特定领域应用框架的方法。　引言　在现代软件工程中，软件重用已经...
C语言之函数指针（持续更新）
最新发布
qq_47607743的博客
05-20 274
C语言指针
c【语言】了解指针，爱上指针（1）
yzqy_的博客
05-16 914
在计算机中，数据是存储在内存中的，cpu从内存中读取数据，为了方便读取数据，内存又被划分为了一个个的内存单元，一个内存单元的大小就是一字节，一字节等于8bit位，我们给内存进行编号，这个编号就是地址，在c语言中给这个地址起了个名字。是的，亲爱的读者你肯定发现了，&a、p和pc输出的地址是一样的,但&a+1与p+1输出的地址是一样的00EFF940，一次都跳过了4字节，而pc+1输出的却是00EFF93D，一次只跳过一个字节。但是硬件与硬件之间是相互独立的，这该如何实现数据传输呢？”答案当然是否定的。
clang frontEnd插件 常见Traverse函数、Visit函数 例子
_
05-17 70
clang插件
C语言如何在链表中的指定位置插⼊结点？
PAP
05-15 263
C语言如何在链表中的指定位置插⼊结点？
PyQt5 中的 List View
xy_optics的博客
05-16 823
有时候，标准模型可能无法满足特定的需求，这时可以自定义数据模型。自定义模型需要继承自 QAbstractItemModel 类，并实现一些关键的方法，如 data()、rowCount()、columnCount() 等，以便 List View 能够正确地显示数据。# 自定义数据模型类return 1# 使用自定义模型。
C语言查漏补缺学习【精简版】
qq_49288362的博客
05-18 622
逗号的组合关系是自左向右，所以左边的表达式会先计算，而右边的表达式的值就留下来作为逗号运算的结果。枚举类型名字通常并不真的使用，要用的是在大括号里的名字，因为它们就是常量符合，它们的类型是int,值则一次从0到n。当要传递的参数的类型比地址大的时候，这是常用的手段：既能用比较少的字节数传递值给参数，又能避免函数对外面的变量的修改。当需要一些可以排列起来的常量值时，定义枚举的意义就是给了这些常量的值的名字。16.*：是一个单目运算符，用来访问指针的值所表示的地址上的变量。
【CCF-CSP】202312-4 宝藏
whaoe_m的博客
05-14 405
对于所有类型为 2的事件，输出一行四个非负整数 C1,1​,C1,2​,C2,1​,C2,2​，表示该时刻的密码 C。西西艾弗岛上埋藏着一份宝藏，小 C 根据藏宝图找到了宝藏的位置。由于小 C 并不会这个问题，他向你发起了求助。你需要帮助小 C 求出所有类型为 22 的事件所对应的密码。小 C 将所有的时刻发生的事件均记录了下来。输入的第一行包含两个正整数n,m。从标准输入读入数据。
C++ 11
qq_65112813的博客
05-17 654
对于类类型，如果定义了接受。
C++ STL标准库解析｜实现string类的迭代器string::iterator
糖炒栗子
05-17 938
的迭代器标识这样我们也可以遍历到底层的最后一个元素。循环过程中做了++it，说明我们当前迭代器要跳到下一个迭代器来完成遍历，至于它底层到底是数组、链表还是哈希表无论是什么我们都不用管，我们作为使用者只需要对迭代器进行++即可。底层数据结构如何到下一个元素的具体操作都封装在了我们迭代器的++操作中，用户作为使用者是无感的（这就是所谓的透明地访问容器内部元素的值）。最后打印使用迭代器进行解引用。
【C++】string类的模拟实现
2301_79345909的博客
05-14 859
在之前学习string的使用时，我们会发现明明std中就有swap，为什么string还要再实现一个？说到erase，自然要跟npos联系起来，npos是string类的静态成员变量。insert的代码，我们要注意画图，尤其是关于边界的一些条件的处理，我们要小心。尾插字符串，这里我们需要计算，然后决定开多少空间（直接开2倍可能不够用）默认生成的赋值重载也会导致浅拷贝，所以我们需要实现深拷贝。这里给出string的各个函数定义和实现的代码。开辟新的空间，然后进行拷贝，对旧空间进行释放。
python 面向对象小游戏
07-08
好的，我可以为你提供一个简单的 Python 面向对象小游戏的例子，帮助你更好地理解面向对象编程的应用。这个小游戏是一个猜数字游戏，玩家需要猜测一个随机生成的数字，直到猜对为止。 ```python import random ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值