Question: 求大佬指教

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

foo就当成一个变量，只不过这个变量接收的实参需要是一个相同类型的函数名，即该函数是：返回值是void，参数是void *的函数；  LPrint函数正好是这样的类型，既可以作为实参，在调用TraverseLQueue是，作为第一个参数传进去。  TraverseLQueue(xxx, LPrint); //这样调用，xxx是第一个参数，根据实际情况传入对应的参数；

(*foo)是函数指针，用函数名就可以了。LPrint 是打印的意思，打印输出函数。


Question: 运行错误73%求解！！！

#include<stdio.h> #include <ctype.h>  int main() {     char st[1000];     int digit[10],i,num,place;     while(scanf("%s",st)!=EOF)     {         for(i=0;i<10;i++)         {             digit[i]=0;         }         i=0;num=0;place=0;         while(st[i]!='\0')         {             /*             switch(st[i]-'0')             {                 case 0:a[0]=a[0]+1;break;                 case 1:a[1]=a[1]+1;break;                 case 2:a[2]=a[2]+1;break;                 case 3:a[3]=a[3]+1;break;                 case 4:a[4]=a[4]+1;break;                 case 5:a[5]=a[5]+1;break;                 case 6:a[6]=a[6]+1;break;                 case 7:a[7]=a[7]+1;break;                 case 8:a[8]=a[8]+1;break;                 case 9:a[9]=a[9]+1;break;             }             */             if (isdigit(st[i]))                 digit[st[i] -'0']++;             i++;         }         num = digit[0];         //for(i=0;i<10;i++)         for(i=1;i<10;i++)         {             //if(num>=a[i+1])             if(num < digit[i])             {                 num = digit[i];                 place = i;                 //num=num;                 //place=place;             }             /*             else             {                 num=a[i+1];                 place=i+1;             }             */         }         printf("%d\n",place);     }     return 0; } 供参考～  楼主的操作越界访问：  for(i=0;i<10;i++)         {             if(num>=a[i+1])    //i+1，当i=9时，i+1等于10，数组越界了             {num=num;place=place;}             else             {num=a[i+1];place=i+1;}         }

供参考：#include <stdio.h>  int main() {     char s;     int  a[10]={0},i,num=-1,place=-1;     while(scanf("%c",&s)!= EOF){   //Ctrl+Z 结束输入           switch (s){                      case  ' ':continue;                      case '\n':                                for(i=0;i<10;i++){                                    if(num < a[i]){                                       num = a[i];                                        place = i;                                    }                                }                                printf("%d\n",place);                                for(i=0;i<10;i++)a[i]=0;                                num=-1;                                  place=-1;                                break;                        default:a[s-'0']++;          }     }          return 0; }


Question: C语言把收到的十六进制数转成对应的10进制

引用 2 楼 赵4老师 的回复:#include <stdio.h> char buf[]={0x12,0x22,0x33,0x44,0x22,0xff,0x21,0x31,0x41,0x01,0x12,0x13,0x00,0x00,0x13,0x00,0x23, 0x01,0x00,0x00,0x00, 0x02,0x00,0x00,0x00, 0x03,0x00,0x00,0x00, 0x04,0x00,0x00,0x00, 0x05,0x00,0x00,0x00, 0x00,0x11,0x00,0x64,0x00,0x64,0x00,0x64,0x00,0x64,0x02,0x00,0x00,0x00,0x01,0x00,0xc1,0x2d,0x23,0xdb,0xa9,0x12}; int a,b,c,d,e; int main() {     a=*(int *)(&buf[17   ]);     b=*(int *)(&buf[17+ 4]);     c=*(int *)(&buf[17+ 8]);     d=*(int *)(&buf[17+12]);     e=*(int *)(&buf[17+16]);     printf("a,b,c,d,e:%d,%d,%d,%d,%d\n",a,b,c,d,e);     return 0; } //a,b,c,d,e:1,2,3,4,5 // 赵4老师就是这么棒，给了个思路，感谢。不对，这是把代码都给我了。哈哈哈哈

了解一下这两个函数：       long int strtol(const char *nptr, char **endptr, int base);         long long int strtoll(const char *nptr, char **endptr, int base);

#include <stdio.h> char buf[]={0x12,0x22,0x33,0x44,0x22,0xff,0x21,0x31,0x41,0x01,0x12,0x13,0x00,0x00,0x13,0x00,0x23, 0x00,0x00,0x00,0x01, 0x00,0x00,0x00,0x02, 0x00,0x00,0x00,0x03, 0x00,0x00,0x00,0x04, 0x00,0x00,0x00,0x05, 0x00,0x11,0x00,0x64,0x00,0x64,0x00,0x64,0x00,0x64,0x02,0x00,0x00,0x00,0x01,0x00,0xc1,0x2d,0x23,0xdb,0xa9,0x12}; int a,b,c,d,e; char *p; int main() {     p=(char *)&a;for (int i=0;i<4;i++) p[i]=buf[17   +3-i];     p=(char *)&b;for (int i=0;i<4;i++) p[i]=buf[17+ 4+3-i];     p=(char *)&c;for (int i=0;i<4;i++) p[i]=buf[17+ 8+3-i];     p=(char *)&d;for (int i=0;i<4;i++) p[i]=buf[17+12+3-i];     p=(char *)&e;for (int i=0;i<4;i++) p[i]=buf[17+16+3-i];     printf("a,b,c,d,e:%d,%d,%d,%d,%d\n",a,b,c,d,e);     return 0; } //a,b,c,d,e:1,2,3,4,5 //

首先，十六进制和十进制，对于单片机来说，都是一堆的01，例如十六进制的 temp = 0x0a，如果你想作为十进制进行计算，不需要转，直接用就好了，即 temp + 10 ==> 0x0a+10 ==20；对于你说的标颜色的那部分，意思是说真实数据是32位的，那么你就需要将这四个字节按照大小端的模式，拼接成一个32位的数据就可以了


Question: 小白题目有大佬讲讲吗

弱弱的问一下 这些任务是在哪里找的啊

引用 3 楼 xiao_yan_1的回复:弱弱的问一下 这些任务是在哪里找的啊 导入了课程应该也有题目

你去传智播客，我这是老师布置的作业

引用 1 楼 user-3的回复:供参考：#define _CRT_SECURE_NO_WARNINGS #include<stdio.h> #include<stdlib.h>  int multiTable(int x) {     int i=0,j=0;     /*----------------------begin-----------------------*/       for(j=1;j<=x;j++){          for(i=1;i<=j;i++)              printf("%d*%d=%2d  ",i,j,i*j);          printf("\n");      }      /*----------------------end-------------------------*/ }  int main() {     int n=0;     printf("请输入乘法表需要打印的行数:");     /*-----------------------begin---------------------*/      scanf("%d",&n);     if(n<0) return -1;      /*-----------------------end-----------------------*/     multiTable(n);          return 0; } 谢谢大佬


Question: 为什么这个程序会生成LIB文件而不是exe

你建立工程的时候，是不是选择编译成静态库了？


Question: 求助！for循环改while循环

正像楼上几个朋友所说的，i++的位置应该在for循环之外。 请参考《C++中for循环语句简析》 希望能够帮到您！

for (A;B;C) D; //等价于 {  A;  while (1) {   if (!(B)) break;   D;   C;  } }

for(j=i+1;j<=n;j++)                  {                          if(factorsum(j)==i&&m==j){                         printf("%d<-->%d\n",i,j);}                         }                         i++;----------------这个放for循环外面吧                 }

每个数求因子太费时间了，好像也没有好办法，和for while 循环应该没什么关系，供参考：#include <stdio.h>  int factorsum(int x){     int a=2,sum=1;     while(a<=x/2){          if(x%a==0)             sum=sum+a;          a++;     }     return sum; }  int main(){     int n,i=2,m;     scanf("%d",&n);     while(i<=n) {           m=factorsum(i);           if(factorsum(m)==i && i<m)                  printf("%d<-->%d\n",i,m);           i++;     }     return 0； }


Question: 非对称的镜像处理

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

啥叫非对称镜像？


Question: C刚入门代码

修正楼上第8行，多了nprintf("请输入一个大于等于3的正整数："); 求1*2*3*4*5 ,还可以这么写： //求1*2*3*4*5 ：  #include<stdio.h> int main(){ 	int t =1; //乘数     int i =5; //被乘数 	while(t *= i,i--,i>0);     printf("%d",t); 	return 0; }

供参考：//给出一个大于或等于3的正整数，判断它是不是一个素数：  #include<stdio.h> int main(){      int prime(int x); 	int n,i; 	printf("请输入一个大于等于3的正整数：",n);     while(scanf("%d",&n) && n < 3){           printf("请重新输入大于等于3的正整数！\n");     } 	i = prime(n); 	if(i == 1){ 		printf("%d是素数\n",n); 	}else{ 		printf("%d不是素数\n",n); 	}          	return 0; }  int prime(int x){ 	int y; 	if(x <= 3) return x > 1;     for(y = 2;y < x-1;++y)         if(x % y == 0)             return 0;     return 1; }

不错啊


Question: 关于树的问题有一点不明白，想问一下各位大佬

你乱了吧，怎么答案说“后根遍历对应二叉树的中序遍历”你觉得对，后面你又觉得“后根遍历就是后续遍历”，那问题不就是后根遍历到底对应中序遍历还是对应后续遍历吗？这个问题你应该知道吧。。。

“先根遍历对应二叉树的先序遍历，后根遍历对应二叉树的中序遍历”这个是针对树跟对应的转换后的二叉树而说的，这点很关键 答案分析应该有问题，虽然先序跟中序能确定一棵二叉树，但这棵二叉树并不能唯一对应一棵树，因为树转二叉树是唯一的，反过来则不是 你理解的也有点儿问题，一棵树本来就是二叉树，但根据数转二叉树的规则转换后，并不是原来的二叉树（否则上面的规则就不对了） 这个题的答案应该是可以确定，严格证明要用归纳法，一般分析如下：之所以二叉树的先序遍历和后序遍历不能唯一确定一棵二叉树，是由于存在度为1的节点，也就是只有一个子节点，它在左在右对应的先序和后续遍历顺序一样但二叉树不一样，但是树没有左右的概念，只要是子节点确定了，那这个树就确定了，在左在右都是一棵树 大概就是这样吧


Question: python

希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10581430.html 希望对你有帮助：https://blog.csdn.net/it_xiangqiang/category_10768339.html

引用 3 楼 ctrigger的回复:“姓名”做key是不行的，如果同名怎么办？ 建议把“姓名”改成学号。保证key唯一。。 这是老师自己编的题 存在不足  感谢指正

student = {} ave = 0.0 for i in range(10):     name = input("请输入第%d个学生姓名："%(i+1))     val1,val2 = eval(input("请输入第%d个学生两门课程的成绩,用逗号分开："%(i+1)))     ave = (val1 + val2)/2     student[name] = ave  print(student)

引用 1 楼 user-4的回复:作业都不自己做 那我总得会做吧???服气了

作业都不自己做


Question: c语言输入两个数判断在第几象限

引用 1 楼 user-2的回复:scanf里的东西跟你输入的要完全一致（里面有逗号 你也得输入一个逗号） 你可以把x y的值输出看一下，看输入对了没 另外你这背景也太秀了吧，我瞎了 谢谢 解决了 果然是scanf的问题 背景确实有点花

谢谢 解决了 果然是scanf的问题 背景确实有点花😂


Question: 有没有关于MINGW里所有静态库的介绍？

学会使用man命令


Question: C语言关int和char并列的问题

不多做解释了，看图，其他改进以后看博客。从二进制起任意进制转十进制终极代码，求数组长度循环外，处理O(N)即可包含数据无效检查进制无效检查功能，免去求乘方循环。

而且O(N)即可无需那么多次循环，当然求长度的循环不计在内。

不但要检查字符还需检查进制

你这么歧视十六进制数字F，F知道么？

#include<stdio.h> #include<string.h> #include<math.h>  //void check(char *b[20]) void check(char b[20]) {     int n,i,flag=0;     n=strlen(b);     for( i=0;i<n;i++)//判断输入是否正确     {         if((b[i]>='0'&&b[i]<='9')||(b[i]>='A'&&b[i]<='E'))             flag++;         else         {printf("请检查，第%d个数开始有错误\n",i+1);             //return 0;             return;         }         if(flag==n)             printf("数字输入正确\n") ;     } } //int turn(char *c[20],int *cccc[20]) int turn(char c[20],int cccc[20]) {     int s=0,m,k, sum = 0;     while(c[s]!='\0')     {         if((c[s]>='A')&&c[s]<='Z')         {             cccc[s]=c[s]-'A'+10;             s++;             continue;         }         cccc[s]=c[s]-'0';         s++;     }     for(m=0;m<s;m++)         cccc[s-m-1]=cccc[s-m-1]*pow(16,m);     for(k=0;k<s;k++)         sum+=cccc[k];     printf("%d",sum); } int main() {     char a[20];     int m=0,n=0,h=0,aaaa[20];     gets(a);     turn(a,aaaa); } 供参考～  代码编译不通过，做了修改；试试，有问题再问吧


Question: 调度原理求最小化滞后时间算法实现


Question: 程序编译没问题，停止运行是为啥呀。。各位大神求教求教！！！

文件打开失败，会报错，所以//exit(0), 其他问题见注释，供参考：#include<stdlib.h> #include<stdio.h> #include <math.h> #include<malloc.h> #include<string.h>  #define R 61 #define S 61 #define N 195 #define dt 0.04 #define PI 3.141593  //void fft(double sr[61][195][61],double sx[61][195][61],int m0,int inv); void fft(float ***sr,float ***sx,int m0,int inv); float ***create_3_array(int m,int n,int t);  int main() {     int r,s,n,k,nfft;     float w,t;     float ***p,***p_re,***p_im;//***p0,***p0_re,***p0_im,***m,***m_re,***m_im;     FILE *fp1,*fp2;      p  = create_3_array(R,N,S);//(r,n,s);     p_re=create_3_array(R,N,S);//(r,n,s);     p_im=create_3_array(R,N,S);//(r,n,s);      //这些没用到     //p0=create_3_array(R,N,S);//(r,n,s);     //p0_re=create_3_array(R,N,S);//(r,n,s);     //p0_im=create_3_array(R,N,S);//(r,n,s);     //m=create_3_array(R,N,S);//(r,n,s);     //m_re=create_3_array(R,N,S);//(r,n,s);     //m_im=create_3_array(R,N,S);//(r,n,s);      /*读数据到p[][][]*/    fp1=fopen("shot_fullwave_new44_use-6_new_sun.dat", "rb");    if (fp1 == NULL)    {       printf("Open failed\n");       //exit(0);    }    else    for(r=0;r<=R; r++)//for(s=0;s<=S; s++)    {        for(n=0;n<=N;n++)//for(r=0;r<=R;r++)        {           for(s=0;s<=S; s++)//for(n=0;n<=N;n++)           {              fread(&p[r][n][s],sizeof(float),1,fp1);           }        }        putchar('\n');    }    fclose(fp1);     /*计算fft次数*/    k=log(N)/log(2);    if(N>pow(2,k))       k=k+1;    nfft=pow(2,k);    printf("nfft=%d k=%d\n",nfft,k);     /*为p_re、p_im赋初值*/    for(r=0;r<=R;r++)//for(s=0;s<=S; s++)    {        for(n=0;n<=N;n++)//for(r=0;r<=R;r++)        {            for(s=0;s<=S; s++)//for(n=0;n<=N;n++)            {                p_re[r][n][s]=p[r][n][s];                p_im[r][n][s]=0.0;            }        }    }              /*对p_re、p_im对时间维度做fft、ifft*/    fft(p_re,p_im,k,1);    fft(p_re,p_im,k,-1);             /*读入数据*/    fp2=fopen("output_m.dat","wb");    if(fp2==NULL)        printf("NULL2");    else    {        for(r=0;r<R;r++)//for(s=0;s<S;s++)        {            for(n=0;n<N;n++)//for(r=0;r<R;r++)            {                for(s=0;s<S;s++)//for(n=0;n<N;n++)                    fwrite(&p[r][n][s],sizeof(float),1,fp2);            }                    //这里保存的是  p[r][n][s]  ？？？？？        }     }     system("pause");     return 0; }   /*fft ifft*/ void fft(float ***sr,float ***sx,int m0,int inv) {     int r,s,i,j,lm,li,k,lmx,np,lix,mm2;     double t1,t2,c,f,cv,st,ct;     if(m0<0)        return;     lmx=1;     for(i=1;i<=m0-1;++i)//for(i=1;i<=m0;++i)数组越界         lmx+=lmx;     cv=2.0*PI/(double)lmx;     ct=cos(cv);     st=-inv*sin(cv);     np=lmx;     mm2=m0-2;     for(s=0;s<S;s++)     {         for(r=0;r<R;r++)         {             for(i=1;i<=mm2;++i)             {                 lix=lmx;                 lmx/=2;                 c=ct;                 f=st;                 for(li=0;li<np;li+=lix)                 {                    j=li;                    k=j+lmx;                    t1=sr[r][j][s]-sr[r][k][s];                    t2=sx[r][j][s]-sx[r][k][s];                    sr[r][j][s]+=sr[r][k][s];                    sx[r][j][s]+=sx[r][k][s];                    sr[r][k][s]=t1;                    sx[r][k][s]=t2;                    ++j;                    ++k;                    t1=sr[r][j][s]-sr[r][k][s];                    t2=sx[r][j][s]-sx[r][k][s];                    sr[r][j][s]+=sr[r][k][s];                    sx[r][j][s]+=sx[r][k][s];                    sr[r][k][s]=c*t1-f*t2;                    sx[r][k][s]=f*t1+c*t2;                 }                 for(lm=2;lm<lmx;++lm)                 {                     cv=c;                     c=ct*c-st*f;                     f=st*cv+ct*f;                     for(li=0;li<np;li+=lix)                     {                        j=li+lm;                        k=lmx+j;                        t1=sr[r][j][s]-sr[r][k][s];                        t2=sx[r][j][s]-sx[r][k][s];                        sr[r][j][s]+=sr[r][k][s];                        sx[r][j][s]+=sx[r][k][s];                        sr[r][k][s]=c*t1-f*t2;                        sx[r][k][s]=f*t1+c*t2;                       }                 }                 cv=ct;                 ct=2.0*ct*ct-1.0;                 st=2.0*st*cv;             }             if(m0>=2)               for(li=0;li<np;li+=4)               {                   j=li;                   k=j+2;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=t1;                   sx[r][k][s]=t2;                   ++j;                   ++k;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=inv*t2;                   sx[r][k][s]=-inv*t1;               }               for(li=0;li<np;li+=2)               {                   j=li;                   k=j+1;                   t1=sr[r][j][s]-sr[r][k][s];                   t2=sx[r][j][s]-sx[r][k][s];                   sr[r][j][s]+=sr[r][k][s];                   sx[r][j][s]+=sx[r][k][s];                   sr[r][k][s]=t1;                   sx[r][k][s]=t2;               }             lmx=np/2;             j=0;             for(i=1;i<np;++i)             {                 k=lmx;                 while(k<=j)                 {                    j-=k;                    k/=2;                 }                 j+=k;                 if(i<j)                 {                    t1=sr[r][j][s];                    sr[r][j][s]=sr[r][i][s];                    sr[r][i][s]=t1;                    t1=sx[r][i][s];                    sx[r][j][s]=sx[r][i][s];                    sx[r][i][s]=t1;                 }             }             if(inv!=-1)                  return;             t1=1.0/np;             for(i=0;i<np;++i)             {                 sr[r][i][s]*=t1;                sx[r][i][s]*=t1;             }         }     }  }  float ***create_3_array(int m,int n,int t) {    float***array=NULL;    int i,j;    array=(float***)malloc(sizeof(float**)*(m+1));    for(i=0;i<=m;i++)    {       array[i]=(float**)malloc(sizeof(float*)*(n+1));       for(j=0;j<=n;j++)           array[i][j]=(float*)malloc(sizeof(float)*(t+1));    }    return array; }

int main() {     int r,s,n,k,nfft;     float w,t;     float ***p,***p_re,***p_im,***p0,***p0_re,***p0_im,***m,***m_re,***m_im;     FILE *fp1,*fp2;     void fft(double sr[61][195][61],double sx[61][195][61],int m0,int inv);     float***create_3_array(int m,int n,int t);     p=create_3_array(r,n,s);     p_re=create_3_array(r,n,s);     p_im=create_3_array(r,n,s);     p0=create_3_array(r,n,s);     p0_re=create_3_array(r,n,s);     p0_im=create_3_array(r,n,s);     m=create_3_array(r,n,s);     m_re=create_3_array(r,n,s);     m_im=create_3_array(r,n,s);       /*读数据到p[][][]*/     //if (fp1=fopen("shot_fullwave_new44_use-6_new_sun.dat", "rb")==NULL)     if ((fp1=fopen("shot_fullwave_new44_use-6_new_sun.dat", "rb"))==NULL)     {         printf("Open failed\n");         exit(0);     }     //else     int i, j;     p = (float ***)malloc(sizeof(float **) * (S+1));     for (i = 0; i <= S; i++) {         p[i] = (float **)malloc(sizeof(float *) * (R+1));         for (j = 0; j <= R; j++) {             p[i][j] = (float *)malloc(sizeof(float) * N);         }     }     for(s=0;s<=S; s++)     {         for(r=0;r<=R;r++)         {             for(n=0;n<=N;n++)             {                 fread(&p[r][n][s],sizeof(float),1,fp1);             }         }         putchar('\n');     }     fclose(fp1);     /*计算fft次数*/     k=log(N)/log(2);     if(N>pow(2,k))         k=k+1;     nfft=pow(2,k);     printf("nfft=%d k=%d\n",nfft,k);     /*为p_re、p_im赋初值*/     for(s=0;s<=S; s++)     {         for(r=0;r<=R;r++)         {             for(n=0;n<=N;n++)             {                 p_re[r][n][s]=p[r][n][s];                 p_im[r][n][s]=0.0;             }         }     }     /*对p_re、p_im对时间维度做fft、ifft*/     fft(p_re,p_im,k,1);     fft(p_re,p_im,k,-1);     /*读入数据*/     fp2=fopen("output_m.dat","wb");     if(fp2==NULL)         printf("NULL2");     else     {         for(s=0;s<S;s++)         {             for(r=0;r<R;r++)             {                 for(n=0;n<N;n++)                     fwrite(&p[r][n][s],sizeof(float),1,fp2);             }         }     }     return 0;  } 供参考～  打开文件有问题，会导致异常，使用野指针也会导致异常，运行之后如果还出现问题，建议继续查查；


Question: C/C++中，函数非正常退出之后会做什么（像exit（1））

引用 楼主 weixin_56922977 的回复:是重新再运行一次这个函数直到正常退出吗？  还是回到前面出错的函数，直到电脑按程序正常执行后正常退出；还是跳过这个非正常退出的函数函数（貌似不太可能）。  来自数据结构的线性表 emm 给我整懵逼了，没太懂。 能具体吗?

函数非正常退出有两种，一种是exit，另一种是return;exit退出说明是异常比较重要（非常重要），以至于需要退出整个程序（exit是退出进程）；另一种是比较不重要，那么就return返回； 第一种exit系统会回收程序（所有的函数，变量比如全局变量堆上的空间等等）的资源；return是系统会回收函数栈的资源；这两个回收的范围不一样；


Question: 求求帮忙看看C语言的题

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

scanf=>cin printf=>cout

引用 1 楼 智者知已应修善业的回复: int a=0,aa=0,aaa=0; while(1) { cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } cout<<aaa<<ends<<aa<<endl;  谢谢谢谢，搞出来了，麻烦了。

引用 7 楼 自信男孩的回复:[quote=引用 4 楼 木沁沁 的回复:][quote=引用 2 楼 自信男孩的回复:]void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf("%d", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf("sum = %d\n", sum); } 供参考～ 不行诶，运行不出来[/quote]  不出来是什么第二个不对吗？ 在这个基础上改改，自己有手有大脑的，自己不能改改吗？  [/quote] 不好意思，真的一点都不懂，麻烦了。现在两个题都搞好了，没事了。还是谢谢你啦。

int a=0,aa=0,aaa=0;                  while(1) {                  std::cin>>a;                  if(!a)break;                  if(a>0)++aa,aaa+=a; }                  std::cout<<aaa<<ends<<aa<<endl;

int a=0,aa=0,aaa=0; while(1) { std::cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } std::cout<<aaa<<ends<<aa<<endl;                                                                                cin>>a;==scanf("%d", &a) cout<<aaa<<ends<<aa<<endl;==printf("%d %d\n", aaa,aa);

引用 4 楼 木沁沁 的回复:[quote=引用 2 楼 自信男孩的回复:]void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf("%d", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf("sum = %d\n", sum); } 供参考～ 不行诶，运行不出来[/quote]  不出来是什么第二个不对吗？ 在这个基础上改改，自己有手有大脑的，自己不能改改吗？

供参考：#include<stdio.h>  int main() {     int ecnt=0,esum=0,n,pcnt=0,psum=0;     while(scanf("%d",&n)==1 && n!=0){          if(n%2==0){    //偶数             ecnt++;             esum += n;          }          if(n>0){      //正数             pcnt++;             psum += n;          }      }     printf("ecnt=%d,esum=%d\n",ecnt,esum);//偶数的累加项数及和     printf("pcnt=%d,psum=%d\n",pcnt,psum);//正数的累加项数及和          return 0; }

引用 1 楼 智者知已应修善业的回复: int a=0,aa=0,aaa=0; while(1) { cin>>a; if(!a)break; if(!(a%2))++aa,aaa+=a; } cout<<aaa<<ends<<aa<<endl;  整不出来诶😣

引用 2 楼 自信男孩的回复:void sum_even(void) {     int num, cnt = 0, sum = 0;       while (scanf("%d", &num) && num) {         if (num > 0) {             cnt++;             sum += cnt;         }     }      printf("sum = %d\n", sum); } 供参考～ 不行诶，运行不出来😣


Question: C语言分析(关于指针，大神帮看看)

原型： char * gets ( char * str ); 功能：通过标准输入（stdin）读入字符并存储到C类型的字符串，当检测到换行符或者文件结束符时停止读入。换行符和文件结束符不读入字符串中。'\0'自动添加到字符串的最后。  int puts(const char *string) 功能 puts()函数用来向标准输出设备屏幕输出字符串并换行。具体是把字符串输出到屏幕上，将‘\0’转换为回车换行。 调用方式是：puts(str)。其中str是字符串数组名或者字符串指针。实际上，数组名就是指针。 1、puts()只能输出字符串，不能输出数值或者进行格式转换，即不能要求输出格式增加空格、换行（指的是输出内容的中间进行换行）等要求； 2、可以将字符串直接写入puts()。如：puts("hello world"); 3、puts()和 printf的用法一样,puts()函数的作用与语句“printf("%s\n",s);的作用相同。注意：puts在输出字 符串后会自动输出一个回车符。

应该会默认用'\0'替换掉'\n'这句有问题吧，不是替换，而是'\n'不会加入到你提供的缓存里～

深入学习，脑洞大开是非常幸福的事情

呃 我还有几个问题： 1、定义了字符数组后例如  char b[1024];   如果不对其进行初始化，那么它的各元素的值是随机值还是 '\0' ? 2、gets() 在对一个字符串赋值之后是不是会默认在该字符串末位加上 '\0' ? 3、puts() 打印结束的标志是什么？  望大佬们在百忙之中能够解答一下小弟的疑惑。。。@qzjhjxj @自信男孩


Question: 求各位大佬帮忙看一下，while和for语句都分别怎么写，谢谢大佬！

要么自己先写写，要么网上搜搜吧，这些问题都有解答的～

作业还是自己做一遍吧小老弟


Question: 求指导，C程序运行openssl里面的函数没反应

已解决，使用MSYS2对openssl库进行编译，生成libssl.a和libcrypto.a

在return 0;前面加一个getc();试试？

引用 4 楼 user-1 的回复:引用 3 楼 qq_31101781 的回复:[quote=引用 1 楼 user-1 的回复:]在return 0;前面加一个getc();试试？还是不行，一跑进Openssl的函数就不行了，SHA1和SHA256都试过，我用powershell看一进SHA1( )函数，就挂死了 如果是函数跑挂了，那可能是环境问题，就不好处理了。。。[/quote]是的，就是找不到问题出在哪里，我安装openssl的时候都是按着网上的教程，安装perl，nasm，vs2017，nmake，nmake test，nmake install来生成库文件的。

引用 3 楼 qq_31101781 的回复:引用 1 楼 user-1 的回复:在return 0;前面加一个getc();试试？还是不行，一跑进Openssl的函数就不行了，SHA1和SHA256都试过，我用powershell看一进SHA1( )函数，就挂死了 如果是函数跑挂了，那可能是环境问题，就不好处理了。。。


Question: 手机适用c语言APP

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

这个现在网上搜一下就有吧，怀念初中用功能机瞎学c语言的时候

不是啦因为个人一些原因是用不了电脑的 只有手机  所以问一问

目前没听说过，弱弱的问一下，在手机上编译运行可以，编辑也在手机上？你是多么不愿意使用电脑呢，可能不方便在盖着被子的情况下写代码～


Question: 想了挺久实在没办法了，希望大佬帮帮忙！

引用 1 楼 自信男孩的回复:因为输入n之后的回车符号正好放在a[0]位置。解决办法是在输入n的scanf后面加一条getchar()试试 谢谢！确实是这样


Question: 求助

引用 7 楼 赵4老师 的回复：输入 1,2 后面跟回车键可是无法输入[face]monkey2:019.png[/face]

输入 1,2 后面跟回车键

引用 4 楼 qzjhjxj 的回复：第8、第9行之间，插入fflush (stdout);rewind (stdin);加了，但是我还是无法输入两个数去比较大小

引用 3 楼 自信男孩 的回复：楼主的问题是环境使用问题，还是结果未达到预期的问题？ 如果是前者，建议找一下编译器（或工具）使用教程～环境应该没有什么问题，我都是按照网上来的

引用 1 楼 赵4老师 的回复：在scanf前加一句 fflush(stdout);这样在输出那里显示了请输入a和b，但是我无法输入数据

在scanf前加一句 fflush(stdout);


Question: 第一行C语言代码，最大值，求和

#define MAX3(x, y, z) (MAX(MAX(x, y), z))

可以不错，加油  #define MAX(x, y) (x > y ? x : y)

挺欢乐啊，哈哈

敬请批评改正

求最大值：x和y的最大值：printf("max = %d\n", x > y ? x:y);


Question: C语言构建顺序索引链接存储结构的索引表

你好，请问你现在有这个题的答案了吗，可以发一下吗

你好，你现在有答案了吗，第四步怎么完成

struct param {     type data;     struct param *next; };  struct param array[10];


Question: 请教 c 语言什么方法可以向文件写入任意个数空格（可变的）

void fun(int test) {     while (test--)         system("echo \" \" >> ./test.log"); }

void fun(int test) {      char *buffer = (char*)malloc(test);      memset(buffer,0,' ');      fwrite(buffer,test,1,fp);      free(buffer); }

用循环fputc不就可以随意写入空格了吗？ fprintf也是可以的～


Question: 为什么scanf放在while(1)外面会出现死循环，放在里面就不会。

因为你的循环条件是 1 ，永远为 true，scanf 又在循环外面，导致你没有机会重新输入 c 来更新 c 的值 而 scanf 放在循环里，由于 scanf 本来是阻塞等待输入，因此每一次循环你都可以重新输入 c ，这样你就有机会来退出循环，比如输入 #

把 scanf("%c",&c);放在while(1){......}外面，只读取键盘输入一次，如果这一次机会if(c=='#')break;没把握住，当然死循环了,while(1)是永远为真。当把 scanf("%c",&c);放到while(1){}内时，就会不停的去读键盘输入，然后if(c=='#')break;判断，就有无限次机会了退出了。

不一定呢，如果一开始就输入#就break出循环，不会出现无线循环了。 如果一开始不是输入#，那么while没有break的条件，因此会死循环～


Question: 小白求助

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

引用 4 楼 给我高高飞起来 的回复:[quote=引用 3 楼 qzjhjxj的回复:]按你写的就可以啊，供参考：typedef int ElemType;        //数据元素的类型为整数  typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数定义 {      LinkList p;      p=LC; }  //我自身定义LinkList p; //我要怎么样才能使p=LC;  int main() {    LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));    MergeList_L(La,Lb,Lc);    system("pause"); } 朋友，我那个LC是取地址（你可以看到是&LC），然后p是LinkList的变量 ，应该是定义指针变量*p，可是LinkList本身又是指针变量，定义p为指针变量我就不知道怎么引用结构体里的成分了，所以我想问怎么才能让p=LC[/quote] 供参考：typedef int ElemType;        //数据元素的类型为整数 typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数头这样定义 {      LinkList p=LC;      p->data=20;      p->next=NULL; }  int main() {     LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));     MergeList_L(La,Lb,Lc);     LinkList p=Lc;    while(p){        printf("%d",p->data);        p=p->next;    }    system("pause"); }

引用 3 楼 qzjhjxj的回复:按你写的就可以啊，供参考：typedef int ElemType;        //数据元素的类型为整数  typedef struct LNode{      ElemType   data;       //数据域      struct LNode  *next;   //指针域 }LNode,*LinkList;           // LinkList为指向结构体LNode的指针类型   void MergeList_L(LinkList LA,LinkList LB,LinkList &LC)//函数定义 {      LinkList p;      p=LC; }  //我自身定义LinkList p; //我要怎么样才能使p=LC;  int main() {    LinkList La = (LinkList)malloc(sizeof(LNode));    LinkList Lb = (LinkList)malloc(sizeof(LNode));    LinkList Lc = (LinkList)malloc(sizeof(LNode));    MergeList_L(La,Lb,Lc);    system("pause"); } 朋友，我那个LC是取地址（你可以看到是&LC），然后p是LinkList的变量 ，应该是定义指针变量*p，可是LinkList本身又是指针变量，定义p为指针变量我就不知道怎么引用结构体里的成分了，所以我想问怎么才能让p=LC

引用 1 楼 自信男孩的回复:先把链表的创建，链表的遍历写出来吧。  链表合并试着写写 好的，谢谢

先把链表的创建，链表的遍历写出来吧。  链表合并试着写写


Question: 自学数据结构 求高人指点

引用 2 楼 自信男孩的回复:看这个函数，循环是找到最小值的位置，L.data[pos] = L.data[L.length-1];这句用的比较巧，用最后一个元素覆盖最小值的位置；  这样做不会丢失原队列数据，但是会改变顺序；如果不考虑顺序，这样的做法还是挺好的。 谢谢大佬

引用 1 楼 user-3的回复:Del_Min()   ListDelet(&L,i,&e) 这些都是自定义的函数名称，函数的名称、形参、返回值等不同，表示函数实现的功能作用不相同，Del_Min（）函数实现的功能是删除顺序表一个值最小的元素， ListDelet(&L,i,&e)函数可能实现的功能是删除顺序表中值为e的元素。虽然这两函数实现的具体的功能有差别，但大的功能就是删除某一个元素，所以为了方便记忆及识别，在它们的名称中都出现了del的字样，这样从名称中我们就可以大致判断这个函数所实现的功能，这也是编写代码过程中普遍采用的方式。当然，自定义的函数的名称理论上可以任意编写，只要所取字符不是系统的关键字符，但这样做的意义不大，写个毫无规律的名称，过一段时间，自己都忘了，想拿来用下，怎么也找不到呢。 谢谢大佬


Question: 求大佬指点

引用 2 楼 Dream1018 lin 的回复:[quote=引用 1 楼 自信男孩 的回复:]#include <stdio.h> #include <stdlib.h>  int main() {     int i=0;     //char a[5];     char a[16];     a[i]=getchar();     while(a[i]!='\n')     {         i++;         if (i > 5) {             printf("Too big!\n");             return 0;         }         a[i]=getchar();     }     printf("%d\n",i);     for(int j=0; j<i-1; j++)     {         printf("%d ",a[j]-48);     }     printf("%d\n",a[i-1]-48);     for(int j=i-1; j>=0; j--)     {         printf("%d",a[j]-48);     } } 供参考～  数组长度为5不合适，因为也得给'\n'留一个空间的，因为你把'\n'放在了a[i]中。我的修改用了16，个人建议数组长度定义为2^n的空间； 试了一下，可以了，谢谢！可以解释一下为什么要数组长度要定义为2^n吗？[/quote] 因为涉及到内存分配的原理，还有页，表之类的信息，等你深入的了解内存的分配原理就知道了。现在先这么做吧

引用 1 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>  int main() {     int i=0;     //char a[5];     char a[16];     a[i]=getchar();     while(a[i]!='\n')     {         i++;         if (i > 5) {             printf("Too big!\n");             return 0;         }         a[i]=getchar();     }     printf("%d\n",i);     for(int j=0; j<i-1; j++)     {         printf("%d ",a[j]-48);     }     printf("%d\n",a[i-1]-48);     for(int j=i-1; j>=0; j--)     {         printf("%d",a[j]-48);     } } 供参考～  数组长度为5不合适，因为也得给'\n'留一个空间的，因为你把'\n'放在了a[i]中。我的修改用了16，个人建议数组长度定义为2^n的空间； 试了一下，可以了，谢谢！可以解释一下为什么要数组长度要定义为2^n吗？


Question: 新手求教

引用 2 楼 weixin_56991544 的回复:也就是中间值的时候都是用的int的类型？ 有一个类型隐式提升，可以查一下～ 比如~i会自动将i的类型提升到int类型～

也就是中间值的时候都是用的int的类型？

这中间都掺杂着类型转换，比如i = ~i;首先~i取反会类型提升到int，所以~i的结果是-251（最高位为符号位int类型）； i = ~i;把-251赋值给i会有类型int转成unsigned char（最终转成unsigned char）。


Question: pintia上浙大的链表题目，求助！

供参考：#include <stdio.h> #include <stdlib.h>  struct ListNode {     int data;     struct ListNode *next; };  struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );  void printlist( struct ListNode *L ) {      struct ListNode *p = L;      while (p) {            printf("%d ", p->data);            p = p->next;      }      printf("\n"); }  int main() {     struct ListNode *L, *Odd;     L = readlist();     Odd = getodd(&L);     printlist(Odd);     printlist(L);          return 0; } struct ListNode *readlist() { 	int num; 	struct ListNode *p,*head,*tail; 	head=tail=NULL; 	while(scanf("%d",&num)){                 if(num==-1)break;                 p=(struct ListNode *)malloc(sizeof(struct ListNode));                 p->data=num;                 p->next=NULL;                 if(head==NULL){                      head=p;                      tail=p;                 }else{                      tail->next=p;                      tail=p;                 }     }     return head; }  struct ListNode *getodd( struct ListNode **L )//L是头指针的地址 *L即为头指针 { 	struct ListNode *head=NULL,*tail=NULL,*p2=NULL,*p1=NULL;     p1=*L;                                //此时的head是奇数链的头指针 	while(p1){               if(p1->data%2!=0){                    if(p1==*L){                       *L=p2=p1->next;                    }else{                       p2->next=p1->next;                    }                    if(head==NULL){ //建立新的奇数链                       head=p1;                       tail=p1;                    }else{                       tail->next=p1;                       tail=p1;                    }               }else{                    p2=p1;               }               p1=p1->next;     }     if(head!=NULL)tail->next=NULL;     if(*L  !=NULL)p2->next=NULL;     return head; }

#include <stdio.h> #include <stdlib.h>  struct ListNode {     int data;     struct ListNode *next; };  struct ListNode *readlist(); struct ListNode *getodd( struct ListNode **L );  void printlist( struct ListNode *L ) {     struct ListNode *p = L;      while (p) {         printf("%d ", p->data);         p = p->next;     }     printf("\n"); }  int main() {     struct ListNode *L, *Odd;     L = readlist();     Odd = getodd(&L);     printlist(Odd);     printlist(L);      return 0; } struct ListNode *readlist() {     int num;     struct ListNode *p,*head,*tail;     head=tail=NULL;      while(scanf("%d",&num)){         if(num==-1)             break;         p=(struct ListNode *)malloc(sizeof(struct ListNode));         p->data=num;         p->next=NULL;         if(head==NULL)             head=p;         else             tail->next=p;         tail=p;     }      return head; } struct ListNode *getodd( struct ListNode **L )//L是头指针的地址 *L即为头指针 {  #if 1     struct ListNode *podd_head = NULL, *p, *q, *tail;      p = q = *L;      while (p) {         if (p->data % 2) {             if (!podd_head)                 podd_head = p;              else                 tail->next = p;             tail = p;              if (p == *L) {                 *L = (*L)->next;                 p = q = *L;             } else {                 q->next = p->next;                 p = p->next;             }         } else {             q = p;             p = p->next;         }     }      tail->next = NULL;      return podd_head; #else     struct ListNode *p=NULL,*head=NULL,*tail=NULL,*p2=NULL,*p1=NULL;//此时的head是奇数链的头指针     p1=*L;     while(p1){         if(p1->data%2){             if(head==NULL)                 head=p1;             else                 tail->next=p1;             tail=p1;             //建立新的奇数链             if(p1==*L)                 *L=p1->next;             else                 p2->next=p1->next;         }         else{             p2=p1;             p1=p1->next;         }     }     return head; #endif  }  供参考～


Question: 该程序编译没问题，输出有错误，求教！！

供参考：#include <stdio.h>  int  intput(int *p); void enter(int *p,int a);  int  main() {     int s[100],k;//k代表输入数的个数     k=intput(s);     enter(s,k);     system("pause"); }  int intput(int *p) //int input(int *p) 函数名少了‘t' {     int a=0;     do       {        scanf("%d",p++);        a++;            //需要对a设个上限值     }while(*(p-1)>0); //while(*p<0);     return a; } void enter(int *p,int a) {     for(int i=0;i<a;i++)// for(int i=0;i<=a;i++)         printf("%d  ",*(p+i)); }

//#include "stdio.h" #include <stdio.h>  int input(int *p, int len); void enter(int *p,int a);  //void main() int main(void) {     int s[100],k;//k代表输入数的个数     //k=intput(s, 100);     k=input(s, 100);     enter(s,k); } int input(int *p, int len) {     int a=0;     do     {         //scanf("%d", p+1);         scanf("%d", p+a);         a++;         if (a >= len)             break;     //} while(*p < 0);     } while(*(p+a-1) > 0);      return a; } void enter(int *p,int a) {     for(int i=0;i<=a;i++)         printf("%d  ",*(p+i)); } 供参考～

intput => input


Question: 求大神解答一下

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

没说解答什么呢；

题目有啥要求？出现啥问题？？说清楚一点吧。


Question: 有大佬能给个这题的代码吗，我是刚学的小白，这题属实是不会弄了，谢谢了谢谢了

供参考：#include<stdio.h> #include<math.h>  int main() {     int    i=1;     double temp=1,sum=1,x;     scanf("%lf",&x);     while(fabs(temp)>=1e-6)     {           temp = temp*x/i;           sum += temp;           temp = -temp;           i++;     }     printf("%lf\n",sum);          return 0; }

这有难度么？为什么自己不动手写一下呢？？

网上搜搜吧，可以看一下别人怎么写的，也能看到别人的讲解～


Question: 为什么我的单链表只能打印第一个位置的，后面调用的不显示？？

引用 1 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h>  typedef struct LNode {     int data;     struct LNode *next; }LNode,*LinkList;  int InitList(LinkList &L) {     L=(LinkList)malloc(sizeof(LNode));     if(L==NULL)         return false;     L->next=NULL;      return true; }  //store //int chucun (LinkList L,int a[],int i) int chucun (LinkList L,int a[], int len) {     int i = 0;     LinkList s;      while(i < len)     {         s = (LinkList)malloc(sizeof(LNode));         if (!s)             return -1;          s->data = a[i];         s->next = L->next;         L->next = s;          /*s->next=NULL;          L->data=a[i];         s->next  =L->next;         L->next=s;s->data=L->data;         */         i++;     }      return 0; } LinkList charu(LNode * L, int pos, int c) {     LinkList p;     int j=0,i=2;     p=L;     while(j < pos - 1 && p->next)     {         p=p->next;++j;     }     LinkList s;     s=(LinkList)malloc(sizeof(LNode));     s->data=c;     s->next=p->next;     p->next=s;      //return L->next;     return L; } int shanchu  (LinkList L, int i) {     LinkList p,s;     int j=0;     p=L;     //while(!(p->next)&&j<i-1){     while((p->next)&&j<i-1){         p=p->next,j++;     }     if (p->next == NULL)         return -1;      s = p->next;     p->next=s->next;     free(s);     s=NULL;      return 0; }  void printlist(LinkList L) {     LinkList temp = L->next;      printf("链表中的值为\n");     while(temp) {         printf("%d\n",temp->data);         temp=temp->next;     } }  //int main() int main(void) {     LinkList L;     InitList(L);     int a[]={11,22,33,44,66};     int i=0;     int c=55;     chucun(L, a, sizeof(a)/sizeof(a[0]));     printf("打印储存的链表\n");     printlist(L);     charu (L, 2, c);     printf("打印插入的链表\n");     printlist(L);     shanchu  (L ,5);     printf("打印删除后的链表\n");     printlist(L);      return 0; }  供参考～ 找到错误了，谢谢大佬


Question: C语言

完全可以这么写呢，但是你的代码不全，上面这么写，下面肯定也是从i=1开始的，所以要改都改了才行～  另外，N的输入值需要判断一下，不能大于99(100-1）因为从1开始，i <= N-1

确实从1开始才符合这题，但从0也是合理

有的人喜欢把手机放进左边口袋，有的人喜欢放右边，你要是喜欢并且方便，拿在手里也可以。  从这个片段中看不出理由， he or she seems like to do so.


Question: 关于C语言scanf的问题

引用 6 楼 Dream1018 lin 的回复:[quote=引用 1 楼 qzjhjxj 的回复:]供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf("%d",&a[i++])==1)&&((getchar())!='\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf("%d",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf("%d ",a[j]);            return 0; } 您好，我有点不太理解这样做的含义，我尝试把代码进行如下修改： int main() {      int a[100],i=0,j;     char m;     while ((scanf("%d",&a[i++])==1)&&((m=getchar())!='\n'))     {         printf("%d,%c\n",a[i-1],m);     }     for (j=0; j<i; j++)         printf("%d ",a[j]);      return 0; } 输入为：1 2 3 4 5(回车) 输出为： 1, 2, 3, 4,    (注意，5是没有被输出的) 1 2 3 4 5  我有疑问的点在于scanf与getchar()是同时工作的?还是说有先把数读给scanf，再读给getchar()? 我的假设是scanf每次进行输出的同时,会将读取到的数字同时作为字符的形式传给getchar(), 然后将每次getchar()读取到的字符给打印出来，但是却没有结果，对这里的getchar()的工作方式不太理解， 尤其是最后边'5,'并没有被打印出来，这又是为什么？还请指点。[/quote] 将上面的写法换种表达，方便对while（）的理解，两个函数的详细用法可以参考网上的资料，以下供参考：#include <stdio.h> int main() {      int a[100],i=0,j;     char m;     while (1)     {         if(scanf("%d",&a[i++])!=1) break;         printf("a[%d]=%d\n",i-1,a[i-1]);         if((m=getchar()) == '\n')  break;     }     for (j=0; j<i; j++)         printf("%d ",a[j]);          return 0; }  //用scanf输入数值类型（int、float、double等） //空格、回车、Tab键不会中断输入，scanf从第一个非空格/回车数值开始录入，即不管中间有多少空格有多少回车， //都不会中断scanf的录入，除非到达scanf中规定的录入数量或遇到非数值类型时scanf("%d",&a[i++])!=1条件成立。  //getchar //getchar()主要用来接收单个字符，不管是空格或者回车都可以接收。

引用 1 楼 qzjhjxj 的回复:供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf("%d",&a[i++])==1)&&((getchar())!='\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf("%d",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf("%d ",a[j]);            return 0; } 您好，我有点不太理解这样做的含义，我尝试把代码进行如下修改： int main() {      int a[100],i=0,j;     char m;     while ((scanf("%d",&a[i++])==1)&&((m=getchar())!='\n'))     {         printf("%d,%c\n",a[i-1],m);     }     for (j=0; j<i; j++)         printf("%d ",a[j]);      return 0; } 输入为：1 2 3 4 5(回车) 输出为： 1, 2, 3, 4,    (注意，5是没有被输出的) 1 2 3 4 5  我有疑问的点在于scanf与getchar()是同时工作的?还是说有先把数读给scanf，再读给getchar()? 我的假设是scanf每次进行输出的同时,会将读取到的数字同时作为字符的形式传给getchar(), 然后将每次getchar()读取到的字符给打印出来，但是却没有结果，对这里的getchar()的工作方式不太理解， 尤其是最后边'5,'并没有被打印出来，这又是为什么？还请指点。

引用 1 楼 qzjhjxj 的回复:供参考：#include <stdio.h>  int main() {       int a[100],i=0,j;       while ((scanf("%d",&a[i++])==1)&&((getchar())!='\n'));      //方法一：以回车作为结束符，最后回车前面不能有空格       //while (scanf("%d",&a[i])==1 && a[i]!=0){i++;}      //方法二：以0或其他数字作为结束符，结束输入       for (j=0;j<i;j++)           printf("%d ",a[j]);            return 0; } 注意考虑一下数组越界～

谢谢，想问一下，程序每次从输入中读取时scanf和getchar是同时进行的吗，意思是：  引用 2 楼 自信男孩 的回复:EOF确实是以ctrl+z（Windows）或ctrl+d（Linux）输入的。  int  i=0; while(scanf("%d",a[i])!=EOF) {     i++; } 这样是可以的，但是不能无限输入呢，因为i要注意不要越界呢。所以可以加一下限制条件：   int  i=0; while(i < MAX_ARRAY_SIZE && scanf("%d",a[i])!=EOF)    //MAX_ARRAY_SIZE自己定义长度，这个是数组的长度 {     i++; } 供参考～ 谢谢！


Question: 简单问题有人能全答对吗

不同编译器，不同内核系统，硬件不同，答案也不同，问题很简单。你把整个底层问个遍 吧 引用 楼主 m0_56094393 的回复:Int类型中最多可以表示多少个不重复的自然数?多少个不重复的整数?int类型最大数在计算机中的ascii码是?最小数在计算机中的ascii码是多少?

看一下int类型占几个字节（跟系统、编译器有关系），另外，看一下int的表示范围～

楼主应该问一下上帝：C语言int类型应该占几个字节？


Question: 球球大佬看一下哪里有问题

注意溢出问题，注意unsigned int表示的范围；

1. 外层for循环里面n=1,n<=9是固定循环9次，按照要求应该是给定的n次才对啊 2. 内层for循环应该带上x=x*10+a，这样才可以达到例如2222的这种要求把 就像3楼大佬给的代码那样

输入，输出C=>C++  scanf("%d",&a);=>cin printf("n=?\n");=>cout

仅供参考 #include <stdio.h>  int Mult10(int n) {     int sum=10;     int m;     if(n==0)return 1;     for(m=1;m<n;m++)sum=sum*10;     return sum; }  int main() {     int a,n,sn,x=0;     int i,j;     printf("a=?\n");     scanf("%d",&a);     printf("n=?\n");     scanf("%d",&n);     sn=0;     for(i=0;i<n;i++)     {         for(j=0;j<=i;j++)             x+=a*Mult10(j);         sn+=x;         x=0;     }     printf("sn=%d\n",sn);     return 0; }

内嵌循环x=0；何意？


Question: 有没有大佬告诉我为什么运行不出正确答案呢？

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

修改如下,供参考：#include<stdio.h> #include<math.h> int main() {    double pi=0.5,term=0.0,n,j=1.0;    int    i=1;      do{         //for(i=1;i>0;i=i+2)         j=j*i/(i+1);         n=1.0/(i+2)*pow(0.5,i+2);         term=j*n;         pi=pi+term;         i+=2;     }while(fabs(term)>=1e-6);     pi=6*pi;     printf("pi=%10.8f\n",pi);          return 0; }


Question: 求大神解答，关于回文数，吸血鬼数，高位数加法。

求素数与判断质数这个解决  大数加法要看使用哪种形式，char数组？

等于反转后的数就是回文数。大数加法把输入部分写出来看看，不同的思路有不同的解法。

引用 1 楼 智者知已应修善业的回复:回文这个解决 啊……这个看不太懂……没学过栈……

引用 3 楼 智者知已应修善业的回复:求素数与判断质数这个解决  大数加法要看使用哪种形式，char数组？ 谢谢！太及时啦!嗯嗯！就是数组的!

回文这个解决


Question: 请问这段代码有什么问题么？。为什么没有输出？

引用 5 楼 自信男孩 的回复:#include <stdio.h> #include <stdlib.h>   //long long int array[1000]= {0}; long long int array[1000];  //全局变量编译器默认会给初始化为0  int main() {     long long int N;     scanf("%lld",&N);      printf("%lld\n", N);     if (N > 1000)         N = 1000 -1;     for(long long int i=0; i<=N; i++)     {         for(long long int m=N; m>0; m--)         {             //if(m%i==0)             if(i != 0 && m%i==0)                 array[m]++;         }     }     for(long long int i=0; i<=N; i++)     {         //printf("%d\n",array[i]);         printf("%lld\n",array[i]);     }     return 0; }  供参考～ 谢谢

if(m%i==0)你 i 从0开始，这里除数为0 异常了

引用 1 楼 user-3 的回复:问题多了，没明白楼主的代码想实现什么，供参考：#include <stdio.h> #include <stdlib.h> long int array[1000]= {0};//这里数组容量是1000,下标0-999 int main() {     long int N;     scanf("%lld",&N);      //这里如果N 是11位数     for(long int i=1; i<=N; i++) //for( int i=0; i<=N; i++)     {         for(long int m=N; m>=0; m--)//相应的for()里的整形变量和N要同类型，有赋值m=N         {             if(m%i==0)   //第一个for()循环里i不能从0开始，这里出现 m%0                array[m]++;//这里数组下标就越界了，因为m=N=11位数         }     }     for(long int i=0; i<=N; i++)     {         printf("%d\n",array[i]);     }          return 0; } 感谢回答，想再请问一下，在主函数外和主函数内定义的数组其最大可容纳元素个数分别是多少呀？


Question: c语言unsigned？

1/3改成1.0f/3目的是将表达式的计算由unsigned int类型转换为float类型。否则1/3得的值为0；

整型相除结果为整型，1/3结果为0


Question: 有大神可以帮我看看这段代码错在哪里了吗？

一个分号引发的惨案

引用 1 楼 user-3的回复:第15行if()语句最后多了‘；’号。 对对对，我真的瞎，这都没发现

第15行if()语句最后多了‘；’号。


Question: 求助，为什么一直不是回文数

#include <stdio.h> int main() {     int a,b,c,d,e,f;      printf("输入一个五位数整数:");     //scanf("d",&a);     scanf("%d",&a); #if 0     b=a/10000;      /*万位数*/     c=a%10000/1000;   /*千位数*/     d=a%1000/100; /*百位数*/     e=a%100/10; /*十位数*/     f=a%10;   /*个位数*/     if (b==f&&c==e)         printf("该数是回文数");     else         printf("该数不是回文数"); #endif      if (a <= 9999 || a > 99999)         return -1;     b = a /10000;     f = a % 10;     if (b != f) {         printf("该数不是回文数");         return -1;     }      c = a % 10000 / 1000;     e = a % 100 / 10;      if (c != e) {         printf("该数不是回文数");         return -1;     }     printf("该数是回文数");      return 0;  } 供参考～

供参考：#include <stdio.h> int main() {     int a,b,c,d,e,f;     printf("输入一个五位数整数:");     scanf("%d",&a);   //scanf("d",&a);     b=a/10000;        /*万位数*/      c=a/1000%10;     /*千位数*/ //c=a%10000/1000; /*千位数*/      d=a/100%10;      //d=a%1000/100;  /*百位数*/      e=a/10%10;       //e=a%100/10;/*十位数*/     f=a%10;         /*个位数*/     if (b==f&&c==e)         printf("该数是回文数\n");     else         printf("该数不是回文数\n");          return 0; }

可参 可参


Question: 为什么它运行不了

‘//.......’表示它的后面所跟的内容只起说明作用，不会被编译进代码里。//scanf("%d%d%d\n",&a,&b,&c);这句是你提供的代码里的内容。 整体修改如下，供参考：#include<stdio.h> #include<math.h> void main() {     int a,b,c;     double area,s;     printf("请输入三角形的三条边a,b,c:\n");     scanf("%d%d%d",&a,&b,&c);//标注--错误在这句：scanf("%d%d%d\n",&a,&b,&c);     if(a+b>c&&a+c>b&&b+c>a)      {         s=(a+b+c)*0.5;         area=sqrt(s*(s-a)*(s-b)*(s-c));         printf("%.2f\n",area);         if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b)               printf("此三角形为直角三角形\n");         else if(a==b||a==c||b==c)               printf("此三角形为等腰三角形\n");         else if((a==b)&&(b==c))               printf("此三角形为等边三角形\n");         else               printf("此三角形为一般三角形\n");      }     else         printf("不能构成三角形\n");      }

等边三角形会被认为是等腰三角形

完善下，供参考：#include<stdio.h> #include<math.h> void main() {     int a,b,c;     double area,s;     printf("请输入三角形的三条边a,b,c:\n");     scanf("%d%d%d",&a,&b,&c);     if(a+b>c&&a+c>b&&b+c>a)      {         s=(a+b+c)*0.5;         area=sqrt(s*(s-a)*(s-b)*(s-c));         printf("%.2f\n",area);         if(a*a==b*b+c*c||b*b==a*a+c*c||c*c==a*a+b*b)               printf("此三角形为直角三角形\n");         else if(((a==b||a==c) && b!=c)||((b==c||b==a)&& a!=c))               printf("此三角形为等腰三角形\n");         else if((a==b)&&(b==c)&&(a==c))               printf("此三角形为等边三角形\n");         else               printf("此三角形为一般三角形\n");      }     else         printf("不能构成三角形\n");      }

而且加了那个\n并没有用，依旧运行不了

为啥前面要加斜杠

这句有错误：scanf("%d%d%d",&a,&b,&c);//scanf("%d%d%d\n",&a,&b,&c);


Question: 函数传参是通过寄存器还是栈？

大部分都是用的栈吧

调用约定 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017

以前调试过一次 x86 平台 用栈 x64 前几个参数 是用通用寄存器

引用 13 楼 六道佩恩的回复:[quote=引用 6 楼 真相重于对错 的回复:]1、用栈和用寄存器都可以达到传递参数的目的 2、c/c++只规定了语言部分，并没有规定实现部分。 3、__stdcall....这些只是微软 ,gun c/c++的厂家的自己实现。这些不是c/c++的标准的关键词。 4、如果用到寄存器，却发生中断，也没有问题，因为中断首先就要保存寄存器，中断结束后恢复寄存器。 5、我用vs看基本还是用栈。  gcc我看64位用的寄存器，32位用的栈。 我知道这不是语言的部分，但问题是，既然GCC自己规定了，为什么64位的时候它自己又不遵守了？[/quote] 我对gcc不是很熟，你既然说是gcc规定。不知道你是从官方文档里得到的还是道听途说呢？ https://gcc.gnu.org/onlinedocs/gcc-4.7.2/gcc/Function-Attributes.html

可以不用push,直接操作栈寄存器就可以了，pop也是类似

什么时候发现的？会不会与python有关？

无怪代码越跑越快，程序越来越大。

xxxxxxxxxxxxxxxxxx

支持一个"><xxxxx>

gcc在windows下也使用的win64 ABI，win64 ABI中只有一种调用约定，fastcall，没有cdecl、 stdcall、pascal这些。源码中虽然可以写_-cdecl、 __stdcall之类的修饰，但是在win64编译器中不起作用，只是出于源码兼容的考虑允许这么写，实际被忽略了。

引用 7 楼 Intel0011 的回复:[quote=引用 楼主 六道佩恩 的回复:]调试查看汇编是通过寄存器传的  但《程序员的自我修养》的“调用惯例”却只说了用栈，没有提用寄存器  连标了__cdecl的库函数，调用时都是通过寄存器的，为什么？不应该是通过栈吗？ x86上函数参数是压栈传递的，但使用时需要从栈上取出放入寄存器中，或用寄存器作为指针指向栈上的数据， 并没有使用寄存器传递参数，但不绝对，C++就使用了ecx传递了对象的this指针  x64中函数参数传递发生了改变 借PC处理器架构由x86向x64过渡之机，MS清理了Windows x64平台上的函数调用约定， 由原来的数种包括stdcall、thiscall、fastcall、cdecl、pascal等，统一为一种新的fastcall调用方式。 这种调用方式得益于x64平台寄存器数量的增加。 　　 Windows x64平台fastcall调用约定的主要特性如下： 00. 前四个整型或指针类型参数由RCX、RDX、R8、R9依次传递，前四个浮点类型参数由XMM0、XMM1、XMM2、XMM3依次传递。 01. 调用函数为前四个参数在调用栈上保留相应的空间，称作shadow space或spill slot。       即使被调用方没有或小于4个参数，调用函数仍然保留那么多的栈空间，这有助于在某些特殊情况下简化调用约定。 02. 除前四个参数以外的任何其他参数通过栈来传递，从右至左依次入栈。 03. 由调用函数负责清理调用栈。[这是不同于x86下fastcall的地方，x86下的fastcall由被调用者清理栈] 04. 小于等于64位的整型或指针类型返回值由RAX传递。 05. 浮点返回值由XMM0传递。 06. 更大的返回值(比如结构体)，由调用方在栈上分配空间，并由RCX持有该空间的指针并传递给被调用函数，       因此整型参数使用的寄存器依次右移一格，实际只可以利用3个寄存器，其余参数入栈。函数调用结束后，RAX返回该空间的指针。 07. 除RCX,RDX,R8,R9以外，RAX、R10、R11、XMM0~XMM5也是易变化的(volatile)寄存器。 08. RBX, RBP, RDI, RSI, R12, R13, R14, R15和XMM6~XMM15寄存器则必须在使用时进行保护。 09. 在寄存器中，所有参数都是右对齐的。小于64位的参数并不进行高位零扩展，也就是高位是无法预测的垃圾数据。  The calling convention for C++ is very similar: the this pointer is passed as an implicit first parameter.  The next three parameters are passed in registers, while the rest are passed on the stack.  x64 provides a new rip-relative addressing mode. Instructions that refer to a single constant address are encoded as offsets from rip.  For example, the mov rax, [addr] instruction moves 8 bytes beginning at addr + rip to rax.  Linux、BSD和Mac OS X系统中的应用程序，会优先使用RDI、RSI、RDX、RCX、R8、R9这6个寄存器传递函数所需的前6个参数，然后使用数据栈传递其余的参数。 [/quote]  老哥你太稳了，不仅释疑，还这么细节，懂起了，等我再凑点分

引用 6 楼 真相重于对错 的回复:1、用栈和用寄存器都可以达到传递参数的目的 2、c/c++只规定了语言部分，并没有规定实现部分。 3、__stdcall....这些只是微软 ,gun c/c++的厂家的自己实现。这些不是c/c++的标准的关键词。 4、如果用到寄存器，却发生中断，也没有问题，因为中断首先就要保存寄存器，中断结束后恢复寄存器。 5、我用vs看基本还是用栈。  gcc我看64位用的寄存器，32位用的栈。 我知道这不是语言的部分，但问题是，既然GCC自己规定了，为什么64位的时候它自己又不遵守了？

引用 11 楼 突触 的回复:[quote=引用 4 楼 六道佩恩 的回复:][quote=引用 1 楼 突触 的回复:]大部分的调用约定都是用栈的，fastcall 会用寄存器不过参数多的话，也会用栈。  虽然寄存器运算快，但寄存器的数量是有限的，且大部分寄存器都有其特定的用途，当参数占用了寄存器，如果不通过内存空间存储的话，就没办法进行复杂的运算了。。。。。  看汇编，实际还是用的寄存器，没按调用约定来[/quote]  你说的是__cdecl 调用使用了寄存器传参吗       如果是64位的话会出现这种情况。 但32位 我没有遇到过这种情况你可以发张图片看看嘛  [/quote]  putchar的声明：  int __cdecl putchar(int _Ch);   代码：  	int a='A'; 	putchar( a );   64位编译后的汇编：     0x000000000040153d <+13>:	mov    DWORD PTR [rbp-0x4],0x41    0x0000000000401544 <+20>:	mov    eax,DWORD PTR [rbp-0x4]    0x0000000000401547 <+23>:	mov    ecx,eax    0x0000000000401549 <+25>:	call   0x402af8 <putchar>   32位：     0x0040150e <+14>:	mov    DWORD PTR [esp+0x1c],0x41    0x00401516 <+22>:	mov    eax,DWORD PTR [esp+0x1c]    0x0040151a <+26>:	mov    DWORD PTR [esp],eax    0x0040151d <+29>:	call   0x4025f8 <putchar>  哦，这么看，32位确实用栈了（是吧？），不过为啥没用push？  看了下自定义的函数，32位的确实也用栈了，64位的则没有用栈

看一下微软的新调用约定

引用 楼主 六道佩恩 的回复:调试查看汇编是通过寄存器传的  但《程序员的自我修养》的“调用惯例”却只说了用栈，没有提用寄存器  连标了__cdecl的库函数，调用时都是通过寄存器的，为什么？不应该是通过栈吗？ x86上函数参数是压栈传递的，但使用时需要从栈上取出放入寄存器中，或用寄存器作为指针指向栈上的数据， 并没有使用寄存器传递参数，但不绝对，C++就使用了ecx传递了对象的this指针  x64中函数参数传递发生了改变 借PC处理器架构由x86向x64过渡之机，MS清理了Windows x64平台上的函数调用约定， 由原来的数种包括stdcall、thiscall、fastcall、cdecl、pascal等，统一为一种新的fastcall调用方式。 这种调用方式得益于x64平台寄存器数量的增加。 　　 Windows x64平台fastcall调用约定的主要特性如下： 00. 前四个整型或指针类型参数由RCX、RDX、R8、R9依次传递，前四个浮点类型参数由XMM0、XMM1、XMM2、XMM3依次传递。 01. 调用函数为前四个参数在调用栈上保留相应的空间，称作shadow space或spill slot。       即使被调用方没有或小于4个参数，调用函数仍然保留那么多的栈空间，这有助于在某些特殊情况下简化调用约定。 02. 除前四个参数以外的任何其他参数通过栈来传递，从右至左依次入栈。 03. 由调用函数负责清理调用栈。[这是不同于x86下fastcall的地方，x86下的fastcall由被调用者清理栈] 04. 小于等于64位的整型或指针类型返回值由RAX传递。 05. 浮点返回值由XMM0传递。 06. 更大的返回值(比如结构体)，由调用方在栈上分配空间，并由RCX持有该空间的指针并传递给被调用函数，       因此整型参数使用的寄存器依次右移一格，实际只可以利用3个寄存器，其余参数入栈。函数调用结束后，RAX返回该空间的指针。 07. 除RCX,RDX,R8,R9以外，RAX、R10、R11、XMM0~XMM5也是易变化的(volatile)寄存器。 08. RBX, RBP, RDI, RSI, R12, R13, R14, R15和XMM6~XMM15寄存器则必须在使用时进行保护。 09. 在寄存器中，所有参数都是右对齐的。小于64位的参数并不进行高位零扩展，也就是高位是无法预测的垃圾数据。  The calling convention for C++ is very similar: the this pointer is passed as an implicit first parameter.  The next three parameters are passed in registers, while the rest are passed on the stack.  x64 provides a new rip-relative addressing mode. Instructions that refer to a single constant address are encoded as offsets from rip.  For example, the mov rax, [addr] instruction moves 8 bytes beginning at addr + rip to rax.  Linux、BSD和Mac OS X系统中的应用程序，会优先使用RDI、RSI、RDX、RCX、R8、R9这6个寄存器传递函数所需的前6个参数，然后使用数据栈传递其余的参数。

引用 4 楼 六道佩恩 的回复:[quote=引用 1 楼 突触 的回复:]大部分的调用约定都是用栈的，fastcall 会用寄存器不过参数多的话，也会用栈。  虽然寄存器运算快，但寄存器的数量是有限的，且大部分寄存器都有其特定的用途，当参数占用了寄存器，如果不通过内存空间存储的话，就没办法进行复杂的运算了。。。。。  看汇编，实际还是用的寄存器，没按调用约定来[/quote]  你说的是__cdecl 调用使用了寄存器传参吗       如果是64位的话会出现这种情况。 但32位 我没有遇到过这种情况你可以发张图片看看嘛

cdecl调用约定肯定是通过栈传参的

cdecl调用约定肯定格式通过栈传参的。如果“连标了__cdecl的库函数，调用时都是通过寄存器的”,要么是inline了，要么你看错了

引用 3 楼 forever74 的回复:x64里面通用寄存器比原来多了，够用了，不用白不用啊。  苹果M1又掀开了新的历史，以后的硬件会越来越个性，我们会越来越理解语言规范里留白的魅力。  用寄存器遇上中断咋办？用栈的话好歹是保存到内存的  主要是，它是标了__cdecl这类使用栈的调用约定的呀，如果不用的话，就不应该标呀，不至于编译器都改了，库的调用约定的实现也该了，但标称的__cdecl却不去掉或者更换？这不合理啊  32位和64位版都用的寄存器，不知道是不是检测了CPU型号才这样做的


Question: 【C语言求助】用指针实现数字从小到大输出

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

引用 4 楼 user-2的回复:q 这里记录的是数组的首地址，在for()循环里，p是往后走的，每循环一次p++一次，当第一轮内循环结束后，p就走到了数组的尾部地址了，我们需要它回到数组的首地址，然后重新开始新一轮的比较，以此类推。后面的输出语句前p=q，也是同样的道理。 嗷，原来是这样 谢谢啦！

搞错了，是p＝q

引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> void min_print(int *p,int n)//输入进来的是数组的储存地址 {     int tmp,i,j,*q=p; //------------------------------------------------ //  把数组的值从小到大赋给指针指向的值      for(i=0;i<n;i++)     {         p=q;         for(j=0;j<n-i-1;j++)//for(j=0;j<n-i;j++)         {             if(*p >= *(p+1))             {                 tmp=*p;                 *p=*(p+1);                 *(p+1)=tmp;                 //p++;             }                 //else if(*p<*(p+1))                 //{             p++;                 //}         }     }   // printf("%d %d %d %d %d\n",*p,*(p+1),*(p+2),*(p+3),*(p+4)); //------------------------------------------------     p=q;     for(i=0;i<n;i++)     {         printf("%d ",*p);         p++;     } } //------------------------------------------------ void main() {     //输入数字的数目     int n;     printf("Please enter the number of digits:\n");     scanf("%d",&n);     //输入数组     int arr[n];       printf("Please enter %d numbers:\n",n);     for(int i=0;i<n;i++)     {         scanf("%d",&arr[i]);     }     getchar();       //把数组的地址给p     int *p;     p=arr;     //     //printf("*(p+1)=%d\n",*(p+2));     min_print(p,n);      system("pause"); }   //Please enter the number of digits: //5 //Please enter 5 numbers: //6 2 7 5 0 //0 2 5 6 7 请按任意键继续. . . 谢谢！ 请问为什么要有q＝p呢？


Question: 【求助】代码引发异常:读取访问权限冲突

试验了下，结果如下，供参考：//链表a 和 链表b 应该都是顺序链表，不存在楼主输入倒序的问题，下面是两次运行的例子，第二次的存在问题.  //第一次输入：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //3,78 //7,88 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //1,98 //5,76 //0 //There are 4 records: //1 98 //3 78 //5 76 //7 88 //请按任意键继续. . .   //第二次输入：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //5,66 //9,88 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //1,76 //2,85 //0 //运行到这里就出错了。

引用 6 楼 Alonzo_11 的回复:那该怎么办呢 能自行解决吗 @user-1 建议先从分析清楚函数struct student* insert(struct student* ah, struct student* bh)里的判断逻辑开始，然后就你发现的问题，想想问题出在哪儿，试着去修改下，改错了也没关系，再把代码复制粘贴回去就是了，加油

那该怎么办呢 能自行解决吗 @user-1

引用 4 楼 Alonzo_11 的回复:引用//运行结果：   //input list a: //input number & scores of student: //if number is 0,stop inputing. //1,60 //4,80 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //3,90 //6,70 //0 //There are 4 records: //1 60 //3 90 //4 80 //6 70 //请按任意键继续. . .  某些测试数据没有排序 对的，这个函数struct student* insert(struct student* ah, struct student* bh)，存在漏洞，有待完善，加油

改了没大问题了，可以运行，小细节上有待完善。供参考：//#include <bits/stdc++.h> #include <iostream.h> using namespace std; #define LEN sizeof(struct student)  struct  student {     long num;     int score;     struct student* next; };  struct student lista, listb; int n, sum = 0;  int main() {     struct student* creat(void);     struct student* insert(struct student*, struct student*);     void print(struct student*);     struct student* ahead, * bhead, * abh;     printf("input list a:\n");     ahead = creat();     sum = sum + n;     printf("input list b:\n");     bhead = creat();     sum = sum + n;     abh = insert(ahead, bhead);     print(abh);      system("pause");     return 0; }  struct student* creat(void) {     struct student* p1, * p2, * head;     n = 0;     p1 = p2 = (struct student*)malloc(LEN);     printf("input number & scores of student:\n");     printf("if number is 0,stop inputing.\n");     scanf("%ld,%d", &p1->num, &p1->score);//这里的输入格式是带','号的，英文半角     head = NULL;     while (p1->num != 0)     {         n = n + 1;         if (n == 1)             head = p2; //head = p1;         else             p2->next = p1;         p2 = p1;         p1 = (struct student*)malloc(LEN);         scanf("%ld,%d", &p1->num, &p1->score);//这里的输入格式是带','号的，英文半角     }     p2->next = NULL;     return(head); }  struct student* insert(struct student* ah, struct student* bh) {     struct student* pa1, * pa2, * pb1, * pb2;     pa2 = pa1 = ah;     pb2 = pb1 = bh;     do     {         while ((pb1->num > pa1->num) && (pa1->next != NULL))  //!= nullptr))         {             pa2 = pa1;             pa1 = pa1->next;         }         if (pb1->num <= pa1->num)         {             if (ah == pa1)                 ah = pb1;             else                 pa2->next = pb1;             pb1 = pb1->next;             pb2->next = pa1;             pa2 = pb2;             pb2 = pb1;         }     } while ((pa1->next != NULL) || (pa1 == NULL && pb1 != NULL));     if ((pb1 != NULL) && (pb1->num > pa1->num) && (pa1->next == NULL))         pa1->next = pb1;     return(ah); }  void print(struct student* head) {     struct student* p;     printf("There are %d records:  \n", sum);     p = head;     if (p != NULL)         do         {             printf("%ld %d\n", p->num, p->score);             p = p->next;         } while (p != NULL); }   //运行结果：  //input list a: //input number & scores of student: //if number is 0,stop inputing. //1,60 //4,80 //0 //input list b: //input number & scores of student: //if number is 0,stop inputing. //3,90 //6,70 //0 //There are 4 records: //1 60 //3 90 //4 80 //6 70 //请按任意键继续. . .

改了还是一样的情况o

while ((pb1->num > pa1->num) && (pa1->next != nullptr))改为：while ((pb1->num > pa1->num) && (pa1->next != NULL ))


Question: 大佬们帮忙看下哪里错了

引用 1 楼 自信男孩的回复:#include<stdio.h> #include<stdlib.h>  #define OVERLOW -2 #define ERROR 0 #define OK 1  typedef int Status; typedef float QElemType;  typedef struct QLNode{     QElemType data;     struct QLNode *next; }QLNode, *QueuePtr; typedef struct {     QueuePtr front;     QueuePtr rear; }LinkQueue;  //创建空队列 Status InitQueue(LinkQueue &Q) {     /*     Q.front = Q.rear = (QueuePtr)malloc(sizeof(QLNode));     if(!Q.front)     {         exit(OVERLOW);     }      //Q.front = NULL;     Q.front->next = NULL;     */     Q.front = Q.rear = NULL;     return OK; } Status ClearQueue(LinkQueue &Q); //销毁队列 Status DestoryQueue(LinkQueue &Q) {     ClearQueue(Q);     /*     while(Q.front)     {         Q.rear = Q.front->next;         free(Q.rear);         Q.front = Q.rear;     }     */     return OK; } //插入元素e为Q的新的队尾元素 Status EnQueue(LinkQueue &Q, QElemType e) {     QueuePtr p;     printf("请输入e的值\n");     scanf("%f", &e);     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p->data = e;     p->next = NULL;      if (Q.rear == NULL) {         Q.rear = Q.front = p;     } else {         Q.rear->next = p;         Q.rear = p;     }     /*     p->data = e;     p->next =NULL;     Q.rear->next = p;     Q.rear = p;     */     return OK; } //删除Q的对头元素，用e带回 Status DeQueue(LinkQueue &Q, QElemType &e) {     QueuePtr p;      if (Q.front == NULL)         return ERROR;      if (Q.front == Q.rear) {         e = Q.front->data;         p = Q.front;         Q.front = Q.rear = NULL;         free(p);         return OK;     }     e = Q.front->data;     p = Q.front;      Q.front = Q.front->next;     free(p);     return OK;      /*     QueuePtr p;     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     if(Q.front == Q.rear)     {         return ERROR;     }     p = Q.front->next;     e = p->data;     Q.front->next = p->next;     if (p == Q.rear) //当删除最后一个元素时，尾指针可能没有指向     {         Q.rear = Q.front;     }     free(p);     */     return OK; } //清空队列 Status ClearQueue(LinkQueue &Q) {     QueuePtr p, q;      p = Q.front;      while (p) {         q = p->next;         free(p);         p = q;     }     Q.front = Q.rear = NULL;      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     while(!Q.rear)     {         p = Q.front->next;         Q.front->next = p->next;         free(p);     }     Q.rear = Q.front;     */     return OK; } //计算队列的长度 Status QueueLength(LinkQueue Q) {     QueuePtr p;     int i = 0;      p = Q.front;      while (p) {         i++;         p = p->next;     }      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     Status i = 1;     p = Q.front->next;     while(p != Q.rear)     {         p = p->next;         i++;     }     */     return i; } //用e返回Q的头部元素 Status GetHead(LinkQueue Q, QElemType &e) {     if (!Q.front)         return ERROR;      e = Q.front->data;     /*     if(Q.front == Q.rear)     {         return ERROR;     }     e = Q.front->next->data;     */     return OK; }  //显示队列 Status VisitQueue(LinkQueue Q) {     QueuePtr p;      p = Q.front;      while (p) {         printf("%.1f ", p->data);         p = p->next;     }     printf("\n");      /*     p = (QueuePtr)malloc(sizeof(QLNode));     if(!p)     {         exit(OVERLOW);     }     p = Q.front->next;     while(p != Q.rear->next)     {         printf("%f", p->data);         p = p->next;     }     */     return 0; } int main() {     LinkQueue Q;     QElemType e;     Status flag;     int len;     while(1)     {         printf("****************************\n");         printf("********队列操作系统********\n");         printf("1.创建空队列                \n");         printf("2.插入元素e为Q的新的队尾元素\n");         printf("3.删除Q的对头元素，用e带回  \n");         printf("4.清空队列                  \n");         printf("5.计算队列的长度            \n");         printf("6.用e返回Q的头部元素        \n");         printf("7.显示队列                  \n");         printf("8.销毁队列                  \n");         printf("请选择功能序号：\n");         scanf("%d", &flag);         switch(flag)         {             case 1: InitQueue(Q);                     break;             case 2: EnQueue(Q, e);                     break;             case 3: DeQueue(Q, e);                     break;             case 4: ClearQueue(Q);                     break;             case 5: len = QueueLength(Q);                     printf("Queue's length: %d\n", len);                     break;             case 6: GetHead(Q, e);                     printf("head data: %.1f\n", e);                     break;             case 7: VisitQueue(Q);                     break;             case 8: DestoryQueue(Q);                     break;         }//switch     }//while     return OK; }  供参考～  除了代码问题之外，架构设计的也有点问题，初始化队列，不应该放在选择项里，而是放在进入循环之前的操作； 清除队列和销毁队列其实是一个意思～ 谢谢，我是大一学生，术语懂得不多，谢大佬指点


Question: C语言求余弦函数的近似值中精度高不可直接计算阶乘的问题

再供参考：#include <iostream> #include <string> using namespace std; inline int compare(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string SUB_INT(string str1,string str2); string ADD_INT(string str1,string str2) {//高精度加法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         if (str2[0]=='-') {             sign=-1;             str=ADD_INT(str1.erase(0,1),str2.erase(0,1));         } else {             str=SUB_INT(str2,str1.erase(0,1));         }     } else {         if (str2[0]=='-') {             str=SUB_INT(str1,str2.erase(0,1));         } else { //把两个整数对齐，短整数前面加0补齐             string::size_type L1,L2;             int i;             L1=str1.size();             L2=str2.size();             if (L1<L2) {                 for (i=1;i<=L2-L1;i++) str1="0"+str1;             } else {                 for (i=1;i<=L1-L2;i++) str2="0"+str2;             }             int int1=0,int2=0; //int2 记录进位             for (i=str1.size()-1;i>=0;i--) {                 int1=(int(str1[i])-'0'+int(str2[i])-'0'+int2)%10;                 int2=(int(str1[i])-'0'+int(str2[i])-'0'+int2)/10;                 str=char(int1+'0')+str;             }             if (int2!=0) str=char(int2+'0')+str;         }     }     //运算后处理符号位     if ((sign==-1)&&(str[0]!='0')) str="-"+str;     return str; } string SUB_INT(string str1,string str2) {//高精度减法     int sign=1; //sign 为符号位     string str;     int i,j;     if (str2[0]=='-') {         str=ADD_INT(str1,str2.erase(0,1));     } else {         int res=compare(str1,str2);         if (res==0) return "0";         if (res<0) {             sign=-1;             string temp =str1;             str1=str2;             str2=temp;         }         string::size_type tempint;         tempint=str1.size()-str2.size();         for (i=str2.size()-1;i>=0;i--) {             if (str1[i+tempint]<str2[i]) {                 j=1;                 while (1) {//zhao4zhong1添加                     if (str1[i+tempint-j]=='0') {                         str1[i+tempint-j]='9';                         j++;                     } else {                         str1[i+tempint-j]=char(int(str1[i+tempint-j])-1);                         break;                     }                 }                 str=char(str1[i+tempint]-str2[i]+':')+str;             } else {                 str=char(str1[i+tempint]-str2[i]+'0')+str;             }         }         for (i=tempint-1;i>=0;i--) str=str1[i]+str;     }     //去除结果中多余的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str ="-"+str;     return str; } string MUL_INT(string str1,string str2) {//高精度乘法     int sign=1; //sign 为符号位     string str;     if (str1[0]=='-') {         sign*=-1;         str1 =str1.erase(0,1);     }     if (str2[0]=='-') {         sign*=-1;         str2 =str2.erase(0,1);     }     int i,j;     string::size_type L1,L2;     L1=str1.size();     L2=str2.size();     for (i=L2-1;i>=0;i--) { //模拟手工乘法竖式         string tempstr;         int int1=0,int2=0,int3=int(str2[i])-'0';         if (int3!=0) {             for (j=1;j<=(int)(L2-1-i);j++) tempstr="0"+tempstr;             for (j=L1-1;j>=0;j--) {                 int1=(int3*(int(str1[j])-'0')+int2)%10;                 int2=(int3*(int(str1[j])-'0')+int2)/10;                 tempstr=char(int1+'0')+tempstr;             }             if (int2!=0) tempstr=char(int2+'0')+tempstr;         }         str=ADD_INT(str,tempstr);     }     //去除结果中的前导0     str.erase(0,str.find_first_not_of('0'));     if (str.empty()) str="0";     if ((sign==-1) && (str[0]!='0')) str="-"+str;     return str; } string DIVIDE_INT(string str1,string str2,int flag) {//高精度除法。flag==1时,返回商; flag==0时,返回余数     string quotient,residue; //定义商和余数     int sign1=1,sign2=1;     if (str2 == "0") {  //判断除数是否为0         quotient= "ERROR!";         residue = "ERROR!";         if (flag==1) return quotient;         else         return residue ;     }     if (str1=="0") { //判断被除数是否为0         quotient="0";         residue ="0";     }     if (str1[0]=='-') {         str1   = str1.erase(0,1);         sign1 *= -1;         sign2  = -1;     }     if (str2[0]=='-') {         str2   = str2.erase(0,1);         sign1 *= -1;     }     int res=compare(str1,str2);     if (res<0) {         quotient="0";         residue =str1;     } else if (res == 0) {         quotient="1";         residue ="0";     } else {         string::size_type L1,L2;         L1=str1.size();         L2=str2.size();         string tempstr;         tempstr.append(str1,0,L2-1);         for (int i=L2-1;i<L1;i++) { //模拟手工除法竖式             tempstr=tempstr+str1[i];             tempstr.erase(0,tempstr.find_first_not_of('0'));//zhao4zhong1添加             if (tempstr.empty()) tempstr="0";//zhao4zhong1添加             for (char ch='9';ch>='0';ch--) { //试商                 string str;                 str=str+ch;                 if (compare(MUL_INT(str2,str),tempstr)<=0) {                     quotient=quotient+ch;                     tempstr =SUB_INT(tempstr,MUL_INT(str2,str));                     break;                 }             }         }         residue=tempstr;     }     //去除结果中的前导0     quotient.erase(0,quotient.find_first_not_of('0'));     if (quotient.empty()) quotient="0";     if ((sign1==-1)&&(quotient[0]!='0')) quotient="-"+quotient;     if ((sign2==-1)&&(residue [0]!='0')) residue ="-"+residue ;     if (flag==1) return quotient;     else         return residue ; } string DIV_INT(string str1,string str2) {//高精度除法,返回商     return DIVIDE_INT(str1,str2,1); } string MOD_INT(string str1,string str2) {//高精度除法,返回余数     return DIVIDE_INT(str1,str2,0); } int main() {     char ch;     string s1,s2,res;      while (cin>>s1>>ch>>s2) {         switch (ch) {             case '+':res=ADD_INT(s1,s2);break;             case '-':res=SUB_INT(s1,s2);break;             case '*':res=MUL_INT(s1,s2);break;             case '/':res=DIV_INT(s1,s2);break;             case '%':res=MOD_INT(s1,s2);break;             default :                   break;         }         cout<<res<<endl;     }     return(0); }

仅供参考：#include <iostream> #include <string> #include <algorithm> using namespace std; inline int COMPARE(string str1,string str2) {//相等返回0，大于返回1，小于返回-1          if (str1.size()>str2.size()) return 1; //长度长的整数大于长度小的整数     else if (str1.size()<str2.size()) return -1;     else                              return str1.compare(str2); //若长度相等，则头到尾按位比较 } string PLUS(string number1,string number2) {     int i;     int length1 = number1.size();     int length2 = number2.size();      string result="";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      for(i = 0; i < length1 && i < length2; i++) {         char c = (char)(number1[i] + number2[i] - 48);         result = result + c;     }      while(i < length1) {         result = result + number1[i];         ++i;     }      while(i < length2) {         result = result + number2[i];         ++i;     }      int carry = 0;     for(i = 0; i < (int)result.size(); ++i) {         int value = result[i] - 48 + carry;         result[i] = (char)(value % 10 + 48);         carry = value / 10;     }      if(carry !=0 ) {         result = result + (char)(carry + 48);     }      for(i = result.size() - 1; i >= 0; i--) {         if(result[i] != '0') break;     }      result = result.substr(0, i + 1);      reverse(result.begin(), result.end());     if(result.length() == 0) result = "0";     return result; } string MULTIPLY(string number1, string number2) {     int i, j;     int *iresult;     int length1 = number1.size();     int length2 = number2.size();     string result = "";      reverse(number1.begin(), number1.end());     reverse(number2.begin(), number2.end());      iresult = (int*)malloc(sizeof(int) * (length1 + length2 + 1));     memset(iresult, 0, sizeof(int) * (length1 + length2 + 1));      for(i = 0; i < length1; i++) {         for(j = 0; j < length2; j++) {             iresult[i+j] += ((number1[i] - 48) * (number2[j] - 48));         }     }      int carry = 0;     for(i = 0; i < length1 + length2; i++) {         int value = iresult[i] + carry;         iresult[i] = value % 10;         carry = value / 10;     }      for(i = length1 + length2 - 1; i >= 0; i--) {         if(iresult[i] != 0)break;     }      for(; i >= 0; i--) {         result = result + (char)(iresult[i]+48);     }      free(iresult);      if(result == "") result = "0";     return result; } string factorial(string n) {     string temp = "1";     string i;     for(i = "1"; COMPARE(i, n) <= 0; i = PLUS(i, "1")) {         temp = MULTIPLY(temp, i);     }     return temp; } int main(void) {     cout << factorial("100") << endl;     return 0; } //93326215443944152681699238856266700490715968264381621468592963895217599993229915608941463976156518286253697920827223758251185210916864000000000000000000000000 //

求阶乘函数里，int n 类型不对，改double型，int型最大值为：2147483647。当精度取0.01 时，n*fact(n-1)=12! , 0.001时14！，0.0001时16！，当13!的时候已经超出n的范围，


Question: 麻烦哪位大神和我说说下面给我的警告是啥意思？为啥我感觉用着也没问题呀？

声明了全局静态数组a[]，却没有给出大小，程序不出错是你的运气。如果你声明了其它静态变量，由于a[]没有给出大小，在scanf向a放入输入字符串的时候，会覆盖其它静态变量，程序必然出错！概念要清晰！

引用 7 楼 forever74 的回复:1、作为一维数组名，a和&a表示的地址值相同是必然的，不是偶然。但更重要的是它们还有区别，位于白马背上的不一定都是猴子的师傅。 2、字符串，是特定的语法概念，其实体结构，开始于某个首地址，结束于码值为0的字符。用首地址表示，同时其语法意义也多半是其首地址。可以放进字符数组这个容器，也可以不放。 字符数组是每个元素占用1字节的数组，可以用来存放字符串也可以用来存放不是字符串的东西。 3、见上，%s引用首地址，打印字符串。碰巧该字符串放在字符数组里，看着好像打印字符数组了。 谢谢

引用 6 楼 user-3 的回复:在CSDN论坛里搜下"字符数组和字符串的区别和联系". scanf()函数用法，参考下：https://blog.csdn.net/luxuejuncarl/article/details/1576513   谢谢

引用 2 楼 forever74的回复:其一，scanf里面第二个参数应该是a，而不是&a。没表现出问题是因为它俩的“值”都是同样的地址值。但是它们的类型不同，乱用是一个很粗浅的错误。 其二，a没有给出长度，未初始化的数组又不给出长度，这应该是个error才对。 兄台我还有三个问题： 1、&a 和a地址值相同是不是一种偶然？ 2、字符数组和字符串有何区别？ 3、以%s格式地址是字符数组首地址，居然能打印出整个字符数组，这是神马情况？

引用 1 楼 user-3的回复:给数组a指定一个长度，如char a[32]. 必须要指定长度吗

这两个问题都不能忽视，不要因为没看出后果就不以为然。 此处省略因措辞严厉而引起读者不适的一百五十字。

给数组a指定一个长度，如char a[32].


Question: 大佬们求助

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

#include<stdio.h>  int main() {     int a=3,b=7,c=5;      //switch(a>0)     switch(a)     {         //case 1:swith(b<0)         case 1:switch(b)                {                    case 1:printf("@");break;                    case 2:printf("!");break;                }                break;   //add break         //case 0:switch(c==5)         case 0:switch(c)                {                    case 0:printf("*");break;                    case 1:printf("#");break;                    case 2:printf("$");break;                }                break;//add break         default:                printf("&");     }     printf("\n");      return 0; }  供参考～  switch注意拼写，别少了c字母  switch()括号里的是一个整型数表达式，不是判断表达式；  如果用a >0，那么下面的case用两个就好了case 0, case 1因为只有两种结果。

case 1:swith(b<0)这句，switch,供参考：#include<stdio.h> int main() {    int a=3,b=7,c=5;    switch(a>0)    {            case 1:switch(b<0) //case 1:swith(b<0)                  {                    case 1:printf("@");break;                    case 2:printf("!");break;                  }            //break; 这里是否缺了break            case 0:switch(c==5)                 {                    case 0:printf("*");break;                    case 1:printf("#");break;                    case 2:printf("$");break;                 }            //break; 这里是否缺了break            default:printf("&");    }    printf("\n");        return 0; }  //#& //请按任意键继续. . .


Question: 求助： C程序 延迟中途如何响应按键？

https://blog.csdn.net/fbysss/article/details/2412485 参考这个博客，只要 getch 不阻塞，你就可以sleep 后判断时间，来决定要不要继续循环了

引用 4 楼 proof1 的回复:[quote=引用 2 楼 forever74 的回复:]变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。 在300次中，读取键盘状态并相应处理？[/quote] 还是这个循环，你原来怎么处理按键，之后自然还是怎么处理。 仅仅是缩短延迟时间，增加一个计数变量，多一两个if

不是中断处理的吗？

引用 2 楼 forever74 的回复:变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。 在300次中，读取键盘状态并相应处理？

弃用sleep() ， delay()  循环获取时间，比较时间，同时读取按键状态？

变通嘛，不要延迟5分钟，做延迟1秒的，然后做个变量计数，转300次再刷字符串。

开个定时器计算没有按键按下的时间咯，如有按键按下，那时间重新计算，如果累计5Min没有按键按下更改显示咯

为什么不用系统 API，监听案件事件？

参考：while (1){  　  sleep(1秒)  计数器+1     读按键 随时响应按键（有按键就退出） 　　if (计数器＝300)  { 　　　　清除字符串 　　　　更改屏幕坐标 　　　　显示字符串 　　　　计数器＝0 　　} }

------------------------------- while (结束标志)  { 　　显示字符串 　　for (i=1; i<=300; i++) 　　　　if  (没有按键)  　　　　　　sleep(1秒) 　　　　else 　　　　　　置结束标志 　　清除字符串 　　更改屏幕坐标 } -------------------------------  ？？？ 有些冗长。

引用 6 楼 forever74 的回复:还是这个循环，你原来怎么处理按键，之后自然还是怎么处理。 仅仅是缩短延迟时间，增加一个计数变量，多一两个if  ------------------------------- while (没有按键)  { 　　sleep(1秒) 　　计数器+1 　　if  (计数器＝300)  { 　　　　清除字符串 　　　　更改屏幕坐标 　　　　显示字符串 　　　　计数器＝0 　　} } -------------------------------  是这样？


Question: 来个大佬帮忙

#include <iostream> //#include "Linklist.h"  #include <iostream> #include <stdio.h>  using namespace std;  #define OK 1 #define ERROR 0 #define TRUE 1 #define FALSE 0  #ifndef EOF #define EOF -1 #endif  #define MAXSiZE 100  typedef int Elemtype; typedef int Status;  //结点 typedef struct Lnode {     Elemtype date;     struct Lnode* next; }Lnode, * Link;   //控制结构 typedef struct link {     Link head, tail;     int len;     int isnotInit; }link;   //初始化 Status Init_Linklist(link& L) {     L.head = L.tail = new Lnode[1];     if (!L.head) { return ERROR; }     //头结点数据域不存数据     L.head->next = NULL;     L.len = 0;     L.isnotInit = 1;      return OK; }  //插入 Status Insert_Linklist(link& L, int i, Elemtype e) {     int j;     Link p, q;     q = p = L.head;     if (L.isnotInit != 1) { return ERROR; }     if (i<1 || i>L.len + 1) { return ERROR; }     if (i != L.len + 1)     {         for (j = 1; j < i; j++) { p = p->next; }//for(j=0;j<i-1;j++),第i-1个结点         q = new Lnode[1];         q->date = e;         q->next = p->next;         p->next = q;         L.tail = q; //Update tail     }     if (i == L.len + 1) {         q = new Lnode[1];         q->date = e;         q->next = L.tail->next;         L.tail->next = q;         L.tail = q;     }//插入在链尾     L.len++;      return OK; }  //删除 Status Delete_Linklist(link& L, int i, Elemtype& e) {     int j;     Link p, q;     p = L.head;     if (L.isnotInit != 1) { return ERROR; }     //if (i < 1 || i < L.len) { return ERROR; }     if (i < 1 || i > L.len) { return ERROR; }      for (j = 1; j < i; j++)         p = p->next;     q = p->next;     e = q->date;     p->next = q->next;     free(q);     /*     if (i != L.len)     {         for (j = 1; j < i; j++) { p = p->next; }         q = p->next;         e = q->date;//保存结点数据         p->next = q->next;         delete[] q;     }     if (i == L.len) {         L.tail = p;     }     */     L.len--;     return OK; }  //按值查找 #if(1) int Locate_Linklist(link L, Elemtype e) {     int i = 1;     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head->next;//第一个结点     while (p != NULL && p->date != e)     {         p = p->next;         i++;     }     //if (p->date == e){return i;}     if (p && p->date == e){return i;}     else     {         cout << "The key is not fine!" << endl;         return -1;//NULL;     }      return -1; } #endif  #if(0) Lnode* Locate_Linklist(link L, Elemtype key) {     Lnode* p = L.head->next;     while (p != NULL && p->date == key) { p = p->next; }     if (p->date == key) { return p; }     else     {         cout << "The key is not fine" << endl;         return NULL;     } } #endif  Status Get_Linklist(link& L, int a, Elemtype& key) {     if (L.isnotInit != 1) { return ERROR; }      Lnode* p = L.head->next;     while (p != NULL && p->date == a) { p = p->next; }     //if (p->date == key) { key = a; }     if (p && p->date == a) { key = a; return OK;}     else     {         cout << "The key is not fine" << endl;         return -1;//NULL;     }      return -1; }  //位置查找 Status Seek_Linklist(link L, int i, Elemtype e) {     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head->next;     //for (int j = 0; j < i - 1; j++) {p = p->next;}     for (int j = 0; j < i - 1 && p; j++) {p = p->next;}     if (!p)         return ERROR;      e = p->date;     return e; }  //位置改值 Status Change_Linklist(link& L, int i, Elemtype& e) {     int j;     if (L.isnotInit != 1) { return ERROR; }     Lnode* p = L.head;     if (i<1 || i>L.len) { return ERROR; }     for (j = 0; j < i - 1; j++) { p = p->next; }     p->date = e;     return OK; }  void Traver_Linklist(link L) {     Lnode* p;     if (!L.head)         return;      p = L.head->next;     while (p)     {         cout << p->date << "\t";         p = p->next;     }     cout<<endl; }  int main() {     int l;     link L;     Elemtype e;     //cout << Init_Linklist(L) << endl;     Init_Linklist(L);      for (int i = 0; i < 10; i++)     {         cin >> e;         Insert_Linklist(L, 1, e);     }     Traver_Linklist(L);     cout << endl;      int n1;     cout << "删除第几个位置:" << " ";     cin >> n1;     Delete_Linklist(L, n1, e);     Traver_Linklist(L);     cout << endl;      int n2;     cin >> e;     n2 = Locate_Linklist(L, e);     Traver_Linklist(L);     cout <<n2<< endl;      int n3;     cin>>n3;     Get_Linklist(L, n3, e);     Traver_Linklist(L);     cout <<e<< endl;      int n4, a;     cin >> e;     a = Seek_Linklist(L, n4, e);     Traver_Linklist(L);     cout << endl;      int n5;     cin >> e>>n5;     Change_Linklist(L, n5, e);     Traver_Linklist(L);     cout << endl;      return 0; } 供参考～

改什么呢？要改成什么样子？


Question: comparison between pointer and integer这个问题

i +=strlen(remain_text[index][0]);

remain_tex这个是怎么定义的？建议提供更多信息吧  remain_tex的类型是不是是int类型？

题目所述疑似不是这行的问题， 而这行正确与否取决于数组的定义。

i +=strlen (remain _text [index]);


Question: 求一个C语言字符串中运算符相关的题的解法

或者就像第一句一样加std::cout试看是否还有问题？另外注意看认真看，最后一个else;是有冒号的。

可把前面的输出全部取消，最后输出替换为C语言的，不该连输入输出都不会！  https://z3.ax1x.com/2021/04/05/cQGMjK.png

这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错 引用 3 楼 智者知已应修善业 的回复:[img=https://img-bbs.csdn.net/upload/202104/03/1617442385_516357.png" alt="" />   引用 7 楼 智者知已应修善业 的回复:花括号自己添加应该会，输入输出自己也该会。ends用“ ”替代。   https://z3.ax1x.com/2021/04/05/cQGMjK.png

花括号自己添加应该会，输入输出自己也该会。ends用“ ”替代。

发出你的代码看看 引用 4 楼 binv 的回复:这个前面的代码是什么，就直接建立工程给的初始代码吗，我看的时候中间倒数第二个else总是报错，而且cout<<  <<ends;的时候也是报错

前四位，前三位啥意思？

先自己写写吧，不懂得再提出来呗。这个应该不难～


Question: 求代码

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html


Question: 求一个矩阵快速比较阙值转换成二值化的 算法

void photo_get() { 	int num = 0; 	for(num = 0;num < MT9V03X_H;num++) 	{ 		memcpy(dis_image[num],mt9v03x_image[num],MT9V03X_W);//原始数据为mt9v03x_image  结果memcpy  复制到dis_image 	}	 } //以下是大津法  计算得到dis_image 图片的阙值 阙值输出为  threshold  uint8 threshold = 0;  void my_adapt_threshold(uint8 *image, uint16 col, uint16 row)   {    #define GrayScale 256     uint16 width = col;     uint16 height = row;     int pixelCount[GrayScale];     float pixelPro[GrayScale];     int i, j, pixelSum = width * height/4;     uint8* data = image;  //?????????     for (i = 0; i < GrayScale; i++)     {         pixelCount[i] = 0;         pixelPro[i] = 0;     }          uint32 gray_sum=0;           for (i = 0; i < height; i+=2)     {         for (j = 0; j < width; j+=2)         {             pixelCount[(int)data[i * width + j]]++;               gray_sum+=(int)data[i * width + j];                }     }                                     for (i = 0; i < GrayScale; i++)     {         pixelPro[i] = (float)pixelCount[i] / pixelSum;              }           float w0, w1, u0tmp, u1tmp, u0, u1, u, deltaTmp, deltaMax = 0;                             w0 = w1 = u0tmp = u1tmp = u0 = u1 = u = deltaTmp = 0;         for (j = 0; j < GrayScale; j++)                  {                              w0 += pixelPro[j];                   u0tmp += j * pixelPro[j];                              w1=1-w0;                u1tmp=gray_sum/pixelSum-u0tmp;                          u0 = u0tmp / w0;                               u1 = u1tmp / w1;                              u = u0tmp + u1tmp;                             deltaTmp = w0 * pow((u0 - u), 2) + w1 * pow((u1 - u), 2);                 if (deltaTmp > deltaMax)                 {                     deltaMax = deltaTmp;                     threshold = j;                 }                 if (deltaTmp < deltaMax)                 {                 break;                 }                     } //  for(i = 0; i < threshold; i++) //	{ //		Bin_Array[i] = 0; //	} //	for(i = threshold; i < 256; i++) //	{ //		Bin_Array[i] = 1; //	} }


Question: 求助，C语言编程题，代码运行不了。

引用 1 楼 user-1的回复:供参考：#include <stdio.h> int main() {     int n;     int time=0;     scanf("%d",&n);     for(;;)     {         if(n==2 || n==3)//if(n==2&&n==3)         {             time++;             printf("%d",time);             break;         }         else         {             if(n%3==0)             {                 time++;                 n=n/3;             }             else             {                 time++;                 n=((n-(n%3))/3)+(n%3);             }         }     }     return 0; } 谢谢！我这属于低级错误。。。。


Question: 为什么执行不到else的内容，即使输入else控制的条件，也会执行if后的语句呢

引用 1 楼 赵4老师的回复:scanf("%d,&n");改为scanf("%d",&n); scanf("%d",b);改为scanf("%d",&b);  printf里面的%和变量的一一对应关系 scanf里面的%和变量以及变量前加不加&的一一对应关系 是C代码中非常容易出错的地方，而且通常编译还不出错。 所以在编译源代码之前值得专门仔细检查一遍甚至多遍。  谢谢大佬！感谢感谢

建议楼主检查一下while， if的条件，条件都是=赋值语句，不是判断语句呢。  scanf第二个参数是（变量）地址，而不是变量值。

判断用==运算符。


Question: c语言，这哪里打错了，刚学还不懂

楼上都说拉，我就不说拉，水个帖子

给你写的代码，头文件引入有问题，你对比一下之前的程序，头文件是不是有不一样的地方？ 建议要学会看编译警告和错误，学会看懂他们

昨天休息了，就改2行代码就行了，在聊天工具输入代码 会有 乱码  引用 楼主 Congratulation395 的回复:c语言问题，不知道怎么改

鼠标双击报错的提示行，光标会自动定位到出错的源代码行。

第一行包含的头文件 #incldue <stdio.h> 把内容的< 改为<   > 改为> 你是到复制的吧 ，< : < 小于号   > :  > 大于号；这是html 页面的转义字符


Question: C语言  经典题型 完数的判断

这个肯定不是VC6

可参

可能是 dev-c吧。

看界面是大学微机教室里的VC6.0啊

每次执行完i没有对sum初始化，这样每次的执行都是上次基础上继续给sum增加值。 建议在第一层循环for，第一句执行sum = 0;


Question: C语言实现全排列


Question: 好心人帮忙看下这段代码为什么会出现runtime error，感激不尽！

引用 1 楼 赵4老师 的回复：#include <stdio.h> #define y 114514 int main() {     static long long int a[1000];     long long int n,c,c1,sum=0,j=0;     int i;     scanf("%lld%lld",&n,&c);     c=c%y;     for (i=0; i<=n; i++) {         c1=1;         scanf("%lld",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf("%lld\n",sum);     } else {         printf("0\n");     }     return 0; } 您看下私信

引用 2 楼 自信男孩 的回复：#include <stdio.h> #define y 114514  int main() {     long long int n,c,c1, a[1000],sum=0;//,j=0;     int i, j;      scanf("%lld%lld",&n,&c);     c=c%y;     if (n > 1000)         n = 1000-1;     for (i=0; i<=n; i++) {         c1=1;         scanf("%lld",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf("%lld\n",sum);     } else {         printf("0\n");     }      return 0; } 供参考～  没看出无限循环的代码，但是程序有可能越界，因为n的值输入若大于999就会越界。a最大是1000谢谢啦

引用 1 楼 赵4老师 的回复：#include <stdio.h> #define y 114514 int main() {     static long long int a[1000];     long long int n,c,c1,sum=0,j=0;     int i;     scanf("%lld%lld",&n,&c);     c=c%y;     for (i=0; i<=n; i++) {         c1=1;         scanf("%lld",&a[i]);         a[i]=a[i]%y;         for (j=0; j<i; j++) {             c1=(c1*c)%y;         }         sum+=a[i]*c1;         sum=sum%y;     }     if (c!=0) {         printf("%lld\n",sum);     } else {         printf("0\n");     }     return 0; } 谢谢啦


Question: 【C语言求助】递归中不加return跟加return的区别？

引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 如果按你写的加return的话，输入483，只会输出4，所以我想知道是怎么执行的

引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 这样是怎么执行的？

引用 3 楼 自信男孩的回复:不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 那如果是return加在trans(n)的前面呢？就是 return trans(n)；

“给定一个小点的输入，完整单步跟踪(同时按Alt+7键查看Call Stack里面从上到下列出的对应从里层到外层的函数调用历史)一遍。”是理解递归函数工作原理的不二法门！ 递归函数关注以下几个因素 ·退出条件 ·参数有哪些 ·返回值是什么 ·局部变量有哪些 ·全局变量有哪些 ·何时输出 ·会不会导致堆栈溢出

return 后，下面的语句就不执行了

看了一下老哥，码龄21年，你是真的编程了20年吗

return 以后本次递归不执行，难道 不对吗？

对啊  这不是语言机制吗 我平时很少遇到编程二十几年的人 ，所以好奇的问了一下，不是质疑你说的对不对的问题 ；

有个问题，你这个功能实现在 vs2019 实现不了 整型 转字符串，  引用 楼主 飞禽走兽卍一2b 的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> /*       函数目的：将输入的整数转换为字符型 */ void trans(int n) {          if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }           putchar(n%10+'0'); }  void main() {  printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d",&n);     if(n>0)     {      trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   }  请问这是怎么回事？最好能具体讲讲执行过程，谢谢！

不好意思楼主，我在vs 2019测试了 ，不论 加不加return 返回的值 都是同一个， return的作用，函数是void 类型 可以省略，如果函数的 返回类型 是Int 或 其他类型 ，需要添加return 返回值 ，我认为可能编译器的问题吧，我的测试结果都一样。  测试： 输入 483 输出 483  #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <math.h> #include <stdlib.h> /*       函数目的：将输入的整数转换为字符型 */ void trans(int n) {      if ((n / 10) != 0)     {         trans(n / 10);//输入483，不加return输出483，加return输出4     }      putchar(n % 10 + '0');    // return; }  void main() {     printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d", &n);     if (n > 0)     {          trans(n);     }     if (n < 0)     {         putchar('-');          int abs_n = abs(n);         trans(abs_n);     }   }

void trans(int n) {         if((n/10)!=0)         {             return  trans(n/10);         }         putchar(n%10+'0'); } 首先你要理解递归。按照你的执行流程，trans （483）将调用 trns(48),再调用 trns(4) 进入到trans(4)，因为 上边的if不满足条件执行 putchar 打印4 退出了trans(4) 返回到 trans（48）  然后立刻退出trans(48) 返回到 trans(483) ,再退出trans(483) 返回到main() ,加了return 后 putchar 这句话将得不到运行所以打印不出来。

引用 6 楼 飞禽走兽卍一2b 的回复:[quote=引用 3 楼 自信男孩的回复:]不加return，只要有退出函数的条件就行，防止函数一直递归下去，而无终止。  void trans(int n) {           if((n/10)!=0)         {            trans(n/10);//输入483，不加return输出483，加return输出4         }             putchar(n%10+'0'); } 这个其实也算是有退出条件的，即n/10 == 0；  所以如果要加return的话，可以这么加: #include <stdio.h> #include <stdlib.h>  void trans(int n) {     if (n/10 == 0) {         putchar(n%10+'0');         return;     }     if((n/10)!=0)     {         trans(n/10);//输入483，不加return输出483，加return输出4     }       putchar(n%10+'0'); }  int  main() {     printf("hw 7.17\n");     int n;     printf("Please enter an interger:\n");     scanf("%d",&n);     if(n>0)     {          trans(n);     }     if(n<0)     {         putchar('-');          int abs_n=abs(n);         trans(abs_n);     }   } 供参考～  递归不一定非要return，但是一定要有递归终止的条件。 如果按你写的加return的话，输入483，只会输出4，所以我想知道是怎么执行的[/quote] 你确定执行了我的代码了吗？如果不确定，那就粘贴我的代码到编译器，然后编译执行一下～  如果只是分析得出你的结论，所以还需要执行一下比较好。  我发的代码基本上很少没经过自测的～


Question: 37个人围城一圈，编上号码（1~37），第一个人从1数起，数到5的人被淘汰，接下来的人继续数，最后剩下的人为赢家

C和C++完整教程:https://blog.csdn.net/it_xiangqiang/category_10581430.html C和C++算法完整教程:https://blog.csdn.net/it_xiangqiang/category_10768339.html

fflush()也可用于标准输入（stdin）和标准输出（stdout），用来清空标准输入输出缓冲区 这句fflush(stdin);在windows下的某些编译器可能有效，不等于其他编译器也一定有效；受限于某些编译器～

rewind(stdin)清除标准输入的按键缓冲区

头文件：#include<stdio.h>   定义函数：int fflush(FILE * stream); 函数说明：fflush()会强迫将缓冲区内的数据写回参数stream指定的文件中，如果参数stream为NULL，fflush()会将所有打开的文件数据更新。 返回值：成功返回0，失败返回EOF，错误代码存于errno中。 fflush()也可用于标准输入（stdin）和标准输出（stdout），用来清空标准输入输出缓冲区。 stdin是standard input的缩写，即标准输入，一般是指键盘；标准输入缓冲区即是用来暂存从键盘输入的内容的缓冲区。stdout是standard output 的缩写，即标准输出，一般是指显示器；标准输出缓冲区即是用来暂存将要显示的内容的缓冲区。     清空标准输出缓冲区， 刷新输出缓冲区，即将缓冲区的东西输出到屏幕上  如果圆括号里是已写打开的文件的指针，则将输出缓冲区的内容写入该指针指向的文件，否则清除输出缓冲区。 这里的stdout是系统定义的标准输出文件指针，默认情况下指屏幕，那就是把缓冲区的内容写到屏幕上。 可是从代码中看不出缓冲区会有什么内容，所以它实际上没有起什么作用

//假设有n个人团团围做，从第1个人开始数数，数到第m个人时候，第m个人出列， //然后继续从1开始数数，数到第m个人退出 #include <stdio.h> #include <conio.h> int i,k,t; int n,m; static char f[1001];//0该座位未出圈,1该座位已出圈 void main() {     while (1) {         printf("Input n m(1000>=n>=m>=1):");         fflush(stdout);         rewind(stdin);         if (2==scanf("%d%d",&n,&m)) {             if (1000>=n && n>=m && m>=1) break;         }     }     t=0;//已出圈总人数     i=1;//座位编号     k=1;//当前要数的数     while (1) {         if (0==f[i]) {             if (m==k) {                 t++;                 f[i]=1;                 printf("%3d ",i);                 if (0==t%10) printf("\n");                 if (t>=n) break;             }             k++;if (k>m) k=1;         }         i++;if (i>n) i=1;     }     cprintf("Press any key ...");     getch(); }


Question: C++ 数组中元素的相邻元素地址只差为1

When two pointers to members of the same array object are subtracted, the difference is divided by the size of a member. The result represents the difference of the subscripts of the two array members.The size of the result is implementation-defined, and its type (a signed integral type) is ptrdiff_t defined in the <stddef.h> header. As with any other arithmetic overflow, if the result does not fit in the space provided, the behavior is undefined. If two pointers that do not point to members of the same array object are subtracted, the behavior is undefined. However, if P points either to a member of an array object or one past the last member of an array object, and Q points to the last member of the same array object, the expression (Q+1) - P has the same value as (Q-P) + 1, even though Q+1 does not point to a member of the array object.  当同一个数组的两个成员的指针相减时，其差值为：地址值的差，再除以一个数组成员的size。这个结果代表了两个指针对应元素的下标之差。    所以大家才遇到了上图中所遇到的问题。这是C语言标准所规定的。  本回答引用  [  https://blog.csdn.net/michaelhan3/article/details/74011258  ]

#include <iostream> #include <vector> using namespace std;  int main() {     vector<double>K;     K.resize(5);     int a = &K[1] - &K[0];     int b = &K[2] - &K[0];     int c = &K[3] - &K[2];      cout << a << '\t' << b << '\t' << c << endl;      double k[10];      printf("%lu\n", (k+2) - (k+1));     printf("%lu\n", &k[2] - &k[1]); } 供参考  这样举例子是否能够很好的理解你的问题；  k+2等价&k[2], k+1等价&k[1]; 然后&k[2] - &k[1] == （k+2) - (k+1)==1

可想而知， 既然指针运算+整数1的时候，指向下一个同类型元素， 那自然，它的逆运算就是楼主写的，两个同型元素求地址差，得到的是整数，语义是下标差。

引用 1 楼 真相重于对错 的回复:因为K[1]....这些都是double &K[...]这些代表是double* 所以 &K[1]-&K[0] 是1,这个1代表的是一个double的长度感谢指导

C/C++指针+-数值运算，转换成相差元素的个数


Question: C语言实现数学组合问题


Question: C语言字符串连接

#include<stdio.h> int main (void) {      char *a,*p;      gets(a);      gets(p);      puts(a);      puts (p);      return 0; }

char ch; int i=0;  cha r* p = a; while(ch=*p++)    arr[i++] = ch;  p = b; while(ch=*p++)    arr[i++] = ch;  arr[i] = '\0';

#include <stdio.h>  #define N 20 char arr[N] = {0};  int main() {     char a[]="acegikm";     char b[]="bdfhjnpq";     int i = 0;     for(i = 0;i < sizeof(a)-1;i++)         arr[i] = a[i];     for(i = 0;i < sizeof(b);i++)         arr[i+7] = b[i]; #if 0     for(i = 0;i < sizeof(a) + sizeof(b) - 1;i++)         printf("%c\n",arr[i]); #else      puts(arr); #endif } 供参考～


Question: C语言标准函数库思维导图

MSDN98_1.ISO http://pan.baidu.com/s/1dDF41ix,  MSDN98_2.ISO http://pan.baidu.com/s/1bnGo0Vl

这笔记做得不错，哈哈。

你们课业有点重啊，今天全是你的帖子


Question: 汉罗塔问C语言递归

挺好的啊。。

做笔记？可以考虑使用印象或有道笔记～


Question: 已触发了一个断点问题怎么解决

#include <stdio.h> #include <stdlib.h>  #define true 1 #define false 0  int InvertSequence(int m) {     int c,d,e=0;     if (m > 0 && m < 10) {         //printf("%d", m);         return m;     }     else if (m >= 10 && m <= 99)     {         c= m / 10;         d = m - 10 * c;         //printf("%d%d", d, c);          return d * 10 + c;     }     else if (m >= 100 && m < 1000)     {         c= m / 100;         d= (m - 100 * c) / 10;         e= m - 100 * c - 10 * d;         //printf("%d%d%d", e,d , c);         return e * 100 + d * 10 + c;     }      return m; } int loop(int x) {     if (x == InvertSequence(x))         return true;     else         return false; } int main() {     int a=0;     int i = 0;     int b = 0;     int p, q = 0;     //scanf("%d%d", a, b);     scanf("%d%d", &a, &b);      for (i = a; i <= b; i++)     {         //p = InvertSequence(i);         //q = loop(p);         q = loop(i);         if (q == true)         {             //printf("%d\n", p);             printf("%d\n", i);         }     }     system("pause"); } 供参考～  猜测楼主的功能，不一定对。建议楼主补充一下需求～

int InvertSequence(int m)没有返回值


Question: 求助，用c语言打出以下字符和字母

印度人口5200万？！

注意输出的位宽，比如%10d, 以及小数点%.2lf，以及%20s等等这些

你需要注意的是printf左对齐和右对齐  1.左对齐 printf(“%d\n”,101010); 默认为左对齐。  printf(“%-10d\n”,101010); “-”表示左对齐，在数字宽度前面加上“-”号即可。 说明：数字宽度为10，如果要打印的位数小于10，则在后面补足空格；如果要打印的位数大于10，则打印所有的数字，不会截断。  2.右对齐 printf(“%10d”,101010); 在%和d之间加上数字宽度，就可以右对齐。 说明：数字宽度为10，如果要打印的位数小于10，左边补足空格；如果要打印的位数大于10，则打印所有的数字，不会截断。