篮球外围下注_篮球投注导航_[所有网址]

篮球外围下注_篮球投注导航_[所有网址]是该公司为打造信誉第一,2014最新体验金,篮球外围下注_篮球投注导航_[所有网址]这里的所有老虎机游戏及真人百家乐游戏都具有欧洲风格,致力成为最具传播力和互动性的娱乐城网站。

美洲杯竞猜网址联合与枚举 、 高级指针 、 C语言

2019-07-31 19:48 来源:未知

问题:

矩形的个数

  在一个3*2的矩形中,能够找到6个1*1的矩形,4个2*1的矩形3个1*2的矩形,2个2*2的矩形,2个3*1的矩形和1个3*2的矩形,总共二十一个矩形。给出A,B,计算能够从中找到多少个矩形


输入:
  本题有多组输入数据(<一千0),你不能忽视理到EOF停止

  输入2个整数A,B(1<=A,B<=1000)


输出:

  输出找到的矩形数。


样例:

输入:

1 2
3 2


输出:
3
18

一同与枚举 、 高等指针 、 C语言标准库(一)

 原代码-1:

#include <stdio.h>  int rectangle(int x,int y)  {      int i,j,sum,temp;        for(i=1,sum=0,temp=0;i<=x;i  )      {          for(j=1;j<=y;j  )          {              temp = (x-i 1)*(y-j 1);              sum  = temp;          }      }        return sum;  }    int main()  {      long int A[1000],B[1000],i;      int rectangle(int x,int y);      //printf("input A&B and end with 0n");        for(i=0;i<1000;i  )      {          scanf("%d",&A[i]);                    if (A[i]==0)          {              break;          }            scanf("%d",&B[i]);      }        for(i=0;A[i]!=0;i  )      {          printf("%dn",rectangle(A[i],B[i]));      }        return 0;  }

1 输入贰个平头,求春夏季首秋冬

 评析:

   写完将来那位女孩儿直爽地承认:

露珠不知晓怎么着以EOF结尾..只可以用0了...哪位引导下..

   小编报告她,

没供给用数组
while( scanf("%d%d", &A,&B)!=EOF )
{
     //总括输出矩形个数
}

  于是他飞速给出了新代码:

1.1 问题

在骨子里运用中,有的变量独有两种也许取值。如人的性别独有二种可能取值,星期独有八种或者取值。在 C 语言中对这么取值相比较优异的变量能够定义为枚举类型。所谓枚举是指将变量的值一一列举出来,变量只限于列举出来的值的限量内取值。

此案例需求运用交互的不二等秘书籍剖断:用户从调整台输入贰个整数,由程序推断该整数是春夏季高商冬哪个季节。春夏季首秋冬分别用四个枚举常量表示。

先后交互进程如图-1所示:

美洲杯竞猜网址 1

图-1

 原代码-2:

#include <stdio.h>  int rectangle(int x,int y)  {      int i,j,sum,temp;        for(i=1,sum=0,temp=0;i<=x;i  )      {          for(j=1;j<=y;j  )          {              temp = (x-i 1)*(y-j 1);              sum  = temp;          }      }        return sum;  }    int main()  {      long int A,B;      int rectangle(int x,int y);      printf("input A&B and end with EOFn");        while(scanf("%d%d",&A,&B)!= EOF)      {          printf("%dn",rectangle(A,B));      }        return 0;  }

1.2 方案

先是,在先后中定义多少个枚举,在枚举中定义春夏季早秋冬三个常量。然后,从调整台输入叁个平头,接着,使用switch结构判定输入的整数是哪位季节,并出口相应季节的称谓。要是输入的整数不在枚举常量的限量以内,则显得输入错误。

评析:

  此次许多了。可是他又有了新的吸引:

自身修改成那样之后,比如小编先输入 2 3 跳出来 18,输入eof 就径直跳 18 结束不了了...
由此可见就是一向跳最终叁次出来的结果 ..

  看来他不清楚EOF是怎么回事,还以为是在键盘上键入eof多少个字符呢。

  作者告诉她:

EOF不是四个字符
而是二个符号常量
假诺你用的是WIN系统
在行首输入Control-Z试试

  实际上EOF是在stdio.h中定义的三个宏,常常是那般的 

#define    EOF    (-1)

  不过C语言并没说EOF一定为-1。

  在键盘上是尚未这么些EOF的,但在输入流中遭受非常的字符,scanf()函数的重返值能够是EOF。那么,那句话毕竟是怎么意思吧?

  平时scanf()的重临值是一个非负整数。举个例子

int i;
scanf("%d", &i ) ;  

  借使您在键盘上键入的是123(1、2、3与%d相相称),scanf("%d", &i )的值就为1,因为为1个变量赋了值;借使您在键盘上键的是abc(a与%d不相配),scanf("%d", &i )的值就为0,因为scanf不可能把"a"视为十进制整数(%d),也无力回天对它进行转移,更敬谢不敏为变量 i 赋值,也正是说scanf这种情景下未有为其他变量赋值,所以回来值为0。假若scanf()在输入流中遇到的是有些特殊的字符(具体是哪些字符与碰到有关),则再次来到值为EOF。

  别的小编告诉她:

把函数类型评释
int rectangle(int x,int y);
写在main()函数之内很傻

(应该把函数类型表明)写在函数外面

其它极度temp多余

temp赋值为零就更加多余

(因为能够一贯)

sum = (x-i 1)*(y-j 1);    

  就那样,他重新开始展览了修改:

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("请输入三个板寸:");
  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. }

原代码-3

#include <stdio.h>  int rectangle(int x,int y)  {      int i,j,sum,temp;        for(i=1,sum=0;i<=x;i  )      {          for(j=1;j<=y;j  )          {              sum  = (x-i 1)*(y-j 1);;          }      }        return sum;  }    int rectangle(int x,int y);  int main()  {      long int A,B;      printf("input A&B and end with EOFn");        while(scanf("%d%d",&A,&B)!= EOF)      {          printf("%dn",rectangle(A,B));      }        return 0;  }

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("请输入三个大背头:");
  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. }

 评析:

   今后病痛少多了,但是照旧有点。

  首先, rectangle()函数定义的职位欠妥,写在main()定义的末端为好。

  其次,数据类型有题目,这一个难点比较严重。 

    long int A,B;

  这里相对没有供给把A、B定义为long类型,int类型足矣。由于不本地把A、B定义成了long类型,所以代码中的

scanf("%d%d",&A,&B)

rectangle(A,B)

这一回调用都是错的。纵然从未发出错误的结果(揣测在十二分系统中long和int类型大小同样),但其实是瞎猫碰着死耗子,侥还好已。

  别的的两处小缺欠就是rectangle()函数定义中的temp变量忘记删除了,循环体内去除语句时不根本,有一“;”也忘记删除了。

  再有就是 

sum  = (x-i 1)*(y-j 1);

   这么些算法本人没看懂,不知情是否科学。

2 用参数重临字符串

重构:

  其实原本代码已经济体改得大致了,只剩余零星小错和劣点。作者在此地只说一下本身的算法:

  作者的算法是,穷举出八个点(P1,P2)的有所结成情状,只要P1能够是某些矩形的左上角,P2能够是某些矩形的右下角(P1_X<P2_X,P1_Y<P2_Y),则构成了二个矩形。

 1 /*   2 矩形的个数    3 在一个3*2的矩形中,可以找到6个1*1的矩形,4个2*1的矩形3个1*2的矩形,   4 2个2*2的矩形,2个3*1的矩形和1个3*2的矩形,总共18个矩形。    5 给出A,B,计算可以从中找到多少个矩形。    6    7 输入:    8 本题有多组输入数据(<10000),你必须处理到EOF为止    9 输入2个整数A,B(1<=A,B<=1000)   10   11 输出:   12 输出找到的矩形数。   13   14 样例:  15   16 输入:   17 1 2   18 3 2   19   20 输出:   21 3   22 18  23   24 作者:薛非  25 出处:http://www.cnblogs.com/pmer/   “C语言初学者代码中的常见错误与瑕疵”系列博文   26   27 */  28   29 #include <stdio.h>  30   31 int count( int , int );   32   33 int main( void )  34 {  35   int A , B ;  36     37   while ( printf( "输入2个整数A,B(1<=A,B<=1000)" ),  38           scanf( "%d%d" , &A , &B )!= EOF      39         )  40   {  41      printf( "%dn" , count( A , B ) );  42   }  43     44   return 0;  45 }  46   47 int count( int A , int B )  48 {  49    int x1 , y1 ;//第一个点的坐标   50    int x2 , y2 ;//第二个点的坐标  51    int num = 0 ;  52      53    for ( x1 = 0 ; x1 <= B ; x1    )  54       for ( y1 = 0 ; y1 <= A ; y1    )//穷举第一个点的各种可能   55          for ( x2 = 0 ; x2 <= B ; x2    )  56             for ( y2 = 0 ; y2 <= A ; y2    )//穷举第二个点的各种可能   57             {  58                if ( x1 < x2 && y1 < y2 )  59                   num    ;  60             }  61   62    return num ;  63 }

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. }

 BUG

  这些代码的不足之处在于尚未认真思虑答案是还是不是在int类型的象征范围以内。在 飞鸟_Asuka 网上朋友提议是还是不是“时间复杂度相当大”的难题后,笔者一并考虑了那四个难点。结论是:1.那一个标题用数学的措施很轻巧消除,不过使用这种方案对上学编制程序是不利的,因为求解太轻巧了;2.答案真的有相当大可能率超过int类型的表示范围(借使int最大能表示到231-1的话)。那应该算是重构代码中留存的三个BUG。作者将要后来的博文中提交考订及数学解答。

  在此感激飞鸟_Asuka 网上亲密的朋友的提示。


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 问题

函数指针是一种指针,三个指向函数入口地址的指针。八个函数须求占用一段内部存款和储蓄器空间,这段空间的序幕地址是函数的进口地址。能够定义一个指南针变量,指向函数的输入地址,然后通过那一个指针变量调用函数。

TAG标签: 篮球外围下注
版权声明:本文由篮球外围下注发布于系统,转载请注明出处:美洲杯竞猜网址联合与枚举 、 高级指针 、 C语言