[资料]

stdlib.h 函数源代码

2011-3-26 10:26:34 8660

atoi ( )/* --C语言库函数源代码 -*/
#include
/*
这个函数调用的是库函数中的
strtol()函数，关于这个函数的
源代码后面将会给出。
*/
int my_atoi(char *str)
{
return (int) strtol(str, NULL, 10);
}
/*
下面的两个函数没有调用strtol()函数，
而是直接给出了该函数的实现。
*/
int my_atoi01(const char *str)
{
long int v=0;
int sign = 0;
while ( *str == ' ') str++;
if(*str == '-'||*str == '+')
sign = *str++;
while (isdigit(*str))
{
v = v*10 + *str - '0';
str++;
}
return sign == '-' ? -v:v;
}
int my_atoi02(char *str)
{
int sign;
int n;
unsigned char *p;
p=str;
while (isspace(*p) ) p++;
sign = (*p == '-' ) ? -1 : 1;
if (*p=='+' || *p=='-' ) p++;
for (n=0; isdigit(*p); p++)
n = 10*n + (*p - '0');
return sign*n;
}
int main()
{
char * str = "2147483647";
printf("%dn",my_atoi(str));
str = "-2147483648";
printf("%dn",my_atoi(str));
str = "2147483647";
printf("%dn",my_atoi01(str));
str = "-2147483648";
printf("%dn",my_atoi01(str));
str = "2147483647";
printf("%dn",my_atoi02(str));
str = "-2147483648";
printf("%dn",my_atoi02(str));
system("pause");
return 0;
}
strtol ( )/* --C语言库函数源代码 -*/
/*
这个函数会将参数nptr字符串根据参数base来转换成长整型数。
参数base范围从2至36，或0。参数base代表采用的进制方式，
如base值为10则采用10进制，若base值为16则采用16进制等。
当base值为0时则是采用10进制做转换，但遇到如’0x’前置
字符则会使用16进制做转换、遇到’0’前置字符而不是’0x’
的时候会使用8进制做转换。一开始strtol()会扫描参数nptr
字符串，跳过前面的空格字符，直到遇上数字或正负符号才
开始做转换，再遇到非数字或字符串结束时('\0')结束转换，
并将结果返回。若参数endptr不为NULL，则会将遇到不合条件
而终止的nptr中的字符指针由endptr返回。
*/
#include
#define LONG_MAX 2147483647L /*0x7FFFFFFF*/
#define LONG_MIN (-2147483647L-1L) /*-0x80000000*/
int my_strtol(const char *nptr, char **endptr, int base)
{
const char *p = nptr;
unsigned long ret;
int ch;
unsigned long Overflow;
int sign = 0, flag, LimitRemainder;
/*
跳过前面多余的空格，并判断正负符号。
如果base是0，允许以0x开头的十六进制数，
以0开头的8进制数。
如果base是16，则同时也允许以0x开头。
*/
do
{
ch = *p++;
} while (isspace(ch));
if (ch == '-')
{
sign = 1;
ch = *p++;
}
else if (ch == '+')
ch = *p++;
if ((base == 0 || base == 16) &&
ch == '0' && (*p == 'x' || *p == 'X'))
{
ch = p[1];
p += 2;
base = 16;
}
if (base == 0)
base = ch == '0' ? 8 : 10;
Overflow = sign ? -(unsigned long)LONG_MIN : LONG_MAX;
LimitRemainder = Overflow % (unsigned long)base;
Overflow /= (unsigned long)base;
for (ret = 0, flag = 0;; ch = *p++)
{
/*把当前字符转换为相应运算中需要的值。*/
if (isdigit(ch))
ch -= '0';
else if (isalpha(ch))
ch -= isupper(ch) ? 'A' - 10 : 'a' - 10;
else
break;
if (ch >= base)
break;
/*如果产生溢出，则置标志位，以后不再做计算。*/
if (flag < 0 || ret > Overflow || (ret == Overflow && ch > LimitRemainder))
flag = -1;
else
{
flag = 1;
ret *= base;
ret += ch;
}
}
/*
如果溢出，则返回相应的Overflow的峰值。
没有溢出，如是符号位为负，则转换为负数。
*/
if (flag < 0)
ret = sign ? LONG_MIN : LONG_MAX;
else if (sign)
ret = -ret;
/*
如字符串不为空，则*endptr等于指向nptr结束
符的指针值；否则*endptr等于nptr的首地址。
*/
if (endptr != 0)
*endptr = (char *)(flag ?(p - 1) : nptr);
return ret;
}
int main()
{
char * str = "2147483647";
printf("%dn",my_strtol(str, NULL, 0));
str = "-2147483648";
printf("%dn",my_strtol(str, NULL, 0));
str = "0x7FFFFFFF";
printf("%dn",my_strtol(str, NULL, 0));
str = "-0x80000000";
printf("%dn",my_strtol(str, NULL, 0));
str = "0x7FFFFFFF";
printf("%dn",my_strtol(str, NULL, 16));
str = "-0x80000000";
printf("%dn",my_strtol(str, NULL, 16));
str = "017777777777";
printf("%dn",my_strtol(str, NULL, 0));
str = "-020000000000";
printf("%dn",my_strtol(str, NULL, 0));
system("pause");
return 0;
}
ldiv ( )/* --C语言库函数源代码 -*/
/*
对两个长整型数相除，返回类型为ldiv_t,
在stdlib.h头文件中定义。
typedef struct
{
long quot;
long rem;
} ldiv_t;
quot存储的是商(quotient)。
rem 存储的是余数(remainder)。
算法和div()函数非常类似。
*/
typedef struct
{
long quot;
long rem;
} ldiv_t;
ldiv_t my_ldiv(long num, long denom)
{
ldiv_t r;
r.quot = num / denom;
r.rem = num % denom;
/*
在我们普通PC（Intel架构系列的CPU）上
可以正常运行。但是我们不知道其他的机器
是怎么来处理整除和取余运算的，所以还是
要写出来错误处理代码。
被除数为正，余数为负，商加1，余数减除数。
被除数为负，余数为正，商减1，余数加除数。
*/
if (num >= 0 && r.rem < 0)
{
++r.quot;
r.rem -= denom;
}
else if (num < 0 && r.rem > 0)
{
--r.quot;
r.rem += denom;
}
return (r);
}
int main()
{
ldiv_t t;
t = my_ldiv(200,-300000000);
printf("Quotient = %dtRemainder = %dn",t.quot,t.rem);
system("pause");
return 0;
}
div ( )/* --C语言库函数源代码 -*/
/*
对两个整数相除，返回类型为div_t,
在stdlib.h头文件中定义。
typedef struct
{
int quot;
int rem;
} div_t;
quot存储的是商(quotient)。
rem 存储的是余数(remainder)。
算法和ldiv()函数非常类似。
这个函数并不进行分母（除数）为0的检测。
*/
typedef struct
{
int quot;
int rem;
} div_t;
div_t my_div(int num, int denom)
{
div_t r;
r.quot = num / denom;
r.rem = num % denom;
/*
在我们普通PC（Intel架构系列的CPU）上
可以正常运行。但是我们不知道其他的机器
是怎么来处理整除和取余运算的，所以还是
要写出来错误处理代码。
被除数为正，余数为负，商加1，余数减除数。
被除数为负，余数为正，商减1，余数加除数。
*/
if (num >= 0 && r.rem < 0)
{
++r.quot;
r.rem -= denom;
}
else if (num < 0 && r.rem > 0)
{
--r.quot;
r.rem += denom;
}
return (r);
}
int main()
{
div_t t;
t = my_div(0x7FFFFFFF,2);
printf("Quotient = %dtRemainder = %dn",t.quot,t.rem);
system("pause");
return 0;
}
atof ( )/* --C语言库函数源代码 -*/
/*
这个函数调用的是库函数中的
strtod()函数，关于这个函数的
源代码后面将会给出。
*/
#include
double my_atof(char *str)
{
return strtod(str,0);
}
int main()
{
char * str = "12345.6789";
printf("%fn",my_atof(str));
str = "-12345.6789";
printf("%fn",my_atof(str));
str = "9.8546721E+4";
printf("%fn",my_atof(str));
str = "-985467.21e-4";
printf("%fn",my_atof(str));
system("pause");
return 0;
}
strtod ( ) 和 atof ( )/* --C语言库函数源代码 -*/
/*
这个函数是把浮点数字符串转换为浮点数的函数。
函数将会跳过字符串中的空格字符和不是'+'、'-'、'.'、
数字的字符。如果字符串是空的或者都是由空格组成，将不会
做任何转换，仅仅是把字符串的结束地址赋给endptr。如果字
符串合法，将会进行转换，并把字符串最后的NULL的地址给
endptr。如果你想使用endptr参数，那么赋一个NULL值就
可以了。
*/
double my_strtod(const char* s, char** endptr)
{
register const char* p = s;
register long double value = 0.L;
int sign = 0;
long double factor;
unsigned int expo;
while ( isspace(*p) )//跳过前面的空格
p++;
if(*p == '-' || *p == '+')
sign = *p++;//把符号赋给字符sign，指针后移。
//处理数字字符
while ( (unsigned int)(*p - '0') < 10u )//转换整数部分
value = value*10 + (*p++ - '0');
//如果是正常的表示方式（如：1234.5678）
if ( *p == '.' )
{
factor = 1.;
p++;
while ( (unsigned int)(*p - '0') < 10u )
{
factor *= 0.1;
value += (*p++ - '0') * factor;
}
}
//如果是IEEE754标准的格式（如：1.23456E+3）
if ( (*p | 32) == 'e' )
{
expo = 0;
factor = 10.L;
switch (*++p)
{
case '-':
factor = 0.1;
case '+':
p++;
break;
case '0':
case '1':
case '2':
case '3':
case '4':
case '5':
case '6':
case '7':
case '8':
case '9':
break;
default :
value = 0.L;
p = s;
goto done;
}
while ( (unsigned int)(*p - '0') < 10u )
expo = 10 * expo + (*p++ - '0');
while ( 1 )
{
if ( expo & 1 )
value *= factor;
if ( (expo >>= 1) == 0 )
break;
factor *= factor;
}
}
done:
if ( endptr != 0 )
*endptr = (char*)p;
return (sign == '-' ? -value : value);
}
double my_atof(char *str)
{
return my_strtod(str,0);
}
int main()
{
char * str = "12345.6789";
printf("%fn",my_strtod(str,0));
printf("%fn",my_atof(str));
str = "-12345.6789";
printf("%fn",my_strtod(str,0));
printf("%fn",my_atof(str));
str = "9.8546721E+4";
printf("%fn",my_strtod(str,0));
printf("%fn",my_atof(str));
str = "-985467.21e-4";
printf("%fn",my_strtod(str,0));
printf("%fn",my_atof(str));
system("pause");
return 0;
}
srandom ( ) 和 random ( )/* --C语言库函数源代码 -*/
/*
这两个函数也是C库中产生随机数的程序。你需要先
使用srandom()函数赋随机数种子值。然后再使用
random()函数来产生随机数。是对srand()和rand()
这两个函数的改良，用法也很类似。现在的这个代码
仅仅是实现了随机数函数srand()和rand()的功能。
在GCC库函数中要比现在的代码完全的多，另外可以
指定其他的状态值，使得随机更完全。
*/
#define ULONG_MAX ((unsigned long)(~0L)) /* 0xFFFFFFFF*/
#define LONG_MAX ((long)(ULONG_MAX >> 1))/* 0x7FFFFFFF*/
#define NULL (void *) 0
static long int RandomTable[32] ={ 3,
0x9a319039, 0x32d9c024, 0x9b663182, 0x5da1f342,
0xde3b81e0, 0xdf0a6fb5, 0xf103bc02, 0x48f340fb,
0x7449e56b, 0xbeb1dbb0, 0xab5c5918, 0x946554fd,
0x8c2e680f, 0xeb3d799f, 0xb11ee0b7, 0x2d436b86,
0xda672e2a, 0x1588ca88, 0xe369735d, 0x904f35f7,
0xd7158fd6, 0x6fa6f051, 0x616e6b96, 0xac94efdc,
0x36413f93, 0xc622c298, 0xf5a42ab8, 0x8a88d77b,
0xf5ad9d0e, 0x8999220b, 0x27fb47b9
};
static long int *fptr = &RandomTable[4];
static long int *rptr = &RandomTable[1];
static long int *state = &RandomTable[1];
static long int *end_ptr = &RandomTable[sizeof(RandomTable) / sizeof(RandomTable[0])];
long int my_random ()
{
long int i;
*fptr += *rptr;
i = (*fptr >> 1) & LONG_MAX;
fptr++;
if (fptr >= end_ptr)
{
fptr = state;
rptr++;
}
else
{
rptr++;
if (rptr >= end_ptr)
rptr = state;
}
return i;
}
void my_srandom (unsigned int seed)
{
state[0] = seed;
register long int i;
for (i = 1; i < 31; ++i)
state[i] = (1103515145 * state[i - 1]) + 12345;
fptr = &state[3];
rptr = &state[0];
for (i = 0; i < 10 * 31; ++i)
my_random();
}
#include
int main()
{
int i;
my_srandom((unsigned)(time(NULL)));
for(i=0;i<100;i++)
{
if(i % 10 == 0)
printf("n");
printf("%dt",my_random()%99+1);
}
system("pause");
return 0;
}
rand ( ) 和 srand ( )/* --C语言库函数源代码 -*/
/*
这两个函数是C库中产生随机数的程序。你需要先
使用srand()函数赋随机数种子值。然后再使用
rand()函数来产生随机数。但是产生随机数的算法
较简单，srandom()和random()函数是对这两个函数
的改良，用法也很类似。
*/
#define RANDOM_MAX 0x7FFFFFFF
static long my_do_rand(unsigned long *value)
{
/*
这个算法保证所产生的值不会超过(2^31 - 1)
这里(2^31 - 1)就是 0x7FFFFFFF。而 0x7FFFFFFF
等于127773 * (7^5) + 2836,7^5 = 16807。
整个算法是通过：t = (7^5 * t) mod (2^31 - 1)
这个公式来计算随机值，并且把这次得到的值，作为
下次计算的随机种子值。
*/
long quotient, remainder, t;
quotient = *value / 127773L;
remainder = *value % 127773L;
t = 16807L * remainder - 2836L * quotient;
if (t <= 0)
t += 0x7FFFFFFFL;
return ((*value = t) % ((unsigned long)RANDOM_MAX + 1));
}
static unsigned long next = 1;
int my_rand(void)
{
return my_do_rand(&next);
}
void my_srand(unsigned int seed)
{
next = seed;
}
#include
int main()
{
int i;
my_srand((unsigned)(time(NULL)));
for(i=0;i<100;i++)
{
if(i % 10 == 0)
printf("n");
printf("%dt",my_rand()%99+1);
}
system("pause");
return 0;
}