函数指针
不只变量有地址，函数也有地址
void example(int n)
{
printf("%d\n",n);
}
int main()
{
//打印函数的地址
printf("%08X\n",&example);
//printf("%p\n",&example);
return 0;
}
每个函数在编译后都对应一串指令，这些指令在内存中的位置就是函数的地址
我们可以用一个指针类型来表示函数的地址
void (*p) (int);
//变量名为p，变量类型为函数指针，记作void (int)* ，返回值为void，参数为int
void example(int n)
{
printf("%d\n",n);
}
int main()
{
void (*p) (int);
p = &example;
return 0;
}
void example(int a,int b)
{
printf("%d,%d\n",a,b);
}
int main()
{
void (*p) (int,int);
p = &example;
return 0;
}
第一个也可以写作
//可读性较差
void (*p) (int) = &example;
指针变量也是变量，其实所有的指针都是整型，08X打印出来都是8位16进制整数。
void ex1(int n)
{
printf(...);
}
void ex2(int n)
{
printf(...);
}
int main()
{
void (*p) (int);
//先指向ex1，再指向ex2
p = &ex1;
p = &ex2;
return 0;
}
与普通指针对比
//普通指针：用于读写目标内存的值
int *p;
p = &a;
*p = 123;
//函数指针：用于调用目标函数
void (*p) (int);
p = &example;
p(123);
#include<stdio.h>
void example(int n)
{
printf("%d\n",n);
}
int main()
{
void (*p) (int) = &example;
p(1);
return 0;
}
注意
&可以舍去，但是为了和普通变量形式上统一起来，最好还是加上
p = &example;
p = example
函数指针的使用
使用typedef可以替换掉void (*p) (int)，后者可读性很差。
使用typedef给函数指针类型起个别名
#include<stdio.h>
void example(int n)
{
printf("%d\n",n);
}
typedef void (*MY_FUNCTION) (int);
int main()
{
MY_FUNCTION p;
p = &example;
p(1);
return 0;
}
函数指针可以作为函数的参数
#include<stdio.h>
void example(int n)
{
printf("%d\n",n);
}
typedef void (*MY_FUNCTION) (int);
void test(MY_FUNCTION f)
{
f(123);
}
int main()
{
test(&example);
//MY_FUNCTION p;
//p = &example;
//test(p);
return 0;
}
函数指针作为成员变量
class Object
{
public:
MY_FUNCTION m_func;
};
C语言里的回调机制
函数指针的应用场景：回调（callback）
我们调用别人提供的 API函数(Application Programming Interface,应用程序编程接口)，称为Call
如果别人的库里面调用我们的函数，就叫Callback
要拷贝一个文件，将1.pdf拷贝为1_copy.pdf
方法：调用Windows API里面有一个CopyFile函数，这种就叫调用Call
注意事先将项目的unicode字符集改为多字节字符集
#include<stdio.h>
#include<Windows.h>
int main()
{
const char* source = "D:\\Document\\1.pdf";
const char* dst = "D:\\Document\\1_copy.pdf";
BOOL result = CopyFile(source,dst,FALSE);
printf("操作完成：%s\n",result ? "success": "failed");
return 0;
}
何时需要Callback？
若拷贝一个很大的文件，这个拷贝过程需要很多时间，如果用CopyFile函数就需要默默等待，用户不知道要多久，而且也不能取消
用户体验差，缺少交互性
我们希望显示拷贝的进度
比如我们提供一个函数
void CopyProgress(int total,int copied)
{
}
我们希望系统能时不时调用这个函数，将total/copied数据通知给我们
这就要使用函数指针，将我们函数的地址作为一个参数传给系统API即可
使用CopyFileEx（系统API的另一个函数）
-
提供一个函数
DWORD CALLBACK CopyProgress(...) -
将函数指针传给CopyFileEx
CopyFileEx(source ,dst ,CopyProgress...) //每拷贝到一定的字节数，就会调用到我们的函数
#include <stdio.h>
#include <Windows.h>
// 将LARGE_INTTEGER类型转成unsigned long long
unsigned long long translate(LARGE_INTEGER num)
{
unsigned long long result = num.HighPart;
result <<= 32;
result += num.LowPart;
return result;
}
// 回调函数
// 注：要求将此函数用关键字CALLBACK修饰（这是Windows API的要求）
DWORD CALLBACK CopyProgress(
LARGE_INTEGER TotalFileSize,
LARGE_INTEGER TotalBytesTransferred,
LARGE_INTEGER StreamSize,
LARGE_INTEGER StreamBytesTransferred,
DWORD dwStreamNumber,
DWORD dwCallbackReason,
HANDLE hSourceFile,
HANDLE hDestinationFile,
LPVOID lpData)
{
// 文件的总字节数 TotalFileSize
unsigned long long total = translate(TotalFileSize);
// 已经完成的字节数
unsigned long long copied = translate(TotalBytesTransferred);
// 打印进度
printf("进度: %I64d / %I64d \n", copied, total); // 64位整数用 %I64d
//printf("进度: %d / %d \n", (int)copied, (int)total); // 文件大小于2G时，可以转成int
return PROGRESS_CONTINUE;
}
int main()
{
const char* source = "D:\\Download\\1.Flv";
const char* dst = "D:\\Download\\1_copy.Flv";
printf("start copy ...\n");
// 将函数指针传给CopyFileEx
BOOL result = CopyFileEx(source, dst, &CopyProgress, NULL, NULL, 0);
printf("operation done ： %s \n", result ? "success" : "failed");
return 0;
}
回调函数的上下文
回调函数总有一个参数用于传递上下文信息，上下文：Context
比如
BOOL WINAPI CopyFileEx(
...
LPPROGRESS_ROUTINE lpProgressRoutine,//回调函数
LPVOID lpData, //上下文对象void*，只要是一个指针就行，不关心是什么类型的
...);
如果我们希望显示[当前用户]源文件->目标文件 ：百分比
然而，上节代码CopyProgress的参数里并没有源文件名和目标文件名
也就是说只能计算百分比，无法得知当前正在拷贝的是哪个文件
观察里面有一个参数LPVOID lpData
上下文对象：携带了所有必要的上下文信息
可以定义为任意数据，由用户决定
比如
struct Context
{
char username[32],
char source[128],
char dst[128]
};
这样就能显示我们想要的了
#include <stdio.h>
#include <Windows.h>
// 文件拷贝所需的上下文信息
struct Context
{
char username[32];
char source[128];
char dst[128];
};
// 将LARGE_INTTEGER类型转成unsigned long long
unsigned long long translate(LARGE_INTEGER num)
{
unsigned long long result = num.HighPart;
result <<= 32;
result += num.LowPart;
return result;
}
// 回调函数
// 注：要求将此函数用关键字CALLBACK修饰（这是Windows API的要求）
DWORD CALLBACK CopyProgress(
LARGE_INTEGER TotalFileSize,
LARGE_INTEGER TotalBytesTransferred,
LARGE_INTEGER StreamSize,
LARGE_INTEGER StreamBytesTransferred,
DWORD dwStreamNumber,
DWORD dwCallbackReason,
HANDLE hSourceFile,
HANDLE hDestinationFile,
LPVOID lpData) // <- 这个就是上下文件对象
{
// 计算百分比
unsigned long long total = translate(TotalFileSize);
unsigned long long copied = translate(TotalBytesTransferred);
int percent = (int) ( (copied * 100 / total) );
// 打印进度，将指针lpData强制转为Context*类型
Context* ctx = (Context*) lpData;
printf("[用户: %s], %s -> %s : 进度 %d %%\n",
ctx->username, ctx->source, ctx->dst, percent);
return PROGRESS_CONTINUE;
}
int main()
{
Context ctx; // 上下文对象
strcpy(ctx.username, "dada");
strcpy(ctx.source, "D:\\Download\\1.Flv" );
strcpy(ctx.dst, "D:\\Download\\1_copy.Flv");
printf("start copy ...\n");
// 将函数指针传给CopyFileEx
BOOL result = CopyFileEx(ctx.source, ctx.dst,
&CopyProgress, // 待回调的函数
&ctx, // 上下文对象
NULL, 0);
printf("operation done ： %s \n", result ? "success" : "failed");
return 0;
}
上下文对象为void*类型，他是透传的（透明的，不关心类型与内容）
C++里的回调实现
c++里用class语法来实现回调，比如有人提供一个类库AfCopyFile，能提供文件拷贝功能，而且能通知用户当前进度
int DoCopy(const char* source, const char* dst,AfCopyFile* listener);
///别人提供的AfCopyFile.h
#ifndef _AF_COPY_FILE_H
#define _AF_COPY_FILE_H
class AfCopyFileListener
{
public:
virtual int OnCopyProgress(long long total, long long transfered) = 0;
};
class AfCopyFile
{
public:
int DoCopy(const char* source,
const char* dst,
AfCopyFileListener* listener);
};
#endif
用户只要自己实现一个AfCopyFileListener对象，传给这个函数就行了
#include <stdio.h>
#include <string.h>
#include "AfCopyFile.h"
class MainJob : public AfCopyFileListener
{
public:
// int DoJob()
// {
// strcpy(user, "shaofa");
// strcpy(source, "c:\\test\\2.rmvb" );
// strcpy(dst, "c:\\test\\2_copy.rmvb");
//
// AfCopyFile af;
// af.DoCopy(source, dst, this); // 将this传过去
//
// return 0;
// }
int OnCopyProgress(long long total, long long transfered)
{
// 打印进度
int percent = (int) ( (transfered * 100 / total) );
printf("[用户: %s], %s -> %s : 进度 %d %%\n",
user, source, dst, percent);
return 0;
}
public:
char source[256];
char dst[256];
char user[64];
};
int main()
{
MainJob job;
strcpy(job.user, "shaofa");
strcpy(job.source, "c:\\test\\2.rmvb" );
strcpy(job.dst, "c:\\test\\2_copy.rmvb");
AfCopyFile af;
af.DoCopy(job.source, job.dst, &job); // 将this传过去
// job.DoJob();
return 0;
}
回调函数的缺点：使代码变得难以阅读，我们应该尽量避免使用回调机制，最好采用单向的函数调用。
