字符串 数字转换函数

头文件：#include <stdlib.h>

atol()函数：

将字符串转换成long(长整型)

原型：

 long atol(const char * str);

【函数说明】atol() 会扫描参数 str 字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('')才结束转换，并将结果返回。

【返回值】返回转换后的长整型数(long)；如果 str 不能转换成 long 或者 str 为空字符串，那么将返回 0。

atof()函数：

将字符串转换为double(双精度浮点数)

double atof (const char* str);

 【函数说明】它会扫描参数str字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('')才结束转换，并将结果返回。参数str 字符串可包含正负号、小数点或E(e)来表示指数部分，如123. 456 或123e-2。

【返回值】返回转换后的浮点数；如果字符串 str 不能被转换为 double，那么返回 0.0。

#include <stdio.h>
#include <stdlib.h>
int main(){
    char *a = "-100.23",
         *b = "200e-2",
         *c = "341",
         *d = "100.34cyuyan",
         *e = "cyuyan";

    printf("a = %.2f
", atof(a));
    printf("b = %.2f
", atof(b));
    printf("c = %.2f
", atof(c));
    printf("d = %.2f
", atof(d));
    printf("e = %.2f
", atof(e));

    system("pause");
    return 0;
}
/*
执行结果：
a = -100.23
b = 2.00
c = 341.00
d = 100.34
e = 0.00
*/

atoi() 函数

用来将字符串转换成整数(int)，

int atoi (const char * str);

其原型为：

【函数说明】atoi() 函数会扫描参数 str 字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，而再遇到非数字或字符串结束时('')才结束转换，并将结果返回。

【返回值】返回转换后的整型数；如果 str 不能转换成 int 或者 str 为空字符串，那么将返回 0。

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    int i;
    char buffer[256];
    printf ("Enter a number: ");
    fgets (buffer, 256, stdin);
    i = atoi (buffer);
    printf ("The value entered is %d.", i);

    system("pause");
    return 0;
}
/*
执行结果：
Enter a number: 233cyuyan
The value entered is 233.
*/

strtod()函数：

将字符串转换为double(双精度浮点数)

double strtod (const char* str, char** endptr);

【参数说明】str 为要转换的字符串，endstr 为第一个不能转换的字符的指针。

【函数说明】strtod() 函数会扫描参数str字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，到出现非数字或字符串结束时('')才结束转换，并将结果返回。参数 str 字符串可包含正负号、小数点或E(e)来表示指数部分。如123. 456 或123e-2。

若endptr 不为NULL，则会将遇到的不符合条件而终止的字符指针由 endptr 传回；若 endptr 为 NULL，则表示该参数无效，或不使用该参数。

【返回值】返回转换后的浮点型数；若不能转换或字符串为空，则返回 0.0。

#include <stdio.h>
#include <stdlib.h>

int main()
{
    char szOrbits[] = "365.24 29.53";
    char* pEnd;
    double d1, d2;
    d1 = strtod (szOrbits, &pEnd);
    d2 = strtod (pEnd, NULL);
    printf ("月球每年绕地球运行 %.2f 周。
", d1/d2);

    system("pause");
    return 0;
}
/*
执行结果：
月球每年绕地球运行 12.37 周。
*/

strtol() 函数

用来将字符串转换为长整型数(long)，其原型为：

long int strtol (const char* str, char** endptr, int base);

【参数说明】str 为要转换的字符串，endstr 为第一个不能转换的字符的指针，base 为字符串 str 所采用的进制。

【函数说明】strtol() 会将参数 str 字符串根据参数 base 来转换成长整型数(long)。参数 base 范围从2 至36，或0。参数base 代表 str 采用的进制方式，如base 值为10 则采用10 进制，若base 值为16 则采用16 进制等。

strtol() 会扫描参数 str 字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('')结束转换，并将结果返回。

两点注意：

• 当 base 的值为 0 时，默认采用 10 进制转换，但如果遇到 '0x' / '0X' 前置字符则会使用 16 进制转换，遇到 '0' 前置字符则会使用 8 进制转换。
• 若endptr 不为NULL，则会将遇到的不符合条件而终止的字符指针由 endptr 传回；若 endptr 为 NULL，则表示该参数无效，或不使用该参数

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    char szNumbers[] = "2001 60c0c0 -1101110100110100100000 0x6fffff";
    char * pEnd;
    long int li1, li2, li3, li4;
    li1 = strtol (szNumbers,&pEnd,10);
    li2 = strtol (pEnd,&pEnd,16);
    li3 = strtol (pEnd,&pEnd,2);
    li4 = strtol (pEnd,NULL,0);
    printf ("转换成10进制: %ld、%ld、%ld、%ld
", li1, li2, li3, li4);

    system("pause");
    return 0;
}
/*
执行结果：
转换成10进制: 2001、6340800、-3624224、7340031
*/

strtoul() 函数

源自于“string to unsigned long”，用来将字符串转换成无符号长整型数(unsigned long)，其原型为：

    unsigned long strtoul (const char* str, char** endptr, int base);

【参数说明】str 为要转换的字符串，endstr 为第一个不能转换的字符的指针，base 为字符串 str 所采用的进制。

【函数说明】strtoul() 会将参数 str 字符串根据参数 base 来转换成无符号的长整型数(unsigned long)。参数 base 范围从2 至36，或0。参数 base 代表 str 采用的进制方式，如 base 值为10 则采用10 进制，若 base 值为16 则采用16 进制数等。

strtoul() 会扫描参数 str 字符串，跳过前面的空白字符（例如空格，tab缩进等，可以通过 isspace() 函数来检测），直到遇上数字或正负符号才开始做转换，再遇到非数字或字符串结束时('')结束转换，并将结果返回。

两点注意：
当 base 的值为 0 时，默认采用 10 进制转换，但如果遇到 '0x' / '0X' 前置字符则会使用 16 进制转换，遇到 '0' 前置字符则会使用 8 进制转换。
若 endptr 不为NULL，则会将遇到的不符合条件而终止的字符指针由 endptr 传回；若 endptr 为 NULL，则表示该参数无效，或不使用该参数。本文最后的范例没有展示 endptr 参数的使用，你可以参考 strtol() 函数的范例来更加直观地了解 endptr 参数。

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    char buffer [256];
    unsigned long ul;
    printf ("Enter an unsigned number: ");
    fgets (buffer, 256, stdin);
    ul = strtoul (buffer, NULL, 0);
    printf ("Value entered: %lu.
", ul);

    system("pause");
    return 0;
}
/*
Enter an unsigned number: 017cyuyan
Value entered: 15.
*/

//由于 base 参数被设置为 0 并且字符串“017cyuyan”以“0”开头，所以采用 8 进制转换。

calloc() 函数

用来动态地分配内存空间并初始化为 0，其原型为：
  

  void* calloc (size_t num, size_t size);

calloc() 在内存中动态地分配 num 个长度为 size 的连续空间，并将每一个字节都初始化为 0。所以它的结果是分配了 num*size 个字节长度的内存空间，并且每个字节的值都是0。

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 calloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

char *ptr = (char *)calloc(10, 10);  // 分配100个字节的内存空间

calloc() 与 malloc() 的一个重要区别是：calloc() 在动态分配完内存后，自动初始化该内存空间为零，而 malloc() 不初始化，里边数据是未知的垃圾数据。下面的两种写法是等价的：

// calloc() 分配内存空间并初始化
char *str1 = (char *)calloc(10, 2);

// malloc() 分配内存空间并用 memset() 初始化
char *str2 = (char *)malloc(20);
memset(str2, 0, 20);

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    int i,n;
    int * pData;

    printf ("要输入的数字的数目：");
    scanf ("%d",&i);

    pData = (int*) calloc (i,sizeof(int));
    if (pData==NULL) exit (1);

    for (n=0;n<i;n++)
    {
        printf ("请输入数字 #%d：",n+1);
        scanf ("%d",&pData[n]);
    }
    printf ("你输入的数字为：");
    for (n=0;n<i;n++) printf ("%d ",pData[n]);
   
    free (pData);
    system("pause");
    return 0;
}
/*
运行结果：
要输入的数字的数目：4
请输入数字 #1：126
请输入数字 #2：343
请输入数字 #3：45
请输入数字 #4：234
你输入的数字为：126 343 45 234
*/

free() 函数

用来释放动态分配的内存空间，其原型为：
    void free (void* ptr);

free() 可以释放由 malloc()、calloc()、realloc() 分配的内存空间，以便其他程序再次使用。

【参数说明】ptr 为将要释放的内存空间的地址。

free() 只能释放动态分配的内存空间，并不能释放任意的内存。下面的写法是错误的

int a[10];
// ...
free(a);

如果 ptr 所指向的内存空间不是由上面的三个函数所分配的，或者已被释放，那么调用 free() 会有无法预知的情况发生。

如果 ptr 为 NULL，那么 free() 不会有任何作用。

注意：free() 不会改变 ptr 变量本身的值，调用 free() 后它仍然会指向相同的内存空间，但是此时该内存已无效，不能被使用。所以建议将 ptr 的值设置为 NULL，例如：

free(ptr);
ptr = NULL;

#include <stdlib.h>
int main ()
{
    int * buffer1, * buffer2, * buffer3;
    buffer1 = (int*) malloc (100*sizeof(int));
    buffer2 = (int*) calloc (100,sizeof(int));
    buffer3 = (int*) realloc (buffer2,500*sizeof(int));
    free (buffer1);
    free (buffer3);

    system("pause");
    return 0;
}
/*
上面的代码没有输出，仅仅用来演示如何分配和释放内存。
*/

malloc() 函数

用来动态地分配内存空间（如果你不了解动态内存分配，请查看：C语言动态内存分配及变量存储类别），其原型为：

void* malloc (size_t size);

【参数说明】size 为需要分配的内存空间的大小，以字节（Byte）计。

【函数说明】malloc() 在堆区分配一块指定大小的内存空间，用来存放数据。这块内存空间在函数执行完成后不会被初始化，它们的值是未知的。如果希望在分配内存的同时进行初始化，请使用 calloc() 函数。

【返回值】分配成功返回指向该内存的地址，失败则返回 NULL。

由于申请内存空间时可能有也可能没有，所以需要自行判断是否申请成功，再进行后续操作。

如果 size 的值为 0，那么返回值会因标准库实现的不同而不同，可能是 NULL，也可能不是，但返回的指针不应该再次被引用。

注意：函数的返回值类型是 void *，void 并不是说没有返回值或者返回空指针，而是返回的指针类型未知。所以在使用 malloc() 时通常需要进行强制类型转换，将 void 指针转换成我们希望的类型，例如：

char *ptr = (char *)malloc(10);  // 分配10个字节的内存空间，用来存放字符

动态内存分配举例：

#include <stdio.h>  /* printf, scanf, NULL */
#include <stdlib.h>  /* malloc, free, rand, system */

int main ()
{
    int i,n;
    char * buffer;

    printf ("输入字符串的长度：");
    scanf ("%d", &i);

    buffer = (char*)malloc(i+1);  // 字符串最后包含 
    if(buffer==NULL) exit(1);  // 判断是否分配成功

    // 随机生成字符串
    for(n=0; n<i; n++)
        buffer[n] = rand()%26+'a';
    buffer[i]='';

    printf ("随机生成的字符串为：%s
",buffer);
    free(buffer);  // 释放内存空间

    system("pause");
    return 0;
}

运行结果：
输入字符串的长度：20
随机生成的字符串为：phqghumeaylnlfdxfirc

该程序生成一个指定长度的字符串，并用随机生成的字符填充。字符串的长度仅受限于可用内存的长度。

 

realloc() 函数

用来重新分配内存空间，其原型为：
    void* realloc (void* ptr, size_t size);

【参数说明】ptr 为需要重新分配的内存空间指针，size 为新的内存空间的大小。

realloc() 对 ptr 指向的内存重新分配 size 大小的空间，size 可比原来的大或者小，还可以不变（如果你无聊的话）。当 malloc()、calloc() 分配的内存空间不够用时，就可以用 realloc() 来调整已分配的内存。

如果 ptr 为 NULL，它的效果和 malloc() 相同，即分配 size 字节的内存空间。

如果 size 的值为 0，那么 ptr 指向的内存空间就会被释放，但是由于没有开辟新的内存空间，所以会返回空指针；类似于调用 free()。

几点注意：

• 指针 ptr 必须是在动态内存空间分配成功的指针，形如如下的指针是不可以的：int *i; int a[2]；会导致运行时错误，可以简单的这样记忆：用 malloc()、calloc()、realloc() 分配成功的指针才能被 realloc() 函数接受。
• 成功分配内存后 ptr 将被系统回收，一定不可再对 ptr 指针做任何操作，包括 free()；相反的，可以对 realloc() 函数的返回值进行正常操作。
• 如果是扩大内存操作会把 ptr 指向的内存中的数据复制到新地址（新地址也可能会和原地址相同，但依旧不能对原指针进行任何操作）；如果是缩小内存操作，原始据会被复制并截取新长度。

【返回值】分配成功返回新的内存地址，可能与 ptr 相同，也可能不同；失败则返回 NULL。

注意：如果分配失败，ptr 指向的内存不会被释放，它的内容也不会改变，依然可以正常使用。

代码示例：

#include <stdio.h>
#include <stdlib.h>

int main ()
{
    int input,n;
    int count = 0;
    int* numbers = NULL;
    int* more_numbers = NULL;

    do {
        printf ("Enter an integer value (0 to end): ");
        scanf ("%d", &input);
        count++;

        more_numbers = (int*) realloc (numbers, count * sizeof(int));

        if (more_numbers!=NULL) {
            numbers=more_numbers;
            numbers[count-1]=input;
        }else {
            free (numbers);
            puts ("Error (re)allocating memory");
            exit (1);
        }
    } while(input!=0);

    printf ("Numbers entered: ");
    for (n=0;n<count;n++) printf("%d ",numbers[n]);
    free (numbers);

    system("pause");
    return 0;
}
/*
运行结果：
Enter an integer value (0 to end): 23
Enter an integer value (0 to end): 45
Enter an integer value (0 to end): 23
Enter an integer value (0 to end): 67
Enter an integer value (0 to end): 0
Numbers entered: 23 45 23 67 0
*/