ශ්‍රිත දර්ශකය යනු ශ්‍රිතයක ලිපිනය අඩංගු විචල්‍යයකි. එය සීමිත ගුණාංග සහිත වුවද එය දර්ශක විචල්‍යයක් බැවින්, දත්ත ව්‍යුහයන්හි වෙනත් ඕනෑම දර්ශක විචල්‍යයක් මෙන් ඔබට එය භාවිතා කළ හැකිය.
මට සිතිය හැකි එකම ව්‍යතිරේකය වන්නේ ශ්‍රිත දර්ශකය තනි අගයක් හැර වෙනත් දෙයකට යොමු කිරීමක් ලෙස සැලකීමයි. ශ්‍රිත දර්ශකයක් වැඩි කිරීමෙන් හෝ අඩු කිරීමෙන් හෝ ශ්‍රිත දර්ශකයට ඕෆ්සෙට් එකක් එකතු කිරීමෙන් / අඩු කිරීමෙන් දර්ශක අංක ගණිතය කිරීම ඇත්ත වශයෙන්ම කිසිදු උපයෝගීතාවයක් නොවේ.
ශ්‍රිත දර්ශක විචල්‍යයක ප්‍රමාණය, විචල්‍යය විසින් අල්ලාගෙන ඇති බයිට් ගණන, යටින් පවතින ගෘහ නිර්මාණ ශිල්පය අනුව වෙනස් විය හැකිය, උදා: x32 හෝ x64 හෝ කුමක් හෝ.
ශ්‍රිත දර්ශක විචල්‍යයක් සඳහා වන ප්‍රකාශය, සී සම්පාදකයා සාමාන්යයෙන් කරන ආකාරයේ චෙක්පත් සිදු කිරීම සඳහා ශ්‍රිත ප්‍රකාශයක් ලෙස එකම ආකාරයේ තොරතුරු නියම කළ යුතුය. ශ්‍රිත දර්ශකයේ ප්‍රකාශනයේ / අර්ථ දැක්වීමේදී ඔබ පරාමිති ලැයිස්තුවක් සඳහන් නොකරන්නේ නම්, සී සම්පාදකයාට පරාමිති භාවිතය පරීක්ෂා කිරීමට නොහැකි වනු ඇත. මෙම පරීක්ෂා කිරීමේ lack නතාවය ප්රයෝජනවත් විය හැකි අවස්ථා තිබේ, කෙසේ වෙතත් ආරක්ෂිත දැලක් ඉවත් කර ඇති බව මතක තබා ගන්න.
උදාහරණ කිහිපයක්:
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.
පළමු ප්‍රකාශ දෙක එහි තරමක් සමාන ය:
funcයනු a intසහ a char *ගෙන නැවත ලබා දෙන ශ්‍රිතයකිintpFuncක ගත වන බව උත්සවයකට ලිපිනය පවරා ඇති කිරීමේ උත්සවයකට පහිටුම් දක්වනය වේ intහා char *හා නැවත පැමිණීමint
එබැවින් ඉහත සිට අපට ශ්‍රිතයේ ලිපිනය func()ශ්‍රිත දර්ශක විචල්‍යයට pFuncලබා දී ඇති ප්‍රභව රේඛාවක් තිබිය හැකිය pFunc = func;.
ස්වාභාවික ක්‍රියාකරු ප්‍රමුඛතා රීති මඟහරවා ගැනීම සඳහා වරහන් භාවිතා කරන ශ්‍රිත දර්ශක ප්‍රකාශනය / අර්ථ දැක්වීම සමඟ භාවිතා කරන වාක්‍ය ඛණ්ඩය සැලකිල්ලට ගන්න.
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
විවිධ භාවිත උදාහරණ කිහිපයක්
ශ්‍රිත දර්ශකයක් භාවිතා කිරීම පිළිබඳ උදාහරණ කිහිපයක්:
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
ශ්‍රිත දර්ශකයේ අර්ථ දැක්වීමේදී ඔබට විචල්‍ය දිග පරාමිති ලැයිස්තු භාවිතා කළ හැකිය.
int sum (int a, int b, ...);
int (*psum)(int a, int b, ...);
නැතහොත් ඔබට පරාමිති ලැයිස්තුවක් කිසිසේත් නියම කළ නොහැක. මෙය ප්රයෝජනවත් විය හැකි නමුත් එය සී සම්පාදකයාට ලබා දී ඇති තර්ක ලැයිස්තුවේ චෙක්පත් සිදු කිරීමේ අවස්ථාව ඉවත් කරයි.
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);
සී ස්ටයිල් කැස්ට්
ශ්‍රිත දර්ශක සමඟ ඔබට සී ස්ටයිල් කැස්ට් භාවිතා කළ හැකිය. කෙසේ වෙතත්, සී සම්පාදකයෙකු චෙක්පත් පිළිබඳ ලිහිල් විය හැකි බව හෝ දෝෂවලට වඩා අනතුරු ඇඟවීම් ලබා දෙන බව මතක තබා ගන්න.
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.
ශ්‍රිත දර්ශකය සමානාත්මතාවයට සංසන්දනය කරන්න
ifප්‍රකාශයක් භාවිතා කරමින් ශ්‍රිත දර්ශකය විශේෂිත ශ්‍රිත ලිපිනයකට සමාන දැයි ඔබට පරීක්ෂා කළ හැකිය, නමුත් එය කොතරම් ප්රයෝජනවත් වේදැයි මට විශ්වාස නැත. වෙනත් සංසන්දනාත්මක ක්‍රියාකරුවන්ට ඊටත් වඩා අඩු උපයෝගීතාවයක් ඇති බව පෙනේ.
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;
}
ශ්‍රිත දර්ශකයන්ගේ පෙළක්
ඔබට තර්ක ලැයිස්තුවේ වෙනස්කම් ඇති සෑම අංගයක්ම ශ්‍රිත දර්ශක සමූහයක් ලබා ගැනීමට අවශ්ය නම්, ඔබට තර්ක ලැයිස්තුව සමඟ නිශ්චිතව දක්වා නැති ( voidඑයින් අදහස් කරන්නේ තර්ක විතර්ක නොව නිශ්චිතව දක්වා ඇති) ශ්‍රිත දර්ශකයක් අර්ථ දැක්විය හැකිය. සී සම්පාදකයාගේ අනතුරු ඇඟවීම් දැකිය හැක. මෙය ශ්‍රිතයක් සඳහා ශ්‍රිත දර්ශක පරාමිතියක් සඳහා ද ක්රියා කරයි:
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.
}
සී ස්ටයිල් namespaceග්ලෝබල් structවිත් ෆන්ෂන් පොයින්ටර්ස් භාවිතා කිරීම
staticගොනු විෂය පථය නම් ශ්‍රිතයක් නියම කිරීමට ඔබට යතුරු පදය භාවිතා කළ හැකි අතර පසුව namespaceC ++ හි ක්‍රියාකාරීත්වයට සමාන යමක් සැපයීමේ ක්රමයක් ලෙස මෙය ගෝලීය විචල්‍යයකට පැවරිය හැකිය.
ශීර්ෂ ගොනුවක අපගේ නාම අවකාශය වන ගෝලීය විචල්‍යයක් සමඟ එය භාවිතා කරන ව්‍යුහයක් අර්ථ දක්වන්න.
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;
C ප්‍රභව ගොනුවේ:
#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};
ශ්‍රිතයට ප්රවේශ වීම සඳහා ගෝලීය ව්‍යුහාත්මක විචල්‍යයේ සම්පූර්ණ නම සහ සාමාජික නාමය සඳහන් කිරීමෙන් මෙය භාවිතා වේ. මෙම constවිකරණකාරකය එය අහම්බෙන් වෙනස් කළ නොහැකි බව ගෝලීය එසේ භාවිතා කර ඇත.
int abcd = FuncThingsGlobal.func1 (a, b);
ක්‍රියාකාරී දර්ශකයන්ගේ යෙදුම් ප්‍රදේශ
ඩීඑල්එල් පුස්තකාල සංරචකයකට සී ස්ටයිල් namespaceප්‍රවේශයට සමාන දෙයක් කළ හැකි අතර, පුස්තකාල අතුරු මුහුණතක කර්මාන්තශාලා ක්‍රමයකින් විශේෂිත පුස්තකාල අතුරු මුහුණතක් ඉල්ලා සිටින අතර එය structඅඩංගු ක්‍රියාකාරී ලක්ෂ්‍යයක් නිර්මාණය කිරීමට සහාය වේ .. මෙම පුස්තකාල අතුරුමුහුණත ඉල්ලූ ඩීඑල්එල් අනුවාදය පටවනු ලැබේ, නිර්මාණය කරයි අවශ්ය ශ්‍රිත දර්ශක සහිත ව්‍යුහයක්, පසුව භාවිතා කිරීම සඳහා ඉල්ලුම්කරු වෙත ව්‍යුහය නැවත ලබා දේ.
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;
}
මෙය පහත පරිදි භාවිතා කළ හැකිය:
LibraryFuncStruct myLib = {0};
LoadLibraryFunc (L"library.dll", &myLib);
// ....
myLib.Func1();
// ....
FreeLibraryFunc (&myLib);
යටින් පවතින දෘඩාංගයේ විශේෂිත ආකෘතියක් භාවිතා කරන කේත සඳහා වියුක්ත දෘඩාංග ස්ථරයක් අර්ථ දැක්වීමට එකම ප්‍රවේශය භාවිතා කළ හැකිය. වියුක්ත දෘඩාංග ආකෘතියේ නිශ්චිතව දක්වා ඇති කාර්යයන් ක්රියාත්මක කරන දෘඩාංග විශේෂිත ක්‍රියාකාරිත්වය සැපයීම සඳහා කර්මාන්තශාලාවක් මඟින් ක්‍රියාකාරී දර්ශක දෘඩාංග විශේෂිත කාර්යයන් වලින් පුරවා ඇත. නිශ්චිත දෘඩාංග ශ්‍රිත අතුරුමුහුණත ලබා ගැනීම සඳහා කර්මාන්තශාලා ශ්‍රිතයක් ලෙස හඳුන්වන මෘදුකාංග භාවිතා කරන වියුක්ත දෘඩාංග ස්ථරයක් සැපයීමට මෙය භාවිතා කළ හැකි අතර පසුව නිශ්චිත ඉලක්කය පිළිබඳ ක්රියාත්මක කිරීමේ තොරතුරු දැන ගැනීමකින් තොරව යටින් පවතින දෘඩාංග සඳහා ක්රියා කිරීමට ලබා දී ඇති ශ්‍රිත දර්ශක භාවිතා කරයි. .
නියෝජිතයින්, හසුරුවන්නන් සහ ඇමතුම් ලබා ගැනීම සඳහා ක්‍රියාකාරී දර්ශක
කිසියම් කාර්යයක් හෝ ක්‍රියාකාරීත්වයක් පැවරීමේ ක්රමයක් ලෙස ඔබට ක්‍රියාකාරී දර්ශක භාවිතා කළ හැකිය. සී සම්භාව්ය උදාහරණයක් ස්ටෑන්ඩර්ඩ් C පුස්තකයන් කාර්යයන් සඳහා භාවිත වන සංසන්දනය නියෝජිතයා කාර්යය පහිටුම් දක්වනය වේ qsort()හා bsearch()භාණ්ඩ ලැයිස්තුවක් වර්ග කිරීම ෙහෝ භාණ්ඩ ක හරිම ලැයිස්තුව පුරා ද්විමය සෝදිසි සිදු කිරීම සඳහා මෙම සංචයනය සඳහා ලබා දීමට. සංසන්දනය කිරීමේ ශ්‍රිත නියෝජිතයා වර්ග කිරීම හෝ ද්විමය සෙවුම සඳහා භාවිතා කරන සංයුක්ත ඇල්ගොරිතම නියම කරයි.
තවත් භාවිතයක් C ++ සම්මත ආකෘති පුස්තකාල බහාලුමකට ඇල්ගොරිතමයක් යෙදීමට සමාන වේ.
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);
තවත් උදාහරණයක් නම්, GUI ප්‍රභව කේතය සමඟ, යම් සිදුවීමක් සඳහා හසුරුවන්නෙකු ලියාපදිංචි කර ඇති අතර, එය සිදුවූ විට සැබවින්ම හැඳින්වෙන ශ්‍රිත දර්ශකයක් සපයයි. මයික්‍රොසොෆ්ට් එම්එෆ්සී රාමුව එහි පණිවිඩ සිතියම් සමඟ වින්ඩෝස් පණිවිඩ හැසිරවීමට සමාන දෙයක් කවුළුවකට හෝ නූලකට යවයි.
නැවත කැඳවීමක් අවශ්ය වන අසමමුහුර්ත කාර්යයන් සිදුවීම් හසුරුවන්නෙකුට සමාන වේ. අසමමුහුර්ත ශ්‍රිතයේ පරිශීලකයා කිසියම් ක්‍රියාවක් ආරම්භ කිරීම සඳහා අසමමුහුර්ත ශ්රිතය අමතන අතර ක්රියාව අවසන් වූ පසු අසමමුහුර්ත ශ්රිතය කැඳවන ශ්‍රිත දර්ශකයක් සපයයි. මෙම අවස්ථාවෙහිදී සිදුවීම යනු එහි කාර්යය සම්පූර්ණ කරන අසමමුහුර්ත ශ්‍රිතයයි.
ඉන්පසු යන්ත්‍රය ඒවා තේරුම් ගන්නේ කෙසේදැයි බලන්න. බිට් 32 ගෘහ නිර්මාණ ශිල්පයෙහි ඉහත වැඩසටහනේ යන්ත්‍ර උපදෙස් පිළිබඳ අවබෝධය.