1 输入一个卡尺头,求春夏季上秋冬

*/

*/ 出自: 高兴编制程序
*/ 作者: neverTheSame E-mail:zhaoxufeng9997@126.com QQ:475818502
*/ 时间: 2008-6-1
*/ 注解: 尊重小编劳动,转发请保留本段文字

1.1 问题

在实际上利用中,有的变量唯有二种恐怕取值。如人的性别唯有三种可能取值,星期独有多样或许取值。在
C
语言中对如此取值比较特殊的变量能够定义为枚举类型。所谓枚举是指将变量的值黄金时代一列举出来,变量只限于列举出来的值的范围内取值。

此案例必要运用交互的方式判别:客户从决定台输入三个整数,由程序决断该整数是春夏季新秋冬哪个季节。春夏季三秋冬分别用二个枚举常量表示。

程序交互作用进程如图-1所示:

澳门新葡萄京所有网站 1

图-1

*/

落到实处用函数名作实参的编制程序举例.

在介绍在此之前,先表达一(Wissu卡塔尔下,用申明指向函数的指针的用法.
诸如,二个这么的函数:int TestFuntion(int integer,int character卡塔尔(قطر‎;
怎么声美赞臣个指南针指向那样的函数.
我们能够那样做,int (*pTestFuntionState of Qatar(int integer,int
character卡塔尔国;那样就声称了多个指向函数类型的指针.
其大器晚成函数再次来到值类型为int,有八个参数,叁个是整型参数,三个是字符型参数.
如同下边包车型客车例证:
#include<stdio.h>
#include<conio.h>
int print(int integer,int character);
int main()
{
   int (*p)(int,int);
   p=print;
   clrscr();
   p(12,’A’);
   getch();
}
int print(int integer,int character)
{
   printf(“integer  = %dn”,integer);
   printf(“character= %cn”,character);
}

自身相信大家对声多美滋个针对函数的指针有一定的摸底了.
那就是说把这么的指针作为函数的形参,就足以兑现实参是五个函数名的.
比如:
void test(int (*p)(int,int),float fData);
那是二个有指向函数的指针作形参.
经过地方的例证领会以下的事例就正常了.
#include<stdio.h>
#include<conio.h>
int print(int integer,char character);
void test(int (*p)(int,char),float fData);
int main()
{
   clrscr();
   test(print,12.0);/*print为函数名*/
   getch();
}
int print(int integer,char character)
{
   printf(“integer  = %dn”,integer);
   printf(“character= %cn”,character);
}
void test(int (*p)(int,char),float fData)
{
   p(1,’A’);
   printf(“fData    = %fn”,fData);
}

就算如此未有何样品事含量,但有一点初读书人并不知道有这么的方法.
故而,就在介绍一下了.以便让更多的人精通这么的章程,就高达了自个儿的目标了.

1.2 方案

先是,在前后相继中定义三个枚举,在枚举中定义春夏秋冬多个常量。然后,从调节台输入二个整数,接着,使用switch布局判别输入的平头是哪位季节,并出口相应季节的称谓。借使输入的子弹头不在枚举常量的界定以内,则突显输入错误。

1.3 步骤

落实此案例须要听从如下步骤进行。

步骤生龙活虎:定义枚举

代码如下:

 

  1. #include <stdio.h>
    1. enum
      Season
  2. {
  3. SPRING,
  4. SUMMER,
  5. AUTUMN,
  6. WINTER,
  7. };
    1. int main(int argc, const char * argv[])
  8. {
    1. return 0;
  9. }

手续二:输入三个平头

概念一个变量,用于存款和储蓄从决定台输入的莫西干发型。

代码如下:

  1. #include <stdio.h>
    1. enum
      Season
  2. {
  3. SPRING,
  4. SUMMER,
  5. AUTUMN,
  6. WINTER,
  7. };
    1. int main(int argc, const char * argv[])
  8. {
  9. int season;
  10. printf(“请输入三个卡尺头:”卡塔尔;
  11. scanf(“%d”, &season);
    1. return 0;
  12. }

步骤三:季节判断

使用switch构造,判定输入的莫西干发型归属哪个季节。

  1. #include <stdio.h>
    1. enum
      Season
  2. {
  3. SPRING,
  4. SUMMER,
  5. AUTUMN,
  6. WINTER,
  7. };
    1. int main(int argc, const char * argv[])
  8. {
  9. int season;
  10. printf(“请输入二个整数:”State of Qatar;
  11. scanf(“%d”, &season);
    1. switch (season)
  12. {
  13. case SPRING:
  14. printf(“对应的时令是:springn”);
  15. break;
  16. case SUMMER:
  17. printf(“对应的季节是:summern”);
  18. break;
  19. case AUTUMN:
  20. printf(“对应的季节是:autumnn”);
  21. break;
  22. case WINTER:
  23. printf(“对应的季节是:wintern”);
  24. break;
  25. default:
  26. printf(“errorn”);
  27. }
    1. return 0;
  28. }

1.4 完整代码

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

  1. #include <stdio.h>
    1. enum
      Season
  2. {
  3. SPRING,
  4. SUMMER,
  5. AUTUMN,
  6. WINTER,
  7. };
    1. int main(int argc, const char * argv[])
  8. {
  9. int season;
  10. printf(“请输入四个卡尺头:”State of Qatar;
  11. scanf(“%d”, &season);
    1. switch (season)
  12. {
  13. case SPRING:
  14. printf(“对应的时令是:springn”);
  15. break;
  16. case SUMMER:
  17. printf(“对应的时令是:summern”);
  18. break;
  19. case AUTUMN:
  20. printf(“对应的时令是:autumnn”);
  21. break;
  22. case WINTER:
  23. printf(“对应的季节是:wintern”);
  24. break;
  25. default:
  26. printf(“errorn”);
  27. }
    1. return 0;
  28. }

2 用参数再次来到字符串

2.1 问题

用参数重临叁个值,该参数须要使用指针,使用形参指针能够在三个函数内部改良它所针对的开始和结果,如下代码所示:

  1. void func(int *x)
  2. {
  3. *x = 10;
  4. }
  5. int main()
  6. {
  7. int a = 0;
  8. func(&a);
  9. printf(“%d”, a);
  10. }

上述代码中,在主函数内将变量a的地点作为实参传递给函数func的形参x,而在函数func中,改革指针x指向的情节,即主函数中的变量a,此时的改换是足以带回主函数的,即主函数中的变量a将改成10。

但是,要是我们修正的不是指针所针对的剧情,而是指针本身,那么,那样的改正是不可能带回主函数的。如上面代码所示:

  1. void func(int *x)
  2. {
  3. static int data = 20;
  4. x = &data;
  5. }
  6. int main()
  7. {
  8. int a = 0;
  9. func(&a);
  10. printf(“%d”, a);
  11. }

2.2 方案

在函数调用的进程中,假使我们要改良的不是指针所指向的内容,而是指针自个儿,那么,这样的改过必需透过二级指针来促成。

所谓的二级指针,是指指向指针的指针,如下代码所示:

  1. int a;
  2. int *p = &a;
  3. int **p1 = &p;

上述代码中,指针变量p是顶级指针,它一向指向三个整型变量;而变量p1,则是一个二级指针,因为它指向的是另叁个指南针变量p,也正是说,p1是指向指针p的指针,即指针的指针。

2.3 步骤

兑现此案例须要根据如下步骤实行。

手续风流倜傥:定义重返字符串的函数

该函数必要使用二级指针,即指针的指针。因为在函数中,须要改良的是指针自己,那样就供给将指针本人之处(也即是指针变量的地址)作为参数字传送递过来。

代码如下:

  1. #include <stdio.h>
    1. void getString(char **str)
  2. {
  3. *str = “This is a string.n”;
  4. }
    1. int main()
  5. {
    1. return 0;
  6. }

上述代码中,指针str为几个二级指针。

手续二:在主程序中,获得并打字与印刷再次来到的字符串

代码如下:

  1. #include <stdio.h>
    1. void getString(char **str)
  2. {
  3. *str = “This is a string.n”;
  4. }
    1. int main()
  5. {
  6. char *string = NULL;
  7. getString(&string);
  8. printf(“%s”,string);
    1. return 0;
  9. }

上述代码中,指针变量str获得的是指针变量string的地点,所以str为二级指针,而对*str的退换就是对string的退换。

2.4 完整代码

本案例的总体代码如下所示:

  1. #include <stdio.h>
    1. void getString(char **str)
  2. {
  3. *str = “This is a string.n”;
  4. }
    1. int main()
  5. {
  6. char *string = NULL;
  7. getString(&string);
  8. printf(“%s”,string);
    1. return 0;
  9. }

3 打字与印刷任性档案的次序变量的内存数据

3.1 问题

void*表示“空类型指针”,与void不相同,void*表示“任性档期的顺序的指针”或意味着“该指针与豆蔻梢头地址值相关,然则不精晓在那地方上的指标的花色”。C是静态类型的语言,定义变量就能够分配内部存款和储蓄器,但是,区别类别的变量所占内部存款和储蓄器分化,假诺定义二个随便档期的顺序的变量,如何为其分配内部存储器呢?所以,C中并未有轻便档案的次序的变量。不过,全体指针类型的变量,无论是int*、char*、string*、Student*等等,他们的内部存款和储蓄器空间未有分裂的,所以能够定义“任性档期的顺序的指针”。

3.2 方案

void*花色的指针能够针对任意等级次序的变量,如上边代码:

  1. int a;
  2. void* p = &a;
  3. float f;
  4. p = &f;

上述代码都以不错的,指针变量p不只能够本着整型变量a,同有时候,它还能针对浮点型变量f。

将一个void*品种的指针指向的剧情赋值给一个鲜明项目标变量时,不可能直接赋值,如下边代码:

  1. int a = 10;
  2. void* p = &a;
  3. int b = *p;//error

上述代码的第三行是错误的,因为void*品类的指针指向的从头到尾的经过的等级次序是不显著的,所以是无法打开赋值的。假若非要举行赋值,必得先将void*品类的指针强转成鲜明的数据类型,如下边代码:

  1. int b = *(int*)p;

3.3 步骤

贯彻此案例供给遵循如下步骤实行。

步骤生龙活虎:编写打字与印刷函数

该函数带有一个void*品类的指针,用于收纳任性等级次序的多少,同一时候还隐含三个整型变量,用于表示void*品类的指针指向的从头到尾的经过的数据类型。在函数体中,使用七个switch构造,用整型变量来差距不一致的数据类型,以打字与印刷区别的数据。

代码如下:

  1. #include <stdio.h>
    1. void print(void *data, int type)
  2. {
  3. switch (type)
  4. {
  5. case 0:
  6. printf(“%dn”, *(int*)data);
  7. break;
  8. case 1:
  9. printf(“%fn”, *(float*)data);
  10. break;
  11. case 2:
  12. printf(“%lfn”, *(double*)data);
  13. break;
  14. case 3:
  15. printf(“%cn”, *(char*)data);
  16. break;
  17. }
  18. }
    1. int main()
  19. {
    1. return 0;
  20. }

手续二:主函数打字与印刷不一致门类的多寡

代码如下:

  1. #include <stdio.h>
    1. void print(void *data, int type)
  2. {
  3. switch (type)
  4. {
  5. case 0:
  6. printf(“%dn”, *(int*)data);
  7. break;
  8. case 1:
  9. printf(“%fn”, *(float*)data);
  10. break;
  11. case 2:
  12. printf(“%lfn”, *(double*)data);
  13. break;
  14. case 3:
  15. printf(“%cn”, *(char*)data);
  16. break;
  17. }
  18. }
    1. int main()
  19. {
  20. int a = 10;
  21. print(&a, 0);
    1. float f = 3.14f;
  22. print(&f, 1);
    1. double d = 1.2345;
  23. print(&d, 2);
    1. char c = ‘a’;
  24. print(&c, 3);
    1. return 0;
  25. }

3.4 完整代码

本案例的全体代码如下所示:

  1. #include <stdio.h>
    1. void print(void *data, int type)
  2. {
  3. switch (type)
  4. {
  5. case 0:
  6. printf(“%dn”, *(int*)data);
  7. break;
  8. case 1:
  9. printf(“%fn”, *(float*)data);
  10. break;
  11. case 2:
  12. printf(“%lfn”, *(double*)data);
  13. break;
  14. case 3:
  15. printf(“%cn”, *(char*)data);
  16. break;
  17. }
  18. }
    1. int main()
  19. {
  20. int a = 10;
  21. print(&a, 0);
    1. float f = 3.14f;
  22. print(&f, 1);
    1. double d = 1.2345;
  23. print(&d, 2);
    1. char c = ‘a’;
  24. print(&c, 3);
    1. return 0;
  25. }

4 排序函数使用函数指针

4.1 问题

函数指针是生龙活虎种指针,一个指向函数输入地址的指针。八个函数要求占用大器晚成段内部存储器空间,这段空间的开始地址是函数的入口地址。能够定义一个指南针变量,指向函数的进口地址,然后通过那些指针变量调用函数。

4.2 方案

大器晚成种排序函数,常常只可以有意气风发种排序法规。比如:要么从大到小排序,要么从小到大排序,或许新鲜的平整,举例根据对3求余数的排序。通过行使函数指针,可以使排序函数将排序法则独立。这样在对点名的数码开展排序的时候,同不平日间钦赐排序法则,使得排序函数第2回被调用时能够从大到小排序,第一回被调用时又足以从小到大排序。

4.3 步骤

落实此案例须求据守如下步骤实行。

步骤少年老成:在主程序中,定义叁个数组

代码如下:

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

手续二:定义数组打字与印刷函数

代码如下:

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

手续三:定义带排序准则的排序函数

排序方法应用冒泡方法。

代码如下:

  1. #include <stdio.h>
    1. void print(int* a, int n)
  2. {
  3. for (int i=0; i<n; i++) {
  4. printf(“%d “, a[i]);
  5. }
  6. printf(“n”);
  7. }
  8. int rule1(int x, int y)
  9. {
  10. return x – y;
  11. }
  12. void sort(int* a, int n, int (*f)(int, int))
  13. {
  14. for (int i=0; i<n-1; i++) {
  15. for (int j=0; j<n-i-1; j++) {
  16. if (f(a[j], a[j+1])>0) {
  17. int t = a[j];
  18. a[j] = a[j+1];
  19. a[j+1] = t;
  20. }
  21. }
  22. }
  23. }
  24. int main()
  25. {
  26. int a[10] = {1,2,3,4,5,6,7,8,9,0};
  27. print(a, 10);
    1. sort(a, 10, rule1);
  28. print(a, 10);
    1. return 0;
  29. }

上述代码中,以下代码:

  1. int rule1(int x, int y)
  2. {
  3. return x – y;
  4. }

是排序准绳,该函数再次回到形参x与y的差,假使重返值大于0,代表x大于y;假使重回值等于0,代表x等于y;假若再次来到值小于0,代表x小于y。

上述代码中,以下代码:

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

是排序函数的函数头,该函数是三个无重临值的函数,函数名叫sort,函数带有八个形参,第三个形参是二个整型指针变量,它用于收纳供给排序的数额;第一个形参是三个整型变量,它用于收纳须求排序的多寡的个数;第八个形参是一个函数的指针变量,int表示该函数指针变量指向的函数的重返值为整型,f为函数指针变量的变量名,(int,int卡塔尔国代表该函数指针变量指向的函数有三个形参。

在主函数中,使用以下代码调用sort函数:

  1. sort(a, 10, rule1);

里面,第二个实参a为数组a的数组名,第二个实参10为数组a的数老板度,第八个实参rule1为函数名,该函数为排序准则。

上述代码中,以下代码:

  1. if (f(a[j], a[j+1])>0) {
  2. int t = a[j];
  3. a[j] = a[j+1];
  4. a[j+1] = t;
  5. }

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

步骤四:定义此外排序法规函数

代码如下:

  1. #include <stdio.h>
    1. void print(int* a, int n)
  2. {
  3. for (int i=0; i<n; i++) {
  4. printf(“%d “, a[i]);
  5. }
  6. printf(“n”);
  7. }
  8. int rule1(int x, int y)
  9. {
  10. return x – y;
  11. }
  12. int rule2(int x, int y)
  13. {
  14. return y – x;
  15. }
  16. int rule3(int x, int y)
  17. {
  18. return x%3 – y%3;
  19. }
  20. void sort(int* a, int n, int (*f)(int, int))
  21. {
  22. for (int i=0; i<n-1; i++) {
  23. for (int j=0; j<n-i-1; j++) {
  24. if (f(a[j], a[j+1])>0) {
  25. int t = a[j];
  26. a[j] = a[j+1];
  27. a[j+1] = t;
  28. }
  29. }
  30. }
  31. }
  32. int main()
  33. {
  34. int a[10] = {1,2,3,4,5,6,7,8,9,0};
  35. print(a, 10);
    1. sort(a, 10, rule1);
  36. print(a, 10);
    1. sort(a, 10, rule2);
  37. print(a, 10);
    1. sort(a, 10, rule3);
  38. print(a, 10);
    1. return 0;
  39. }

4.4 完整代码

  1. #include <stdio.h>
    1. void print(int* a, int n)
  2. {
  3. for (int i=0; i<n; i++) {
  4. printf(“%d “, a[i]);
  5. }
  6. printf(“n”);
  7. }
  8. int rule1(int x, int y)
  9. {
  10. return x – y;
  11. }
  12. int rule2(int x, int y)
  13. {
  14. return y – x;
  15. }
  16. int rule3(int x, int y)
  17. {
  18. return x%3 – y%3;
  19. }
  20. void sort(int* a, int n, int (*f)(int, int))
  21. {
  22. for (int i=0; i<n-1; i++) {
  23. for (int j=0; j<n-i-1; j++) {
  24. if (f(a[j], a[j+1])>0) {
  25. int t = a[j];
  26. a[j] = a[j+1];
  27. a[j+1] = t;
  28. }
  29. }
  30. }
  31. }
  32. int main()
  33. {
  34. int a[10] = {1,2,3,4,5,6,7,8,9,0};
  35. print(a, 10);
    1. sort(a, 10, rule1);
  36. print(a, 10);
    1. sort(a, 10, rule2);
  37. print(a, 10);
    1. sort(a, 10, rule3);
  38. print(a, 10);
    1. return 0;
  39. }

5 重新分配申请的半空中

5.1 问题

在堆内部存款和储蓄器中,能够使用malloc函数分配一块存款和储蓄空间。malloc(卡塔尔函数其实就在堆内部存储器中找一片内定大小的半空中,然后将以此空间的首地址再次回到给二个指针变量,这里的指针变量能够是三个独立的指针,也足以是二个数组的首地址,这要看malloc(State of Qatar函数中参数size的具体内容。大家这里malloc分配的内部存款和储蓄器空间在逻辑上海市总是的,而在情理上能够三番五次也能够不总是。对于我们程序猿来讲,大家关心的是逻辑上的总是,因为操作系统会帮我们布置内部存款和储蓄器分配,所以我们运用起来就足以视作是连接的。

还足以动用realloc函数对用malloc函数分配好的长空重新分配,经常是扩充。对于realloc函数,假若有丰裕空间用于扩充mem_address指向的内存块,则分分配的定额外内部存款和储蓄器,并赶回分配内部存款和储蓄器的首地址。这里说的是“扩充”,我们知晓,realloc是从堆上分配内存的,当扩张学一年级块内部存款和储蓄器空间时,
realloc(卡塔尔(قطر‎试图直接从堆上现成的多少背后的这些字节中收获附加的字节,要是能够满足,自然休保健息。也正是说,如若原先的内部存储器大小前边还也是有丰富的闲暇空间用来分配,加上原本的半空中山高校小就等于新的空中尺寸。获得的是一块三番五次的内部存储器。要是原来的内部存款和储蓄器大小前边没有丰盛的空余空间用来分配,那么从堆中其余找一块新大小的内存。并把原本大小内部存储器空间中的内容复制到新空间中。重回新的内部存款和储蓄器的指针。这样数据被移位了新空间,先前的长空被释放。

当使用malloc分配的长空不再动用的时候,能够选用free函数将这块空间还给堆内部存款和储蓄器,以使那块内存能够被再度使用。

5.2 方案

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

然后,再采纳realloc函数将已分配的3个整型数据的半空中增添为5个整型数据的空中。

最终,当已分配的5个整型数据的半空中不再接收时,使用free函数释放。

5.3 步骤

落到实处此案例要求根据如下步骤举办。

手续生龙活虎:分配3个数据空间

采纳malloc函数分配空间。

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main()
  3. {
  4. int *p;
  5. p = (int*)malloc(3 * sizeof(int));
  6. for (int i = 0; i < 3; i++)
  7. p[i] = i + 1;
  8. for (int i = 0; i < 3; i++)
  9. printf(“%d “, p[i]);
  10. printf(“n”);
    1. return 0;
  11. }

上述代码中,malloc函数的再次回到值为void*连串,而指针变量p是int*项目,所以供给将malloc的再次回到值强逼转变到int*。

别的,malloc函数在运用前须要包内含stdlib.h头函数。

手续二:重新分配为5个数据

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main()
  3. {
  4. int *p;
  5. p = (int*)malloc(3 * sizeof(int));
  6. for (int i = 0; i < 3; i++)
  7. p[i] = i + 1;
  8. for (int i = 0; i < 3; i++)
  9. printf(“%d “, p[i]);
  10. printf(“n”);
    1. p = (int*)realloc(p, 5 * sizeof(int));
  11. for (int i = 0; i < 5; i++)
  12. p[i] = i + 1;
  13. for (int i = 0; i < 5; i++)
  14. printf(“%d “, p[i]);
  15. printf(“n”);
    1. return 0;
  16. }

上述代码中,realloc函数将已分配为3个数据空间的指针p,重新分配为5个数据空间。realloc函数的首先个实参是原本空间的指针,第三个实参是重新分配的半空中的字节个数,再次来到值仍然为void*花色,所以意气风发律须求将其强逼转变到int*类型。

在意:realloc函数在应用早前也必要富含stdlib.h头函数。

5.4 完整代码

本案例的完全代码如下所示:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main()
  3. {
  4. int *p;
  5. p = (int*)malloc(3 * sizeof(int));
  6. for (int i = 0; i < 3; i++)
  7. p[i] = i + 1;
  8. for (int i = 0; i < 3; i++)
  9. printf(“%d “, p[i]);
  10. printf(“n”);
    1. p = (int*)realloc(p, 5 * sizeof(int));
  11. for (int i = 0; i < 5; i++)
  12. p[i] = i + 1;
  13. for (int i = 0; i < 5; i++)
  14. printf(“%d “, p[i]);
  15. printf(“n”);
    1. return 0;
  16. }

6 各连串型数据的输入和出口

6.1 问题

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

1卡塔尔 函数 scanf(卡塔尔国是从正式输入流stdio
(标准输入设备,日常是键盘卡塔尔(قطر‎中读内容的通用子程序,可以注明的格式读入多个字符,并保存在对应地址的变量中。scanf函数的语法格式为:

  1. scanf(“<格式表达字符串>”, 变量地址卡塔尔国;

其间,变量地址要求有效,何况与格式表明的程序豆蔻梢头致。

2)函数printf(卡塔尔(قطر‎是格式化输出函数,
平时用来向专门的学业输出设备按规定格式输出音信。printf(卡塔尔(قطر‎函数的语法格式为:

  1. printf(“<格式化字符串>”,
    <参量表>卡塔尔国。

格式化字符串由要出口的文字和数码格式表达结合。要出口的文字除了能够采用假名、数字、空格和一些数字符号以外,还足以应用部分转义字符表示特别的意思。

3)scanf函数与printf函数在动用以前,必得满含stdio.h头函数。

6.2 方案

应用scanf函数输入一些数量,使用printf函数输出一些数目。

下表表明了scanf函数与printf函数中“格式化字符”的接纳格局:

澳门新葡萄京所有网站 2

6.3 步骤

兑现此案例供给遵守如下步骤举行。

步骤风流罗曼蒂克:定义变量

概念各样数据类型的变量,代码如下所示:

  1. #include <stdio.h>
    1. int main()
  2. {
  3. int i;
  4. short int si;
  5. long int li;
  6. unsigned int ui;
  7. unsigned short int usi;
  8. unsigned long int uli;
  9. float f;
  10. double d;
  11. long double ld;
  12. char c;
  13. unsigned char uc;
    1. return 0;
  14. }

步骤二:使用scanf输入数据

代码如下所示:

  1. #include <stdio.h>
    1. int main()
  2. {
  3. char c;
  4. int i;
  5. short int si;
  6. long int li;
  7. unsigned int ui;
  8. unsigned short int usi;
  9. unsigned long int uli;
  10. float f;
  11. double d;
    1. scanf(“%c”, &c);
  12. scanf(“%d”, &i);
  13. scanf(“%hd”, &si);
  14. scanf(“%ld”, &li);
  15. scanf(“%u”, &ui);
  16. scanf(“%hu”, &usi);
  17. scanf(“%lu”, &uli);
  18. scanf(“%f”, &f);
  19. scanf(“%lf”, &d);
    1. return 0;
  20. }

手续三:使用printf输出数据

代码如下所示:

  1. #include <stdio.h>
    1. int main()
  2. {
  3. char c;
  4. int i;
  5. short int si;
  6. long int li;
  7. unsigned int ui;
  8. unsigned short int usi;
  9. unsigned long int uli;
  10. float f;
  11. double d;
    1. scanf(“%c”, &c);
  12. scanf(“%d”, &i);
  13. scanf(“%hd”, &si);
  14. scanf(“%ld”, &li);
  15. scanf(“%u”, &ui);
  16. scanf(“%hu”, &usi);
  17. scanf(“%lu”, &uli);
  18. scanf(“%f”, &f);
  19. scanf(“%lf”, &d);
    1. printf(“c=%cn”, c);
  20. printf(“i=%dn”, i);
  21. printf(“si=%hdn”, si);
  22. printf(“li=%ldn”, li);
  23. printf(“ui=%un”, ui);
  24. printf(“usi=%hun”, usi);
  25. printf(“uli=%lun”, uli);
  26. printf(“f=%fn”, f);
  27. printf(“d=%lfn”, d);
    1. return 0;
  28. }

6.4 完整代码

本案例的总体代码如下所示:

  1. #include <stdio.h>
    1. int main()
  2. {
  3. char c;
  4. int i;
  5. short int si;
  6. long int li;
  7. unsigned int ui;
  8. unsigned short int usi;
  9. unsigned long int uli;
  10. float f;
  11. double d;
    1. scanf(“%c”, &c);
  12. scanf(“%d”, &i);
  13. scanf(“%hd”, &si);
  14. scanf(“%ld”, &li);
  15. scanf(“%u”, &ui);
  16. scanf(“%hu”, &usi);
  17. scanf(“%lu”, &uli);
  18. scanf(“%f”, &f);
  19. scanf(“%lf”, &d);
    1. printf(“c=%cn”, c);
  20. printf(“i=%dn”, i);
  21. printf(“si=%hdn”, si);
  22. printf(“li=%ldn”, li);
  23. printf(“ui=%un”, ui);
  24. printf(“usi=%hun”, usi);
  25. printf(“uli=%lun”, uli);
  26. printf(“f=%fn”, f);
  27. printf(“d=%lfn”, d);
    1. return 0;
  28. }

7 卡尺头、浮点数、字符串之间的互相转变函数

7.1 问题

1卡塔尔国C语言使用sprintf函数,能够将随便档案的次序(整型、长整型、浮点型等卡塔尔国的数字转换为字符串。而下边罗列的各函数在C99规范中早已不再动用。

aState of Qataritoa(卡塔尔国:将整型值调换为字符串。

b卡塔尔ltoa(State of Qatar:将长整型值调换为字符串。

c)ultoa(State of Qatar:将无符号长整型值转变为字符串。

d)gcvt(卡塔尔国:将浮点型数调换为字符串,取四舍五入。

eState of Qatarecvt(卡塔尔:将双精度浮点型值调换为字符串,调换结果中不包蕴十进制小数点。

2State of QatarC语言提供了多少个标准库函数,能够将字符串转变为专擅等级次序(整型、长整型、浮点型等卡塔尔(قطر‎。

a)atof(卡塔尔:将字符串调换为双精度浮点型值。

b卡塔尔国atoi(卡塔尔(قطر‎:将字符串调换为整型值。

c卡塔尔国atol(卡塔尔:将字符串转变为长整型值。

7.2 方案

该案例使用的函数:

1卡塔尔(قطر‎sprintf函数是字符串格式化命令,重要功能是把格式化的数目写入有个别字符串中。该函数的语法格式为:

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

在那之中,第一个形参是转变来的字符串寄存的字符数组,第2个形参是格式化字符串,其选用方式与printf函数的格式化字符串类似,第多个形参为要改造的莫西干发型或浮点数变量。

2卡塔尔(قطر‎atof函数是将三个字符串转换来浮点数的函数,该函数的语法格式为:

  1. double     atof(const char *);

里面,函数形参为要转换来浮点数的字符串,重返值为调换来的浮点数。

3State of Qataratoi函数是将一个字符串调换到整数的函数,该函数的语法格式为:

  1. int     atoi(const char *);

内部,函数形参为要调换来整数的字符串,重回值为转变到的莫西干发型。

4State of Qataratol函数是将三个字符串转变来长整数的函数,该函数的语法格式为:

  1. long     atol(const char *);

个中,函数形参为要转变到长整数的字符串,重返值为转换来的长整数。

7.3 步骤

落到实处此案例要求遵守如下步骤实行。

步骤风华正茂:整型和浮点型数据转换到字符串

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main (void)
  3. {
  4. int i = 10;
  5. char string[100] = {};
  6. sprintf(string, “%d”, i);
  7. printf(“%sn”, string);
    1. double d = 123.456;
  8. sprintf(string, “%lf”, d);
  9. printf(“%sn”, string);
    1. return 0;
  10. }

步骤二:将字符串转变到浮点数

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main (void)
  3. {
  4. int i = 10;
  5. char string[100] = {};
  6. sprintf(string, “%d”, i);
  7. printf(“%sn”, string);
    1. double d = 123.456;
  8. sprintf(string, “%lf”, d);
  9. printf(“%sn”, string);
    1. char str[25] = “3.14”;
  10. d = atof(str);
  11. printf(“%lfn”, d);
    1. return 0;
  12. }

手续三:将字符串转变到整数

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main (void)
  3. {
  4. int i = 10;
  5. char string[100] = {};
  6. sprintf(string, “%d”, i);
  7. printf(“%sn”, string);
    1. double d = 123.456;
  8. sprintf(string, “%lf”, d);
  9. printf(“%sn”, string);
    1. char str[25] = “3.14”;
  10. d = atof(str);
  11. printf(“%lfn”, d);
    1. int num1 = 0;
  12. char str1[25] = “100”;
  13. num1 = atoi(str1);
  14. printf(“%dn”, num1);
    1. return 0;
  15. }

手续四:将字符串调换来长整数

代码如下:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main (void)
  3. {
  4. int i = 10;
  5. char string[100] = {};
  6. sprintf(string, “%d”, i);
  7. printf(“%sn”, string);
    1. double d = 123.456;
  8. sprintf(string, “%lf”, d);
  9. printf(“%sn”, string);
    1. char str[25] = “3.14”;
  10. d = atof(str);
  11. printf(“%lfn”, d);
    1. int num1 = 0;
  12. char str1[25] = “100”;
  13. num1 = atoi(str1);
  14. printf(“%dn”, num1);
    1. long num2 = 0;
  15. char str2[25] = “100000”;
  16. num2 = atol(str2);
  17. printf(“%ldn”, num2);
    1. return 0;
  18. }

7.4 完整代码

本案例的风度翩翩体化代码如下所示:

  1. #include <stdio.h>
  2. #include <stdlib.h>
    1. int main (void)
  3. {
  4. int i = 10;
  5. char string[100] = {};
  6. sprintf(string, “%d”, i);
  7. printf(“%sn”, string);
    1. double d = 123.456;
  8. sprintf(string, “%lf”, d);
  9. printf(“%sn”, string);
    1. char str[25] = “3.14”;
  10. d = atof(str);
  11. printf(“%lfn”, d);
    1. int num1 = 0;
  12. char str1[25] = “100”;
  13. num1 = atoi(str1);
  14. printf(“%dn”, num1);
    1. long num2 = 0;
  15. char str2[25] = “100000”;
  16. num2 = atol(str2);
  17. printf(“%ldn”, num2);
    1. return 0;
  18. }