標準庫只是定義接口，具體怎么實現(xiàn)就得看操作系統(tǒng)，你說win下和linux下這些函數(shù)的實現(xiàn)會一樣嗎。當然不一樣，看這些學源碼，不如看看c標準，c89或c99.
創(chuàng)新互聯(lián)長期為千余家客戶提供的網(wǎng)站建設服務，團隊從業(yè)經(jīng)驗10年，關注不同地域、不同群體，并針對不同對象提供差異化的產品和服務；打造開放共贏平臺，與合作伙伴共同營造健康的互聯(lián)網(wǎng)生態(tài)環(huán)境。為珠海企業(yè)提供專業(yè)的網(wǎng)站設計制作、網(wǎng)站設計，珠海網(wǎng)站改版等技術服務。擁有十載豐富建站經(jīng)驗和眾多成功案例,為您定制開發(fā)。
那可以看內核，看系統(tǒng)調用是怎么樣實現(xiàn)的，你說的那些都是基于系統(tǒng)調用的
文件stddef.h里包含了標準庫的一些常用定義，無論我們包含哪個標準頭文件，stddef.h都會被自動包含進來。
這個文件里定義：
類型size_t （sizeof運算符的結果類型，是某個無符號整型）；
類型ptrdiff_t（兩個指針相減運算的結果類型，是某個有符號整型）；
類型wchar_t （寬字符類型，是一個整型，其中足以存放本系統(tǒng)所支持的所有本地環(huán)境中的字符集的所有編碼值。這里還保證空字符的編碼值為0）；
符號常量NULL （空指針值）；
宏offsetor （這是一個帶參數(shù)的宏，第一個參數(shù)應是一個結構類型，第二個參數(shù)應是結構成員名。 offsetor(s,m)求出成員m在結構類型t的變量里的偏移量）。
void __fileDECL qsort (
void *base,
size_t num,
size_t width,
int (__fileDECL *comp)(const void *, const void *)
)
#endif /* __USE_CONTEXT */
{
char *lo, *hi; /* ends of sub-array currently sorting */
char *mid; /* points to middle of subarray */
char *loguy, *higuy; /* traveling pointers for partition step */
size_t size; /* size of the sub-array */
char *lostk[STKSIZ], *histk[STKSIZ];
int stkptr; /* stack for saving sub-array to be processed */
/* validation section */
_VALIDATE_RETURN_VOID(base != NULL || num == 0, EINVAL);
_VALIDATE_RETURN_VOID(width 0, EINVAL);
_VALIDATE_RETURN_VOID(comp != NULL, EINVAL);
if (num 2)
return; /* nothing to do */
stkptr = 0; /* initialize stack */
lo = (char *)base;
hi = (char *)base + width * (num-1); /* initialize limits */
/* this entry point is for pseudo-recursion calling: setting
lo and hi and jumping to here is like recursion, but stkptr is
preserved, locals aren't, so we preserve stuff on the stack */
recurse:
size = (hi - lo) / width + 1; /* number of el's to sort */
/* below a certain size, it is faster to use a O(n^2) sorting method */
if (size = CUTOFF) {
__SHORTSORT(lo, hi, width, comp, context);
}
else {
/* First we pick a partitioning element. The efficiency of the
algorithm demands that we find one that is approximately the median
of the values, but also that we select one fast. We choose the
median of the first, middle, and last elements, to avoid bad
performance in the face of already sorted data, or data that is made
up of multiple sorted runs appended together. Testing shows that a
median-of-three algorithm provides better performance than simply
picking the middle element for the latter case. */
mid = lo + (size / 2) * width; /* find middle element */
/* Sort the first, middle, last elements into order */
if (__COMPARE(context, lo, mid) 0) {
swap(lo, mid, width);
}
if (__COMPARE(context, lo, hi) 0) {
swap(lo, hi, width);
}
if (__COMPARE(context, mid, hi) 0) {
swap(mid, hi, width);
}
/* We now wish to partition the array into three pieces, one consisting
of elements = partition element, one of elements equal to the
partition element, and one of elements than it. This is done
below; comments indicate conditions established at every step. */
loguy = lo;
higuy = hi;
/* Note that higuy decreases and loguy increases on every iteration,
so loop must terminate. */
for (;;) {
/* lo = loguy hi, lo higuy = hi,
A[i] = A[mid] for lo = i = loguy,
A[i] A[mid] for higuy = i hi,
A[hi] = A[mid] */
/* The doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same
value for both pointers. */
if (mid loguy) {
do {
loguy += width;
} while (loguy mid __COMPARE(context, loguy, mid) = 0);
}
if (mid = loguy) {
do {
loguy += width;
} while (loguy = hi __COMPARE(context, loguy, mid) = 0);
}
/* lo loguy = hi+1, A[i] = A[mid] for lo = i loguy,
either loguy hi or A[loguy] A[mid] */
do {
higuy -= width;
} while (higuy mid __COMPARE(context, higuy, mid) 0);
/* lo = higuy hi, A[i] A[mid] for higuy i hi,
either higuy == lo or A[higuy] = A[mid] */
if (higuy loguy)
break;
/* if loguy hi or higuy == lo, then we would have exited, so
A[loguy] A[mid], A[higuy] = A[mid],
loguy = hi, higuy lo */
swap(loguy, higuy, width);
/* If the partition element was moved, follow it. Only need
to check for mid == higuy, since before the swap,
A[loguy] A[mid] implies loguy != mid. */
if (mid == higuy)
mid = loguy;
/* A[loguy] = A[mid], A[higuy] A[mid]; so condition at top
of loop is re-established */
}
/* A[i] = A[mid] for lo = i loguy,
A[i] A[mid] for higuy i hi,
A[hi] = A[mid]
higuy loguy
implying:
higuy == loguy-1
or higuy == hi - 1, loguy == hi + 1, A[hi] == A[mid] */
/* Find adjacent elements equal to the partition element. The
doubled loop is to avoid calling comp(mid,mid), since some
existing comparison funcs don't work when passed the same value
for both pointers. */
higuy += width;
if (mid higuy) {
do {
higuy -= width;
} while (higuy mid __COMPARE(context, higuy, mid) == 0);
}
if (mid = higuy) {
do {
higuy -= width;
} while (higuy lo __COMPARE(context, higuy, mid) == 0);
}
/* OK, now we have the following:
higuy loguy
lo = higuy = hi
A[i] = A[mid] for lo = i = higuy
A[i] == A[mid] for higuy i loguy
A[i] A[mid] for loguy = i hi
A[hi] = A[mid] */
/* We've finished the partition, now we want to sort the subarrays
[lo, higuy] and [loguy, hi].
We do the smaller one first to minimize stack usage.
We only sort arrays of length 2 or more.*/
if ( higuy - lo = hi - loguy ) {
if (lo higuy) {
lostk[stkptr] = lo;
histk[stkptr] = higuy;
++stkptr;
} /* save big recursion for later */
if (loguy hi) {
lo = loguy;
goto recurse; /* do small recursion */
}
}
else {
if (loguy hi) {
lostk[stkptr] = loguy;
histk[stkptr] = hi;
++stkptr; /* save big recursion for later */
}
if (lo higuy) {
hi = higuy;
goto recurse; /* do small recursion */
}
}
}
/* We have sorted the array, except for any pending sorts on the stack.
Check if there are any, and do them. */
--stkptr;
if (stkptr = 0) {
lo = lostk[stkptr];
hi = histk[stkptr];
goto recurse; /* pop subarray from stack */
}
else
return; /* all subarrays done */
}
如果你安裝的Visual Studio，以及它的Visual C++的話，
那么在安裝目錄下的VC/crt/src下有所有標準C庫的源代碼
另外，h后綴的頭文件包含函數(shù)的聲明，具體的實現(xiàn)都在c后綴的源碼文件中
很遺憾,標準庫中的函數(shù)結合了系統(tǒng),硬件等的綜合能力,是比較近機器的功能實現(xiàn),所以大部分是用匯編完成的,而且已經(jīng)導入到了lib和dll里了,就是說,他們已經(jīng)被編譯好了,似乎沒有代碼的存在了.
能看到的也只有dll中有多少函數(shù)被共享.
第三方可能都是dll,因為上面也說了,dll是編譯好的,只能看到成品,就可以隱藏代碼,保護自己的知識產權,同時也是病毒的歸宿...... 當然,除了DLL的確還存在一種東西,插件程序~~~
重慶分公司
重慶分公司
