文章目录
 
一、DECLARE_MESSAGE_MAP(),BEGIN_MESSAGE_MAP(),END_MESSAGE_MAP()
二、afx_msg函数
三、自己添加的消息
 

 
一、DECLARE_MESSAGE_MAP(),BEGIN_MESSAGE_MAP(),END_MESSAGE_MAP()
 
DECLARE_MESSAGE_MAP()宏的作用是向类中添加消息i映射必要的结构体和函数声明，只需要添加一次，放在什么位置并不重要，就如同类里其他普通函数的声明可以相互交换顺序一样。
 
函数的修饰符也是可以自己决定的，遵循一般原则。比如你需要在类外部也可以调用该消息响应函数，就可以定义成public的。
 
但是其实真正的消息映射是在cpp文件里面的
 BEGAIN_MESSAGE_MAP()
 END_MESSAGE_MAP()
 这两个宏之间
 
比如：
 h：
 
 cpp：
 
 如上大体意思就是：只要是CCmdTarget(用于所有能够消息映射的基类)派生类,必有消息映射以处理消息，则在类的说明文件的尾部有DECLARE_MESSAGE_MAP宏，在类的定义文件中有BEGIN_MESSAGE_MAP宏和END_MESSAGE_MAP宏以处理用户消息。
 其中BEGIN_MESSAGE_MAP(参数1,参数2) ,参数1为该类的类名，参数2为该类基类的类名。
 
在一些资料上，也书面的说明为：
 用户程序中的每个CCmdTarget派生类必须提供消息映射以处理消息。在类定义的末尾使用DECLARE_MESSAGE_MAP宏。接着，在定义类成员函数的.CPP文件中，使用BEGIN_MESSAGE_MAP宏，及END_MESSAGE_MAP宏。
 注（如果在DECLARE_MESSAGE_MAP之后定义任何一个成员，那么必须为他们指定一个新存取类型（公共的，私有的，保护的））
 
二、afx_msg函数
 
应用程序框架产生的消息映射函数
 例如：afx_msg void OnBnClickedButton1(); 其中 afx_msg为消息标志，它向系统声明：有消息映射到函数实现体；
 而在map宏定义中，就有具体消息和此函数的映射定义（可以是自定义，也可以是系统自动完成的）
 afx是 application framework
 如定义一个Edit的Change处理函数：
 
也可参照以上文中图片例子
 
一、在类的头文件(*.h)中增加 :
 
  //{{AFX_MSG(CDialogDemo)   
  afx_msg  void OnChangeEdit1();
  //{{AFX_MSG   
 
二、在类的实现文件(*.cpp)中增加:
 
1.消息定义( ON_EN_CHANGE)：
 
BEGIN_MESSAGE_MAP(CDialogDemo, CDialog)
//{{AFX_MSG_MAP()   
ON_EN_CHANGE(IDC_EDIT1, OnChangeEdit1)
 //}}AFX_MSG_MAP   
END_MESSAGE_MAP()   
 
2.执行函数：
 
void CDialogDemo::OnChangeEdit1() 
{
 TODO: 添加你的控件相关代码
……
}  
 
在afxwin.h中afx_msg的解释：
 
 #ifndef   afx_msg  
  #define   afx_msg                   //   intentional   placeholder  
  #endif  
 
没什么意思.只是定义了这个符号而已. 这个对编译器来说,相当于什么都没有,对于人来说,我们可以看到这样的符号. 。
 
对于类向导来说.这个符号才是有意义的.它是一个消息处理函数的前缀. 类向导生成的消息函数,分发函数,事件响应函数都以这个为前缀.
 如果去掉了,向导将不能识别
 
三、自己添加的消息
 
如果是自己写的afx_msg函数，则需自己在cpp中添加消息处理代码
 
ON_MESSAGE(参数1，参数2）
 
其中参数1是自己定义的消息ID，参数2是函数名
 例如：
 
 其中消息ID是自己定义的
 
 其中WM_USER宏定义可以看我的另一篇文章介绍
 https://blog.csdn.net/weixin_45525272/article/details/106426221

消息映射机制是Windows编程的核心内容。Windows下的应用程序也都是通过消息驱动的机制来进行工作的。虽然VC开发环境自带了大量的系统消息处理函数，但我们实际的程序开发过程中总还是避免不了要写一些自定义的消息处理函数以满足所编写的软件功能的需要。那么在VC中如何定义自己的消息处理函数呢？其步骤如下： 
 
 
 
1、在要定义消息映射函数的类的首部通过宏定义的方式定义一个用户类型的消息标识。定义方法如下：#define WM_USER1 WM_USER + 1 其中的WM_USER是系统定义好的用户类型的消息。只要以此为自定义消息的起点加上一个偏移量在0～0x3FFF之间的值，就不会和系统定义的其它消息发生冲突了。 
 
 
2、在类上点击右键，然后在弹出的菜单中选择“添加成员函数”（Add member Function）。在弹出的添加函数对话框中的函数类型框中输入函数的类型。如：afx_msg LRESULT 消息处理函数一定要以afx_msg关键字开头，表明是全局函数。LRESULT是函数的类型。表明是系统回调函数。也可以是其它的类型。如int,void 等等合法的数据类型。在函数名称框中输入函数名。如：MyFunction(WPARAM wParam, LPARAM lParam)，这两个参数是系统用于传递消息的附加参数。W开头的是十六位的信息参数。L开头的是三十二位的信息参数。 
 
 
3、打开类的源文件。找到“BEGIN MESSAGE MAP” 和 "END MESSAGE MAP"。在两者之间声明消息与消息处理函数。如：ON_MESSAGE(WM_USER1, MyFunction).ON_MESSAGE是定义用户消息映射函数的系统函数。消息映射语句最好从 "//}}AFX_MSG_MAP"的下一行开始写起，因为它是系统维护自动生成代码的标记。如果写在它的上面，有可能会被删除。 
 
 
4、在类的源文件中找到刚定义的消息函数，写入实现代码。 
 
 
5、在需要调用消息映射函数的地方用SendMessage(WM_USER1);即可调用所定义的函数。WM_USER1 就是我们刚定义的消息名称。
 

例子如下
 

 

这篇文章主要介绍了Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法 ,本文通过实例代码给大家介绍的非常详细，具有一定的参考借鉴价值，需要的朋友可以参考下
 一. lamda匿名函数
 　　为了解决一些简单的需求而设计的一句话函数
 
# 计算n的n次方
def func(n):
 return n**n
print(func(10))
f = lambda n: n**n
print(f(10))
 
lambda表示的是匿名函数. 不需要用def来声明, 一句话就可以声明出一个函数
 
语法:
 　　　　函数名 = lambda 参数: 返回值
 
注意:
 
1. 函数的参数可以有多个. 多个参数之间用逗号隔开
 　　2. 匿名函数不管多复杂. 只能写一行, 且逻辑结束后直接返回数据
 　　3. 返回值和正常的函数一样, 可以是任意数据类型
 
匿名函数并不是说一定没有名字. 这里前面的变量就是一个函数名. 说他是匿名原因是我们通过__name__查看的时候是没有名字的. 统一都叫lambda. 在调用的时候没有什么特别之处.像正常的函数调用即可
 
二. sorted() 排序函数
 　　语法: sorted(Iterable, key=None, reverse=False)
 
Iterable: 可迭代对象
 
key: 排序规则(排序函数), 在sorted内部会将可迭代对象中的每一个元素传递给这个函数的参数. 根据函数运算的结果进行排序
 
reverse: 是否是倒叙. True: 倒叙, False: 正序
 
lst = [1,5,3,4,6]
lst2 = sorted(lst)
print(lst) # 原列表不会改变
print(lst2) # 返回的新列表是经过排序的
dic = {1:'A', 3:'C', 2:'B'}
print(sorted(dic)) # 如果是字典. 则返回排序过后的key
 
和函数组合使用
 
# 根据字符串长度进行排序
lst = ["鲁班七号", "程咬金", "安琪拉", "阿珂"]
# 计算字符串长度
def func(s):
 return len(s)
print(sorted(lst, key=func))
 
和lambda组合使用
 
# 根据字符串长度进行排序
lst = ["鲁班七号", "程咬金", "安琪拉", "阿珂"]
# 计算字符串长度
def func(s):
 return len(s)
print(sorted(lst, key=lambda s: len(s)))
lst = [{"id":1, "name":'鲁班', "age":28},
  {"id":2, "name":'安琪拉', "age":16},
  {"id":3, "name":'阿珂', "age":25}]
# 按照年龄对信息进行排序
print(sorted(lst, key=lambda e: e['age']))
 
三. filter() 筛选函数
 
语法: filter(function. Iterable)
 
function: 用来筛选的函数. 在filter中会自动的把iterable中的元素传递给function. 然后根据function返回的True或者False来判断是否保留此项数据
 
map() 映射函数
 
Iterable: 可迭代对象
 
lst = [1,2,3,4,5,6,7]
ll = filter(lambda x: x%2==0, lst) # 筛选所有的偶数
print(ll)
print(list(ll))
lst = [{"id":1, "name":'鲁班', "age":18},
  {"id":2, "name":'安琪拉', "age":16},
  {"id":3, "name":'阿珂', "age":17}]
fl = filter(lambda e: e['age'] > 16, lst) # 筛选年龄大于16的数据
print(list(fl))
 
四. map() 映射函数
 
语法: map(function, iterable) 可以对可迭代对象中的每一个元素进行映射. 分别取执行function
 
计算列表中每个元素的平方,返回新列表
 
def func(e):
 return e*e
mp = map(func, [1, 2, 3, 4, 5])
print(mp)
print(list(mp))
 
改写成lambda
 
print(list(map(lambda x: x * x, [1, 2, 3, 4, 5])))
 
计算两个列表中相同位置的数据的和
 
# 计算两个列表相同位置的数据的和
lst1 = [1, 2, 3, 4, 5]
lst2 = [2, 4, 6, 8, 10]
print(list(map(lambda x, y: x+y, lst1, lst2)))
 
五. 递归
 
在函数中调用函数本身,就是递归
 
　　def func():
 print("我是递归")
 func()
func()
 
在python中递归的深度最大到998
 
def foo(n):
 print(n)
 n += 1
 foo(n)
foo(1)　
 
递归的应用:
 　　我们可以使用递归来遍历各种树形结构, 比如我们的文件夹系统. 可以使用递归来遍历该文件夹中的所有文件
 
import os
def func(filepath,n):
 files = os.listdir(filepath) # 查案当前文件的目录
 for file in files: # 获取每一个文件名
  # 获取文件路径
  file_p = os.path.join(filepath,file)
  if os.path.isdir(file_p): # 判断file是否是一个文件夹
   print("\t"*n,file)
   func(file_p,n+1)
  else:
   print("\t"*n,file)
func("/Volumes/扩展盘/网站css",0)
 
六. 二分查找
 
二分查找. 每次能够排除掉一半的数据. 查找的效率非常高. 但是局限性比较大. 必须是有序序列才可以使用二分查找
 
要求: 查找的序列必须是有序序列.
 
　　# 判断n是否在lst中出现. 如果出现请返回n所在的位置
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
# 非递归算法
# 使用二分法可以提高效率 前提条件有序序列
n = 88
left = 0
right = len(lst) - 1
 
while left <= right: # 边界,当右边比左边还小的时候退出循环
 mid = (left + right) // 2 # 这里必须是整除,应为索引没有小数
 if lst[mid] > n:
  right = mid - 1
 if lst[mid] < n:
  left = mid + 1
 if lst[mid] == n:
  print("找到这个数")
  break
else:
 print("没有这个数!")
 
# 递归来完成二分法
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(n,left,right):
 if left <= right:
  mid = (left + right) // 2
  if n > lst[mid]:
   left = mid + 1
   return func(n,left,right) # 递归,递归入口
  elif n < lst[mid]:
   right = mid - 1
   # 深坑,函数的返回值返回给调用者
   return func(n,left,right) # 递归
  elif lst[mid] == n:
   # print("找到了")
   return mid
 else:
  print("没找到")
  return -1 # 避免返回None
 
# 找66,左边界0,右边界len(lst) - 1
ret = func(66,0,len(lst) - 1)
print(ret)
 
# 递归二分法另一种形式,但是无法实现位置计算
lst = [22, 33, 44, 55, 66, 77, 88, 99, 101, 238, 345, 456, 567, 678, 789]
def func(lst,target):
 left = 0
 right = len(lst) - 1
 if left > right:
  print("没有这个数")
 middle = (left + right)//2
 if target < lst[middle]:
  return func(lst[:middle],target)
 elif target > lst[middle]:
  return func(lst[middle + 1:],target)
 elif target == lst[middle]:
  print("找到这个数了")
func(lst,101)
 
核心: 掐头去尾取中间. 一次砍一半
 　　两种算法: 常规循环, 递归循环
 
# 时间复杂度最低, 空间复杂度最低
lst1 = [5,6,7,8]
 lst2 = [0,0,0,0,0,1,1,1,1]
 for el in lst1:
 lst2[el] = 1
 lst2[4] == 1 # o(1)
 
写到这里，给大家推荐一个资源很全的python学习聚集地，点击进入，这里有资深程序员分享以前学习心得，学习笔记，还有一线企业的工作经验，且给大家精心整理一份python零基础到项目实战的资料，每天给大家讲解python最新的技术，前景，学习需要留言的小细节
 总结
 以上所述是小编给大家介绍的Python匿名函数/排序函数/过滤函数/映射函数/递归/二分法，希望对大家有所帮助