如果是“.cpp”文件并且有VC++的环境，可直接双击文件打开或者先打开编译环境，在新建一个控制台下的源文件，然后，选择file菜单下的open找到你的文件导入，然后编译运行；如果是其他格式的，如txt文件，也可先打开编译环境，新建一个控制台下的源文件，然后直接复制粘贴进去，然后编译运行；
十多年的习水网站建设经验，针对设计、前端、开发、售后、文案、推广等六对一服务，响应快，48小时及时工作处理。网络营销推广的优势是能够根据用户设备显示端的尺寸不同，自动调整习水建站的显示方式，使网站能够适用不同显示终端，在浏览器中调整网站的宽度，无论在任何一种浏览器上浏览网站，都能展现优雅布局与设计，从而大程度地提升浏览体验。成都创新互联公司从事“习水网站设计”,“习水网站推广”以来，每个客户项目都认真落实执行。
便已运行的操作如图：
你说的就是库函数的源码，也就是glibc，源码在可以下到，比如下载，打开后就可以看到你需要的各种库的具体实现代码，比如在string中的strcat.c中就有
char *strcat (dest, src)
char *dest;
const char *src;
{
char *s1 = dest;
const char *s2 = src;
reg_char c;
/* Find the end of the string. */
do
c = *s1++;
while (c != '\0');
/* Make S1 point before the next character, so we can increment
it while memory is read (wins on pipelined cpus). */
s1 -= 2;
do
{
c = *s2++;
*++s1 = c;
}
while (c != '\0');
return dest;
}
1、首先标准只是规定了这些函数的接口和具体的运行效率的要求，这些函数具体是怎么写得要看各个编译器的实现和平台。
2、例如使用的编译器是visual studio，微软提供了一部分C运行时(CRT)的源码，里面会有memcpy，strcpy之类的函数的实现，在visual studio 2005下的路径是C:\Program Files\Microsoft Visual Studio 8\VC\crt\src。
C语言
C语言是一门通用计算机编程语言，应用广泛。C语言的设计目标是提供一种能以简易的方式编译、处理低级存储器、产生少量的机器码以及不需要任何运行环境支持便能运行的编程语言。
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 */
}