联合与枚举、高级指针、 C语言标准库（一）

1 输入一个整数，求春夏秋冬

1.1 问题

在实际应用中，有的变量只有几种可能取值。如人的性别只有两种可能取值，星期只有七种可能取值。在 C 语言中对这样取值比较特殊的变量可以定义为枚举类型。所谓枚举是指将变量的值一一列举出来，变量只限于列举出来的值的范围内取值。

本案例需要使用交互的方式判断：用户从控制台输入一个整数，由程序判断该整数是春夏秋冬哪个季节。春夏秋冬分别用一个枚举常量表示。

程序交互过程如图-1所示：

图-1

1.2 方案

首先，在程序中定义一个枚举，在枚举中定义春夏秋冬四个常量。然后，从控制台输入一个整数，接着，使用switch结构判断输入的整数是哪个季节，并输出相应季节的名称。如果输入的整数不在枚举常量的范围之内，则显示输入错误。

1.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义枚举

代码如下：

#include <stdio.h>
enum Season
{
SPRING,
SUMMER,
AUTUMN,
WINTER,
};
int main(int argc, const char * argv[])
{
return 0;
}

步骤二：输入一个整数

定义一个变量，用于存储从控制台输入的整数。

代码如下：

#include <stdio.h>
enum Season
{
SPRING,
SUMMER,
AUTUMN,
WINTER,
};
int main(int argc, const char * argv[])
{
int season;
printf("请输入一个整数：");
scanf("%d", &season);
return 0;
}

步骤三：季节判断

使用switch结构，判断输入的整数属于哪个季节。

#include <stdio.h>
enum Season
{
SPRING,
SUMMER,
AUTUMN,
WINTER,
};
int main(int argc, const char * argv[])
{
int season;
printf("请输入一个整数：");
scanf("%d", &season);
switch (season)
{
case SPRING:
printf("对应的季节是：spring\n");
break;
case SUMMER:
printf("对应的季节是：summer\n");
break;
case AUTUMN:
printf("对应的季节是：autumn\n");
break;
case WINTER:
printf("对应的季节是：winter\n");
break;
default:
printf("error\n");
}
return 0;
}

1.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
enum Season
{
SPRING,
SUMMER,
AUTUMN,
WINTER,
};
int main(int argc, const char * argv[])
{
int season;
printf("请输入一个整数：");
scanf("%d", &season);
switch (season)
{
case SPRING:
printf("对应的季节是：spring\n");
break;
case SUMMER:
printf("对应的季节是：summer\n");
break;
case AUTUMN:
printf("对应的季节是：autumn\n");
break;
case WINTER:
printf("对应的季节是：winter\n");
break;
default:
printf("error\n");
}
return 0;
}

2 用参数返回字符串

2.1 问题

用参数返回一个值，该参数需要用到指针，使用形参指针可以在一个函数内部修改它所指向的内容，如下代码所示:

void func(int *x)
{
*x = 10;
}
int main()
{
int a = 0;
func(&a);
printf(“%d”, a);
}

上述代码中，在主函数内将变量a的地址作为实参传递给函数func的形参x，而在函数func中，修改指针x指向的内容，即主函数中的变量a，此时的修改是可以带回主函数的，即主函数中的变量a将变为10。

但是，如果我们修改的不是指针所指向的内容，而是指针本身，那么，这样的修改是无法带回主函数的。如下面代码所示：

void func(int *x)
{
static int data = 20;
x = &data;
}
int main()
{
int a = 0;
func(&a);
printf(“%d”, a);
}

2.2 方案

在函数调用的过程中，如果我们要修改的不是指针所指向的内容，而是指针本身，那么，这样的修改必须通过二级指针来实现。

所谓的二级指针，是指指向指针的指针，如下代码所示：

int a;
int *p = &a;
int **p1 = &p;

上述代码中，指针变量p是一级指针，它直接指向一个整型变量；而变量p1，则是一个二级指针，因为它指向的是另一个指针变量p，也就是说，p1是指向指针p的指针，即指针的指针。

2.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义返回字符串的函数

该函数需要使用二级指针，即指针的指针。因为在函数中，需要修改的是指针本身，这样就需要将指针本身的地址（也就是指针变量的地址）作为参数传递过来。

代码如下：

#include <stdio.h>
void getString(char **str)
{
*str = "This is a string.\n";
}
int main()
{
return 0;
}

上述代码中，指针str为一个二级指针。

步骤二：在主程序中，获得并打印返回的字符串

代码如下：

#include <stdio.h>
void getString(char **str)
{
*str = "This is a string.\n";
}
int main()
{
char *string = NULL;
getString(&string);
printf("%s",string);
return 0;
}

上述代码中，指针变量str得到的是指针变量string的地址，所以str为二级指针，而对*str的修改就是对string的修改。

2.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
void getString(char **str)
{
*str = "This is a string.\n";
}
int main()
{
char *string = NULL;
getString(&string);
printf("%s",string);
return 0;
}

3 打印任意类型变量的内存数据

3.1 问题

void*表示“空类型指针”，与void不同，void*表示“任意类型的指针”或表示“该指针与一地址值相关，但是不清楚在此地址上的对象的类型”。C是静态类型的语言，定义变量就会分配内存，然而，不同类型的变量所占内存不同，如果定义一个任意类型的变量，如何为其分配内存呢？所以，C中没有任意类型的变量。但是，所有指针类型的变量，无论是int*、char*、string*、Student*等等，他们的内存空间都是相同的，所以可以定义“任意类型的指针”。

3.2 方案

void*类型的指针可以指向任意类型的变量，如下面代码：

int a;
void* p = &a;
float f;
p = &f;

上述代码都是正确的，指针变量p既可以指向整型变量a，同时，它还可以指向浮点型变量f。

将一个void*类型的指针指向的内容赋值给一个确定类型的变量时，不能直接赋值，如下面代码：

int a = 10;
void* p = &a;
int b = *p;//error

上述代码的第三行是错误的，因为void*类型的指针指向的内容的类型是不确定的，所以是无法进行赋值的。如果非要进行赋值，必须先将void*类型的指针强转成确定的数据类型，如下面代码：

int b = *(int*)p;

3.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：编写打印函数

该函数带有一个void*类型的指针，用于接收任意类型的数据，同时还带有一个整型变量，用于表示void*类型的指针指向的内容的数据类型。在函数体中，使用一个switch结构，用整型变量来区分不同的数据类型，以打印不同的数据。

代码如下：

#include <stdio.h>
void print(void *data, int type)
{
switch (type)
{
case 0:
printf("%d\n", *(int*)data);
break;
case 1:
printf("%f\n", *(float*)data);
break;
case 2:
printf("%lf\n", *(double*)data);
break;
case 3:
printf("%c\n", *(char*)data);
break;
}
}
int main()
{
return 0;
}

步骤二：主函数打印不同类型的数据

代码如下：

#include <stdio.h>
void print(void *data, int type)
{
switch (type)
{
case 0:
printf("%d\n", *(int*)data);
break;
case 1:
printf("%f\n", *(float*)data);
break;
case 2:
printf("%lf\n", *(double*)data);
break;
case 3:
printf("%c\n", *(char*)data);
break;
}
}
int main()
{
int a = 10;
print(&a, 0);
float f = 3.14f;
print(&f, 1);
double d = 1.2345;
print(&d, 2);
char c = 'a';
print(&c, 3);
return 0;
}

3.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
void print(void *data, int type)
{
switch (type)
{
case 0:
printf("%d\n", *(int*)data);
break;
case 1:
printf("%f\n", *(float*)data);
break;
case 2:
printf("%lf\n", *(double*)data);
break;
case 3:
printf("%c\n", *(char*)data);
break;
}
}
int main()
{
int a = 10;
print(&a, 0);
float f = 3.14f;
print(&f, 1);
double d = 1.2345;
print(&d, 2);
char c = 'a';
print(&c, 3);
return 0;
}

4 排序函数使用函数指针

4.1 问题

函数指针是一种指针，一个指向函数入口地址的指针。一个函数需要占用一段内存空间，这段空间的起始地址是函数的入口地址。可以定义一个指针变量，指向函数的入口地址，然后通过这个指针变量调用函数。

4.2 方案

一种排序函数，一般只能有一种排序规则。例如：要么从大到小排序，要么从小到大排序，或者特殊的规则，比如按照对3求余数的排序。通过使用函数指针，可以使排序函数将排序规则独立。这样在对指定的数据进行排序的时候，同时指定排序规则，使得排序函数第一次被调用时可以从大到小排序，第二次被调用时又可以从小到大排序。

4.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：在主程序中，定义一个数组

代码如下：

#include <stdio.h>
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
return 0;
}

步骤二：定义数组打印函数

代码如下：

#include <stdio.h>
void print(int* a, int n)
{
for (int i=0; i<n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
print(a, 10);
return 0;
}

步骤三：定义带排序规则的排序函数

排序方法采用冒泡方法。

代码如下：

#include <stdio.h>
void print(int* a, int n)
{
for (int i=0; i<n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int rule1(int x, int y)
{
return x - y;
}
void sort(int* a, int n, int (*f)(int, int))
{
for (int i=0; i<n-1; i++) {
for (int j=0; j<n-i-1; j++) {
if (f(a[j], a[j+1])>0) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
print(a, 10);
sort(a, 10, rule1);
print(a, 10);
return 0;
}

上述代码中，以下代码：

int rule1(int x, int y)
{
return x - y;
}

是排序规则，该函数返回形参x与y的差，如果返回值大于0，代表x大于y；如果返回值等于0，代表x等于y；如果返回值小于0，代表x小于y。

上述代码中，以下代码：

void sort(int* a, int n, int (*f)(int, int))

是排序函数的函数头，该函数是一个无返回值的函数，函数名为sort，函数带有三个形参，第一个形参是一个整型指针变量，它用于接收需要排序的数据；第二个形参是一个整型变量，它用于接收需要排序的数据的个数；第三个形参是一个函数的指针变量，int表示该函数指针变量指向的函数的返回值为整型，f为函数指针变量的变量名，(int,int)代表该函数指针变量指向的函数有两个形参。

在主函数中，使用以下代码调用sort函数：

sort(a, 10, rule1);

其中，第一个实参a为数组a的数组名，第二个实参10为数组a的数组长度，第三个实参rule1为函数名，该函数为排序规则。

上述代码中，以下代码：

if (f(a[j], a[j+1])>0) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}

是使用函数指针调用函数，指针变量f作为形参，接收实参传递过来的函数的入口地址，即rule1函数，使用f(a[j],a[j+1])调用rule1函数，其中，a[j]和a[j+1]是函数指针变量f指向的函数的两个实参，即函数rule1的两个实参。

步骤四：定义其它排序规则函数

代码如下：

#include <stdio.h>
void print(int* a, int n)
{
for (int i=0; i<n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int rule1(int x, int y)
{
return x - y;
}
int rule2(int x, int y)
{
return y - x;
}
int rule3(int x, int y)
{
return x%3 - y%3;
}
void sort(int* a, int n, int (*f)(int, int))
{
for (int i=0; i<n-1; i++) {
for (int j=0; j<n-i-1; j++) {
if (f(a[j], a[j+1])>0) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
print(a, 10);
sort(a, 10, rule1);
print(a, 10);
sort(a, 10, rule2);
print(a, 10);
sort(a, 10, rule3);
print(a, 10);
return 0;
}

4.4 完整代码

#include <stdio.h>
void print(int* a, int n)
{
for (int i=0; i<n; i++) {
printf("%d ", a[i]);
}
printf("\n");
}
int rule1(int x, int y)
{
return x - y;
}
int rule2(int x, int y)
{
return y - x;
}
int rule3(int x, int y)
{
return x%3 - y%3;
}
void sort(int* a, int n, int (*f)(int, int))
{
for (int i=0; i<n-1; i++) {
for (int j=0; j<n-i-1; j++) {
if (f(a[j], a[j+1])>0) {
int t = a[j];
a[j] = a[j+1];
a[j+1] = t;
}
}
}
}
int main()
{
int a[10] = {1,2,3,4,5,6,7,8,9,0};
print(a, 10);
sort(a, 10, rule1);
print(a, 10);
sort(a, 10, rule2);
print(a, 10);
sort(a, 10, rule3);
print(a, 10);
return 0;
}

5 重新分配申请的空间

5.1 问题

在堆内存中，可以使用malloc函数分配一块存储空间。malloc()函数其实就在堆内存中找一片指定大小的空间，然后将这个空间的首地址返回给一个指针变量，这里的指针变量可以是一个单独的指针，也可以是一个数组的首地址，这要看malloc()函数中参数size的具体内容。我们这里malloc分配的内存空间在逻辑上连续的，而在物理上可以连续也可以不连续。对于我们程序员来说，我们关注的是逻辑上的连续，因为操作系统会帮我们安排内存分配，所以我们使用起来就可以当做是连续的。

还可以使用realloc函数对用malloc函数分配好的空间重新分配，一般是扩大。对于realloc函数，如果有足够空间用于扩大mem_address指向的内存块，则分配额外内存，并返回分配内存的首地址。这里说的是“扩大”，我们知道，realloc是从堆上分配内存的，当扩大一块内存空间时， realloc()试图直接从堆上现存的数据后面的那些字节中获得附加的字节，如果能够满足，自然天下太平。也就是说，如果原先的内存大小后面还有足够的空闲空间用来分配，加上原来的空间大小就等于新的空间大小。得到的是一块连续的内存。如果原先的内存大小后面没有足够的空闲空间用来分配，那么从堆中另外找一块新大小的内存。并把原来大小内存空间中的内容复制到新空间中。返回新的内存的指针。这样数据被移动了新空间，先前的空间被释放。

当使用malloc分配的空间不再使用的时候，可以使用free函数将这块空间还给堆内存，以使这块内存可以被再次使用。

5.2 方案

首先，使用malloc函数分配3个整型数据的空间。

然后，再使用realloc函数将已分配的3个整型数据的空间扩大为5个整型数据的空间。

最后，当已分配的5个整型数据的空间不再使用时，使用free函数释放。

5.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：分配3个数据空间

使用malloc函数分配空间。

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p;
p = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++)
p[i] = i + 1;
for (int i = 0; i < 3; i++)
printf("%d ", p[i]);
printf("\n");
return 0;
}

上述代码中，malloc函数的返回值为void*类型，而指针变量p是int*类型，所以需要将malloc的返回值强制转换成int*。

另外，malloc函数在使用前需要包内含stdlib.h头函数。

步骤二：重新分配为5个数据

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p;
p = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++)
p[i] = i + 1;
for (int i = 0; i < 3; i++)
printf("%d ", p[i]);
printf("\n");
p = (int*)realloc(p, 5 * sizeof(int));
for (int i = 0; i < 5; i++)
p[i] = i + 1;
for (int i = 0; i < 5; i++)
printf("%d ", p[i]);
printf("\n");
return 0;
}

上述代码中，realloc函数将已分配为3个数据空间的指针p，重新分配为5个数据空间。realloc函数的第一个实参是原有空间的指针，第二个实参是重新分配的空间的字节个数，返回值仍然是void*类型，所以同样需要将其强制转换成int*类型。

注意：realloc函数在使用之前也需要包含stdlib.h头函数。

5.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
#include <stdlib.h>
int main()
{
int *p;
p = (int*)malloc(3 * sizeof(int));
for (int i = 0; i < 3; i++)
p[i] = i + 1;
for (int i = 0; i < 3; i++)
printf("%d ", p[i]);
printf("\n");
p = (int*)realloc(p, 5 * sizeof(int));
for (int i = 0; i < 5; i++)
p[i] = i + 1;
for (int i = 0; i < 5; i++)
printf("%d ", p[i]);
printf("\n");
return 0;
}

6 各种类型数据的输入和输出

6.1 问题

C语言的格式化输入与输出函数分别是scanf函数和printf函数。

1) 函数 scanf() 是从标准输入流stdio (标准输入设备，一般是键盘)中读内容的通用子程序，可以说明的格式读入多个字符，并保存在对应地址的变量中。scanf函数的语法格式为：

scanf(“<格式说明字符串>”, 变量地址)；

其中，变量地址要求有效，并且与格式说明的次序一致。

2) 函数printf()是格式化输出函数, 一般用于向标准输出设备按规定格式输出信息。printf()函数的语法格式为:

printf("<格式化字符串>", <参量表>)。

格式化字符串由要输出的文字和数据格式说明组成。要输出的文字除了可以使用字母、数字、空格和一些数字符号以外，还可以使用一些转义字符表示特殊的含义。

3) scanf函数与printf函数在使用之前，必须包含stdio.h头函数。

6.2 方案

使用scanf函数输入一些数据，使用printf函数输出一些数据。

下表说明了scanf函数与printf函数中“格式化字符”的使用方式：

6.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：定义变量

定义各种数据类型的变量，代码如下所示：

#include <stdio.h>
int main()
{
int i;
short int si;
long int li;
unsigned int ui;
unsigned short int usi;
unsigned long int uli;
float f;
double d;
long double ld;
char c;
unsigned char uc;
return 0;
}

步骤二：使用scanf输入数据

代码如下所示：

#include <stdio.h>
int main()
{
char c;
int i;
short int si;
long int li;
unsigned int ui;
unsigned short int usi;
unsigned long int uli;
float f;
double d;
scanf("%c", &c);
scanf("%d", &i);
scanf("%hd", &si);
scanf("%ld", &li);
scanf("%u", &ui);
scanf("%hu", &usi);
scanf("%lu", &uli);
scanf("%f", &f);
scanf("%lf", &d);
return 0;
}

步骤三：使用printf输出数据

代码如下所示：

#include <stdio.h>
int main()
{
char c;
int i;
short int si;
long int li;
unsigned int ui;
unsigned short int usi;
unsigned long int uli;
float f;
double d;
scanf("%c", &c);
scanf("%d", &i);
scanf("%hd", &si);
scanf("%ld", &li);
scanf("%u", &ui);
scanf("%hu", &usi);
scanf("%lu", &uli);
scanf("%f", &f);
scanf("%lf", &d);
printf("c=%c\n", c);
printf("i=%d\n", i);
printf("si=%hd\n", si);
printf("li=%ld\n", li);
printf("ui=%u\n", ui);
printf("usi=%hu\n", usi);
printf("uli=%lu\n", uli);
printf("f=%f\n", f);
printf("d=%lf\n", d);
return 0;
}

6.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
int main()
{
char c;
int i;
short int si;
long int li;
unsigned int ui;
unsigned short int usi;
unsigned long int uli;
float f;
double d;
scanf("%c", &c);
scanf("%d", &i);
scanf("%hd", &si);
scanf("%ld", &li);
scanf("%u", &ui);
scanf("%hu", &usi);
scanf("%lu", &uli);
scanf("%f", &f);
scanf("%lf", &d);
printf("c=%c\n", c);
printf("i=%d\n", i);
printf("si=%hd\n", si);
printf("li=%ld\n", li);
printf("ui=%u\n", ui);
printf("usi=%hu\n", usi);
printf("uli=%lu\n", uli);
printf("f=%f\n", f);
printf("d=%lf\n", d);
return 0;
}

7 整数、浮点数、字符串之间的相互转换函数

7.1 问题

1) C语言使用sprintf函数，可以将任意类型(整型、长整型、浮点型等)的数字转换为字符串。而下面列举的各函数在C99标准中已经不再使用。

a) itoa()：将整型值转换为字符串。

b) ltoa()：将长整型值转换为字符串。

c) ultoa()：将无符号长整型值转换为字符串。

d) gcvt()：将浮点型数转换为字符串，取四舍五入。

e) ecvt()：将双精度浮点型值转换为字符串，转换结果中不包含十进制小数点。

2) C语言提供了几个标准库函数，可以将字符串转换为任意类型(整型、长整型、浮点型等)。

a) atof()：将字符串转换为双精度浮点型值。

b) atoi()：将字符串转换为整型值。

c) atol()：将字符串转换为长整型值。

7.2 方案

本案例使用的函数：

1) sprintf函数是字符串格式化命令，主要功能是把格式化的数据写入某个字符串中。该函数的语法格式为：

int sprintf( char *buffer, const char *format, [ argument] … );

其中，第一个形参是转换成的字符串存放的字符数组，第二个形参是格式化字符串，其使用方法与printf函数的格式化字符串相同，第三个形参为要转换的整数或浮点数变量。

2) atof函数是将一个字符串转换成浮点数的函数，该函数的语法格式为：

double atof(const char *);

其中，函数形参为要转换成浮点数的字符串，返回值为转换成的浮点数。

3) atoi函数是将一个字符串转换成整数的函数，该函数的语法格式为：

int atoi(const char *);

其中，函数形参为要转换成整数的字符串，返回值为转换成的整数。

4) atol函数是将一个字符串转换成长整数的函数，该函数的语法格式为：

long atol(const char *);

其中，函数形参为要转换成长整数的字符串，返回值为转换成的长整数。

7.3 步骤

实现此案例需要按照如下步骤进行。

步骤一：整型和浮点型数据转换成字符串

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int i = 10;
char string[100] = {};
sprintf(string, "%d", i);
printf("%s\n", string);
double d = 123.456;
sprintf(string, "%lf", d);
printf("%s\n", string);
return 0;
}

步骤二：将字符串转换成浮点数

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int i = 10;
char string[100] = {};
sprintf(string, "%d", i);
printf("%s\n", string);
double d = 123.456;
sprintf(string, "%lf", d);
printf("%s\n", string);
char str[25] = "3.14";
d = atof(str);
printf("%lf\n", d);
return 0;
}

步骤三：将字符串转换成整数

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int i = 10;
char string[100] = {};
sprintf(string, "%d", i);
printf("%s\n", string);
double d = 123.456;
sprintf(string, "%lf", d);
printf("%s\n", string);
char str[25] = "3.14";
d = atof(str);
printf("%lf\n", d);
int num1 = 0;
char str1[25] = "100";
num1 = atoi(str1);
printf("%d\n", num1);
return 0;
}

步骤四：将字符串转换成长整数

代码如下：

#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int i = 10;
char string[100] = {};
sprintf(string, "%d", i);
printf("%s\n", string);
double d = 123.456;
sprintf(string, "%lf", d);
printf("%s\n", string);
char str[25] = "3.14";
d = atof(str);
printf("%lf\n", d);
int num1 = 0;
char str1[25] = "100";
num1 = atoi(str1);
printf("%d\n", num1);
long num2 = 0;
char str2[25] = "100000";
num2 = atol(str2);
printf("%ld\n", num2);
return 0;
}

7.4 完整代码

本案例的完整代码如下所示：

#include <stdio.h>
#include <stdlib.h>
int main (void)
{
int i = 10;
char string[100] = {};
sprintf(string, "%d", i);
printf("%s\n", string);
double d = 123.456;
sprintf(string, "%lf", d);
printf("%s\n", string);
char str[25] = "3.14";
d = atof(str);
printf("%lf\n", d);
int num1 = 0;
char str1[25] = "100";
num1 = atoi(str1);
printf("%d\n", num1);
long num2 = 0;
char str2[25] = "100000";
num2 = atol(str2);
printf("%ld\n", num2);
return 0;
}