求C語言標準函數庫的源代碼

標準庫只是定義接口，具體怎么實現就得看操作系統，你說win下和linux下這些函數的實現會一樣嗎。當然不一樣，看這些學源碼，不如看看c標準，c89或c99.

創新互聯長期為千余家客戶提供的網站建設服務，團隊從業經驗10年，關注不同地域、不同群體，并針對不同對象提供差異化的產品和服務；打造開放共贏平臺，與合作伙伴共同營造健康的互聯網生態環境。為珠海企業提供專業的網站設計制作、網站設計，珠海網站改版等技術服務。擁有十載豐富建站經驗和眾多成功案例,為您定制開發。

那可以看內核，看系統調用是怎么樣實現的，你說的那些都是基于系統調用的

c語言常用庫函數有哪些

文件stddef.h里包含了標準庫的一些常用定義，無論我們包含哪個標準頭文件，stddef.h都會被自動包含進來。

這個文件里定義：

類型size_t （sizeof運算符的結果類型，是某個無符號整型）；

類型ptrdiff_t（兩個指針相減運算的結果類型，是某個有符號整型）；

類型wchar_t （寬字符類型，是一個整型，其中足以存放本系統所支持的所有本地環境中的字符集的所有編碼值。這里還保證空字符的編碼值為0）；

符號常量NULL （空指針值）；

宏offsetor （這是一個帶參數的宏，第一個參數應是一個結構類型，第二個參數應是結構成員名。 offsetor(s,m)求出成員m在結構類型t的變量里的偏移量）。

C語言庫函數qsort源代碼

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 */

}

求C語言中的庫函數的源代碼 如printf()函數，我要它的源代碼

如果你安裝的Visual Studio，以及它的Visual C++的話，

那么在安裝目錄下的VC/crt/src下有所有標準C庫的源代碼

另外，h后綴的頭文件包含函數的聲明，具體的實現都在c后綴的源碼文件中

如何看c語言標準庫函數的源代碼?

很遺憾,標準庫中的函數結合了系統,硬件等的綜合能力,是比較近機器的功能實現,所以大部分是用匯編完成的,而且已經導入到了lib和dll里了,就是說,他們已經被編譯好了,似乎沒有代碼的存在了.

能看到的也只有dll中有多少函數被共享.

第三方可能都是dll,因為上面也說了,dll是編譯好的,只能看到成品,就可以隱藏代碼,保護自己的知識產權,同時也是病毒的歸宿...... 當然,除了DLL的確還存在一種東西,插件程序~~~