C

最新推荐文章于 2023-03-20 13:01:04 发布
最新推荐文章于 2023-03-20 13:01:04 发布
阅读量2k 收藏 22
点赞数 1
分类专栏： 笔记
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_50035165/article/details/113177771
版权

C学习

error

  • |error: stray '\243' in program|
    译：错误：程序中丢失 ‘\243’ ，或，非法字符 ‘\243’ 在程序中。
    意：有不标准的ASCII字符出现，一般为中英文问题，比如中文分号（；;），中文逗号（，,），中文引号（“ "）。汉字，汉语标点，全角英文。😉（意外发现英文分号加后括号会有小表情）
    |error: stray '\254' in program|
    数组初始化时各个数组元素之间的,误用了几个，。
  • |error: expected declaration or statement at end of input|
    译：错误:在输入的末尾有预期的声明或语句（在输入的结尾处缺少应有的声明或语句）。
    意：获得该error是因为缺少了一个 } ，1. 某个地方（不一定是报错的地方）缺少括号。 2. 某个函数或变量在使用之前没有声明（？）。
  • |error: unterminated comment|
    译：无端接的评论（注释没有结束）
    意：一般而言，是注释标示/* */没有写全
  • |error: 'x' undeclared (first use in this function)|
    译：'x’未被声明（第一次在该函数中使用）
    意：使用了未声明的标识符x，表示无法识别（忘记定义/声明某变量或常量或其他标识符却在后续使用）；在使用scanf函数时，地址参数表中没有使用&而直接以原需赋值的变量作为参数，也会报该错（如下）。
int x;
scanf("%d", x);

一个语句同时定义多个变量时若误用;也会报该错。
int i; *pa;
//|error: 'pa' undeclared (first use in this function)|

  • |error: break statement not within loop or switch|
    译：break语句没有位于循环或者switch语句中
    意：该error获取是因为for循环语句在for代码行多输入了一个‘;’，导致for循环的循环体变为空，原应有的循环体变成了一个单纯的被大括号括起来的复合语句，其中的break语句也就相应报错。（for循环后多加分号）
  • |error: called object 'rand' is not a function or function pointer|
    译：调用的对象“rand”不是函数或函数指针
    意：
    1.同时定义了一个函数名和一个变量都叫rand。
    2.在表达式中错误使用引用函数的格式，例如i = 3 * rand();错误写作i = 3rand();，i = a[2][3]写作i = a(2, 3)导致编辑器认为你在引用未知函数。
#include <stdio.h>
#include <stdlib.h>

int main()
{
    int a;             //int rand;
	a = rand();        // = rand();
	printf("%d", a);   //printf("rand = %d", rand);
    return 0;
}
  • |fatal error: alloc.h: No such file or directory|
    译：|致命错误:alloc.h:没有这样的文件或目录|
    意：已经致命了 😉 使用动态分配内存的malloc函数时按照教材需要头文件alloc.h，实际不需要，有stdlib.h头文件即可。相关见malloc动态内存分配。
  • |error: void value not ignored as it ought to be|
    译：错误:无效值没有被忽略
    意：获得该error的原因是我将一个定义数据类型为void的函数作为了赋值表达式的右值。
void f();
i = f();
  • |note: previous declaration of 'swap' was here|
    |error: conflicting types for 'swap'|
    译：注释：先前声明的（）在这里；错误：（）的类型冲突
    意：函数声明与函数定义时的返回值类型不一致;或者函数声明和函数定义中的参数不一致。
#include <stdio.h>
float pn(float x, int n);

void main()
{
   //float pn();  //|error: conflicting types for 'pn'| ???
   float x, lyd;
   int n;

   scanf("%d%f", &n, &x);
   lyd = pn(x, n);
   printf("pn = %f", lyd);
}

float pn(float x, int n)
{
   float temp;
   if (n == 0)
   {
       temp = 1;
   }
   else if (n = = 1)
   {
       temp = x;
   }
   else
   {
       temp = (2 * n - 1) * x * pn(x, n-1) - (n - 1) * pn(x, n -2) / n;
   }
   return (temp);
}
  • |error: parameter name omitted|
    译：错误：参数名省略
    意：函数声明时的形参表可以省去参数名而只写参数类型；但在函数定义时的参数表必须有参数类型和参数名，无参数名将会报错。
  • |error: expected identifier or '(' before 'int'|
    译：错误：在‘int’之前缺少预期的标识符或者‘(’。
    意：在同一个语句中只能定义一种数据类型的变量
    //for (int a = 1, int b = n; b >= 1; b--)
    //for (int a = 1, b = n; b >= 1; b--)
  • |error: expected identifier or '(' before '{' token|
    译：错误：在‘{’之前缺少预期的标识符或者‘(’。
    意：函数声明时在末尾需加分号；在函数定义时末尾不可加分号，否则会报错。（函数定义后多加分号）
  • |error: expected ')' before ';' token|
    译：错误：在‘;’之前缺少预期的‘)’。
    意：printf时多个参数需要输出，参数之间误用;分隔。
  • |error: expected ']' before ';' token|
    译：错误：在‘;’之前缺少预期的‘]’。
    意：宏定义 #define时末尾不需要分号（宏定义后多加分号）
  • |error: expected '}' before numeric constant|
    译：错误：在数值常量之前缺少预期的‘}’。
    意：数组初始化时误用了中文逗号时出现的报错。
  • |error: expected ';', ',' or ')' before '+' token|
    译：错误：在‘+’之前缺少预期的‘;’或者‘,’
    意：int findmax(int a[]; int +n);
  • |error: parameter 'a' has just a forward declaration|
    |note: declared here|
    译：错误：参数‘a’只有一个前置声明;注释：在这里声明
    意：int findmax(int a[]; int n);a后面是“；”而不是“，”导致的。是GNU C拓展语法里面的 parameter forward declaration feature的特性。
  • |error: invalid type argument of unary '*' (have 'int')|
    译：错误：无效的参数类型关于一元的‘*’，（有‘int’）。
    意：采用数组指针时用数组指针输出时同时使用了一个 * 和两个[] (*pdata[][])。
	······
	pdata[0] = data[0];
    pdata[1] = data[1];

    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++, pdata[i]++)//for (j = 0; j < 3; j++)
        {
            printf("data[%d][%d]:%-2d\n", i, j, *pdata[i]);//printf("data[%d][%d]:%-2d\n", i, j, *pdata[i][j]);//|error: invalid type argument of unary '*' (have 'int')|
        }
    }

编辑时回到目录

浏览时回到目录

warning

  • |warning: too many arguments for format [-Wformat-extra-args]|
    意：警告：格式参数太多[-W(W应该是Warning的意思吧)格式化-参数-额外]
    译：获得该warring是因为printf时忘记输入格式化字符%d，故为，格式化字符少于参数表中参数。此时参数作废。
  • |warning: format '%d' expects a matching 'int' argument [-Wformat=]|
    译：格式’%d’需要一个匹配的’int’参数[-Wformat=]
    意：与上一个相反，格式化字符多于参数表中的参数，此时会随机输出无匹配参数的。
  • |warning: format '%d' expects argument of type 'int *', but argument 2 has type 'float *' [-Wformat=]|
    译：警告:格式化’%d’需要类型为’int *‘的参数，但参数2的类型为’float *’ [-Wformat=]
    意：float a[]; scanf("%f", &a[i]); // scanf("%d", &a[i]);
  • |warning: format '%f' expects argument of type 'float *', but argument 2 has type 'double' [-Wformat=]|
    译：警告:格式化’%f’需要类型为’float *‘的参数，但参数2的类型为’double’ [-Wformat=]
    意：
	 float a[10], b[10];
     int c[10], d[10];
     int i;

     printf("//f-d input array a number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &a[i]);  //|warning: format '%d' expects argument of type 'int *', but argument 2 has type 'double' [-Wformat=]|
     }
     printf("\n");

     printf("//f-f input array b number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &b[i]);  //|warning: format '%f' expects argument of type 'float *', but argument 2 has type 'double' [-Wformat=]|
     }
     printf("\n");

     printf("//d-d input array c number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &c[i]);
     }
     printf("\n");

     printf("//d-f input array d number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &d[i]);
     }
     printf("\n");
  • |warning: return type of 'main' is not 'int' [-Wmain]|
    译：警告:‘main’的返回类型不是’int’ 。
    意：C默认main的返回值类型为int型，void main()的话就会warning。
  • |warning: implicit declaration of function 'pritnf'; did you mean 'printf'? [-Wimplicit-function-declaration]|
    译：函数pritnf的隐式声明;你是说“printf”吗?(-Wimplicit-function-declaration) |分号前：该函数名的函数未声明；分号后：你是不是打错了 😉 😃
    意：获得该warning是因为将printf函数打错为printf。
    未声明的函数却是warning而非error，可以编译。

C和C++是强类型语言，变量类型均应在代码执行前确定。
在函数声明方面C和C++则不同，C++语言中，在被调用之前未声明或定义是不允许的，而C语言是允许的。初看起来C语言这一特性是灵活、省事，但缺点是：
1、程序可读性差。
2、易出错。函数先声明再调用，是一种纠错机制，如果不声明，则没有用到这种纠错机制，虽然编译、连接通过，程序也能运行，但很可能结果不正确。
一个好的程序员，应该养成严谨、规范的编程习惯，编译程序时应打开显示所有警告选项“-Wall”，并且对编译器提出的所有警告都要给予处理，仅以编译、连接通过为目标，这可能会有潜在的危害。
引用于该博客（侵删）

  • |warning: implicit declaration of function 'add' [-Wimplicit-function-declaration]|
    意：同上，使用未声明函数
  • |warning: unused variable 'a' [-Wunused-variable]|
    译：警告：变量’a’未使用。
    意：与undeclared (first use in this function)相反，该warning说明存在变量被定义后却在整个程序中未被使用，开辟分配了内存空间但未使用。
  • |warning: passing argument 1 of 'findmax' makes integer from pointer without a cast [-Wint-conversion]|
    译：警告:函数“findmax”的第一个整型integer参数的没有转换为指针型pointer
    意：函数的参数理应为指针型（或数组型），但实际使用了一个整型。
  • |note: expected 'int (*)[10]' but argument is of type 'int (*)[4]'|
    |warning: passing argument 1 of 'findmax' from incompatible pointer type [-Wincompatible-pointer-types]|
    译：注释：期望 ‘int ()[10]’ 但实参类型是 'int ()[4]’。
    警告：函数“findmax”的第一个参数为不兼容的指针类型。
    意：函数声明的形参表中的数组类型和调用函数时给的实参的函数类型不一致。
  • |warning: assignment to 'short int *' from 'int' makes pointer from integer without a cast [-Wint-conversion]|
    译：把int型的值赋值给short int *型使得int型参数没有强制类型转换为指针型。
    意：*pa = i + 1误写为pa = i + 1pa为short int *型，i为short int型，i + 1自动类型转换为int型？
  • |warning: left-hand operand of comma expression has no effect [-Wunused-value]|
    译：警告:逗号表达式的左操作数没有影响
    意：？

编辑时回到目录

浏览时回到目录

非warning非error的undefined

| undefined reference to 'add'|

同样的undeined在本博客中/随机数的生成/中的最后一个实例中也存在。随机数的生成

编辑时回到目录

浏览时回到目录

debug

变量初始化

  • 全局变量未初始化，缺省默认为0；(缺省的extern,外部的static)
    局部非静态变量未初始化，缺省随机；(缺省的auto,以及register?)
    静态局部变量未初始化，缺省默认为0；(局部的static)

编辑时回到目录

浏览时回到目录

内外层同名变量

int a = 1;
for (int a = 2, i = 1; i < 4; i++)
{
	a *= i;          //a = a * 1 * 2 * 3 = a * 3! = 12
}
printf("a = %d", a);
  • 输出 a = 1
    在该段代码中，for循环内外同时定义了两个同名变量a，在此时两个同名变量允许都进行变量声明且被视作两个不同的变量。
    可以理解为，循环外定义的变量a为a1，循环内定义的变量a为a2，进入for循环内，是变量a2参与了相关运算，而printf函数输出的则是循环外的a1变量，a1变量并未参与运算，其值为初始值1.

编辑时回到目录

浏览时回到目录

小TIPS

  • 输出多个空格时可以采用的printf("%4c", ’ ');
  • while (1)循环中的每一个离开循环的分支要确定其是否脱离循环 break和continue

  • \n
    % -4 d

  • scanf("%d", & a)
    for(;;)最后无 ;
    do while 最后while后有 ;

;)后紧跟汉字就不会变小表情

  • HEX十六进制
//*
注释小技巧   此时该代码片未被注释
// */


/*
注释小技巧   此时该代码片被注释掉
// */

编辑时回到目录

浏览时回到目录

bios.h

  • bios.h头文件无法使用？
    教材中原本为采用bios.h头文件，利用bioskey()函数通过keyboard键入截取键盘信息得到键值。
    实际上bios.h已经被淘汰了，这些对驱动，硬件端口操作的东西，已经是dos时代的残留物了，现如今已经无法使用了。

bios.h 是16位 DOS 编译器的东西，例如古老的 TC ，Open Watcom C 才有。bios.h 文件 编译器之间不兼容。
你没有那种编译器和它的库，要来bios.h 也无用。你要是有那种编译器，你就已经有了 bios.h
如果想考古，网上也许能找到 TC 的 bios.h （例如3个 w 点 sandroid 点 org 杠 TurboC杠 – 写 成英文字符，无空白）

引用于百度百科及百度问答。

头文件bios.h存放有接口函数，在tc2下应该没问题，如果是在VC下，可能不成功，因为bios.h是在DOS模式下才能调用的，而VC是基于图形、窗口的。库函数：
　　BIOS.H：这几个函数是经常用到的
　　int _Cdecl int86(int __intno, union REGS *__inregs, union REGS *__outregs);
　　int _Cdecl int86x(int __intno, union REGS *__inregs, union REGS *__outregs, struct
　　SREGS *__segregs);
　　union REGS {
　　struct WORDREGS x;
　　struct BYTEREGS h;

bios.h里的函数可以直接访问底层硬件。

/*    bios.h

    Access to bios services.

    Copyright (c) Borland International 1987,1988
    All Rights Reserved.
*/
#if __STDC__
#define _Cdecl
#else
#define _Cdecl    cdecl
#endif

int    _Cdecl bioscom(int cmd, char abyte, int port);
int    _Cdecl biosdisk(int cmd, int drive, int head, int track, int sector,
            int nsects, void *buffer);
int    _Cdecl biosequip(void);
int    _Cdecl bioskey(int cmd);
int    _Cdecl biosmemory(void);
int    _Cdecl biosprint(int cmd, int abyte, int port);
long    _Cdecl biostime(int cmd, long newtime);

最常用的就是bioskey函数；例如
#include <stdio.h>
#include <bios.h>
main()
{
int n = bioskey(0); /*读取一个输入字符*/
printf("you entered:%c", n);
getch();
}

编辑时回到目录

浏览时回到目录

进行计算时的整型与浮点型

int a, b;
float c, d;
int result1, result2;
float result3, result4;

a = c = 1;
b = d = 2;

result1 = a / b;      0             //int = int / int;              1 / 2 = 0(int)
result2 = c / d;      0             //int = float / float;        1.000000 / 2.000000 = 0.500000(float) = 0(int)
result3 = a / b;      0.000000      //float = int / int;           1 / 2 = 0(int) = 0.000000(float)
result4 = c / d;      0.500000      //float = float / float;      1.000000 / 2.000000 = 0.500000(float)

以及输出时的%d%f和对应参数int float

 //float 型的数组  如果输入数组元素时用int %d  则 全为0？
 #include <stdio.h>
 int main()
 {
     float a[10], b[10];
     int c[10], d[10];
     int i;

     printf("//f-d input array a number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &a[i]);  
     }
     printf("\n");

     printf("//f-f input array b number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &b[i]);  
     }
     printf("\n");

     printf("//d-d input array c number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &c[i]);
     }
     printf("\n");

     printf("//d-f input array d number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &d[i]);
     }
     printf("\n");
   
     printf("f-d-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", a[i]);
     }
     printf("\n"); 
     printf("f-d-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", a[i]);
     }
     printf("\n");
     printf("f-f-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", b[i]);
     }
     printf("\n");
     printf("f-f-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", b[i]);
     }
     printf("\n");
     printf("d-d-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", c[i]);
     }
     printf("\n");
     printf("d-d-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", c[i]);
     }
     printf("\n");
     printf("d-f-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", d[i]);
     }
     printf("\n");
     printf("d-f-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", d[i]);
     }
     return 0;

}
f-d input array a number :10 2 5 9 8 7 22 51 15 12
//
f-f input array b number :10 2 5 9 8 7 22 51 15 12
//
d-d input array c number :10 2 5 9 8 7 22 51 15 12
//
d-f input array d number :10 2 5 9 8 7 22 51 15 12
//
//f-d-d
//0        0        0        0        0        0        0        0        0        0
//f-d-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000
//f-f-d
//0        0        0        0        0        0        0        0        0        0
//f-f-f
//10.0000002.000000 5.000000 9.000000 8.000000 7.000000 22.00000051.00000015.00000012.000000
//d-d-d
//10       2        5        9        8        7        22       51       15       12
//d-d-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000
//d-f-d
//1092616192107374182410842275841091567616109051904010884218881102053376111227699210978590721094713344
//d-f-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

scanf相关
//疑问 我没加getchar  加一下试试
 #include <stdio.h>
 int main()
 {
     float a[10], b[10];
     int c[10], d[10];
     int i;

     printf("//f-d input array a number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &a[i]);  
     }
     printf("\n");
     getchar();
     printf("//f-f input array b number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &b[i]); 
     }
     printf("\n");
     getchar();
     printf("//d-d input array c number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%d", &c[i]);
     }
     printf("\n");
     getchar();
     printf("//d-f input array d number :");
     for (i = 0; i < 10; i++)
     {
         scanf("%f", &d[i]);
     }
     printf("\n");


     printf("f-d-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", a[i]);
     }
     printf("\n");
     printf("f-d-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", a[i]);
     }
     printf("\n");
     printf("f-f-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", b[i]);
     }
     printf("\n");
     printf("f-f-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", b[i]);
     }
     printf("\n");
     printf("d-d-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", c[i]);
     }
     printf("\n");
     printf("d-d-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", c[i]);
     }
     printf("\n");
     printf("d-f-d \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9d", d[i]);
     }
     printf("\n");
     printf("d-f-f \n");
     for (i = 0; i < 10; i++)
     {
         printf("%-9f", d[i]);
     }
     return 0;

}
f-d input array a number :10 2 5 9 8 7 22 51 15 12
//
f-f input array b number :10 2 5 9 8 7 22 51 15 12
//
d-d input array c number :10 2 5 9 8 7 22 51 15 12
//
d-f input array d number :10 2 5 9 8 7 22 51 15 12
//
//f-d-d
//0        0        0        0        0        0        0        0        0        0
//f-d-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000
//f-f-d
//0        0        0        0        0        0        0        0        0        0
//f-f-f
//10.0000002.000000 5.000000 9.000000 8.000000 7.000000 22.00000051.00000015.00000012.000000
//d-d-d
//10       2        5        9        8        7        22       51       15       12
//d-d-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000
//d-f-d
//1092616192107374182410842275841091567616109051904010884218881102053376111227699210978590721094713344
//d-f-f
//0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000 0.000000

编辑时回到目录

浏览时回到目录

运算符的优先级和结合性

C语言中有44个运算符

优先级个数内容结合性编程规范之空格
14()括号运算符
[] 数组下标
-> 指向结构体成员运算符
. 结构体成员访问运算符		->从左向右前后都不加
210++ 自增运算符
- - 自减运算符
& 取地址运算符
* 取（指针所指）内容运算符
! 逻辑非 ，逻辑运算符
~ 按位求反，位运算运算符
+ 取正数（单目算术运算符）
- 取负数（单目算术运算符）
(数据类型） 强制类型转换
sizeof 计算数据类型长度		<-从右向左单目 不加
33* 乘法算术运算符
/ 除法算术运算符
% 求余算术运算符		->从左向右算数运算符 前后都加
42+ 加法双目算术运算符
- 减法双目算术运算符		->从左向右算数运算符 前后都加
52<< 左移位位运算符
>> 右移位位运算符		->从左向右位运算符？加不加
64< 小于关系运算符
<= 小于等于关系运算符
> 大于关系运算符
>= 大于等于关系运算符		->从左向右关系运算符 前后加
72== 相等关系运算符
!= 不相等关系运算符（!为英文感叹号）		->从左向右关系运算符 前后加
81& 按位与位运算符->从左向右位运算符？加不加
91^ 按位异或位运算符->从左向右位运算符？加不加
101| 按位或位运算符->从左向右位运算符？加不加
111&& 逻辑与逻辑运算符->从左向右位运算符？加不加
121|| 逻辑或逻辑运算符->从左向右位运算符？加不加
131?: 三目条件运算符<-从右向左前后加
1411= 基本赋值运算符
*= /= %= += -= 算术复合赋值运算符
<<= >>= &= ^= |= 位运算复合赋值运算符		<-从右向左前后加
151, 逗号运算符->从左向右前不加后加
  • c = a / b >= 1e-6
    原意 ((c = (a / b)) >= 1e-6)
    实际(c = ((a / b) >= 1e-6))
#include <stdio.h>
#define PRINT3(x, y, z) \
        printf(#x "= %d \t" #y "= %d \t" #z "= %d \n", x, y, z)
void main()
{
    int x, y, z;

    x = y = z = 1;
    // 结合性 优先级 运算顺序  && > ||
    //1 || ++y && ++z;    //x= 1    y= 1    z= 1     1 || (++y && ++z);  ||左真，右不执行
    //++x|| (++y && ++z);  //x= 2    y= 1    z= 1      ++x执行 执行后||左真，右不执行
    //++y && ++z;          //x= 1    y= 2    z= 2
    //--x|| ++y && ++z;    //x= 0    y= 2    z= 2
    //++x|| ++y && ++z;    //x= 2    y= 1    z= 1
    //++y && ++z || ++x;   //x= 1    y= 2    z= 2
    //(++y && ++z) || ++x; //x= 1    y= 2    z= 2
    PRINT3(x, y, z);

     x = y = z = 1;
    ++x && (++y) || ++z;
    PRINT3(x, y, z);

     x = y = z = 1;
    ++x && ++y && ++z;
    PRINT3(x, y, z);

     x = y = z = -1;
    (++x) && ++y || ++z;
    PRINT3(x, y, z);

     x = y = z = -1;
    ++x || (++y) && ++z;
    PRINT3(x, y, z);

     x = y = z = -1;
    (++x) && (++y) && ++z;
    PRINT3(x, y, z);
}
//x= 2    y= 1    z= 1 ???????
//x= 2    y= 2    z= 1
//x= 2    y= 2    z= 2
//x= 0    y= -1   z= 0
//x= 0    y= 0    z= -1
//x= 0    y= -1   z= -1

编辑时回到目录

浏览时回到目录

随机数的生成

  • 需要头文件：<time.h>和<stdlib.h>

  • <stdlib.h>中包含有随机函数 rand函数和伪随机数发生器的初始化函数srand函数。

  • 随机函数 rand函数，可以随机产生0~rand_max 的随机数， 最大值会随其定义类型改变。(?)

  • 在int型时其界限（最大值）：在stdlib头文件中宏定义#define RAND_MAX 0x7fff 故其最大值32767 (2 ^15 - 1)（32bit下）(?也有说因其unsigned,为2 ^16 - 1?)（64bit下则为2 ^31 - 1）

  • 此外也可以人为限制随机数区域，如int r = rand()%10即是产生[0, 9]这个区间内的整数随机数，int r = 66 + rand()%10产生[66, 75]这个区间内的整数随机数。也能通过运算产生一定区间范围内的浮点数，如double r = (double)(rand() / RAND_MAX产生区间[0, 1]之间的小数随机数，同样方法也可产生随机字符。

  • rand函数原型

#inlcude <stdlib.h>
int rand(void);

#include<stdio.h>
#include<stdlib.h>
int main()
{
	int i;
	i = rand();
	printf("rand = %d", rand);
	return 0;
}

  • rand函数产生的是伪随机数，是通过根据一个数然后按照某个公式推算出来的(公式为：rand = rand * const_1 + c_var, rand初始为1)，这个数我们称之为“种子”，但是这个种子在系统启动之后为一个定值，所以你会发现，每次产生的随机数都是相同的。(rand函数的内部实现是用线性同余法实现的，是伪随机数，由于周期较长，故一定范围内可以视作是随机的)

  • rand函数每次被调用之前都会查询程序是否调用过srand函数。

  • srand函数是伪随机数发生器的初始化函数。
    srand函数原型void srand(unsigned seed);(也有说是void srand(unsigned int seed);)
    形参为无符号的一个类型，可以是int,float,char等等。

  • 其中的seed即是“种子”，如果调用过srand函数，那么rand函数会自动调用srand(seed)一次初始化自己的初始值；如果没有调用过srand函数，则系统会自动给seed赋初始值，自动设计随机数种子为1，即为srand(1)，然后再自动调用一次。

  • srand函数相当于给rand函数产生一个起点。也可以手动输入种子。unsigned int seed; scanf("%d", &seed);
    41 18467 6334 26500 19169 15724 11478 29358 26962 24464 ......
    所以如果srand(1)，则每次它都会按照上述固定序列产生随机数，（例如，上面的代码每次都会产生41这个“随机数”）

  • 要想获得每次都不一样的随机数，需要使srand函数的“seed”不同，所以我们采用了一个time函数使时间作为种子，因为每次运行程序，时间一定不同，因而产生的随机数也就不同了。

  • time函数的头文件为#include <time.h>

  • time.h这个头文件可以访问系统时间。
    包含七个函数。

  1. long clock(void); 返回程序开始执行后占用的处理其时间。
  2. double difftime(long t2, long t1); 返回t2 - t1的值，可以得到时间差。
  3. long mktime(struct tm*); 将结构体中的当地时间转换为日历时间。
  4. long time(long tp); 返回当前日历时间，同时将返回值赋给tp。
  5. char *asctime(const struct tm *tp); 时间转换函数，得到以ASCII码表示的时间。
  6. char *ctime(const time_t *tp); 得到字符串表示的时间。
  7. size_t strftime(char *s, size_t smax, const char *fmt, const struct tm *tp); 得到指定格式的时间。

时间类里面有九个属性：秒，分，时，日，天数，星期，月，夏令，年。

time.h
#ifndef _TM_DEFINED
struct tm
{
	int tm_sec;  秒[0~59]
	int tm_min;  分[0~59]
	int tm_hour;  时[0~23]
	int tm_mday; 日[0~31]
	int tm_yday;  天数[0~365]
	int tm_wday;  星期[0~6]
	int tm_isdst;  夏令
}
#define _TM_DEFINED
#endif

time函数的原型为time_t time(time_t *tloc);（也有time_t time(time_t *t);）

  • 其中注意，time函数的(返回值的)类型为time_t，time_t类型被定义为一个长整型；time函数的形参为一个指针变量，通常写作time(NULL)，表示不需要经过参数得到的time_t数据，srand((unsigned)time(NULL));直接传入一个空指针，因为你的程序中往往并不需要经过参数得到的t数据；srand((unsigned)time(&t));是获得了系统时间后将time_t型数据转化为(unsigned)型再传给srand函数

  • time函数的功能使：返回 自1970年1月1日00：00：00GMT(CUT Coordinated Universal Time 被称为UNIX系统的Epoch时间) 到程序运行时的时间(单位:秒)，这个数会随程序的运行而发生改变。（系统时间）

  • 如果写在循环内，每次循环感觉时间间隔过小，导致种子变化不大（小于1s），出现同一随机序列，可以将调用time函数时将其返回子乘以一个适当的整数，例如srand((unsigned)time(NULL) * 100)

  • 综上，为了达到随机数的效果，我们使用time函数产生一个随机数，然后将其作为srand函数的形参，以此通过srand函数给rand函数产生一个随机的起点，再通过rand函数产生随机数。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
int main()
{
	int r = 0;
	srand((unsigned)time(NULL));  //srand(time(0));也可以
	r = rand()%10;
	return 0;
}

实例

//将20-29十个数字乱序输出
#include <stdio.h>
#include <stdlib.h>
#include <time.h>

int main()
{
    int i, a[10];

    srand((unsigned int)time(NULL));

    for (i = 0; i < 10; i++)
    {
        a[i] = rand()%10 + 20;
    }
    printf("//");
    for (i = 0; i < 10; i++)
    {
        printf("%-4d", a[i]);
    }
    printf("\n");
    return 0;
}
//21  27  21  26  29  20  23  28  27  28

//电脑自动猜数字
#include <stdio.h>
#include <time.h>
#include <process.h>
#include <stdlib.h>
#include <Windows.h>

int main()
{
    int ret = 0;
    int guess = 50;
    int left = 0;
    int right = 100;

    srand((unsigned int)time(NULL));
    ret = rand()%101;
    printf("//answer is:%d\n", ret);

    while (1)
    {
        if (guess > ret)
        {
            printf("//too big: %d\n", guess);
            right = guess;
            guess = (right +left) / 2;
            //sleep(1000);?too long time to wait  /ms?/
        }
        else if (guess < ret)
        {
            printf("//too small: %d\n", guess);
            left = guess;
            guess = (right + left) / 2;
            //sleep(1000);
        }
        else
        {
            printf("//ok : %d\n", guess);
            break;
        }
    }
    system("pause");
    return 0;
}
//answer is:77
//too small: 50
//too small: 75
//too big: 87
//too big: 81
//too big: 78
//too small: 76
//ok : 77

自己猜数字的小游戏
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
void main()
{
    int i, j, s;                                
    srand(time(NULL));
    i = rand();
    printf("please guess :");
    for (s = 1; s <= 20; s++)               
    {
        scanf("%d", &j);
        if (i == j)
        {
            printf("%d\n", s);
            break;
        }
        else if(i > j)
        {
            printf("bigger\n");          
        }
        else
        {
            printf("smaller\n");        
        }

    }
    if (s > 20)                               
    {
        printf("lj\n");
        printf("the number is %d", i);
    }


}
  • 除此之外还有一种取得随机数的方法：采用getpid()函数

getpid函数功能是取得进程识别码，许多程序利用取到的此值来建立临时文件，以避免临时文件相同带来的问题
头文件：旧版本：unistd.h，在VC++6.0下可以用process.h
函数原型：旧的原型为pid_t getpid(void);，推荐使用int _getpid( void );这种形式。注意，函数名第一个字符是下划线。
函数说明：getpid函数用来取得目前进程的进程ID，许多程序利用取到的此值来建立临时文件，以避免临时文件相同带来的问题。
返回值：目前进程的进程ID

  • 这样生成的随机数仍是按照固定序列，但该序列在不同程序中是不同的，但在同一程序中多次运行序列不变。
  • srand((unsigned int?)getpid());
  • getpid()作为seed的返回值
补充实例
//2020.12.13 15:20 随机小学算数
#include <stdio.h>
#include <time.h>
#include <stdlib.h>
void main()
{
    int a, b, s;
    char op;
    int score = 0;
    srand((unsigned)time(NULL));                                     //srand(time(NULL));//randomize();//|undefined reference to `randomize'|
    for (int i = 1; i <= 10; i++)                        //第一次修改 i未定义 for (i = 1; i <= 10; i++)
    {

        a = rand()%101;                                   //a = random(101);
        b = rand()%101;                                //b = random(101);//|undefined reference to `random'|
        op = rand()%3;                                //op = random(3);
        if (op == 0)
        {
            printf("%d + %d = ?\n", a, b);
            scanf("%d", &s);
            if (s == a + b)
            {
                printf("true\n");
                score += 10;
            }
            else
            {
                printf("false\n");
                printf("answer is %d\n", a + b);
            }
        }
        else if(op == 1)
        {
            printf("%d - %d = ?\n", a, b);
            scanf("%d", &s);
            if (s == a - b)
            {
                printf("true\n");
                score += 10;

            }
            else
            {
                printf("false\n");
                printf("answer is %d\n", a - b);
            }
        }
        else
        {
            printf("%d * %d = ?\n", a, b);
            scanf("%d", &s);
            if (s == a * b)
            {
                printf("true\n");
                score += 10;
            }
            else
            {
                printf("false\n");
                printf("answer is %d\n", a * b);
            }
        }
    }
    printf("your score is %d \n", score);
}

86 + 19 = ?
105
true
3 * 86 = ?
154
false
answer is 258
32 + 6 = ?
38
true
88 + 31 = ?
119
true
61 * 38 = ?
1
false
answer is 2318
30 * 34 = ?
1020
true
46 + 85 = ?
131
true
38 - 77 = ?
-39
true
88 * 0 = ?
0
true
70 + 51 = ?
121
true
your score is 80
  • |undefined reference to 'randomize'|
    |undefined reference to 'random'|
    译：未定义的引用

编辑时回到目录

浏览时回到目录

>scanf

  • scanf函数
    • scanf函数头文件<stdio.h>
    • int scanf([const] char *format, ...);
  • 缓冲区

    • buffer，缓冲区是内存空间的一部分。内存空间预留了一定的存储空间来缓冲输入和输出的数据，即缓冲区。并据此分为输入缓冲区和输出缓冲区。缓冲区有一定的大小。

    • 缓冲区，顾名思义，是用来缓冲的一片存储区域。
      在生活中，当我们从高速向低速过渡时，我们需要缓冲带来缓冲。在数据传输时，同样的，当高速设备想向低速设备传输数据时，并非直接传输，而是高速设备先将数据传输到缓冲区，再由低速设备从缓冲区取出数据。这样子，高速设备无需花时间等待低速设备，提高了计算机的效率。
      举个例子，CPU是一个高速设备，而打印机便是一个低速设备，当我们打印东西时，CPU先将相关数据传输到相应的缓冲区，然后CPU便可去处理其他数据，打印机再逐步从缓冲区取出数据慢慢打印。
      此外

      可以减少数据的读写次数，如果每次数据只传输一点数据，就需要传送很多次，这样会浪费很多时间，因为开始读写与终止读写所需要的时间很长，如果将数据送往缓冲区，待缓冲区满后再进行传送会大大减少读写次数，这样就可以节省很多时间。例如：我们想将数据写入到磁盘中，不是立马将数据写到磁盘中，而是先输入缓冲区中，当缓冲区满了以后，再将数据写入到磁盘中，这样就可以减少磁盘的读写次数，不然磁盘很容易坏掉。
      简单来说，缓冲区就是一块内存区，它用在输入输出设备和CPU之间，用来存储数据。它使得低速的输入输出设备和高速的CPU能够协调工作，避免低速的输入输出设备占用CPU，解放出CPU，使其能够高效率工作。
      对缓冲区的理解
      缓冲区与缓存

scanf时最好格式化字符外不要有其他东西
比如\n 逗号之类 空格问题不大
对于逗号，

//用一个scanf输入多个字符串 输入时以空格分隔
 #include <stdio.h>
 int main()
 {
     char a[4], b[6], c[3];
     //char d[2];
     //printf("//input d:");
     //scanf("%s", d);
     //getchar();
     //printf("//%s\n", d);

     printf("//input a b c:");
     scanf("%s%s%s", a, b, c);

     printf("//%s\n//%s\n//%s\n", a, b, c);
 }
//input a b c:abcd abcd abcd
//abcd
//d
//abcd
//???????????????????


//input d:abcdefg
//abcdefg
//input a b c:abc abc abc
//abc
//
//abc

//input a b c:123 12345 13
//123
//12345
//13

//input a b c:123 123 12
//123
//123
//12

//input a b c:123 123 123
//123
//
//123

//input a b c:1234 1234 12
//1234
//1234
//12

//input a b c:1234 1234 1234
//1234
//4
//1234

//input a b c:1234 12345 1234
//1234
//4
//1234

//input a b c:1234 1234 12345
//1234
//45
//12345

编辑时回到目录

浏览时回到目录

>printf

int printf(char *format, ...);

编辑时回到目录

浏览时回到目录

寄存器变量

寄存器变量
//2020.12.18 18:21
#include <stdio.h>
#define T 10000
void delay1();
void delay2();

void delay1()
{
    register unsigned i = 0;
    for (; i < T; i++)
    {

    }
}
void delay2()
{
    unsigned i;
    for (i = 1; i< T; i++)
    {

    }
}

void main()
{
    unsigned int i;
    printf("\a调用delay1()第一次延时！\n");
    for (i = 0; i < 60000; i++)
    {
        delay1();
    }

    printf("\a第一次延时结束\n调用delay2()第二次延时！\n");
    for (i = 0; i < 60000; i++)
    {
        delay2();
    }
    printf("\a第二次延时结束！\n");


}

编辑时回到目录

浏览时回到目录

extern变量

//2020.12.18 18:53
#include <stdio.h>
extern int n;  //n 的定义性说明在hanshu()之后，须使用extern对n作引用说明  对外部变量引用说明时不分配存储单元 也不初始化。
void hanshu();

void hanshu(void)
{
    n -= 20;
}

int n = 100;  //系统在该处给变量分配存储单元并执行初始化？
int main(void)
{
    printf("n = %d \n", n);
    for (; n >= 60; )
    {
        hanshu();
        printf("n = %d \n", n);
    }
    return 0;
}

编辑时回到目录

浏览时回到目录

>宏定义

#define 标识符 字符串
放在程序开头的这部分内容我们称之为宏定义，在程序中，使用了相应的标识符，标识符将被相应的字符串取代。
举个栗子 在预处理时#define PI 3.1415926535，则在程序中出现的所有的‘PI’都将用‘3.1415926535’代替。
用这种方式将一个字符串用一个标识符代替，我们把这个标识符称为“宏名”，在程序中代替的过程我们称为“宏展开”。
用宏定义的方式我们可以做到“一改全改”。
值得注意的是，宏定义只是进行简单的替换，不作正确性检查。例如在编程时1与l十分相像，若两者错写，在程序中依旧会将错误代入，不作语法检查。只有对已被宏展开后的源程序进行编译时才会发现语法错误并报错。
宏定义不需要在句末加分号，因为其不是C语句，如果加了会将分号一同进行替换。
C语言宏定义讲解

#define PRINT(int) printf(#int " = %d \n", int)

int x = 3;
PRINT(x);
***********
x = 3

#define PRINT3(x, y, z) \(?) printf(#x "= %d \t" #y "= %d \t" #z "= %d \n", x, y, z)

编辑时回到目录

浏览时回到目录

求素数

10~100之间的素数
#include <stdio.h>
void main()
{
    int a, i, j;
    for (a = 10; a<= 100; a++)
    {
        for (i = 2; i < a; i++)
        {
            j = a % i;
            if (j == 0)
            {
                break;
            }
        }
        if(i >= a)
        {
            printf("%6d", a);
        }
    }
}
//输出     11    13    17    19    23    29    31    37    41    43    47    53    59    61    67    71    73    79    83    89    97

求100~200之间的全部素数。
#include <stdio.h>
#include <math.h>
void main()
{
    int i, j, N, t;
    int p;
    for (i = 100; i <= 200; i++)
    {
        N = (int)sqrt(i);
        for (p = 0, j = 2; j <= N; j++)
        {
            t = i % j;
            if (!t)
            {
                p = 1;
                break;
            }

        }
        if (!p)
        {
            printf("%5d", i);
        }
    }

}
//  101  103  107  109  113  127  131  137  139  149  151  157  163  167  173  179  181  191  193  197  199

作业参考答案

 是否素数
#include <stdio.h>
void main()
{
    int x, i, j;
    printf("input the number :");
    scanf("%d", &x);  
    if (x <= 1)
    {
        printf("the input data is error");

    }
    else
    {
        for (i = 2; i < x; i++) 
        {
            j = x % i;
            if (j == 0)
            {
                break;
            }
        }
        if (i >= x)
        {
            printf("素数");
        }
        else
        {
            printf("非素数");
        }
    }
}

编辑时回到目录

浏览时回到目录

>malloc动态分配内存

#include <stdio.h>
#include <stdlib.h>
//#include <alloc.h>             //|fatal error: alloc.h: No such file or directory|
void invert(int *a, int n);

void main()
{
    int i, *a, N;
    printf("Input array length :");
    scanf("%d", &N);
    a = (int *)malloc(N * sizeof(int));
    printf("Input array number : ");
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }
    //free(a);
    printf("\n");
    invert(a, N);
    printf("invert array: \n");
    for (i = 0; i < N; i++)
    {
        printf("%-4d", a[i]);
    }
    free(a);
}

void invert(int *a, int n)
{
    int i, j, temp;
    for (i = 0, j = n - 1; i < j; i++, j--)
    {
        temp = a[i];
        a[i] = a[j];
        a[j] = temp;
    }
}
//Input array length :8
//Input array number : 1 2 3 4 5 6 7 8

//invert array:
//8   7   6   5   0   110103840   11036736

//Input array length :10
//Input array number : 1 2 3 4 5 6 7 8 9 0
//
//invert array:
//0   9   8   7   6   5   0   15732000   1599552


//Input array length :4
//Input array number : 1 2 3 4

//invert array:
//0   119934240   12019776

//Input array length :6
//Input array number : 9 8 4 7 22 1

//invert array:
//1   22  0   126487840   12675136


以上错误因为free函数的位置


//芜湖
//Input array length :6
//Input array number : 2 5 7 9 4 1
//
//invert array:
//1   4   9   7   5   2

//2021.1.3 19:20    指针之动态分配
//if (指针名 = (类型 *) malloc(空间大小) == NULL){出错处理操作}
//if (!(指针名 = (类型 *)mlloc (空间大小))){出错处理操作}

#include <stdio.h>
                                //一 #include <stdlib.h>
#include <malloc.h>  //一 增    //一 #include <alloc.h>

int main()
{
    int i = 0;
    int *a;
    int N;

    printf("input the array length:");
    scanf("%d", &N);
    //定义数组长度
    a = (int *) malloc(sizeof(int) * N);
    //动态
    for (i = 0; i < N; i++)
    {
        a[i] = i + 1;
        printf("%-5d", a[i]);
        //给数组赋值并打印

        if ((i + 1) % 10 == 0)
        {
            printf("\n");
        }
        //十个一行
    }
    free(a);
    //动态
    printf("\n");
    return 0;
}
//一 C:\Users\Administrator\Desktop\lidididi\lidididi.c|4284|fatal error: alloc.h: No such file or directory|

//二
//input the array length:16
//1    2    3    4    5    6    7    8    9    10
//11   12   13   14   15   16


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

int main()
{
    int i;
    int *p;
    int N;

    printf("//input N:");
    scanf("%d", &N);

    p = (int *)malloc(N * sizeof(int));

    printf("//");
    for (i = 0; i < N; i++)
    {
        p[i] = i + 1;
        printf("%-5d", p[i]);
        if ((i + 1) % 10 == 0)
        {
            printf("\n");
        }
    }
    free(p);
    return 0;
}
//void *malloc(unsigned size);
//void free(void *ptr);


//input N:10
//1    2    3    4    5    6    7    8    9    10

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

int main()
{
    int **a;
    int i, j;
    int m, n;

    printf("//input row and column:");
    scanf("%d%d", &m, &n);

    a = (int **)malloc(sizeof(int *) * m);
    for (i = 0; i < m; i++)
    {
        a[i] = (int *)malloc(sizeof(int) * n);
    }

    for (i = 0; i < m; i++)
    {
        for (j = 0; j < n; j++)
        {
            printf("//%p\n", &a[i][j]);
        }
    }

    for (i = 0; i < m; i++)
    {
        free(a);
    }

    return 0;

}
//input row and column:3 5
//0000000000BD6AF0
//0000000000BD6AF4
//0000000000BD6AF8
//0000000000BD6AFC
//0000000000BD6B00
//0000000000BD6B10
//0000000000BD6B14
//0000000000BD6B18
//0000000000BD6B1C
//0000000000BD6B20
//0000000000BD6B30
//0000000000BD6B34
//0000000000BD6B38
//0000000000BD6B3C
//0000000000BD6B40


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

int main()
{
    int i, j;
    int (*a)[2] = (int (*)[2])malloc(sizeof(int) * 3 * 2);

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 2; j++)
        {
            printf("//%p\n", &a[i][j]);
        }
    }
    free(a);
    return 0;
}
//0000000000AA1440
//0000000000AA1444
//0000000000AA1448
//0000000000AA144C
//0000000000AA1450
//0000000000AA1454


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

int main()
{
    int nrows, ncolumns;
    int *Array;
    int i, j;

    printf("//please input nrows & ncolumns:");
    scanf("%d%d", &nrows, &ncolumns);

    Array = (int *)malloc(nrows * ncolumns * sizeof(int));

    for (i = 0; i < nrows; i++)
    {
        for (j = 0; j < ncolumns; j++)
        {
            printf("//%p\t", &Array[i * ncolumns + j]);
        }
        printf("\n");
    }
    free(Array);
    return 0;
}
//please input nrows & ncolumns:4 3
//0000000000776AD0      //0000000000776AD4      //0000000000776AD8
//0000000000776ADC      //0000000000776AE0      //0000000000776AE4
//0000000000776AE8      //0000000000776AEC      //0000000000776AF0
//0000000000776AF4      //0000000000776AF8      //0000000000776AFC

#include <stdio.h>
#include <stdlib.h>
/*函数声明* /
void Spiral_fun(int maxf, int minf, int **af, int *pnum);
void Spiral_matrix(int **a, int n);
void print(int **a, int n);

/*函数功能：完成半圈的旋转赋值，作为螺旋矩阵生成函数的子函数*/
/*函数参数：maxf:该圈最大行列号（右下角）（方针行列号相等）*/
/*          minf:该圈起始行列号（左上角）（方针行列号相等）*/
/*          **af:二级指针，传递？ */
/*          *pnum:指针指向该圈起始元素值 * /
void Spiral_fun(int maxf, int minf, int **af, int *pnum)
{
    int row = minf, col = minf;
    if ((row == minf) && (col == minf))  //上边
    {
        for (col = minf; col <= maxf; col++)  //为什么不能<  而是<=
        {
            *(*(af + row - 1) + col - 1) =  *pnum;
            (*pnum)++;  //两个语句其实可以合并
        }
        row++;
        col--;

    }

    if ((col == maxf) && (row ==minf + 1))  //右边
    {
        for (row = minf + 1; row <= maxf; row++)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
        row--;
        col--;
    }

    if ((col == maxf - 1) && (row == maxf))   //下边
    {
        for (col = maxf - 1; col >= minf; col--)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
        row--;
        col++;
    }

    if ((col == minf) && (row == maxf - 1)) //左边
    {
        for (row = maxf - 1; row > minf; row--)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
    }
}

/*函数功能：生成题中形式的螺旋矩阵*/
/*参数：a为二级指针形参，n为矩阵阶数（分奇偶两种情况）* /
void Spiral_matrix(int **a, int n)   //采用二级指针传递指针数组
{
    int i, num = 1;
    int max = n;
    int min = 1;
    int *pnum = &num;

    if ((n > 0) && (n % 2 == 0))  //偶数阶情况
    {
        for(i = 1; i <= n / 2; i++) //进行单圈循环赋值，由内环到外环
        {
            Spiral_fun(max, min, a, pnum);//调用单圈累加赋值函数
            if ((max >= (n / 2) && (min <= (n / 2))))
            {
                max--;
                min++;  //调整环的行列范围
            }
        }
    }

    if ((n > 0) && (n % 2 == 1))  // 奇数阶情况
    {
        for (i = 1; i <= n / 2 + 1; i++)
        {
            Spiral_fun(max, min, a, pnum);
            if ((max >= (n / 2) && (min <= (n /2))))
            {
                max--;
                min++;
            }
        }
    }

}

/*函数功能：任意阶方阵显示 */
/*参数：a为指向所显示的方阵的二级指针,n为阶数 * /
void print(int **a, int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        printf("//");
        for (j = 0; j < n; j++)
        {
            printf("%-4d", *(*(a + i) + j));//借助二级指针输出数组元素
        }
        printf("\n");
    }
}

int main()
{
    int **p;
    int i, j;
    int m;

    printf("//input jie:");
    scanf("%d", &m);

    p = (int **)malloc(sizeof(int *) * m);
    for (i = 0; i < m; i++)
    {
        p[i] = (int *)malloc(sizeof(int) * m);
    }
    Spiral_matrix(p, m);
    printf("//the spiral matrix is:\n");
    print(p, m); //调用方针显示函数
    free(p);
    return 0;
}
//input jie:7
//the spiral matrix is:
//1   2   3   4   5   6   7
//24  25  26  27  28  29  8
//23  40  41  42  43  30  9
//22  39  48  49  44  31  10
//21  38  47  46  45  32  11
//20  37  36  35  34  33  12
//19  18  17  16  15  14  13

编辑时回到目录

浏览时回到目录

>小游戏？

一个简陋的小球到处跑的东东
#include <stdio.h>
#include <stdlib.h>
#include <windows.h>

int main()
{
    int i, j;
    int x = 0;
    int y = 5;

    int velocity_x = 1;
    int velocity_y = 1;
    int left = 0;
    int right = 20;
    int top = 0;
    int bottom = 10;

    while (1)
    {
        x = x + velocity_x;
        y = y + velocity_y;

        system("cls");

        for (i = 0; i < x; i++)
        {
            printf("\n");
        }
        for (j = 0; j < y; j++)
        {
            printf(" ");
        }
        printf("o");
        printf("\n");
        Sleep(50);

        if ((x == top) || (x == bottom))
        {
            velocity_x = -velocity_x;
        }
        if ((y == left) || (y == right))
        {
            velocity_y = -velocity_y;
        }
    }
    return 0;
}

//飞机小游戏
#include <stdio.h>
#include <stdlib.h>
#include <conio.h>

int main()
{
    int i, j;
    int x = 5;
    int y = 10;
    char input;
    int isFire = 0;

    int ny = 5;
    int isKilled = 0;

    while (1)
    {
        system("cls");
        if (!isKilled)
        {
            for (j = 0; j < ny; j++)
            {
                printf(" ");
            }
            printf("+\n");
        }

        if (isFire == 0)
        {
            for (i = 0; i < x; i++)
            {
                printf("\n");

            }
        }
        else
        {
            for (i = 0; i < x; i++)
                {
                    printf(" ");
                }
                printf(" |\n");

            if ( y + 2 == ny)
            {
                isKilled = 1;
            }
            isFire = 0;
          }

        for (j = 0; j < y; j++)
        {
            printf(" ");

        }
        printf(" *\n");
        for (j = 0; j < y; j++)
        {
            printf(" ");
        }
        printf("*****\n");
        for (j = 0; j < y; j++)
        {
            printf(" ");
        }
        printf(" * * \n");

        if (kbhit())
        {
            input = getch();
            if (input == 'a')
            {
                y--;
            }
            if (input == 'd')
            {
                y++;
            }
            if (input == 'w')
            {
                x--;

            }
            if (input == 's')
            {
                x++;
            }
            if (input == ' ')
            {
                isFire = 1;
            }

        }
    }
    return 0;
}

编辑时回到目录

浏览时回到目录

>数组

  • 超出输出乱码
#include <stdio.h>
int main()
{
    int a[1] = {1}, i;
    for (i = 0; i < 10; i++)
    {
        printf("%d\t", a[i]);
    }
}
//1       1       10752944        0       4199367 0       0       0       63      0

#include <stdio.h>
int main()
{
    int data1[5] = {1, 2, 3, 4, 5};//123450000000000000000
    int data2[5] = {1, 2, 3};    //1230000000000000
    int data3[5] = {1, 2, 3, 4, 5, 6, 7, 8};//123450000000

    int data4[] = {1, 2, 3};   //123123123123123
    int data5[] = {1, 2, 3, 4, 5};  //123451234512345
    int data6[] = {};   //和紧邻的上一个相同

    int data7[5] = {};//000000000000

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data1[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data2[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data3[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data4[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data5[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data6[i]);
    }
    printf("\n");

    for (int i = 0; i <= 5; i++)
    {
        printf("%d", data7[i]);
    }
    printf("\n");





     for (int i = 0; i <= 4; i++)
    {
        printf("%d", data1[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data2[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data3[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data4[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data5[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data6[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data7[i]);
    }
    printf("\n");
}
//123450
//123000
//123450
//123123
//123451
//123451
//000000

//123450
//123000
//123450
//123123
//123451
//123451
//000000
//12345
//12300
//12345
//12312
//12345
//12345
//00000


//123450
//123000
//123450
//123123
//123451
//123123
//000000
//12345
//12300
//12345
//12312
//12345
//12312
//00000
#include <stdio.h>
int main()
{
    int data1[5] = {1, 2, 3, 4, 5};//123450000000000000000
    int data2[5] = {1, 2, 3};    //1230000000000000
    int data3[5] = {1, 2, 3, 4, 5, 6, 7, 8};//123450000000

    int data4[] = {1, 2, 3};   //123123123123123
    int data5[] = {1, 2, 3, 4, 5};  //123451234512345
    int data6[] = {};   //和紧邻的上一个相同

    int data7[5] = {};//000000000000

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data1[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data2[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data3[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data4[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data5[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data6[i]);
    }
    printf("\n");

    for (int i = 0; i <= 20; i++)
    {
        printf("%d\t", data7[i]);
    }
    printf("\n");





     for (int i = 0; i <= 4; i++)
    {
        printf("%d", data1[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data2[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data3[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data4[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data5[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data6[i]);
    }
    printf("\n");

    for (int i = 0; i <= 4; i++)
    {
        printf("%d", data7[i]);
    }
    printf("\n");
}
/*

 #include <stdio.h>
int main()
{
   // int a[] = {};                     //0       16      2       660368  0       4199367 0       0
   // int b[20] = {1,2,3,4,5};           //1       2       3       4       5       0       6       8
    int c[] = {1,2,3};                     //1       2       3       4       5       5       8       8
    for (int i = 0; i < 20; i++)
    {
        printf("%d\t", a[i]);
    }
    printf("\n");
	for (int i = 0; i < 20; i++)
    {
        printf("%d\t", b[i]);
    }
    printf("\n");
	for (int i = 0; i < 20; i++)
    {
        printf("%d\t", c[i]);
    }
	printf("\n");
	return 0;
}
*/
  • 矩阵转置
//编写程序，用指针形式访问数组元素，实现矩阵转置功能。
#include <stdio.h>
#define N1 3
#define N2 4
void convert(int (*)[], int (*)[], int , int );

int main()
{
    int arr1[N1][N2] =
    {
        {1, 2, 3, 4},
        {5, 6, 7, 8},
        {9, 10, 11, 12}
    };
    int arr2[N2][N1];
    int (*p)[N2], (*pt)[N1];
    int i, j;
    p = arr1;
    pt = arr2;
    convert(p, pt, N1, N2);
    printf("//the new array is:\n");   //采用指针方法输出
    for (i = 0; i < N2; i++)
    {
        printf("//");
        for (j = 0; j < N1; j++)
        {
            printf("%-4d", *(*(pt + i) +j));
        }
        printf("\n");
    }

    printf("//the new array is:\n");         //采用数组方法输出
    for (i = 0; i < N2; i++)
    {
        printf("//");
        for (j = 0; j < N1; j++)
        {
            printf("%-4d", arr2[i][j]);
        }
        printf("\n");
    }
}

//转置函数 convert()
//指针数组a 和 at指向转置前后的矩阵
//row 和 rol 为转置之前矩阵的行列值
void convert(int (*a)[N2], int (*at)[N1], int row, int col)
{
    int i, j;
    for (i = 0; i < row; i++)
    {
        for (j = 0; j < col; j++)
        {
            *(*(at + j) + i) = *(*(a + i) + j);
        }
    }
}
  • 矩阵乘法及数组初始化
//计算两个矩阵的乘积
#include <stdio.h>

int main()
{
    int valueA[3][4] = {0};//int valueA[3][4];
    int valueB[4][5] = {0};//int valueB[4][5];
    int i, j, k;
    int a, b, c, d, e, f;
    int valueC[3][5] = {{0}};

    printf("input A: \n");
    for (a = 0; a < 3; a++) //for (i = 0; i < 3; i++)
    {
        for (b = 0; b < 4; b++)//for (j = 0; j < 4; j++)
        {
            scanf("%d", &valueA[a][b]);//scanf("%d", &valueA[i][j]);  //scanf("%d", &a[i][j]);//C:\Users\Administrator\Desktop\lidididi\lidididi.c|3879|error: 'a' undeclared (first use in this function)|
        }
        getchar();
    }

    printf("input B: \n");
    for (c = 0; c < 4; c++)//for (i = 0; i < 4; i++)
    {
        for (d = 0; d < 5; d++)//for (j = 0; j < 5; j++)
        {
           scanf("%d", &valueB[c][d]);//scanf("%d", &valueB[i][j]); //scanf("%d", &a[i][j]);
        }
        getchar();
    }

    for (i = 0; i < 3; i++)
    {
        for (j = 0; j < 5; j++)
        {
            for (k = 0; k < 4; k++)
            {
                valueC[i][j] += valueA[i][k] * valueB[k][j];//valueC[i][j] += valueA[i][k] + valueB[k][j];
            }
        }
    }

    printf("valueC is :\n");
    for (e = 0; e < 3; e++)//for (i = 0; i < 3; i++)
    {

        for (f = 0; f < 5; f++)//for (j = 0; j < 5; j++)
        {
            printf("%4d", valueC[e][f]);//printf("%4d", valueC[i][j]);//printf("%d", valueC[i][j]);
        }
        printf("\n");
    }


}
//input A:
//2 3 -5 0
//12 -1 27 8
//91 22 -32 1
//input B:
//25 13 65 0 5
//-2 0 18 10 45
//53 33 3 9 0
//7 61 26 -37 -1
//83107112-1849
//1291531582895
//16518919464131


//input A:
//2 3 -5 0
//12 -1 27 8
//91 22 -32 1
//input B:
//25 13 65 0 5
//-2 0 18 10 45
//53 33 3 9 0
//7 61 26 -37 -1
//valueC is :
//  83 107 112 -18  49
// 129 153 158  28  95
// 165 189 194  64 131

//input A:
//2 3 -5 0
//12 -1 27 8
//91 22 -32 1
//input B:
//25 13 65 0 5
//-2 0 18 10 45
//53 33 3 9 0
//7 61 26 -37 -1
//valueC is :
//  83 107 112 -18  49
// 129 153 158  28  95
// 165 189 194  64 131


//input A:
//2 3 -5 0
//12 -1 27 8
//91 22 -32 1
//valueA is :
//   2   3  -5   0
//  12  -1  27   8
//  91  22 -32   1
//input B:
//25 13 65 0 5
//-2 0 18 10 45
//53 33 3 9 0
//7 61 26 -37 -1
//valueB is :
//   0   0   0   0   0
//   0   0   0   0   0
//   0   0   0   0   0
//   0  25  13  65   0
//valueC is :
//  83 107 112 -18  49
// 129 153 158  28  95
// 165 189 194  64 131

//input A:
//2 3 -5 0
//12 -1 27 8
//91 22 -32 1
//input B:
//25 13 65 0 5
//-2 0 18 10 45
//53 33 3 9 0
//7 61 26 -37 -1
//valueC is :
//-221-139 169 -15 145
//178915351051 -63   7
// 542 1886241-1051444
//数组初始化！！！



//网上 矩阵乘法
#include <stdio.h>
#define M 3
#define N 5
#define K 4

int main()
{
    int A[M][K];//四int A[M][K] = {0};//三后int A[M][K];
    int B[K][N];//四int B[K][N] = {0};//三后int B[K][N];
    int C[M][N];//四int C[M][N] = {0};//三后int C[M][N];
    int i, j, m;

    printf("input A:\n");
    for (i = 0; i < M; i++)
    {
        printf("the row %d\n", i + 1);
        for (j = 0; j < K; j++)
        {
            scanf("%d", &A[i][j]);
        }
    }

    printf("input B:\n");
    for (i = 0; i < K; i++)
    {
        printf("the row %d\n", i + 1);
        for (j = 0; j < N; j++)
        {
            scanf("%d", &B[i][j]);
        }
    }

    printf("C is:\n");
    for (i = 0; i < M; i++)
    {
        for (j = 0 ; j < N; j++)
        {

            for (m = 0; m < K; m++)
            {
                C[i][j] += A[i][m] * B[m][j];//三后C[i][j] += A[i][m] + B[m][j];
            }
        }
    }

    for (i = 0; i < M; i++)//一后 for (i = 0; j < M; i++)
    {
        for (j = 0; j < N; j++)
        {
            printf("%5d", C[i][j]);// 二后printf("%3d", C[i][j]);
        }
        printf("\n");
    }

    return 0;
}
//input A:
//the row 0
//2 3 -5 0
//the row 1
//12 -1 27 8
//the row 2
//91 22 -32 1
//input B:
//the row 025 13 65 0 5
//the row 1-2 0 18 10 45
//the row 253 33 3 9 0
//the row 37 61 26 -37 -1
//C is:

//input A:
//the row 1
//2 3 -5 0
//the row 2
//12 -1 27 8
//the row 3
//91 22 -32 1
//input B:
//the row 1
//25 13 65 0 5
//the row 2
//-2 0 18 10 45
//the row 3
//53 33 3 9 0
//the row 4
//7 61 26 -37 -1
//C is:
//127190271077878864-184223057
//12926850116215812715892 95
//943827755329524206506 64131


//input A:
//the row 1
//1 1 1 1
//the row 2
//1 1 1 1
//the row 3
//1 1 1 1
//input B:
//the row 1
// 2 2 2 2 2
//the row 2
//2 2 2 2 2
//the row 3
//2 2 2 2 2
//the row 4
//2 2 2 2 2
//C is:
//1512300   127157868   124223020
//   12268501021   121509220   12
//943827602327754206324   12   12


//input A:
//the row 1
//1 1 1 1
//the row 2
//1 1 1 1
//the row 3
//1 1 1 1
//input B:
//the row 1
//2 2 2 2 2
//the row 2
//2 2 2 2 2
//the row 3
//2 2 2 2 2
//the row 4
//2 2 2 2 2
//C is:
//    8    8    8    8    8
//    8    8    8    8    8
//    8    8    8    8    8


//input A:
//the row 1
//1 1 1 1
//the row 2
//1 1 1 1
//the row 3
//1 1 1 1
//input B:
//the row 1
//2 2 2 2 2
//the row 2
// 2 2 2 2 2
//the row 3
//2 2 2 2 2
//the row 4
//2 2 2 2 2
//C is:
//12587880    87813224    84223016
//    8268501017    812584800    8
//943827598327714206320    8    8
//数组输入元素之前需初始化！！


#include <stdio.h>
int main()
{
    int data[2][3], *pdata[2];
    int i, j;

    for (i = 0; i < 2; i++)
    {
        pdata[i] = data[i];
    }
    //数组未初始化？？可行吗？
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            data[i][j] = (i + 1) * (j + 1);
        }
    }

    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            printf("//data[%d][%d]:%-2d\n", i, j, *(pdata[i] + j));
        }
    }
    printf("\n");
    for (i = 0; i < 2; i++)
    {
        for (j = 0; j < 3; j++)
        {
            printf("//data[%d][%d]:%d\n", i, j, *pdata[i]);
            pdata[i]++;
        }
    }

    return 0;
}
//data[0][0]:1
//data[0][1]:2
//data[0][2]:3
//data[1][0]:2
//data[1][1]:4
//data[1][2]:6

//data[0][0]:1
//data[0][1]:2
//data[0][2]:3
//data[1][0]:2
//data[1][1]:4
//data[1][2]:6

编辑时回到目录

浏览时回到目录

排序

//选择排序法
#include <stdio.h>
#define N 10

int main()
{
    int i, j;
    int a[N], t;

    printf("input the array(10):\n");
    for (i = 0; i < N; i++)           //输入数组啊中的元素
    {
        scanf("%d", &a[i]);
    }

    for (i = 0; i < N - 1; i++)        //进行N-1次排序
    {
        for (j = i + 1; j < N; j++)// for (j = 1; j < N; j++)         //对剩下的进行搜索
        {
            if (a[i] > a[j])
            {
                t = a[i];
                a[i] = a[j];
                a[j] = t;

            }
        }

    }

    for (i = 0; i < N; i++)
    {
        printf("%4d", a[i]);
    }
    return 0;
}

#include <stdio.h>
#define N 10

int main()
{
    int i, j, k;
    int a[N], t;

    printf("input the array: \n");  //输入数组元素
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }

    for (i = 0; i < N - 1; i++)  //进行N - 1次搜索
    {
        j = i;         //记录最小值下标

        for (k = i + 1; k < N; k++)      //将搜索了i次后，剩下的元素进行搜索， 记录最小值的下标
        {
            if (a[k] < a[j])
            {
                j = k;
            }

        }
        if (j != 1)
        {
            t = a[j];
            a[j] = a[i];
            a[i] = t;
        }
    }

    for (i = 0; i < 10; i++)
    {
        printf("%d\t", a[i]);
    }

    return 0;
}

//冒泡排序法
#include <stdio.h>
#define N 10

int main()
{
    int i, j;
    int a[N], t;

    printf("input the array(10): \n");
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }

    for (i = 0; i < N - 1; i++)
    {
        for (j = 0; j < N - 1 - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }

    for(i = 0; i < N; i++)
    {
        printf("%d\t", a[i]);

    }
    return 0;
}
//input the array(10):
//4 7 9 23 78 33 40 12 0 2
//0       2       4       7       9       12      23      33      40      78

#include <stdio.h>
#define N 10
void BubSort(int a[], int n);

int main()
{
    int a[N];
    int i;

    printf("input the array(10):\n");
    for (i = 0; i < N; i++)
    {
        scanf("%d", &a[i]);
    }

    BubSort(a, N);

    for (i = 0; i < N; i++)
    {
        printf("%4d", a[i]);//printf("%d", a[i]);
    }

    return 0;
}

void BubSort(int a[], int n)
{
    int i, j, t;

    for (i = 0; i < N; i++)
    {
        for (j = 0; j  < N - 1 - i; j++)
        {
            if (a[j] > a[j + 1])
            {
                t = a[j];
                a[j] = a[j + 1];
                a[j + 1] = t;
            }
        }
    }
}

编辑时回到目录

浏览时回到目录

>指针

  • data[i][j] == *(data[i] + j) == *(pdata[i] + j) == pdata[i][j]
a = &a[0] ;
a + i = &a[i];
[] = *;
a[0] = *a ;
a[i] = *(a + i);  
a[][] = **a;
a[i][j] = *(*(a + i) + j);
a[0][i] = *(*a + i) = (*a)[i];
a[i][0] = *(*(a + i)) = *a[i]; 

int a[m][n]; a[i][j] = a[0][i * n + j];
  • 不能用auto型变量的地址初始化内部的static型指针
#include <stdio.h>
#define N 10 //第四次输出成功后修改
/*函数声明* /
void Spiral_fun(int maxf, int minf, int **af, int *pnum);
void Spiral_matrix(int **a, int n);
void print(int **a, int n);

/*函数功能：完成半圈的旋转赋值，作为螺旋矩阵生成函数的子函数*/
/*函数参数：maxf:该圈最大行列号（右下角）（方针行列号相等）*/
/*          minf:该圈起始行列号（左上角）（方针行列号相等）*/
/*          **af:二级指针，传递？ */
/*          *pnum:指针指向该圈起始元素值 * /
void Spiral_fun(int maxf, int minf, int **af, int *pnum)
{
    int row = minf, col = minf;//第二次输出错误后修改 col = maxf;
    if ((row == minf) && (col == minf))  //上边
    {
        for (col = minf; col <= maxf; col++)  //为什么不能<  而是<=
        {
            *(*(af + row - 1) + col - 1) =  *pnum;
            (*pnum)++;  //两个语句其实可以合并
        }
        row++;
        col--;

    }

    if ((col == maxf) && (row ==minf + 1))  //右边
    {
        for (row = minf + 1; row <= maxf; row++)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
        row--;
        col--;
    }

    if ((col == maxf - 1) && (row == maxf))   //下边
    {
        for (col = maxf - 1; col >= minf; col--)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
        row--;
        col++;
    }

    if ((col == minf) && (row == maxf - 1)) //左边
    {
        for (row = maxf - 1; row > minf; row--)
        {
            *(*(af + row - 1) + col - 1) = *pnum;
            (*pnum)++;
        }
    }
}

/*函数功能：生成题中形式的螺旋矩阵*/
/*参数：a为二级指针形参，n为矩阵阶数（分奇偶两种情况）* /
void Spiral_matrix(int **a, int n)   //采用二级指针传递指针数组
{
    int i, num = 1;
    int max = n;
    int min = 1;
    int *pnum = &num;

    if ((n > 0) && (n % 2 == 0))  //偶数阶情况
    {
        for(i = 1; i <= n / 2; i++) //第三次输出后修改for (i = 1; i <= 2/ n; i++)  //进行单圈循环赋值，由内环到外环
        {
            Spiral_fun(max, min, a, pnum);//调用单圈累加赋值函数
            if ((max >= (n / 2) && (min <= (n / 2))))
            {
                max--;
                min++;  //调整环的行列范围
            }
        }
    }

    if ((n > 0) && (n % 2 == 1))  // 奇数阶情况
    {
        for (i = 1; i <= n / 2 + 1; i++)
        {
            Spiral_fun(max, min, a, pnum);
            if ((max >= (n / 2) && (min <= (n /2))))
            {
                max--;
                min++;
            }
        }
    }

}

/*函数功能：任意阶方阵显示 */
/*参数：a为指向所显示的方阵的二级指针,n为阶数 * /
void print(int **a, int n)
{
    int i, j;
    for (i = 0; i < n; i++)
    {
        printf("//");
        for (j = 0; j < n; j++)
        {
            printf("%-4d", *(*(a + i) + j));//借助二级指针输出数组元素
        }
        printf("\n");
    }
}

int main()
{
    int i;
    int arr[N][N];  //第四次输出成功后修改 int arr[6][6];   //存储六阶螺旋矩阵
    int *p[N];  //第四次输出成功后修改int *p[6];      //定义指针数组指向矩阵

    for (i = 0; i < N; i++) //第四次输出成功后修改  for (i = 0; i < 6; i++)
    {
        p[i] = arr[i];      //指针数组存放数组arr每行的首地址
    }

    Spiral_matrix(p, N); //第四次输出成功后修改  Spiral_matrix(p, 6);
    printf("//the spiral matrix is:\n");
    print(p, N); //第四次输出成功后修改  print(p, 6);//printf(p, 6);  //调用方针显示函数  //第一次输出后warning修改 C:\Users\Administrator\Desktop\lidididi\lidididi.c|6488|warning: passing argument 1 of 'printf' from incompatible pointer type [-Wincompatible-pointer-types]|
    return 0;
}
//     //the spiral matrix is:
//     €齛


//the spiral matrix is:
//42067600   0   0   41997440
//8   0   0   0   2685010090
//16402880   943827590327638   0
//0   0   42008160   16  0
//0   0   0   0   8   0
//41997050   8   0   63  0

//the spiral matrix is:
//42067600   0   0   41997440
//8   0   0   0   2685010090
//80628160   943827590327638   0
//0   0   42008160   16  0
//0   0   0   0   8   0
//41997050   8   0   63  0

//the spiral matrix is:
//1   2   3   4   5   6
//20  21  22  23  24  7
//19  32  33  34  25  8
//18  31  36  35  26  9
//17  30  29  28  27  10
//16  15  14  13  12  11

编辑时回到目录

浏览时回到目录

>我也不知道是啥

//一个班3个学生， 他们各学4门功课，编程实现分别显示每个学生有几门课程是优秀的（90分以上为优秀）以及每个学生的成绩
#include <stdio.h>
void search(int (*p)[4], int n);

int main()
{
    int score[3][4] = {{93, 96, 44, 61}, {83, 87, 90, 45}, {48, 95, 26, 59}};
    search(score, 3);
    return 0;
}

void search(int (*p)[4], int n)
{
    int i, j, k, flag_f;

    for (i = 0; i < n; i++)
    {
        k = 0;
        flag_f = 0;
        do
        {
            for (j = k; j < 4; j++)
            {
                if (p[i][j] > 90)
                {
                    flag_f++;
                    break;
                }
            }
            k = j + 1;
        }while(j < 4);

        printf("No.%d has %d grade excellently, his score are:\n", i + 1, flag_f);//|warning: left-hand operand of comma expression has no effect [-Wunused-value]|
        for (j = 0; j < 4; j++)
        {
            printf("%-4d", p[i][j]);
        }
        printf("\n");
    }
}
//No.1 has 2 grade excellently, his score are:
//93  96  44  61
//No.2 has 0 grade excellently, his score are:
//83  87  90  45
//No.3 has 1 grade excellently, his score are:
//48  95  26  59
//?????????????????????k的结构、？？？？

#include <stdio.h>
void search(int (*p)[4], int n);

int main()
{
    int score[3][4] = {{93, 96, 44, 61}, {83, 87, 90, 45}, {48, 95, 26, 59}};
    search(score, 3);
    return 0;
}

void search(int (*p)[4], int n)
{
    int i, j, k, flag_f;

    for (i = 0; i < n; i++)
    {
        flag_f = 0;
        do
        {
            for (j = 0; j < 4; j++)
            {
                if (p[i][j] > 90)
                {
                    flag_f++;
                }
            }
        }while (j < 4);

        printf("No.%d has %d grade excellently, his score are:\n", i + 1, flag_f);//|warning: left-hand operand of comma expression has no effect [-Wunused-value]|
        for (j = 0; j < 4; j++)
        {
            printf("%-4d", p[i][j]);
        }
        printf("\n");
    }
}
//No.1 has 2 grade excellently, his score are:
//93  96  44  61
//No.2 has 0 grade excellently, his score are:
//83  87  90  45
//No.3 has 1 grade excellently, his score are:
//48  95  26  59

编辑时回到目录

浏览时回到目录

>字符串

 #include <stdio.h>
 int length(char *string);

 int main()
 {
     int m, i, j, x, y, p, q, o;
     char a[20];

     char b[20] = {'i', ' ', 'm', 'y', ' ', 'm', 'e', ' ', 'm', 'i', 'n', 'e', '\0'};

     char c[20] = "ldddddddddd";

     char d[] = "lddddddddddddddddddddddd";

     char e[] = "ld ld ld ld";

     char f[20];
     f[1] = 'i';
     f[2] = 'm';
     f[3] = 'e';
     f[4] = ' ';
     f[5] = 't';
     f[6] = '\0';

     char g[20];
     char h[20];

     printf("//输入a:");
     gets(a);   //输入字符串的函数 可以包括空格

     printf("//输入g:");
     scanf("%s", g);

     //printf("//输入e:");
     //scanf("%s", e);
     printf("//输入h:");
     scanf("%s", h);

     m = length(a);
     i = length(b);
     j = length(c);
     x = length(d);
     y = length(e);
     p = length(f);
     q = length(g);
     o = length(h);

     printf("//a /%s\n", a);
     printf("//b /%s\n", b);
     printf("//c /%s\n", c);
     printf("//d /%s\n", d);
     printf("//e /%s\n", e);
     printf("//f /%s\n", f);
     printf("//g /%s\n", g);
     printf("//h /%s\n", h);
     printf("//\n");

     printf("//the length of string a is %d\n", m);
     printf("//the length of string b is %d\n", i);
     printf("//the length of string c is %d\n", j);
     printf("//the length of string d is %d\n", x);
     printf("//the length of string e is %d\n", y);
     printf("//the length of string f is %d\n", p);
     printf("//the length of string g is %d\n", q);
     printf("//the length of string h is %d\n", o);



     return 0;
 }

 int length(char *string)   //形参也可写作字符数组形式char string[]
 {
     int i = 0;
     while (string[i] != '\0')    //统计字符个数，如果字符不等于‘\0’则循环
     {
         i++;                     //计数i加一
     }
     return (i);              //返回个数计数值
 }

//输入a:my name is king
//输入g:lalala
//输入e:la la la
//a /my name is king                 正常//利用gets()输入字符数组 可空格
//b /i my me mine                    正常//利用逐个元素指出其初值  可空格 定义长度 记得最后带\0
//c /ldddddddddd                     正常//利用字符串直接初始化  定义长度
//d /lddddddddddddddddddddddd        正常//利用字符串直接初始化  未定义长度
//e /la                            不正常//利用scanf()输入字符数组 不可空格
//f / ime t                          正常//错乱了 h与e  再来一次
//g /lalala
//h /                            //所以这是空的
//
//the length of string a is 15
//the length of string b is 12
//the length of string c is 11
//the length of string d is 24
//the length of string e is 2
//the length of string f is 6
//the length of string g is 6
//the length of string h is 1          //空的也有1长度



//输入a:my name is king
//输入g:lalala
//输入h:la la la
//a /my name is king                             正常//利用gets()输入字符数组 可空格
//b /i my me mine                                正常//利用逐个元素指出其初值  可空格 定义长度 记得最后带\0
//c /ldddddddddd                                 正常//利用字符串直接初始化  定义长度
//d /lddddddddddddddddddddddd                    正常//利用字符串直接初始化  未定义长度
//e /ld ld ld ld                                 正常//利用字符串直接初始化  带空格 未定义长度
//f / ime t                                      正常//利用逐个初始化  可空格 \0记得
//g /lalala                                      正常//利用scanf()输入字符数组  未带空格
//h /la                                        不正常//利用scanf()输入字符数组 不可空格
//
//the length of string a is 15
//the length of string b is 12
//the length of string c is 11
//the length of string d is 24
//the length of string e is 11
//the length of string f is 6
//the length of string g is 6
//the length of string h is 2

编辑时回到目录

浏览时回到目录

头文件

STDLIB.H 说明一些常用的子程序：转换子程序、搜索/ 排序子程序等。
FCNTL.H 定义在与open库子程序连接时的符号常量。
IO.H 包含低级I/O子程序的结构和说明。
其它的如下：
ALLOC.H 说明内存管理函数(分配、释放等)。
ASSERT.H 定义 assert调试宏。
BIOS.H 说明调用IBM—PC ROM BIOS子程序的各个函数。（见 bios.h 部分）
CONIO.H 说明调用DOS控制台I/O子程序的各个函数。
CTYPE.H 包含有关字符分类及转换的名类信息(如 isalpha和toascii等)。
DIR.H 包含有关目录和路径的结构、宏定义和函数。
DOS.H 定义和说明MSDOS和8086调用的一些常量和函数。
ERRON.H 定义错误代码的助记符。
FCNTL.H 定义在与open库子程序连接时的符号常量。
FLOAT.H 包含有关浮点运算的一些参数和函数。
GRAPHICS.H 说明有关图形功能的各个函数，图形错误代码的常量定义，正对不同驱动程序的各种颜色值，及函数用到的一些特殊结构。
IO.H 包含低级I/O子程序的结构和说明。
LIMIT.H 包含各环境参数、编译时间限制、数的范围等信息。
MATH.H 说明数学运算函数，还定了 HUGE VAL 宏， 说明了matherr和matherr子程序用到的特殊结构。
MEM.H 说明一些内存操作函数(其中大多数也在STRING.H 中说明)。
PROCESS.H 说明进程管理的各个函数，spawn…和EXEC …函数的结构说明。
SETJMP.H 定义longjmp和setjmp函数用到的jmp buf类型， 说明这两个函数。
SHARE.H 定义文件共享函数的参数。
SIGNAL.H 定义SIG[ZZ(Z] [ZZ)]IGN和SIG[ZZ(Z] [ZZ)]DFL常量，说明rajse和signal两个函数。
STDARG.H 定义读函数参数表的宏。(如vprintf,vscarf函数)。
STDDEF.H 定义一些公共数据类型和宏。
STDIO.H 定义Kernighan和Ritchie在Unix System V 中定义的标准和扩展的类型和宏。还定义标准I/O 预定义流：stdin,stdout和stderr，说明 I/O流子程序。STRING.H 说明一些串操作和内存操作函数。
SYS\STAT.H 定义在打开和创建文件时用到的一些符号常量。
SYS\TYPES.H 说明ftime函数和timeb结构。
SYS\TIME.H 定义时间的类型time[ZZ(Z] [ZZ)]t。
TIME.H 定义时间转换子程序asctime、localtime和gmtime的结构，ctime、 difftime、 gmtime、 localtime和stime用到的类型，并提供这些函数的原型。(见 随机数 部分)
VALUE.H 定义一些重要常量， 包括依赖于机器硬件的和为与Unix System V相兼容而说明的一些常量，包括浮点和双精度值的范围。

编辑时回到目录

浏览时回到目录

conio.h

相关 先放这
#include <stdio.h>
#include <conio.h>

int main()
{
    int input;
    printf("请输入a/b/c/d : \n");
    int flag = 1;
    while (flag)
    {
        input = 0;
        if (kbhit())
        {
            input = getch();
        }
        switch(input)
        {
        case 'a':
            printf("您输入的是a : %c \n", input);
            break;
        case 'b':
            printf("您输入的是b : %c \n", input);
            break;
        case 'c':
            printf("您输入的是c : %c \n", input);
            break;
        case 'd':
            printf("您输入的是d : %c \n", input);
            break;
        case 'f':
            printf("您输入的是f : %c \n", input);
            break;
        default:
            if (input)
            {
                printf("您输入的不正确 : %d \n", input);

            }
            break;
        }
    }
}
//请输入a/b/c/d :
//您输入的是d : d
//您输入的是c : c
//您输入的不正确 : 115
//您输入的是f : f
//您输入的是c : c
//您输入的是a : a
//您输入的是b : b
//您输入的是f : f
//您输入的不正确 : 103
//您输入的不正确 : 13 //回车
//您输入的不正确 : 13
//您输入的不正确 : 13

编辑时回到目录

浏览时回到目录

v

编辑时回到目录

浏览时回到目录

木支牙鸟
关注
  • 1
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【C语言进阶】很诡异的编译报错expected declaration or statement at end of input
一个专注于嵌入式IoT领域的架构师，深耕IoT领域多年，深度掌握IoT领域的相关技术栈，包括但不限于RTOS内核的实现及其移植、硬件驱动移植开发、网络通讯协议开发、编译构建原理及其实现、底层汇编及编译原理、编译优化及代码重构、嵌入式IoT系统的架构设计等。
12-11 1万+
一个很诡异的编译报错，不仔细还真发现不了！
8分钟为你详解前端三大主流技术框架
小程序公社
05-29 5385
编辑搜图 请点击输入图片描述 当前世界中，技术发展非常迅速并且变化迅速，开发者需要更多的开发工具来解决不同的问题。本文就对于当下主流的前端开发技术React、Vue、Angular这三个框架做个相对详尽的探究，目的是为了解开这些前端技术的面纱，看看各自的庐山真面目。 1、React React是一个用于构建用户界面的JavaScript库。它由Facebook和一个由个人开发者和公司组成的社区来维护。 React可以作为开发单页或移动应用的基础。然而，React只关注向DOM渲染数据，因此创建..
error: expected declaration or statement at end of input
一夜知秋的博客
07-22 2万+
报警提示： error: expected declaration or statement at end of input 中文翻译：在输入的结尾处缺少应有的声明或语句 问题原因：缺少括号。 问题代码： #include <stdio.h> void show_pyramid(char c,int layer){ int i; int j; if(layer<1){ prin...
C语言错误：expected declaration or statement at end of input、编写函数求100万以内的素数
热门推荐
ZSWAries的博客
06-13 6万+
C语言错误：expected declaration or statement at end of input 可能错误： 某一个函数或者变量没有在使用之前声明。 某个地方少了个括号。（这种情况，编译器一般会在最后一行代码报错，但错误很可能不在最后一行，要靠自己去找出来，比如下面我那个程序就是提示最后一行，不提示我的自定义函数，我也就没去看自定义函数，后来看了看自定义函数，找出来了） 所提示句子中有些函数的头文件没有加上（比如你用了math.h函数库里的函数，比如pow、sqrt这种） 自己定义的函数名和
es6文档笔记(全)
奋斗到天明~
04-18 5960
一、let 和 const 命令 1.let 命令 基本用法 ES6 新增了let命令，用来声明变量。它的用法类似于var，但是所声明的变量，只在let命令所在的代码块内有效。 for循环的计数器，就很合适使用let命令。 另外，for循环还有一个特别之处，就是设置循环变量的那部分是一个父作用域，而循环体内部是一个单独的子作用域。 不存在变量提升 var命令会发生”变量提升“现象，即变量可以在声明...
Deep-C:C语言的深度学习库
05-18
Deep-C：C语言的深度学习库 Deep-C是C的开源深度学习库。它目前处于预Alpha阶段。 几年之内将会取得进展。 图书馆 感知器 激活 神经网络 mnist 等等。 安装Deep-C (not ready yet) 引文 Deep-C仍处于测试前阶段...
C标准库-中文.rar_C 标准库_C语言标准_c语言标准库_中文_语言库
07-14
c语言标准库，包含c语言标准库中的函数的介绍
C语言参考手册 C标准 (内含6个chm格式手册)
04-19
内含：C参考手册.chm(最全的一个) 、C函数查询.chm 、C语言库函数速查手册.chm 、C语言100例.chm、C语言标准库函数大全.chm、C语言库函数使用大全CHM版.chm、 这6个是我找了好久才找到的，各有各的好处，3个互补十分...
C语言编程规范 MISRA C 2012
12-31
主要是汽车电子行业c编程规范 MISRA C 2012 Addendum 1 - Rule Mapping
C语言头文件 STACK
06-13
C语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 STACKC语言头文件 ...
关于出现expected declaration or statement at end of input [solution.c]
qq_63624313的博客
07-27 720
关于出现expected declaration or statement at end of input [solution.c]
C++基础部分-学习笔记
CSDN爱好者的独到见解
03-20 1031
变量及基本类型 1.1 基本内置类型 1.1.1 算术类型 类型unsigned int可以缩写为unsigned， 在算术表达式中不要使用char或bool，只有在存放字符或布尔值时才使用它们。因为类型char在一些机器上是有符号的，而在另一些机器上又是无符号的，所以如果使用char进行运算特别容易出问题。如果你需要使用一个不大的整数，那么明确指定它的类型是signed char或者unsigned char。执行浮点数运算选用double，这是因为float通常精度不够而且双精度浮...
常用函数
weixin_43581646的博客
09-09 344
switch case 语句 switch case 语句判断一个变量与一系列值中某个值是否相等，每个值称为一个分支。 语法 switch case 语句语法格式如下： switch(expression){ case value : //语句 break; //可选 case value : //语句 break; //可选 //你可以有任意数量的case语句 default : //可选 //语句 }
[Error] expected declaration or statement at end of input
最新发布
Scacus_0的博客
03-20 780
检查后发现 因为前面注释了代码，把结束括号}也给注释了。ps：因为编译器报错一直都在最后一行，所以没太注意前面。
C/C++语言中的声明
linux驱动开发大纲
08-11 1374
一般的声明形式如下： 声明说明符+声明符列表 声明说明符：描述声明的变量或函数的性质。         声明说明符分为三大类：         1.存储类型：auto、static、extern、register。每次声明只能出现一个存储类型，并且放在声明语句的最前面。         2.类型限定符：const、volatile、（:C99restrict）。每次声明可以包含零个或多个...
angular 应为声明或语句_关于 Angular 动态组件你需要知道的
weixin_39743414的博客
10-24 343
原文链接：Here is what you need to know about dynamic components in Angular 原文作者：Max Koretskyi，aka Wizard 原技术博文由 Max Koretskyi 撰写发布，他目前于 ag-Grid 担任开发者职位。译者按：开发大使负责确保其所在的公司认真听取社区的声音并向社区传达他们的行动及目标，其作为社区和公司之...
嵌入的语句不能是声明或标记语句解决备忘
qq_32559539的博客
11-01 5443
原代码如下： if (Input.GetKeyDown(KeyCode.Space)) GameObject bullet = Instantiate(bulletPrefab, mount.position, transform.rotation) as GameObject; 报错：嵌入的语句不能是声明或标记语句 改为 if (Input.GetKeyDown(KeyCode.Space)) ...
声明语句
r8711274r的博客
07-09 1478
1.var var语句用来声明一个或多个变量，语法如下： var name_1[=value_1][,...,name_n[=value_n]] 关键字var之后跟随的是要声明的变量列表，列表中的每一个变量都可以带有初始化表达式，用于指定它的初始值，例如： var i; //一个简单的变量 var j=1; //一个带有初始值的变量 var a,b; //两个变量 var x=...
Head First C：英文版C语言编程入门指南
"Head First C（英文版） 是一本C语言的学习资料，以PDF形式提供，适合在学习C语言的同时提升英语阅读能力。" 《Head First C》是C语言学习的一本创新性教材，其英文版旨在帮助读者在掌握C语言编程技能的同时，提升...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值