İşlev işaretçisi, işlevin adresini içeren bir değişkendir. Bazı sınırlı özelliklere sahip bir işaretçi değişkeni olduğu için, veri yapılarında diğer işaretçi değişkenlerinde olduğu gibi kullanabilirsiniz.
Düşünebildiğim tek istisna, işlev işaretçisini tek bir değerden başka bir şeye işaret ediyormuş gibi davranmaktır. Bir işlev işaretçisini arttırarak veya azaltarak veya işlev işaretçisine bir ofset ekleyerek / çıkararak işaretçi aritmetiği yapmak, işlev işaretçisi yalnızca tek bir şeyi, bir işlevin giriş noktasını işaret ettiği için gerçekten herhangi bir yardımcı program değildir.
Bir işlev işaretçisi değişkeninin boyutu, değişken tarafından işgal edilen bayt sayısı, temeldeki mimariye, örneğin x32 veya x64'e veya başka bir şeye bağlı olarak değişebilir.
Bir işlev işaretçisi değişkeni için bildirim, C derleyicisinin normalde yaptığı denetim türlerini yapabilmesi için işlev bildirimi ile aynı tür bilgileri belirtmesi gerekir. İşlev işaretçisinin bildiriminde / tanımında bir parametre listesi belirtmezseniz, C derleyicisi parametrelerin kullanımını kontrol edemez. Bu kontrol eksikliğinin yararlı olabileceği durumlar vardır, ancak bir güvenlik ağının kaldırıldığını unutmayın.
Bazı örnekler:
int func (int a, char *pStr); // declares a function
int (*pFunc)(int a, char *pStr); // declares or defines a function pointer
int (*pFunc2) (); // declares or defines a function pointer, no parameter list specified.
int (*pFunc3) (void); // declares or defines a function pointer, no arguments.
İlk iki beyanda biraz benzer:
funca intve a alan char *veintpFunc, a intve a alan bir işlevi char *döndüren veint
Dolayısıyla yukarıdakilerden, fonksiyonun adresinin func()fonksiyon işaretçisi değişkenine pFuncolduğu gibi atandığı bir kaynak hattına sahip olabiliriz pFunc = func;.
Doğal işleç öncelik kurallarının üstesinden gelmek için parantezin kullanıldığı bir işlev işaretçisi bildirimi / tanımıyla kullanılan sözdizimine dikkat edin.
int *pfunc(int a, char *pStr); // declares a function that returns int pointer
int (*pFunc)(int a, char *pStr); // declares a function pointer that returns an int
Birkaç Farklı Kullanım Örneği
İşlev işaretçisinin kullanımına bazı örnekler:
int (*pFunc) (int a, char *pStr); // declare a simple function pointer variable
int (*pFunc[55])(int a, char *pStr); // declare an array of 55 function pointers
int (**pFunc)(int a, char *pStr); // declare a pointer to a function pointer variable
struct { // declare a struct that contains a function pointer
int x22;
int (*pFunc)(int a, char *pStr);
} thing = {0, func}; // assign values to the struct variable
char * xF (int x, int (*p)(int a, char *pStr)); // declare a function that has a function pointer as an argument
char * (*pxF) (int x, int (*p)(int a, char *pStr)); // declare a function pointer that points to a function that has a function pointer as an argument
İşlev işaretçisi tanımında değişken uzunluklu parametre listelerini kullanabilirsiniz.
int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);
Veya bir parametre listesi belirtemezsiniz. Bu yararlı olabilir, ancak C derleyicisinin sağlanan argüman listesinde kontrol yapma fırsatını ortadan kaldırır.
int sum (); // nothing specified in the argument list so could be anything or nothing
int (*psum)();
int sum2(void); // void specified in the argument list so no parameters when calling this function
int (*psum2)(void);
C tarzı oyuncular
İşlev işaretçileri olan C stili dökümleri kullanabilirsiniz. Bununla birlikte, bir C derleyicisinin hatalar yerine denetimler konusunda gevşek olabileceğini veya uyarı verebileceğini unutmayın.
int sum (int a, char *b);
int (*psplsum) (int a, int b);
psplsum = sum; // generates a compiler warning
psplsum = (int (*)(int a, int b)) sum; // no compiler warning, cast to function pointer
psplsum = (int *(int a, int b)) sum; // compiler error of bad cast generated, parenthesis are required.
İşlev İşaretçisini Eşitlikle Karşılaştırma
Bir işlev işaretçisi bir ifdeyim kullanarak belirli bir işlev adresine eşit olup olmadığını kontrol edebilirsiniz, ancak bunun ne kadar yararlı olacağından emin değilim. Diğer karşılaştırma operatörleri daha az faydaya sahip gibi görünmektedir.
static int func1(int a, int b) {
return a + b;
}
static int func2(int a, int b, char *c) {
return c[0] + a + b;
}
static int func3(int a, int b, char *x) {
return a + b;
}
static char *func4(int a, int b, char *c, int (*p)())
{
if (p == func1) {
p(a, b);
}
else if (p == func2) {
p(a, b, c); // warning C4047: '==': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
} else if (p == func3) {
p(a, b, c);
}
return c;
}
Bir İşlev İşaretçisi Dizisi
Ve her biri bağımsız değişken listesinin farklı olduğu bir işlev işaretçisi dizisine sahip olmak istiyorsanız, bağımsız değişken listesi belirtilmemiş bir işlev işaretçisi tanımlayabilirsiniz ( voidbu hiçbir bağımsız değişken anlamına gelmez, yalnızca belirtilmemiş) C derleyicisinden gelen uyarıları görebilir. Bu, bir işleve bir işlev işaretçisi parametresi için de çalışır:
int(*p[])() = { // an array of function pointers
func1, func2, func3
};
int(**pp)(); // a pointer to a function pointer
p[0](a, b);
p[1](a, b, 0);
p[2](a, b); // oops, left off the last argument but it compiles anyway.
func4(a, b, 0, func1);
func4(a, b, 0, func2); // warning C4047: 'function': 'int (__cdecl *)()' differs in levels of indirection from 'char *(__cdecl *)(int,int,char *)'
func4(a, b, 0, func3);
// iterate over the array elements using an array index
for (i = 0; i < sizeof(p) / sizeof(p[0]); i++) {
func4(a, b, 0, p[i]);
}
// iterate over the array elements using a pointer
for (pp = p; pp < p + sizeof(p)/sizeof(p[0]); pp++) {
(*pp)(a, b, 0); // pointer to a function pointer so must dereference it.
func4(a, b, 0, *pp); // pointer to a function pointer so must dereference it.
}
C stili namespaceGlobal'i structİşlev İşaretçileriyle Kullanma
Sen kullanabilirsiniz staticAdını dosya kapsamı ve daha sonra benzer bir şey sağlayan bir yolu olarak küresel bir değişkene atar bir işlev belirtmek için anahtar kelime namespaceC ++ işlevselliği.
Bir başlık dosyasında, onu kullanan global bir değişkenle birlikte ad alanımız olacak bir yapı tanımlayın.
typedef struct {
int (*func1) (int a, int b); // pointer to function that returns an int
char *(*func2) (int a, int b, char *c); // pointer to function that returns a pointer
} FuncThings;
extern const FuncThings FuncThingsGlobal;
Sonra C kaynak dosyasında:
#include "header.h"
// the function names used with these static functions do not need to be the
// same as the struct member names. It's just helpful if they are when trying
// to search for them.
// the static keyword ensures these names are file scope only and not visible
// outside of the file.
static int func1 (int a, int b)
{
return a + b;
}
static char *func2 (int a, int b, char *c)
{
c[0] = a % 100; c[1] = b % 50;
return c;
}
const FuncThings FuncThingsGlobal = {func1, func2};
Bu daha sonra, işleve erişmek için genel yapı değişkeninin tam adını ve üye adını belirterek kullanılır. constDeğiştirici o kazara değiştirilemez küresel vb kullanılır.
int abcd = FuncThingsGlobal.func1 (a, b);
Fonksiyon İşaretleyicilerinin Uygulama Alanları
Bir DLL kitaplığı bileşeni, içeren bir işlev işaretçisi namespaceoluşturmayı destekleyen bir kitaplık arabiriminde fabrika yönteminden belirli bir kitaplık arabiriminin istendiği C stili yaklaşımına benzer bir şey yapabilir struct. Bu kitaplık arabirimi, istenen DLL sürümünü yükler, gerekli işlev işaretçileri olan bir yapı oluşturur ve ardından, yapıyı kullanım için istekte bulunan arayana döndürür.
typedef struct {
HMODULE hModule;
int (*Func1)();
int (*Func2)();
int(*Func3)(int a, int b);
} LibraryFuncStruct;
int LoadLibraryFunc LPCTSTR dllFileName, LibraryFuncStruct *pStruct)
{
int retStatus = 0; // default is an error detected
pStruct->hModule = LoadLibrary (dllFileName);
if (pStruct->hModule) {
pStruct->Func1 = (int (*)()) GetProcAddress (pStruct->hModule, "Func1");
pStruct->Func2 = (int (*)()) GetProcAddress (pStruct->hModule, "Func2");
pStruct->Func3 = (int (*)(int a, int b)) GetProcAddress(pStruct->hModule, "Func3");
retStatus = 1;
}
return retStatus;
}
void FreeLibraryFunc (LibraryFuncStruct *pStruct)
{
if (pStruct->hModule) FreeLibrary (pStruct->hModule);
pStruct->hModule = 0;
}
ve bu şu şekilde kullanılabilir:
LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
// ....
myLib.Func1();
// ....
FreeLibraryFunc (&myLib);
Aynı yaklaşım, temel donanımın belirli bir modelini kullanan kod için soyut bir donanım katmanı tanımlamak için kullanılabilir. İşlev işaretçileri, soyut donanım modelinde belirtilen işlevleri uygulayan donanıma özgü işlevleri sağlamak için fabrika tarafından donanıma özgü işlevlerle doldurulur. Bu, belirli bir donanım işlev arabirimini elde etmek için fabrika işlevini çağıran ve daha sonra belirli bir hedefle ilgili uygulama ayrıntılarını bilmeye gerek kalmadan temel donanım için eylemleri gerçekleştirmek üzere sağlanan işlev işaretçileri kullanan yazılım tarafından kullanılan soyut bir donanım katmanı sağlamak için kullanılabilir. .
Temsilci, İşleyici ve Geri Arama oluşturmak için İşaretçiler İşlev
İşlev işaretçileri, bazı görevleri veya işlevleri temsil etmenin bir yolu olarak kullanabilirsiniz. C'deki klasik örnek, Standart C kitaplığı işlevleriyle kullanılan qsort()ve bsearch()bir öğe listesini sıralamak veya sıralı bir öğe listesi üzerinde ikili arama yapmak için harmanlama sırası sağlamak için kullanılan karşılaştırma temsilcisi işlev işaretçisidir . Karşılaştırma işlevi temsilcisi, sıralamada veya ikili aramada kullanılan harmanlama algoritmasını belirtir.
Başka bir kullanım, bir C ++ Standart Şablon Kitaplığı kapsayıcısına algoritma uygulanmasına benzer.
void * ApplyAlgorithm (void *pArray, size_t sizeItem, size_t nItems, int (*p)(void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for ( ; pList < pListEnd; pList += sizeItem) {
p (pList);
}
return pArray;
}
int pIncrement(int *pI) {
(*pI)++;
return 1;
}
void * ApplyFold(void *pArray, size_t sizeItem, size_t nItems, void * pResult, int(*p)(void *, void *)) {
unsigned char *pList = pArray;
unsigned char *pListEnd = pList + nItems * sizeItem;
for (; pList < pListEnd; pList += sizeItem) {
p(pList, pResult);
}
return pArray;
}
int pSummation(int *pI, int *pSum) {
(*pSum) += *pI;
return 1;
}
// source code and then lets use our function.
int intList[30] = { 0 }, iSum = 0;
ApplyAlgorithm(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), pIncrement);
ApplyFold(intList, sizeof(int), sizeof(intList) / sizeof(intList[0]), &iSum, pSummation);
Başka bir örnek, olay gerçekleştiğinde gerçekten çağrılan bir işlev işaretçisi sağlayarak belirli bir olay için bir işleyicinin kaydedildiği GUI kaynak kodudur. Microsoft MFC çerçevesi ileti eşlemeleriyle, bir pencereye veya iş parçacığına teslim edilen Windows iletilerini işlemeye benzer bir şey kullanır.
Geri arama gerektiren asenkron işlevler, olay işleyiciye benzer. Eşzamansız işlevin kullanıcısı, bir eylem başlatmak için eşzamansız işlevi çağırır ve eylem tamamlandığında eşzamansız işlevin çağıracağı bir işlev işaretçisi sağlar. Bu durumda olay, görevini tamamlayan eşzamansız işlevdir.
Bundan sonra, makinenin onları nasıl anladığını görelim. 32 bit mimaride yukarıdaki programın makine talimatını görebilirsiniz.