Question: 线性表的基本操作的顺序表示及实现

//以下三个函数最后一个形参可以不用，这里偷懒，均设了个初值 //Status GetELem(SqList L, int i, int e=0); //Status PriorElem(SqList L, int cur_e, int pri_e=0); //Status NextElem(SqList L, int cur_e, int Nex_e=0);第一个问题，这三个函数均是三个形参的设计，功能是找到元素本身及前驱和后驱元素，均有返回值，返回值可以通过函数名返回，并不需要返回到形参，所以只要有前两个形参就能达到我们的目的了。第二个问题，将这三个函数的最后一个形参在声明的时候都初始化了一个值，我们在后面调用这些函数时，可以两个参数的调用  ai = GetELem(La, i)，也可以三个参数的调用  ai = GetELem(La, i，e)，这是C第几版的规定我已经忘了，这极大方便了我们函数的编写和灵活的函数调用，你可以网上搜索下相关的资料。

引用 1 楼 user-2的回复:修改如下，供参考：//以下三个函数最后一个形参可以不用，这里偷懒，均设了个初值 //Status GetELem(SqList L, int i, int e=0); //Status PriorElem(SqList L, int cur_e, int pri_e=0); //Status NextElem(SqList L, int cur_e, int Nex_e=0); //file:xc.h  //#ifndef x_h //#define x_h #include<stdio.h> #include<stdlib.h>  #define MAXSIZE 20 //存储空间初始分配量 #define TURE 1 #define FALSE 0 #define OK 1 #define ERROR 0 #define INFEASIBLE -1 #define OVERFLOW -2  typedef int ElemType; typedef int Status; typedef struct {     ElemType* elem;//数组存储数据元素,最大值为MAXSIZE     int listsize;     int len;//线性表当前长度 }SqList; void CreateList(SqList* L, ElemType a[5], int n);//应该是先声明所构造的线性表操作或者说线性表相关函数 Status InitList(SqList* L); Status DestroyList(SqList* L); Status ClearList(SqList* L); Status ListEmpty(SqList L); Status ListLength(SqList L); Status GetELem(SqList L, int i, int e=0); Status LocateList(SqList L, int e); Status PriorElem(SqList L, int cur_e, int pri_e=0); Status NextElem(SqList L, int cur_e, int Nex_e=0); Status ListInsert(SqList* L, int i, int e); Status ListDelete(SqList* L, int i, int e); Status TravelList(SqList L); //#endif  //file:2.c  //#include "xc.h" //#include"xc.c" void MergeList(SqList La, SqList Lb, SqList* Lc) {     int i, j, k, La_len, Lb_len, ai, bj;     i = j = 0;     k = 0;     La_len = La.len;     Lb_len = Lb.len;     while (i < La_len && j < Lb_len)     {         ai = GetELem(La, i);         bj = GetELem(Lb, j);         if (ai <= bj)         {             ListInsert(Lc, k++, ai);//ListInsert(&Lc, k++, ai);             ++i;         }         else         {             ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);             ++j;         }     }     while (i < La_len)     {         ai = GetELem(La, i++);         ListInsert(Lc, k++, ai); //ListInsert(&Lc, k++, ai);     }     while (j < Lb_len)     {         bj = GetELem(Lb, j++);         ListInsert(Lc, k++, bj);//ListInsert(&Lc, k++, bj);     } } int main() {     int la[5] = { 1,3,5,7,9 };     int lb[5] = { 2,3,6,8,10 };     int i, m, n, k;     int a = 10;     i = 3;     SqList La, Lb, Lc;     InitList(&La);     InitList(&Lb);     InitList(&Lc);     CreateList(&La, la, 5);     CreateList(&Lb, lb, 5);     printf("下面展现已创立的线性表 La Lb\n\n");     printf("线性表La：\n");     TravelList(La);     printf("\n线性表Lb：\n");     TravelList(Lb);     printf("\n下面合并线性表La和Lb成为Lc:\n");     MergeList(La, Lb, &Lc);     TravelList(Lc);     printf("下面销毁线性表Lc\n销毁后线性表为空\n");     DestroyList(&Lc);     TravelList(Lc);     printf("下面判断线性表是否为空：%d（1为是，0为否）\n", ListEmpty(Lc));     printf("\n下面展现已有线性表La的长度为：%d\n", ListLength(La));     printf("\n有线性表La中第3个元素为：%d\n",GetELem(La, i - 1));     printf("\n下面置空线性表Lb\n则置空后Lb为：\n");     ClearList(&Lb);     TravelList(Lb);     printf("下面判断线性表是否为空：%d（1为是，0为否）\n", ListEmpty(Lb));     printf("\n下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继\n");     m = GetELem(La, i - 1);     n = PriorElem(La, i - 1);     k = NextElem(La, i - 1);     printf("第三个元素为：%d\n第三个元素的前驱为：%d\n第三个元素的后继为：%d\n\n", m, n, k);     printf("下面我们往La表中插入一个元素\n");     printf("假使往第三个位置插入元素a=10\n");     a = 10;     ListInsert(&La, i, a);     printf("插入后线性表La为：\n");     TravelList(La);     printf("\n我们删除线性表La中的第3个元素后得到La为：\n");     ListDelete(&La, i, a);     TravelList(La);     printf("\n下面查找线性表中是否有值为3的元素:\n");     LocateList(La, i);          return 0; }    //file:xc.c  //#include "xc.h" void CreateList(SqList* L, ElemType a[100], int n)//应该是先声明所构造的线性表操作或者说线性表相关函数 {     int i;     for (i = 0; i < n; i++)     {         *(L->elem + i) = a[i];     }     L->len = n; } Status InitList(SqList* L) {     L->elem = (ElemType*)malloc(MAXSIZE * sizeof(ElemType));     if (!L->elem) exit(OVERFLOW);//错误退出     L->len = 0;     L->listsize = MAXSIZE;     return OK; } Status DestroyList(SqList* L) {     free(L->elem);     L->elem = NULL;     L->len = 0;     L->listsize = 0;     return OK; } Status ClearList(SqList* L) {     L->len = 0;     return OK; } Status ListEmpty(SqList L) {     if (L.len == 0)         return TURE;     else         return FALSE; } Status ListLength(SqList L) {     return L.len; }  Status GetELem(SqList L, int i, int e) {     if (i < L.len)     {         e = L.elem[i];         return e;     }     else     {         return FALSE;     } } Status LocateList(SqList L, int e) {     int i;     for (i = 0; i < L.len; i++)     {         if (L.elem[i] == e)         {             printf("值为%d的元素是表中第%d个元素\n", e, i + 1);             return i;         }     } } Status PriorElem(SqList L, int cur_e, int pri_e) {      if (cur_e + 1 == 0)     {         return FALSE;     }     if (cur_e + 1 != 0 && cur_e < L.len)     {         pri_e = L.elem[cur_e - 1];         return  pri_e;     } } Status NextElem(SqList L, int cur_e, int Nex_e) {     if (cur_e == L.len)     {         return FALSE;     }     if (cur_e != L.len && cur_e > 0)     {         Nex_e = L.elem[cur_e + 1];         return Nex_e;     }  } Status ListInsert(SqList* L, int i, int e) {     int* p, * q;     p = L->elem + i;     q = L->elem + L->len;     for (; q >= p-1 ; q--)         *(q + 1) = *q;     * p = e;   //*(--p) = e; //插入元素     L->len++;     return TURE; } Status ListDelete(SqList* L, int i, int e) {     int* p, * q;     if (i<1 || i>L->len)     {         return FALSE;     }     //if (i > 1 && i < L->len)     {         p = L->elem + i - 1;         q = L->elem + L->len - 1;         for (; p <= q; p++)             *p = *(p + 1);         L->len--;         return TURE;     } } Status TravelList(SqList L) {     int i;     int* p = L.elem;     for (i = 0; i < L.len; i++, p++)     {         printf("第%d个元素为：%d\n", i, *p);     }     return TURE; }  //下面展现已创立的线性表 La Lb  //线性表La： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：7 //第4个元素为：9  //线性表Lb： //第0个元素为：2 //第1个元素为：3 //第2个元素为：6 //第3个元素为：8 //第4个元素为：10  //下面合并线性表La和Lb成为Lc: //第0个元素为：1 //第1个元素为：2 //第2个元素为：3 //第3个元素为：3 //第4个元素为：5 //第5个元素为：6 //第6个元素为：7 //第7个元素为：8 //第8个元素为：9 //第9个元素为：10 //下面销毁线性表Lc //销毁后线性表为空 //下面判断线性表是否为空：1（1为是，0为否）  //下面展现已有线性表La的长度为：5  //有线性表La中第3个元素为：5  //下面置空线性表Lb //则置空后Lb为： //下面判断线性表是否为空：1（1为是，0为否）  //下面寻找线性表La中第三个元素，以及第三个元素的前驱和后继 //第三个元素为：5 //第三个元素的前驱为：3 //第三个元素的后继为：7  //下面我们往La表中插入一个元素 //假使往第三个位置插入元素a=10 //插入后线性表La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：5 //第3个元素为：10 //第4个元素为：7 //第5个元素为：9  //我们删除线性表La中的第3个元素后得到La为： //第0个元素为：1 //第1个元素为：3 //第2个元素为：10 //第3个元素为：7 //第4个元素为：9  //下面查找线性表中是否有值为3的元素: //值为3的元素是表中第2个元素 //请按任意键继续. . . 首先非常感谢你的回答 有两个疑惑，在Getelem函数，PriorELem函数，NextElem函数的调用就应该传递三个参数吧？最后我选择修改为保留三个参数，调用 过程传递三个参数，成功将其运行，但是全部代码看下来 为何要将其修改如此       ai = GetELem(La, i);         bj = GetELem(Lb, j)呢？可否解释一下，非常非常感谢！


Question: CCF201909-1，运行错误，有大佬帮忙看看吗？

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

引用 3 楼 qzjhjxj 的回复:供参考：#include<iostream> #include<math.h> using namespace std; struct tree{        int pick;        int sum; }; struct SUM{        int b; };  struct SUM su[100000];//定义全局变量  int main() {     int n,m,a=0;      int max=0;     int c=0;      cin>>n>>m;      tree tr[m];     //struct tree *tr = new struct tree [m];      //struct SUM su[100000];      for(int i=0;i<n;i++){         cin>>tr[i].sum;         for(int j=0;j<m;j++){             cin>>tr[j].pick;             tr[j].pick=abs(tr[j].pick);             tr[i].sum=tr[i].sum-tr[j].pick;             su[i].b=su[i].b+tr[j].pick;         }         c=c+tr[i].sum;         if(su[i].b>su[max].b){              max=i;         }else if(su[i].b==su[max].b&&i<max){             max=i;        }     }     cout<<c<<" "<<max+1<<" "<<su[max].b;     //delete []tr;      } 需要考虑到m!=n 且m < n否则会出现越界问题。因为m是tr变量的长度，但是下面循环是用n做比较的。

引用 1 楼 focuslight的回复:什么错误阿，贴出来吧， 我运行这代码没报错阿 我也不知道，但是交上去就是80分了，显示运行错误

什么错误阿，贴出来吧， 我运行这代码没报错阿


Question: 迪杰斯拉求最短路径


Question: 数字塔，小白想问问c有类似用法么，就是一下子输出字符的几倍，不用for循环输出

自己实现一个函数，函数在需要的地方调用这个函数


Question: 【C语言求助】函数部分：矩阵转置输出奇怪的数

引用 3 楼 forever74的回复:主函数里调用时实参写的不对。 PrintArray(array);  //PrintArray(array[3][3]); 不好意思，可以了，谢谢

引用 3 楼 forever74的回复:主函数里调用时实参写的不对。 PrintArray(array);  //PrintArray(array[3][3]); 还是不行呀。

引用 1 楼 user-4的回复:打印函数里，printf ()里arr [i+1 ][j+1]数组下标越界了，直接就是i j 还是不行呀。

上面第一个for里面缺个分号，不可能通过编译，相信是复制时操作马虎造成的。

楼上说的对，为什么要i+1,j+1呢


Question: miracl大数库编写Paillier同态加密，powmod函数导致计算结果越界怎么解决呢

有解决方案了吗

引用 2 楼 qq_42039327 的回复:有解决方案了吗 已解决，是大数库使用不正确的问题，先初始化大数mirvar(0),再进行赋值

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


Question: C语言段错误，如何解决

str第i个值，存在以下可能  1. i越界 2. str[i]为NULL 3. str[i]为野指针   PS：建议以后添加代码发帖

内存泄露  int index = *str[i]; //err 编译器 会 保留第一次的数据内容，等你第二次调用，你已经解引用 ，把内存数据弄没了，也就是指针指向为NULL空，等你第二次指针指向，当然是内存泄露了，所以这样写是错的 根据需求，你在改一下吧

没看懂楼主的需求。建议楼主发一下执行实例。就是楼主的代码怎么测试。  另外，把需求也描述一下～

嗯，string作为类型可不是C语言风格，另外楼主还试探着把*敲着玩，这俩习惯不好哦。 这个程序作为经验，可以让楼主进一步理解指针，地址和值 了。

... str[i] 不是 string 对象吗？解引用是干啥？还赋值给 int，你这题目是想要干啥？

for (int i = 0, len = strlen(*str); i < len; i++)


Question: 要将时间复杂度控制在O(N)以内！！

引用 44 楼 SleekStone 的回复:[quote=引用 43 楼 是疗伤烧肉粽~ 的回复:][quote=引用 37 楼 SleekStone 的回复:][quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了[/quote]用这个试试：int* fun(int *d, int N) {     int *pResult = 0;        if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }            int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }            pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }        return pResult; }[/quote]行了，都过了

引用 28 楼 是疗伤烧肉粽~ 的回复:[quote=引用 24 楼 早打大打打核战争 的回复:][quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf("%d", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf("%d", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf("%c%d", i ? ',' : '{', buf2[i]);   printf("}\n");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢[/quote]  这三行：   for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]]; 第一行统计0~100分每个得分的人数，第三行把超过每个得分的人数写回数组，不必多说。 第二行，因为题目假定分数在0~100，所以超过100的肯定没有，就不计算了（已经预置为0）。超过99的显然就是100分的人数，超过98的就是99+100的人数... 于是得到递推公式：超过x分的人数就是x+1分的人数加上超过x+1的人数（好像是废话啊），从99逆推到0就得到超过每个得分的人数

评估角度：一个算法通常有最理想情况、平均情况、最糟糕情况，我们一般只考虑最糟糕情况 f(n)：一个算法运行的精确次数，如上面的例子，数据集合的大小为n, 则f(n) = 3n + 3 O(f(n))：精确次数===>渐进次数，因为我们通常考虑n趋于无穷大的情况，具体的规则如下： 当f(n)为常数时，如f(n) = 10，则O(f(n)) = O(10) = O(1) 当f(n)为多项式时，只取最高阶项，如f(n) = 2 n 2 + n + 3 2n^2 + n + 32n  2  +n+3，则O(f(n)) = O(2 n 2 2n^22n  2  ) 当f(n)有乘常数，则去除常数，如f(n) = 2 n 2 2n^22n  2  ，则O(f(n)) = O(n 2 n^2n  2  ) 什么是时间复杂度：一个算法运行所需要的时间，但不同的服务器所需的时间不同，通常采用一个算法运行的渐进次数来表示，即T(n)，n是数据集合的大小，表示公式为T(n) = O(f(n)) ———————————————— 版权声明：本文为CSDN博主「Bulut0907」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。 原文链接：https://blog.csdn.net/yy8623977/article/details/109813724

好厉害的样子

引用 27 楼 是疗伤烧肉粽~ 的回复:nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]我想知道这种算法能通过测试不，试一下告诉我结果

引用 27 楼 是疗伤烧肉粽~ 的回复:nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换

引用 43 楼 是疗伤烧肉粽~ 的回复:[quote=引用 37 楼 SleekStone 的回复:][quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了[/quote]用这个试试：int* fun(int *d, int N) {     int *pResult = 0;        if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }            int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }            pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }        return pResult; }

引用 37 楼 SleekStone 的回复:[quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]就是pResult = new int[N];这句过不了

引用 35 楼 是疗伤烧肉粽~ 的回复:[quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]int* fun(int *d, int N) {     int *pResult = 0;       if (0 != d && 0 < N)     {         int nTemp[101] = { 0 };         for (int i = 0; i < N; i++)         {             ++nTemp[d[i]];         }           int nTotalCount = 0;         for (int i = 100; i > -1; i--)         {             int nCurrent = nTemp[i];             nTemp[i] = nTotalCount;             nTotalCount += nCurrent;             if (nTotalCount == N)             {                 break;             }         }           pResult = (int*)malloc(sizeof(int) * N);         for (int i = 0; i < N; i++)         {             pResult[i] = nTemp[d[i]];         }     }       return pResult; }

引用 40 楼 forever74 的回复:[quote=引用 37 楼 SleekStone 的回复:]怎么可能，nullptr的地方都用0替换，不应该编不过啊  new是++范儿。[/quote]啊.....好吧...

引用 37 楼 SleekStone 的回复:怎么可能，nullptr的地方都用0替换，不应该编不过啊  new是++范儿。

new是c++运算符，需要改成malloc，你可能没注意到楼主发的是c语言版

引用 37 楼 SleekStone 的回复:[quote=引用 35 楼 是疗伤烧肉粽~ 的回复:][quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊[/quote]  还有 new 呢...  多少为这楼主感到可惜

引用 35 楼 是疗伤烧肉粽~ 的回复:[quote=引用 30 楼 SleekStone 的回复:][quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了[/quote]怎么可能，nullptr的地方都用0替换，不应该编不过啊

引用 33 楼 早打大打打核战争 的回复:[quote=引用 28 楼 是疗伤烧肉粽~ 的回复:][quote=引用 24 楼 早打大打打核战争 的回复:][quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf("%d", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf("%d", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf("%c%d", i ? ',' : '{', buf2[i]);   printf("}\n");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢[/quote]  这三行：   for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]]; 第一行统计0~100分每个得分的人数，第三行把超过每个得分的人数写回数组，不必多说。 第二行，因为题目假定分数在0~100，所以超过100的肯定没有，就不计算了（已经预置为0）。超过99的显然就是100分的人数，超过98的就是99+100的人数... 于是得到递推公式：超过x分的人数就是x+1分的人数加上超过x+1的人数（好像是废话啊），从99逆推到0就得到超过每个得分的人数 [/quote]懂了，谢谢，代码过了

引用 30 楼 SleekStone 的回复:[quote=引用 27 楼 是疗伤烧肉粽~ 的回复:]nullptr是什么？怎么没定义就冒出来？？？ [quote=引用 23 楼 SleekStone 的回复:]int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }[/quote]你要编不过可以用NULL或者0替换[/quote]编译错误，是用c语言的，不能用c++，换了也过不了

引用 26 楼 是疗伤烧肉粽~ 的回复:引用 25 楼 早打大打打核战争 的回复:另，他的OJ是要提交整个程序还是只要一个函数？只要一个函数  改成静态分配：  int *fun(int *d, int N) {   int b[2][101] = {0};   //int *r = (int *)malloc(sizeof(int) * N);   static int r[1048576];    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }

引用 24 楼 早打大打打核战争 的回复:[quote=引用 17 楼 是疗伤烧肉粽~ 的回复:]还是运行超时了，要O(N)才行 [quote=引用 15 楼 早打大打打核战争 的回复:]稍微优化一下：  #include <stdio.h> #include <stdlib.h>  int *fun(int *d, int N) {   int b[2][101] = {0};   int *r = (int *)malloc(sizeof(int) * N);    for (int i = 0; i < N; i++) b[0][d[i]]++;   for (int i = 99; i >= 0; i--) b[1][i] = b[0][i + 1] + b[1][i + 1];   for (int i = 0; i < N; i++) r[i] = b[1][d[i]];    return r; }  int main() {   int n, *buf, *buf2;    scanf("%d", &n);   buf = (int *)malloc(sizeof(int) * n);   for (int i = 0; i < n; i++) scanf("%d", &buf[i]);   buf2 = fun(buf, n);   for (int i = 0; i < n; i++)     printf("%c%d", i ? ',' : '{', buf2[i]);   printf("}\n");   free(buf), free(buf2);    return 0; } [/quote]  这个就是O(N)的，而且在O(N)算法中也属于比较优化的，如果还超时，应该是他卡内存分配和I/O时间了，可以改成静态分配（OJ程序是判断不出来动态申请还是静态分配的~） [/quote]能不能简单说一下思路，这代码我看不太懂，谢谢

nullptr是什么？怎么没定义就冒出来？？？ 引用 23 楼 SleekStone 的回复:int* fun(int *d, int N) { 	int *pResult = nullptr;  	if (nullptr != d && 0 < N) 	{ 		int nTemp[101] = { 0 }; 		for (int i = 0; i < N; i++) 		{ 			++nTemp[d[i]]; 		}  		int nTotalCount = 0; 		for (int i = 100; i > -1; i--) 		{ 			int nCurrent = nTemp[i]; 			nTemp[i] = nTotalCount; 			nTotalCount += nCurrent; 			if (nTotalCount == N) 			{ 				break; 			} 		}  		pResult = new int[N]; 		for (int i = 0; i < N; i++) 		{ 			pResult[i] = nTemp[d[i]]; 		} 	}  	return pResult; }


Question: 形参为地址上存储的值即20,30，为什么实参的地址值可以传递过去啊？求教！！！

你是把地址传过去，然后交换的是两个地址空间对应的值呀

计算机组成原理→DOS命令→汇编语言→C语言（不包括C++）、代码书写规范→数据结构、编译原理、操作系统→计算机网络、数据库原理、正则表达式→其它语言（包括C++）、架构……  对学习编程者的忠告： 多用小脑和手，少用大脑、眼睛和嘴，会更快地学会编程！ 眼过千遍不如手过一遍！ 书看千行不如手敲一行！ 手敲千行不如单步一行！ 单步源代码千行不如单步Debug版对应汇编一行！ 单步Debug版对应汇编千行不如单步Release版对应汇编一行！ 不会单步Release版对应汇编？在你想单步Release版C/C++代码片断的前面临时加一句DebugBreak();重建所有，然后在IDE中运行。（一般人我不告诉他！）  单步类的实例“构造”或“复制”或“作为函数参数”或“作为函数返回值返回”或“参加各种运算”或“退出作用域”的语句对应的汇编代码几步后，就会来到该类的“构造函数”或“复制构造函数”或“运算符重载”或“析构函数”对应的C/C++源代码处。  VC调试时按Alt+8、Alt+7、Alt+6和Alt+5,打开汇编窗口、堆栈窗口、内存窗口和寄存器窗口看每句C对应的汇编、单步执行并观察相应堆栈、内存和寄存器变化，这样过一遍不就啥都明白了吗。 对VC来说，所谓‘调试时’就是编译连接通过以后，按F10或F11键单步执行一步以后的时候，或者在某行按F9设了断点后按F5执行停在该断点处的时候。  调用约定 https://docs.microsoft.com/zh-cn/cpp/cpp/calling-conventions?view=vs-2017

悟了：在void swap(int *pa,int *pb)中 *pa,*pb是定义其为指针变量； 而在t=*pa,*pb=*pa,*pa=t中 *pa,*pb是指指针指向地址中存储的值。

C语言是值传递

你不是传的地址过去吗？参数是指针呀


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<stdlib.h>  typedef int datatype; typedef struct node {     datatype data;     struct node *next; }linklist;  void creatlist1(linklist *head,int n) {     linklist *p,*s;     int i;      head->next=NULL;     s=head;     for(i=0;i<n;i++)     {         p=(linklist*)malloc(sizeof(linklist));         scanf("%d",&p->data);         s->next=p;         s=p;     }      s->next = NULL; //last node's next pointer NULL } void displaylist(linklist *head) {     linklist *p;     //int i=0;     p=head->next;     if(p==NULL)     {         printf("这是个空指针\n");         return; //exit from displylist     }     while(p)     {          printf("%d ",p->data);         p=p->next;     } } int main() {     linklist *head;     head=(linklist*)malloc(sizeof(linklist));     creatlist1(head,5);   //创建一个链式列表     displaylist(head);    //输出列表中的元素     return 0; }  供参考～  原因是创建链表的时候没有对最后一个节点做处理，即最后一个节点的next指针应该指向NULL displaylist出现无限循环就是因为没有找到NULL

数据结构对单链表进行数据排序 http://bbs.csdn.net/topics/392201633

正如楼上朋友说的，代码产生问题的主要原因在于displaylist()函数的 while (p) 	{ 		printf("%d ", p->data); 		p = p->next; 	} 在遍历链表的时候，最后一个元素时，理论上p->next应该指向空指针，但是由于createlist1()函数的for循环中分配内存时，并没有对p->next值进行显式地赋空指针值，导致最后一个元素的p->next不是空指针而是一个随机值，在我调试的VS2015中，这个值是0xcdcdcdcd。这样就导致在displaylist()函数的while()语句中会访问0xcdcdcdcd，而这个地址是不能访问的，就会直接报错。 解决的方法就是在createlist1()函数的for循环中 p = (linklist*)malloc(sizeof(linklist)); 		p->next = nullptr;

p=(linklist*)malloc(sizeof(linklist)); p->next=NULL


Question: 小白数据结构的求助

供参考：//头文件 /*************************************************************     顺序表的实现  头文件 **************************************************************/  #include <stdio.h> #include <stdlib.h> //#include "Seqlist.h"  #define  MAXSIZE 100//最大长度  typedef int ElemType;  typedef  struct {   ElemType  *elem; //指向数据元素的起始地址   int  length;     //线性表的当前长度  }SqList;  //declaration of functions:  // 顺序表的初始化，即构造一个空的顺序表 void SL_Initiate(SqList &L);  // 释放顺序表 void SL_Free(SqList &L);  // 判断顺序表是否空 bool SL_IsEmpty(SqList L);  // 判断顺序表是否满 bool SL_IsFull(SqList L);  // 输入n个数据元素，创建一个顺序表L void SL_Create(SqList &L,int n);  // 输出整个顺序表 void SL_Print(SqList L);  // 获取顺序表L的第i个元素赋给e，i的有效范围[1,L.length]。 void SL_GetAt(SqList L, int i, ElemType &e);  // 在顺序表L中查找第一个值为x的元素， // 找到则返回该元素在表中的位置，否则返回0。 int SL_FindValue(SqList L, ElemType x);  // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 //i的有效范围[1,L.length+1] void SL_InsAt(SqList &L, int i, ElemType e);  // 删除顺序表L的第i个元素 //i的有效范围[1,L->length] void SL_DelAt(SqList &L, int i);  // 删除第一个值为x的元素 void SL_DelValue(SqList &L, ElemType x);    /*************************************************************     顺序表的实现之增删功能 实现文件     更新于2020年4月13日     **************************************************************/   void SL_Initiate(SqList &L) // 顺序表的初始化，即构造一个空的顺序表 {     L.elem = (ElemType*)malloc(sizeof(ElemType)*MAXSIZE);     L.length=0; }  void SL_Free(SqList &L) // 释放顺序表 {     free(L.elem); }  bool SL_IsEmpty(SqList L) // 判断顺序表是否空 {     return L.length==0; }  bool SL_IsFull(SqList L) // 判断顺序表是否满 {     return L.length==MAXSIZE; }  void SL_Create(SqList &L,int n) // 输入n个数据元素，创建一个顺序表L {     int i;     L.length=n;     for(i=0; i<n; i++)        scanf("%d", &L.elem[i]); }  void SL_Print(SqList L) // 输出整个顺序表 {     if (L.length==0)     {        printf("The slist is empty.\n");        return ;     }      for (int i=0; i<L.length; i++)          printf("%d  ", L.elem[i]);     printf("\n"); }  void SL_InsAt(SqList &L, int i, ElemType e) // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 // i的有效范围[1,L.length+1] {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a;     a=&L;     if(i<0 || i>MAXSIZE) return;     int j,k=99;      for(j=L.length;j>i-1;j--)//for(j=MAXSIZE;j>i-1;j--)     {        a->elem[j]=a->elem[j-1];                              //k--;     }     a->elem[i-1]=e;      L.length ++;      /********** End **********/ }  void SL_DelAt(SqList &L, int i) // 删除顺序表L的第i个元素 //i的有效范围[1,L.length] {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a;     a=&L;     if(i<0 || i>MAXSIZE) return;     int k=i,j;     for(j=i-1;j<L.length;j++)  //for(j=i-1;j<99;j++)     {         a->elem[j]=a->elem[j+1];                                //k++;     }     L.length--;     /********** End **********/ }  void SL_DelValue(SqList &L, ElemType x) // 删除第一个值为x的元素 {     // 请在这里补充代码，完成本关任务     /********** Begin *********/     SqList *a=&L;     int i,j;     for(i=0;i<L.length;i++)//for(i=0;i<MAXSIZE;i++)     {         if(a->elem[i]==x)         {          for(j=i;j<L.length;j++) //for(j=i;j<99;j++)               a->elem[j]=a->elem[j+1];          L.length--;          return ;         }     }     return;      /********** End **********/ }  //主函数  //#include <stdio.h> //#include <stdlib.h> //#include "Seqlist.h" //#include "Seqlist.cpp"  int main() {     SqList L;     int n,i,x;      SL_Initiate(L);      printf("输入元素的个数及值\n");     scanf("%d", &n);//输入元素的个数     SL_Create(L, n);     SL_Print(L);      printf("输入待插入的位置和待插入元素的值\n");     scanf("%d%d", &i,&x);//输入待插入的位置和待插入元素的值     SL_InsAt(L, i, x);     SL_Print(L);      printf("输入待删除元素的位置\n");     scanf("%d", &i);//输入待删除元素的位置     SL_DelAt(L, i);     SL_Print(L);      printf("输入待删除元素的值");     scanf("%d", &x);//输入待删除元素的值     SL_DelValue(L, x);     SL_Print(L);      //SL_Print(L);     SL_Free(L);      return 0; }

为什么小弟运行程序以后程序最后会多出一个0 当我输入这串数据它就多出一个0 6 5 9 11 31 9 88 2 10 7 9

头文件 /*************************************************************     顺序表的实现  头文件 **************************************************************/  #define  MAXSIZE 100     //最大长度 typedef int ElemType;  typedef  struct {   ElemType  *elem;     //指向数据元素的起始地址   int  length;          //线性表的当前长度                                                        }SqList;  //declaration of functions:  // 顺序表的初始化，即构造一个空的顺序表 void SL_Initiate(SqList &L);  // 释放顺序表 void SL_Free(SqList &L);  // 判断顺序表是否空 bool SL_IsEmpty(SqList L);  // 判断顺序表是否满 bool SL_IsFull(SqList L);  // 输入n个数据元素，创建一个顺序表L void SL_Create(SqList &L,int n);  // 输出整个顺序表 void SL_Print(SqList L);  // 获取顺序表L的第i个元素赋给e，i的有效范围[1,L.length]。 void SL_GetAt(SqList L, int i, ElemType &e);  // 在顺序表L中查找第一个值为x的元素， // 找到则返回该元素在表中的位置，否则返回0。 int SL_FindValue(SqList L, ElemType x);  // 在顺序表的第i个位置插入新元素e, 即在元素L.elem[i-1]之前插入 //i的有效范围[1,L.length+1] void SL_InsAt(SqList &L, int i, ElemType e);  // 删除顺序表L的第i个元素 //i的有效范围[1,L->length] void SL_DelAt(SqList &L, int i);  // 删除第一个值为x的元素 void SL_DelValue(SqList &L, ElemType x);

主函数  #include <stdio.h> #include <stdlib.h> #include "Seqlist.h" //#include "Seqlist.cpp"  int main() { 	SqList L;int n,i,x;  	SL_Initiate(L);  	scanf("%d", &n);//输入元素的个数 	SL_Create(L, n);  	scanf("%d%d", &i,&x);//输入待插入的位置和待插入元素的值 	SL_InsAt(L, i, x); 	 	scanf("%d", &i);//输入待删除元素的位置 	SL_DelAt(L, i);  	scanf("%d", &x);//输入待删除元素的值 	SL_DelValue(L, x);  	SL_Print(L);	 	SL_Free(L); }


Question: c语言打印日历

还可以先定义一个二维字符数组，先“定位”输出到这个数组中，最后输出这个数组到屏幕或打印机。

定位不是标准C语言的一部分 所以如果是C语言初学者 这个题目一定不打算让你定位 而是想办法从左上依次输出到右下 中间适当加空格 以达到看起来定位的效果


Question: C语言中什么时候用%d和%f

嗯，你说得很对， 不过printf("b=%.2f",b);可以保留两位小数，这样应该更正确

输出时，%f可用于float，也可用于double 输入时，%f用于float，%lf用于double

%d和%f 既用来指明输出的格式，也用来指明对应的实参是什么类型。

C语言新手，刚入门，写个博客记录下学习，不足之处，欢迎大家指正，不吝赐教！！

这是广告帖吗？内存里都是二进制数据，用%d输出是一个值，用%f输出是一个值。结果虽然不一样，但是内存了的二进制不变，因为浮点数和整型数表示的方法不一样，即对于相同的二进制数，不同的符号，比如%d和%f，它的解析方法不一样，因此结果是不一样的。

好。。自问自答啊。。。


Question: Cyv'y求助！！！

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

x y 嘛，天生就是当坐标的样子

因为我还是个学生，所以电脑现在不在身边，主要是想做个坐标，按w就y++，s就y--那种，你这个应该可以解决吧

引用 2 楼 user-2的回复:按现有内容理解：  char *s[2][2]={"火车站","机场","万达广场","立交桥下"}; ... printf("你来到了%s\n",s[x][y]);  大约就这个意思，参考一下。 明天实验一下，觉得有希望了。。。 终于解决了！

引用 2 楼 user-2的回复:按现有内容理解：  char *s[2][2]={"火车站","机场","万达广场","立交桥下"}; ... printf("你来到了%s\n",s[x][y]);  大约就这个意思，参考一下。 感谢，差不多就是这样，我没有想到。。。 这个坐标方法很好！谢谢！

不太理解你确切的意思，有完整一些的代码表达么？


Question: 目标文件（.a或.obj）之间的链接算静态链接吗？

请问楼主这个问题解决啦吗，大家的回复对你有帮助吗？

bucuo                             不错

准确的说，静态链接这个概念发生在可执行链接之前。静态链接是库链接，是编译时的操作。可执行链接是把目标文件接入系统执行方案的操作。

自己动手搜索了一下，没有找到static link，static-link的字典式解释。（当然，这不等于它不存在。） 所以一边喝茶，一边捋一捋我主观理解的“静态链接”的由来。  起初，没有操作系统，没有高级语言，没有文件系统，自然是在物理地址上编程，没有链接。 那么链接/link应该出现在有了文件系统/操作系统/汇编语言的时代，用来在分模块的程序设计中主要表达两个意思：模块间符号解析和调用地址绑定（重定位）。 这个词出现初期，还没有库，只有分别编译/汇编的模块。后来出现了库，链接扩展了它的含义也处理库里的模块。  随着操作系统的进化，忽然有一天（浪漫说法）出现了动态链接，也就是运行时模块间符号解析与模块调用的地址绑定，链接再次扩展其含义以接受动态。 从这时起，为了与新技术进行区别，传统生成可执行文件前的链接方式就都被称为静态链接。  这就是我为什么那样认为，因为这个词本来就是作为新定义的动态链接概念的补集而出现的，而不是独立定义的，所以没有留下缝隙（既不动态也不静态的链接行为）。  我一直强调主观性，心虚。 各位老师如果也是归纳式理解，我们就各说各的好了；如果有权威解释，欢迎指出我的错误，我改。

那应该称呼为什么？

补丁：#6的“两行以上”是“这句话上方两行距离提到的”的意思，敲的时候欠考虑了，易生歧义。

我一直觉得， 静态链接库 是 供静态链接过程使用的库 的意思， 并没有“甩开我就都不算静态链接”的语义 。

看来这个问题变成语文问题了 可以先约定一下确切的词汇语义和讨论范畴。  个人仍然认为，我们在讨论C语言， 立足于主函数和主函数所在的文件， 那么其他处于另外文件的函数， 只要是在运行以前，确切地说是生成可执行文件以前， 招招手呼叫一下，就从其他目标文件飘过来一个函数的二进制代码， 拼装到我的产品内， 这个过程就都算静态链接。 链接，说的就是两行以上的拼装过程，当然还有各种细节， 静态，强调的是运行前，代码进入可执行文件， 和代码的来源并没有什么必然联系。  欢迎咬文嚼字批判我。

静态链接是专指库文件的链接方式，所以不能说 .o 也是静态链接。 .o 通过 ar 打包成了 .a，链接的时候 .a 也会解包成 .o，再使用链接 .o 的方式链接

不算

没办法，自学的局限性，归纳式理解术语确实理解不精确。 一直主观认为链接是个动词，静态和动态是它的修饰，但不妨碍作为词组的静态链接和动态链接都是作为动词描述一个过程的。 静态链接描述的是生成过程中，复制目标代码进入可执行文件并进一步处理重定位等细节的过程，终止于出错或可执行文件生成。 而与之相对的动态链接用于描述可执行文件载入内存准备运行的时候和内存中的不属于这个可执行文件的二进制代码对接协调的过程。（这里的术语又不专业了）  所以请教一下静态链接这个词的比较精确的字典式定义出自哪里？求指点。

.o组合为.a/.lib或.so/.dll或.out/.exe发生在生成时，此时应该没有静态/动态link一说。 非要说对某个函数的调用是静态链接还是动态链接，得看下面运行时对函数实际调用得情况：  当.out/.exe被运行后，调用的函数只要来自.out/.exe文件内，该函数就是静态链接；反之，不是来自.out/.exe文件内，而是来自外部.so./.dll就是动态链接。  个人理解，不喜勿喷。

引用 22 楼 forever74 的回复:那么NorZ老师认为，静态链接和动态链接这两个术语只用于描述对库的引用，我们这里讨论的项目里两个源文件之间的普通链接过程和这两个术语无关。 我们的分歧确实是语文问题，不在于实质。  那么赵4老师，您给出的参考资料的52页上这段话描述的是两个源文件的链接过程，这段的末尾指出作者认为这个属于静态链接啊，您为什么据此认为不算呢？   你要是把随意使用专业术语，当作是语文问题...那也是你的语文理解不到位 包括你引用的这本书的内容。注意看最后一句话，前面的句号，最后一句只是表述前面的描述是“静态链接的最基本的过程”，并没有说前面的描述就是静态链接。

引用 21 楼 flying_music 的回复:[quote=引用 3 楼 六道佩恩 的回复:][quote=引用 1 楼 flying_music 的回复:]目标文件之间只能算是打包吧，只是物理的组合，并没有重定位等一系列操作，所以一般不叫"链接"  你说的是目标文件组合成静态库吗？（可能是我没懂起你说的）  目标文件之间的函数调用、全局变量访问这些不是会有重定位吗？[/quote] 重定位只会发生在生成可执行文件时，多个库组成一个库就只是打包，“打包”“链接”“静态链接”“动态链接”这些都是比较专业的词，最好不要乱用，虽然基本也能明白[/quote]  我说的不一直都是目标文件链接成exe吗？

引用 3 楼 六道佩恩 的回复:[quote=引用 1 楼 flying_music 的回复:]目标文件之间只能算是打包吧，只是物理的组合，并没有重定位等一系列操作，所以一般不叫"链接"  你说的是目标文件组合成静态库吗？（可能是我没懂起你说的）  目标文件之间的函数调用、全局变量访问这些不是会有重定位吗？[/quote] 重定位只会发生在生成可执行文件时，多个库组成一个库就只是打包，“打包”“链接”“静态链接”“动态链接”这些都是比较专业的词，最好不要乱用，虽然基本也能明白

库(.lib、a等等)是目标文件(.obj、.o之类)的合集，链接是以目标文件为单位的，链接单独的目标文件也是可以的

引用 18 楼 forever74 的回复:所以精确一些描述， 在链接/连接这个范畴/全集下， 1、静态链接无疑是个子集，动态链接也是，那么静态链接子集和动态链接子集的并集（我们这里不讨论交集）有没有非空补集？有的话叫做什么？ 2、main.o和fun.o的链接，main.obj和fun.obj的链接，在这个语境里完全是同义，它在静态链接子集里，还是在补集里？  我完全没有引经据典，全凭不知来源的记忆和主观理解，认为， 1、不存在这个补集 2、所以它只能落进静态链接圈  静态链接和动态链接，只是链接库文件的方式。 从来没有.o 文件的动态和静态链接之说。 .o 文件的链接过程就大概就叫做链接 linking 吧，和库文件的链接过程是不同


Question: 求求大佬们帮帮忙啊(´-ω-`)！这个题目该怎么编程啊

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


Question: 要在链式列表中某位置插入一个元素，然后写了下面这个函数来查找该位置的前一个位置并用指针指向它，最后传回该指针，但是感觉这个函数有点问题，求大神们帮我看看，怎么改

供参考：linklist * find(linklist *head,int i) {     linklist *p;     if (i==0)return head;//如果表头，返回头结点     p=head;     int j=0;     while(p!=NULL && j<i-1)      {          j++;          p=p->next;      }     if(!p) return NULL:     return p; }

linklist * find(linklist *head,int i) {     linklist *p;     p=head;     int j=1;     while(p!=NULL&&j<=i)     {         j++;         p=p->next;     }     if(!p) {         printf("p=NULL");         return NULL;     }     //else     return p;  } 供参考～  如果没找到应该是返回NULL


Question: C语言

可以这么算，但没意义 str[i]-'0'的意思是str[i]是一个'0'到'9'的字符，str[i]-'0'这样可以计算出其数值，比如'2'-'0'正好等于2 str[i]-'a'时，str[i]应该是一个字母对应的字符，比如str[i]-'a'+'A'可以把一个小写字母转成大写字母 上面用到的特性，其实是ASCII中，0-9 a-z A-Z是连续编码的，但0跟a的编码没啥关系，所以不同性质的两个字符相减是没意义的

只要在序列中都是可以计算的,没发现问题.

引用 楼主 m0_45257832 的回复:str[i]-'0' 为什么不会对'a'运算， 'a'-'0'=49，为什么不会这样算  并没有什么机制在阻止这个运算，这样算是完全可以地

char a[] = "a"; cout << a[0] - '0';

仅供参考： #include <stdio.h> #include <string.h> FILE *f; char buffer[4096]; int r,a; void HexDump(char *buf,int len,int addr) {     int i,j,k;     char binstr[80];      for (i=0;i<len;i++) {         if (0==(i%16)) {             sprintf(binstr,"%08x -",i+addr);             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         } else if (15==(i%16)) {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);             sprintf(binstr,"%s  ",binstr);             for (j=i-15;j<=i;j++) {                 sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');             }             printf("%s\n",binstr);         } else {             sprintf(binstr,"%s %02x",binstr,(unsigned char)buf[i]);         }     }     if (0!=(i%16)) {         k=16-(i%16);         for (j=0;j<k;j++) {             sprintf(binstr,"%s   ",binstr);         }         sprintf(binstr,"%s  ",binstr);         k=16-k;         for (j=i-k;j<i;j++) {             sprintf(binstr,"%s%c",binstr,('!'<buf[j]&&buf[j]<='~')?buf[j]:'.');         }         printf("%s\n",binstr);     } } int main(int argc,char **argv) {     if (argc<2) {         fprintf(stderr,"Usage: %s filename.ext\n",argv[0]);         return 2;     }     f=fopen(argv[1],"rb");     if (NULL==f) {         fprintf(stderr,"Can not open file [%s]!\n",argv[1]);         return 1;     }     a=0;     while (1) {         r=fread(buffer,1,4096,f);         HexDump(buffer,r,a);         a+=r;         if (r<4096) break;     }     fclose(f);     return 0; }

电脑内存或文件内容或传输内容只是一个一维二进制字节数组及其对应的二进制地址； 人脑才将电脑内存或文件内容或传输内容中的这个一维二进制字节数组及其对应的二进制地址的某些部分看成是整数、有符号数/无符号数、浮点数、复数、英文字母、阿拉伯数字、中文/韩文/法文……字符/字符串、汇编指令、函数、函数参数、堆、栈、数组、指针、数组指针、指针数组、数组的数组、指针的指针、二维数组、字符点阵、字符笔画的坐标、黑白二值图片、灰度图片、彩色图片、录音、视频、指纹信息、身份证信息……  推荐使用WinHex软件查看硬盘或文件或内存中的原始字节内容。

'a'的ASCII对应的十进制是65即0x61，而'0'~'9'对应的是0x30~0x39  一般对于'0'-'9'字符是与'0'比较和做差 一般是'A'-'Z'与'A'比较和做差  同理'a'-'z'与'a'


Question: 为什么出不来结果

scanf("%d", &p->data); 空格问题～

scanf("%d ",&(p->data));这句里面"%d   " 后面多了空格符，应该这样：scanf("%d",&(p->data));


Question: stm32 两个串口在某个时间点需要同时处理任务，请问怎么处理？等三个问题

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

了解一下有限状态自动机。

请问有大佬帮忙看看吗0.0

引用 2 楼 赵4老师 的回复:了解一下有限状态自动机。  感谢您 这就去看看


Question: codeblocks 环境错误问题


Question: 水仙花数在一定范围内输出。

根据楼主的代码，应该是返回的返回值有问题。楼主的逻辑里，z++是在循环里一定会执行的，因为它在for的大循环里，每次都执行到；第二cn函数有返回非0的可能吗？没有，因为最后还是return 0；z只要执行for循环，就一定会执行z++，即使for循环一次不执行，那么最终也会执行return 0；所以，非0从哪里来呢？   int cnt (int n , int m) {      int sum, tmp, i;      int cnt = 0;       if (m > n)          swap(&m, &n);       for (i = m ; i < n; i++) {          tmp = i;          sum = 0;          while (tmp) {              rem = tmp % 10;              sum += pow(rem, 3);   //or rem * rem * rem;              tmp /= 10;          }          if (sum == i) {              printf("%d is narcissus number!\n", i);              cnt++;          }      }       return cnt; } static int swap(int *a, int *b) {     int tmp = *a;     *a = *b;     *b = tmp; }    供参考代码，可以试一下。

int cn()函数修改，供对照：int cn(int n,int m) {     int hun,ten,ind,a,flog=1,z=0;     for(a=n;a<=m;a++)      {        hun = a/100;        ten = a/10%10;        ind = a%10;        if(a == hun*hun*hun + ten*ten*ten + ind*ind*ind)          {            printf("%d ",a);            z++;          }      }      if(z==0) flog = 0;      return flog;  }


Question: C语言

//C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+

引用 8 楼 user-3的回复:就你的问题（因为题目没写分号，我也不写） j=!c&&i++ 来说，它是 j=(   (!c) && (i++)  ) 的意思，而不是 (j=!c) && (i++)  或者 j=(!c && i)++ 或者别的 这是运算符优先级的作用----注意，我们一直没有开始算呢，讨论的是怎么正确理解那个式子  真的要算结果了，其实优先级分析就退休了。上面第四行告诉我们， 它是个赋值语句，先求右侧表达式的值，然后送给j  ----注意，我们首先关注的是这里面优先级最低的赋值运算符啊  上一行里的“先”“然后”描述的是执行次序，但这是由赋值运算符的语义决定的，和优先级完全没有关系 然后我们才注意到要被求值的是个逻辑与运算，这是我们马上反应，左边若为假，右边被忽略----这是逻辑与的语义决定的  至此兴尽，return to sleep; printf（"thanks +++++"）；

引用 6 楼 user-3的回复:优先级跟运算次序没有决定性关系，要从小学数学的思维习惯摆脱出来。 运算符优先级其实是个小学语文的概念。  应该听过 下雨天留客天留我不留 这个梗吧？ 在恰当的位置加逗号是语文风格 把应该结合在一起的东西括起来是C风格 不用括起来也优先黏糊在一起，这就叫优先级高 这就是为什么int *a[3]是个数组而int (*a)[3]是个指针，优先级是干这个用的。 谢谢您！我明白了 十分感谢

运算符的优先级那是讨论结合性用的，用在编译期间。 而运算顺序，只有 &&   ||    ?:     ,    这四个运算符存在确定的顺序，并且前两个有可能，第三个一定会忽略一部分子表达式的求值。这是运行期概念。

引用 2 楼 user-3的回复:哦，至于这个题目，那是短路效应造成的。 写完这题，我突然就不懂运算的优先级了

引用 2 楼 user-3的回复:哦，至于这个题目，那是短路效应造成的。 请问有&&运算符的话就直接从左到右计算吗？

哦，至于这个题目，那是短路效应造成的。

莫非你忘了 ++写在i后面了？


Question: C语言

从网上找一下判断闰年的逻辑，自定义一个函数，然后用一个循环，穷举法就是循环遍历m--n之间的每一个年份，再用判断闰年的函数即可。

课后作业？自己百度一下吧，不难


Question: 问大佬们一个简单的问题

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

括号里是一个整体，中间是逗号，则取最后一个逗号后面的赋值给c

逗号表达式，结果是最后那个值，也就是2

不要迷信书、考题、老师、回帖； 要迷信CPU、编译器、调试器、运行结果。 并请结合“盲人摸太阳”和“驾船出海时一定只带一个指南针。”加以理解。 任何理论、权威、传说、真理、标准、解释、想象、知识……都比不上摆在眼前的事实！  //C++ Operators //  Operators specify an evaluation to be performed on one of the following: //    One operand (unary operator) //    Two operands (binary operator) //    Three operands (ternary operator) //  The C++ language includes all C operators and adds several new operators. //  Table 1.1 lists the operators available in Microsoft C++. //  Operators follow a strict precedence which defines the evaluation order of //expressions containing these operators.  Operators associate with either the //expression on their left or the expression on their right;    this is called //“associativity.” Operators in the same group have equal precedence and are //evaluated left to right in an expression unless explicitly forced by a pair of //parentheses, ( ). //  Table 1.1 shows the precedence and associativity of C++ operators //  (from highest to lowest precedence). // //Table 1.1   C++ Operator Precedence and Associativity // The highest precedence level is at the top of the table. //+------------------+-----------------------------------------+---------------+ //| Operator         | Name or Meaning                         | Associativity | //+------------------+-----------------------------------------+---------------+ //| ::               | Scope resolution                        | None          | //| ::               | Global                                  | None          | //| [ ]              | Array subscript                         | Left to right | //| ( )              | Function call                           | Left to right | //| ( )              | Conversion                              | None          | //| .                | Member selection (object)               | Left to right | //| ->               | Member selection (pointer)              | Left to right | //| ++               | Postfix increment                       | None          | //| --               | Postfix decrement                       | None          | //| new              | Allocate object                         | None          | //| delete           | Deallocate object                       | None          | //| delete[ ]        | Deallocate object                       | None          | //| ++               | Prefix increment                        | None          | //| --               | Prefix decrement                        | None          | //| *                | Dereference                             | None          | //| &                | Address-of                              | None          | //| +                | Unary plus                              | None          | //| -                | Arithmetic negation (unary)             | None          | //| !                | Logical NOT                             | None          | //| ~                | Bitwise complement                      | None          | //| sizeof           | Size of object                          | None          | //| sizeof ( )       | Size of type                            | None          | //| typeid( )        | type name                               | None          | //| (type)           | Type cast (conversion)                  | Right to left | //| const_cast       | Type cast (conversion)                  | None          | //| dynamic_cast     | Type cast (conversion)                  | None          | //| reinterpret_cast | Type cast (conversion)                  | None          | //| static_cast      | Type cast (conversion)                  | None          | //| .*               | Apply pointer to class member (objects) | Left to right | //| ->*              | Dereference pointer to class member     | Left to right | //| *                | Multiplication                          | Left to right | //| /                | Division                                | Left to right | //| %                | Remainder (modulus)                     | Left to right | //| +                | Addition                                | Left to right | //| -                | Subtraction                             | Left to right | //| <<               | Left shift                              | Left to right | //| >>               | Right shift                             | Left to right | //| <                | Less than                               | Left to right | //| >                | Greater than                            | Left to right | //| <=               | Less than or equal to                   | Left to right | //| >=               | Greater than or equal to                | Left to right | //| ==               | Equality                                | Left to right | //| !=               | Inequality                              | Left to right | //| &                | Bitwise AND                             | Left to right | //| ^                | Bitwise exclusive OR                    | Left to right | //| |                | Bitwise OR                              | Left to right | //| &&               | Logical AND                             | Left to right | //| ||               | Logical OR                              | Left to right | //| e1?e2:e3         | Conditional                             | Right to left | //| =                | Assignment                              | Right to left | //| *=               | Multiplication assignment               | Right to left | //| /=               | Division assignment                     | Right to left | //| %=               | Modulus assignment                      | Right to left | //| +=               | Addition assignment                     | Right to left | //| -=               | Subtraction assignment                  | Right to left | //| <<=              | Left-shift assignment                   | Right to left | //| >>=              | Right-shift assignment                  | Right to left | //| &=               | Bitwise AND assignment                  | Right to left | //| |=               | Bitwise inclusive OR assignment         | Right to left | //| ^=               | Bitwise exclusive OR assignment         | Right to left | //| ,                | Comma                                   | Left to right | //+------------------+-----------------------------------------+---------------+


Question: 循环队列入队出队（数据结构c语言）

引用 2 楼 ┍Æ ζざ 的回复:[quote=引用 楼主 ┍Æ ζざ的回复:]怎么写啊，各位大佬  我写了，不对[/quote] 贴代码吧，贴图片也不全呢，怎么知道哪里有问题。帮你也是无从下手～

引用 10 楼 ┍Æ ζざ的回复:[quote=引用 9 楼 自信男孩的回复:][quote=引用 8 楼 ┍Æ ζざ 的回复:]感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug [/quote] 我没有看到代码啊！[/quote] 看到了，谢谢你

引用 9 楼 自信男孩的回复:[quote=引用 8 楼 ┍Æ ζざ 的回复:]感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug [/quote] 我没有看到代码啊！

引用 8 楼 ┍Æ ζざ 的回复:感谢！麻烦帮我看看  我的代码发给你了，你自己看看。如果r, m超过2^31-1的话，可能会有问题  这也是我代码的一个小bug

感谢！麻烦帮我看看

那个是函数题。我的代码如下： void EnQueue_seq(SeqQueue squeue, DataType x) {      SeqQueue *p;     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if((p->r+1)%Max==p->f)         return 0;     p->r = x;     p->r = (p->r+1)%Max;     return 1;   } void DeQueue_seq(SeqQueue squeue) {     SeqQueue *p;     SeqQueue *q;     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if(p->f==p->r)         return 0;     q = p->f;     p->f = (p->f+1)%Max;     return 1; } DataType FrontQueue_seq(SeqQueue squeue) {     SeqQueue *p;     int data[100];     p = (SeqQueue*)malloc(sizeof(SeqQueue));     if(!p)     {         printf("It is empty queue!");     }    return p->f;     if((p->r+1)%Max==p->f)         printf("It is FULL Queue!It is FULL Queue!p->f");      }

你是写了不对？还是没写？函数体是@@这样算是不对？  #include <stdio.h> #include <stdlib.h>  typedef char DataType; struct Queue {     int Max;     int f;     int r;     DataType *elem; }; typedef struct Queue *SeqQueue;  SeqQueue SetNullQueue_seq(int m) {     SeqQueue squeue;     squeue = (SeqQueue)malloc(sizeof(struct Queue));     if (squeue == NULL)     {         printf("Alloc failure\n");         return NULL;     }     squeue->elem = (char*)malloc(sizeof(DataType)*m);     if (squeue->elem != NULL)     {         squeue->Max = m;         squeue->f = 0;         squeue->r = 0;         return squeue;     }      //add this     free(squeue);     return NULL; }  int IsNullQueue_seq(SeqQueue squeue) {     return (squeue->f == squeue->r); } void EnQueue_seq(SeqQueue squeue, DataType x) {     int pos, len;     if (squeue->f  < squeue->r)         return;     pos = squeue->f;     len = squeue->Max;      printf("%s--> r:%d, w:%d\n", __func__, squeue->r, squeue->f);     squeue->elem[pos%len] = x;     if (squeue->f + 1 < 0)         squeue->f = 0;     squeue->f += 1;  } void DeQueue_seq(SeqQueue squeue) {     int pos, len;     if (squeue->r >= squeue->f)         return;      pos = squeue->r;     len = squeue->Max;     DataType ch;      printf("%s--> r:%d, w:%d\n", __func__, squeue->r, squeue->f);     ch = squeue->elem[pos%len];     if (squeue->r + 1 < 0)         squeue->r = 0;     squeue->r += 1;     printf("%c\n", ch);     //@@ } DataType FrontQueue_seq(SeqQueue squeue) {     DataType ch;     int pos, len;      pos = squeue->r;     len = squeue->Max;     ch = squeue->elem[pos%len];      return ch;     //@@ }  int main() {     char ch;     SeqQueue queueA = SetNullQueue_seq(5);     ch = getchar();     while (ch != '#')     {         EnQueue_seq(queueA, ch);         ch = getchar();     }     DeQueue_seq(queueA);     printf("%c" ,FrontQueue_seq(queueA));      /*     DeQueue_seq(queueA);     DeQueue_seq(queueA);     DeQueue_seq(queueA);      printf("%c" ,FrontQueue_seq(queueA));     ch = getchar();     ch = getchar();     EnQueue_seq(queueA, ch);     DeQueue_seq(queueA);     printf("%c" ,FrontQueue_seq(queueA));     */     return 0; }

引用 3 楼 自信男孩的回复:[quote=引用 2 楼 ┍Æ ζざ 的回复:][quote=引用 楼主 ┍Æ ζざ的回复:]怎么写啊，各位大佬  我写了，不对[/quote] 贴代码吧，贴图片也不全呢，怎么知道哪里有问题。帮你也是无从下手～[/quote] 本题要求实现队列的顺序存储表示，包括入队、出队和取队头操作 函数接口定义： void EnQueue_seq(SeqQueue squeue, DataType x)  ; void DeQueue_seq(SeqQueue squeue)  ; DataType FrontQueue_seq(SeqQueue squeue) ; 其中，squeue 是操作的队列，x是入队的元素 裁判测试程序样例：  #include <stdio.h> #include <stdlib.h> typedef char DataType; struct Queue {     int Max;       int f;        int r;       DataType *elem;  }; typedef struct Queue *SeqQueue;  SeqQueue SetNullQueue_seq(int m)  {     SeqQueue squeue;     squeue = (SeqQueue)malloc(sizeof(struct Queue));     if (squeue == NULL)     {         printf("Alloc failure\n");         return NULL;     }     squeue->elem = (char*)malloc(sizeof(DataType)*m);     if (squeue->elem != NULL)     {         squeue->Max = m;         squeue->f = 0;         squeue->r = 0;         return squeue;     } }  int IsNullQueue_seq(SeqQueue squeue)  {     return (squeue->f == squeue->r); } void EnQueue_seq(SeqQueue squeue, DataType x)   {     @@ } void DeQueue_seq(SeqQueue squeue)   {     @@ } DataType FrontQueue_seq(SeqQueue squeue)  {     @@ }  int main() {     char ch;     SeqQueue queueA = SetNullQueue_seq(5);     ch = getchar();     while (ch != '#')     {         EnQueue_seq(queueA, ch);         ch = getchar();     }     DeQueue_seq(queueA);     printf("%c" ,FrontQueue_seq(queueA));     return 0; } 输入样例： ABCD# 输出样例： B 输入样例： A# 输出样例： It is empty queue! 输入样例： ABCDEF# 输出样例： It is FULL Queue!It is FULL Queue!B

引用 楼主 ┍Æ ζざ的回复:怎么写啊，各位大佬  我写了，不对

先按照自己思路写写吧


Question: C语言求助 指针输出val = 0000000000000001

BTW: 这里的指针变量们其实起到的仍然是非指针普通变量的作用。因为它们没有被解引用。 所以楼主还需要额外注意一下，为了避免总线错误，指针变量实际上是不能随意赋值的。

因为val是将(int *)1传给了fun函数里的a（局部变量），这两个变量是相互独立的，除了传值，没有其他关系；  所以fun函数不会把(int *)3带出来； 所以val还是main函数里初始化的(int *)1；结果自然是这个了。  可以试试这样void fun(int** a) {     *a = (int *)3; } 调用  fun(&val);  再输出来的结果应该就不是这个了。

%p 就是按32位或64位，16进制输出。你在程序里修改指针的地址，出了函数依然是原来的地址


Question: c语言用if怎么写

先自己写写吧，首先是不是奇数，if (n % 2)如果是奇数对2取余得到肯定是非0 是不是5位数，if (n / 10000)如果是肯定商是非0；否则商为0呢；同理判断2位数，1位数还是4位数。  这些似乎都是小学的数学问题～

#include <stdio.h>  #define MAX_NUM     100000 int main(void) {     int n;     int ret;      printf("Please input a number: ");     while ((ret = scanf("%d", &n)) != 1 && n >= MAX_NUM)         printf("Input err!\n");      if (n % 2) {         printf("%d is an odd number!\n", n);         if (n % 3 == 0)             printf("%d is a multiple of 3!\n", n);         else             printf("%d is not a multiple of 3!\n", n);     } else {         if (n / 10000)             printf("五");         else if (n / 1000)             printf("四");         else if (n / 100)             printf("三");         else if (n / 10)             printf("二");         else             printf("一");         printf("位数.\n");     }      return 0; } 供参考  可以按照要求把打印改改～


Question: 这个怎么写？

楼主富二代吗，不好好学习

没看出楼主指的是那个问题？具体问题都懒得描述了，那你学习上是不是书都懒得看了。  这么懒，大学还怎么进行下去？

这种过于基础的，还是作为训练吧，否则以后...就没有以后了。


Question: 一阶抛物型方程经典问题，求问如何用c语言或c++解决

#include<iostream> using namespace std;  int main() { 	double x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, xx, PI; 	PI = 3.1415926; x0 = 0; x1 = sin(0.1 * PI); 	x2 = sin(0.2 * PI); x3 = sin(0.3 * PI); x4 = sin(0.4 * PI); 	x5 = sin(0.5 * PI); x6 = sin(0.6 * PI); x7 = sin(0.7 * PI); 	x8 = sin(0.8 * PI); x9 = sin(0.9 * PI); xx = 0; 	double y0, y1, y2, y3, y4, y5, y6, y7, y8, y9, yy; 	y0 = 0; yy = 0; 	int i; 	for (i = 1; i <= 5; i++) { 		y1 = 0.8 * x0 + 0.1 * (x1 + x2); 		y2 = 0.8 * x1 + 0.1 * (x2 + x3); 		y3 = 0.8 * x2 + 0.1 * (x3 + x4); 		y4 = 0.8 * x3 + 0.1 * (x4 + x5); 		y5 = 0.8 * x4 + 0.1 * (x5 + x6); 		y6 = 0.8 * x5 + 0.1 * (x6 + x7); 		y7 = 0.8 * x6 + 0.1 * (x7 + x8); 		y8 = 0.8 * x7 + 0.1 * (x8 + x9); 		y9 = 0.8 * x8 + 0.1 * (x9 + xx); 		x1 = y1; x2 = y2; x3 = y3; x4 = y4; 		x5 = y5; x6 = y6; x7 = y7; x8 = y8; 		x9 = y9; 	} 	double a0, a1, a2, a3, a4, a5, a6, a7, a8, a9, aa; 	a0 = 0; aa = 0; a1 = pow(2.718281828459, -PI * PI / 40) * 0.1; 	a2 = pow(2.718281828459, -PI * PI / 40) * 0.2; a3 = pow(2.718281828459, -PI * PI / 40) * 0.3; 	a4 = pow(2.718281828459, -PI * PI / 40) * 0.1; a5 = pow(2.718281828459, -PI * PI / 40) * 0.1; 	a6 = pow(2.718281828459, -PI * PI / 40) * 0.1; a7 = pow(2.718281828459, -PI * PI / 40) * 0.1; 	a8 = pow(2.718281828459, -PI * PI / 40) * 0.1; a9 = pow(2.718281828459, -PI * PI / 40) * 0.1; 	cout << "差分方法结果 实际结果" << endl; 	cout << x0 << "             "<< a0 << endl; cout << x1 << "  " << a1 << endl; cout << x2 << "  " << a2 << endl; 	cout << x3 << "  " << a3 << endl; cout << x4 << "  " << a4 << endl; cout << x5 << "  " << a5 << endl; 	cout << x6 << "  " << a6 << endl; cout << x7 << "  " << a7 << endl; cout << x8 << "  " << a8 << endl; 	cout << x9 << "  " << a9 << endl; cout << xx << "             " << aa << endl; 	return 0; } 龙哥，把代码改一改，只要不相似就好了。


Question: 新手刚学，请大佬们赐教

会了，多谢各位🙏

今年大二，刚开始学编程，有时候看着头疼，

能帮我改改吗，[face]monkey2:025.png[/face]，就想输入任意温度求出电阻值

错了错了，你只是要输入t。应该改为scanf("%f", &t);

供参考，楼主漏说话了：#include<stdio.h> int main() {     float R,t;     scanf("%f",&t);     R = 10+30*t+t*t;     printf("R=%f\nt=%f\n",R,t);          return 0; }

有点迷惑的代码？      float R, t;     scanf("%f %f", &R, &t);     R = 10 + 30 * t + t * t;     printf("R = %f\nt = %f\n",R, t);  提供参考 第一眼很迷惑，再看一眼，你应该是把scanf和printf函数用错了


Question: 【C语言求助】幼儿园计算器 2.0（一位正整数±乘除）相关问题

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

引用 2 楼 user-2的回复:问题：参与运算的只能一位数。式子中不能连乘或连除（如：1+2*3*4）。供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {        printf("hw 附加题\n");        int i,j=0,result,sz,tmp=0,m;        char t[2];                           //增加字符数组t        printf("请输入参与计算数字的个数：\n");        scanf("%d",&sz);        int size=2*sz-1; //size是所有字符的长度，后面用于控制循环条件         getchar();   //吸收回车~        printf("请输入算式：\n");        char a[1000],c[1000],d[1000],n[1000]; //a[1000] 为原始字符，n[1000]用于记录a[]里的数字部分                                              //c[1000]记录a中乘除运算后的字符（就是说a与c的区别在于c里没有乘除）                                              //d[1000]为c转成整型的数组        int tmp1,tmp2;                //这两个临时变量是整型        gets(a);        //记录a中数字（a-->n)        for(int i=0;i<size;i++)        {             if(a[i]!='\n')             {                 if(a[i]<='9'&&a[i]>='0')                 {                     sscanf(&a[i],"%d",&n[i]);                      printf("n[%d]=%d ",i,n[i]);                 }             }             else break;         }        //记录乘除，并将乘除项算出来        for(i=0;i<size;i++)        {             if(a[i]!='\n')             {                 if(a[i]=='*')                 {                     m=i-(2*tmp+1);  // m=i-(2*tmp+1)是在乘除后生成的新的数的排列序数。如1-2*3   *号位于i=4，进行运算后变成1-6， // 数字6位于i'=3  ==  m=i-(2*tmp+1)=4-(2*0+1)=3 完美印证计算公式~ //tmp是当前乘除号以前的乘除号的数目                     tmp1=n[i-1]*n[i+1]; //如tmp1=2*3                     //printf("tmp1=%d\n",tmp1);                     sprintf(t,"%d",tmp1); //把整型tmp1转化为字符                     c[m] = t[0];                     //printf("c[%d]=%c",m,c[m]);                     tmp++;  //每乘除一次，tmp自增一                     i++;    //i自增一次                 }                 else if(a[i]=='/')                 {                     m=i-(2*tmp+1);                     tmp2=n[i-1]/n[i+1];//没考虑不能整除的情况                     sprintf(t,"%d",tmp2);                     c[m] = t[0];                     tmp++;                     i++;                 }                 else                 {                     m=i-2*tmp; //在当前不是乘除号的情况下，算出当前字符的序数                     c[m]=a[i]; //非乘除时直接赋给c                 }             }             else break;        }        //输出c[m]，以便观察        for(i=0;i<m+1;i++)//for(m=0;m<size;m++)        {            printf("c[%d]=%c\n",i,c[i]);        }        //system("pause");        for(m=0;m<size;m++) //记录c中数字（c——>d)        {             if(c[m]!='\n')             {                 if(c[m]<='9'&&c[m]>='0')                 {                     sscanf(&c[m],"%d",&d[m]);                     printf("c[%d]=%c ",m,c[m]);                     printf("d[%d]=%d ",m,d[m]);                  }             }             else break;          }         result=d[0];         printf("result0=%d\n",result);          //以下为加减计算部分         for(m=0;m<size-2*tmp;m++)  //size-2*tmp为进行乘除后的总字符数         {           if(c[m]!='\n')           {             if(c[m]=='-')               {                   printf("d[%d]=%d ",m+1,d[m+1]);                   result-=d[m+1];               }               else if(c[m]=='+')               {                   result+=d[m+1];               }           }           else break;        }        printf("result=%d",result);          }  //hw 附加题 //请输入参与计算数字的个数： //6 //请输入算式： //1+2*3+1*5+4 //n[0]=1 n[2]=2 n[4]=3 n[6]=1 n[8]=5 n[10]=4 c[0]=1 //c[1]=+ //c[2]=6 //c[3]=+ //c[4]=5 //c[5]=+ //c[6]=4 //c[0]=1 d[0]=1 c[2]=6 d[2]=6 c[4]=5 d[4]=5 c[6]=4 d[6]=4 result0=1 //result=16请按任意键继续. . . 哇⊙∀⊙！谢谢！ 之后细看

麻烦帮忙看看。。。


Question: 求指点！VC++的几道题

不明白，看不懂是个什么鬼？看不懂什么？如果代码看不懂是基础问题～  求平均数：代码里看到s变量，很明显没有定义，double/float s;首先需要定义，然后循环次数i <= 10，因为i从1开始；  s /= 10;求平均值的；  7.头文件,题目6已经给了，如果这个也不懂，其实下一个问题问一下自己，懂什么？学这个编程做啥？  第二个空，通过输出的是n，很明显要把结果赋值给n；在比较n和c,很明显将小的赋值给n；即n = c; 8. break；退出循环；m是最小，n是最大；  努努力，或许结果会不一样～


Question: 关于位移运算，下面这段话是什么意思，感谢指教

找理由的话，一旦移位超过w位，按照正常移法就应该全是0了，所以不如直接赋值0更干脆。 所以设计者们大概认为用户不会做这种无聊的事，于是他们决定让这些操作“有聊”一些？

引用 2 楼 forever74 的回复:log2(32)的值是5 这句话的意思是，对于移位运算符的右操作数来说，起作用的是低端的5个二进制位。 也就是把32啊，36啊，40啊这些东西都先切掉第6位以及左边的内容再用，也就是先&0x1f 也就是等价于先%32  图片里也说了，C语言规范不规定这个，所以对C程序来说，不能依赖这个“规律”。  感谢。还有一个问题请教一下。 c语言的规范，既然没说对“大数”还是“小数”起作用，那应该是不分大数和小数啊。  比如，某游乐园说自己的门票是 10 块钱，“并没有分别说小孩、成人、老人收多少钱”。 那这个价格应该是所有群体都生效啊。  是不是在实现编译器时，大的位移量有什么难言之隐？

移动的位数，是这个数对求余  例如<<32 则是移动0 因为32%32=0； >>36 则36%32 等于=4； 40下同


Question: 【C语言求助】幼儿园计算器(1位数加减)

引用 2 楼 飞禽走兽卍一2b 的回复:快被整疯了，虽然这已经是最简单的计算器了研究和计算机对话的方式，让它听你的，加油！

引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {         //{  //这里多了‘{’        printf("hw 附加题\n");        int i,j=0,result,sz;        printf("请输入参与计算数字的个数：\n");        scanf("%d",&sz);    /*sz是计算数字个数，控制一下循环条件，防止后面出现多余的奇怪的项*/        getchar();  //吸收回车        printf("请输入算式：\n");        char *a = new char[2*sz-1],*n = new char[2*sz-1],tmp;//char a[2*sz-1],n[2*sz-1],tmp;        gets(a);                                             //动态的char[]      //这一段是将字符转化为整型       for(int i=0;i<2*sz-1;i++)           {               if(a[i]!='\n')  //遇回车结束，然并卵               {                   if(a[i]<='9'&&a[i]>='0')                   {                       n[i]=a[i]-'0';                      printf("n[%d]=%d ",i,n[i]);                    }               }               else break;            }       result=n[0];                                        // printf("result0=%d",result);                                        //下面这段就是计算加减       for(i=0;i<2*sz-1;i++)        {                       if(a[i]!='\n')           {                if(a[i]=='-')//if(a[i]='45')//这里是‘== ’ //减号的ASCII码为45               {                   printf("n[%d]=%d ",i+1,n[i+1]);                   result-=n[i+1];               }               else if(a[i]=='+')//else if(a[i]='43') 这里是‘==’ //加号               {                   result+=n[i+1];               }           }           else break;        }        printf("result=%d",result);        delete []a;delete []n;         } 那个*a  *n 我们好像还没学

引用 1 楼 user-2的回复:供参考：#include <stdio.h> #include <math.h> #include <stdlib.h> void main() {         //{  //这里多了‘{’        printf("hw 附加题\n");        int i,j=0,result,sz;        printf("请输入参与计算数字的个数：\n");        scanf("%d",&sz);    /*sz是计算数字个数，控制一下循环条件，防止后面出现多余的奇怪的项*/        getchar();  //吸收回车        printf("请输入算式：\n");        char *a = new char[2*sz-1],*n = new char[2*sz-1],tmp;//char a[2*sz-1],n[2*sz-1],tmp;        gets(a);                                             //动态的char[]      //这一段是将字符转化为整型       for(int i=0;i<2*sz-1;i++)           {               if(a[i]!='\n')  //遇回车结束，然并卵               {                   if(a[i]<='9'&&a[i]>='0')                   {                       n[i]=a[i]-'0';                      printf("n[%d]=%d ",i,n[i]);                    }               }               else break;            }       result=n[0];                                        // printf("result0=%d",result);                                        //下面这段就是计算加减       for(i=0;i<2*sz-1;i++)        {                       if(a[i]!='\n')           {                if(a[i]=='-')//if(a[i]='45')//这里是‘== ’ //减号的ASCII码为45               {                   printf("n[%d]=%d ",i+1,n[i+1]);                   result-=n[i+1];               }               else if(a[i]=='+')//else if(a[i]='43') 这里是‘==’ //加号               {                   result+=n[i+1];               }           }           else break;        }        printf("result=%d",result);        delete []a;delete []n;         } 好好好，我慢慢看

快被整疯了，虽然这已经是最简单的计算器了


Question: 求求帮忙看一下C语言的编程题

引用 2 楼 朕守山河的回复:忘记加注释，就是将小时转化分钟，然后相减得相差分钟，再格式化转化为小时 了解啦，蟹蟹😀

引用 3 楼 赵4老师的回复:#include <stdio.h> int main() {     char ln[80];     int H1,M1,H2,M2;     int d;      while (1) {         rewind(stdin);         fgets(ln,80,stdin);         if (4==sscanf(ln,"%2d:%2d %2d:%2d",&H1,&M1,&H2,&M2)) {             if (0<=H1 && H1<=23              && 0<=M1 && M1<=59              && 0<=H2 && H2<=23              && 0<=M2 && M2<=59) break;         }         printf("H1:M1 H2:M2 format error. Input again\n");     }     d=H2*60+M2-(H1*60+M1);     printf("%d:%02d\n",d/60,d%60);     return 0; } //输入10:30 11:45 //输出1:15   对的对的，蟹蟹蟹蟹😁

printf("%d:%02d\n",d/60,(d%60>0)?(d%60):-(d%60));

忘记加注释，就是将小时转化分钟，然后相减得相差分钟，再格式化转化为小时

你要的纯C #include <stdio.h>  int analysisHourAndMin(char* pTime); void main() { 	char preTime[] = "10:30"; 	char nexTime[] = "11:45";  	int nPreTime = analysisHourAndMin(preTime); 	int nNextTime = analysisHourAndMin(nexTime);  	int nCurTime = nNextTime - nPreTime; 	printf("%d: %d", nCurTime / 60, nCurTime % 60); 	 }  int analysisHourAndMin(char* pTime) { 	int nHour = (pTime[0] - '0') * 10 + (pTime[1] - '0'); 	int nMin = (pTime[3] - '0') * 10 + (pTime[4] - '0'); 	return nHour * 60 + nMin; }


Question: 【C语言求助】一位数计算器(个人)中的一部分

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

引用 6 楼 qzjhjxj的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> //无用 void main() {       // {        printf("hw 附加题\n");        int i,j=0,n[1000];         char a[1000],tmp[2];        gets(a);     //输入字符串如：1-2        for(int k=0;;k++)            {                if(a[k]<='9'&&a[k]>='0') //如果字符为数字                {                    tmp[0]=a[k];tmp[1]= '\0';                    printf("tmp=%s\n",tmp);                    sscanf(tmp,"%d",&n[j]);  //将字符转化为整型                     printf("n[%d]=%d ",j,n[j]);                }                else if(a[k]=='\n')  //遇到回车结束                {                    break;                }            }         } 说实话，没太看懂。。。tmp定义是做什么的啊？我原来的代码里tmp好像没啥用。。。  还有就是，你的蓝色背景的代码是怎么贴上去的啊？  哦，最最重要的还是我发的另一个帖子。。快被整疯了，麻烦看一下

引用 6 楼 qzjhjxj的回复:#include <stdio.h> #include <math.h> #include <stdlib.h> #include <string.h> //无用 void main() {       // {        printf("hw 附加题\n");        int i,j=0,n[1000];         char a[1000],tmp[2];        gets(a);     //输入字符串如：1-2        for(int k=0;;k++)            {                if(a[k]<='9'&&a[k]>='0') //如果字符为数字                {                    tmp[0]=a[k];tmp[1]= '\0';                    printf("tmp=%s\n",tmp);                    sscanf(tmp,"%d",&n[j]);  //将字符转化为整型                     printf("n[%d]=%d ",j,n[j]);                }                else if(a[k]=='\n')  //遇到回车结束                {                    break;                }            }         } 谢谢！ 我还有一个帖子，麻烦看看吧X﹏X

引用 3 楼 qzjhjxj的回复:这句改为： sscanf(&a[k],"%d",&n[j]);  //将字符转化为整型 发了发了，帖子

引用 3 楼 qzjhjxj的回复:这句改为： sscanf(&a[k],"%d",&n[j]);  //将字符转化为整型 转化的问题，我用另一种方法解决了，结果又碰到另一个bug。超级奇怪，麻烦看一下

引用 1 楼 user-3的回复:你的sscanf读的是a啊，也就是从头读起。 那我怎么样才能把a[i]一一对应的转化为n[i]？

你的sscanf读的是a啊，也就是从头读起。


Question: c语言指针复杂定义

引用 4 楼 脚味 的回复:[quote=引用 2 楼 自信男孩 的回复：]char *func（int **p 这个是函数变量；  可以用a[0] = func;这样赋值；也可以a[0] = &func;  调用可以用a[0](p); 例子如下：  #include <stdio.h>  char *func(int **a);  int main(void) {     int **p = NULL;     char *(*a[3])(int **);      //两种写法一样的     //a[0] = func;     a[0] = &func;      a[0](p);      return 0; }  char *func(int **a) {     printf("%p\n", a);      printf("helloworld!\n");     return NULL; }  因为func函数名就是地址名，加不加&都是可以的。不是很懂，char *func （int **a）意思是这个函数参数是int 二级指针，返回的是char类型指针对吗？ [/quote]  函数名前面的是返回值类型，char * func(int **a);char *是返回值类型；

仅供参考：//char (*(*x[3])())[5];//x是什么类型的变量? // //分析C语言声明，关键是搞清楚这个变量是个什么东西（函数、指针、数组）， //是函数那么剩下的就是他的参数和返回值， //是指针那剩下部分是说明他指向什么， //是数组剩下的部分就是说明数组的成员是什么类型。 //解析C语言声明规则： //从左侧第一个标识符开始，按照优先级进行结合。*表示是..的指针，const表示只读的，volatile表示可变的，[]表示是数组，()表示是函数。 // //x和[3]结合说明是一个大小为3的数组，该数组的每个元素为一类指针，该类指针指向一类函数，该类函数无参数，返回一类指针，该类指针指向一个大小为5的char型数组 #include <stdio.h> #include <typeinfo.h> char num[5]; char (*x00())[5] {     return # } int main() {     char (*(*x[3])())[5];//是个数组，大小为3     char (*(*x0  )())[5];//数组的元素，是个函数指针     char (*( x00 )())[5];//函数原型，参数为空，返回值为指针     char (*  x000   )[5];//返回值      x0 = x00;     x[0] = x0;     x[1] = x0;     x[2] = x0;     printf("typeid(x).name() is %s\n",typeid(x).name());     return 0; } //typeid(x).name() is char (* (__cdecl**)(void))[5]

引用 5 楼 真相重于对错 的回复：#include <stdio.h> char* f1(int**){     printf("%s", __FUNCTION__);     return nullptr; } char* f2(int**){     printf("%s", __FUNCTION__);     return nullptr; } char* f3(int** ){     printf("%s", __FUNCTION__);      return nullptr; } char* (*a[3])(int** p) {f1,f2,f3};  int main(){     a[0](nullptr);     a[1](nullptr);     a[2](nullptr);          }老师可以不传入空参数吗？来个稍微复杂的

是不是char *func（int **p）这个函数接受一个类型是int的二级指针然后返回一个值是char类型的指针，这样理解对吗

引用 2 楼 自信男孩 的回复：char *func（int **p 这个是函数变量；  可以用a[0] = func;这样赋值；也可以a[0] = &func;  调用可以用a[0](p); 例子如下：  #include <stdio.h>  char *func(int **a);  int main(void) {     int **p = NULL;     char *(*a[3])(int **);      //两种写法一样的     //a[0] = func;     a[0] = &func;      a[0](p);      return 0; }  char *func(int **a) {     printf("%p\n", a);      printf("helloworld!\n");     return NULL; }  因为func函数名就是地址名，加不加&都是可以的。不是很懂，char *func （int **a）意思是这个函数参数是int 二级指针，返回的是char类型指针对吗？

引用 1 楼 真相重于对错 的回复：char *(*a[3])(int **p) 代表是一个3个元素的数组，其中的元素类型是 char* func(int**)  这就是一个函数，这个函数的返回值是char* 参数是int**意思是数组里面三个元素都是返回类型是char 指针的函数这个函数的参数是int的二级指针。对吗？老师


Question: 请问一下 为什么会不断输入

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

1.scanf()读数据碰到空白符就停止输入。 2.scanf()忽略缓冲区中先导的空白符。 3.当参数为%c的时候，返回缓冲区中第一个字符，包括空白符。 也就是说，在这行代码"scanf("%d\n");中要让缓冲区读两次，才能停止scanf();，第一次缓冲区读入%d后碰到回车，程序停止等待读入\n，由于忽略先导的空白符，程序一直在等待，直到遇到一个非空白符才继续读入。

去掉scanf中的\n，否则无法结束输入～

输入成绩的个数，scanf (“%d \n”,&n);里面多了\n。


Question: C语言，程序错误怎么改

编译出错，还是运行出错？总得有一个错误内容吧～

提问要把出错信息带着一起贴，别让人猜。

要是用个新点的IDE，通过变色你早就发现了。

明显缺半边双引号

仿佛能猜到是什么问题，你把return 1.0;和resule *= n--;这两句话分别用个大括号括起来试试呢

这个我换了个


Question: 一个菱形画不出

楼主代码，只输出菱形上半部，见注释：#include "stdio.h" int main() {   int i;   int j;   int k;   for(i=1;i<=4;i++)    {     for(j=3;j>=i;j--)    //{ 这里多了‘{’       {          printf(" ");       }     for(k=1;k<=2*i-1;k++) //for(k=1;k<2*i-1;k++) 中间 k<2*i-1少了‘=’号       {          printf("*");       }     printf("\n");        //} 这里多了‘}’    }      for(i=3;i>=1;i--)    //增加下半部    {     for(j=3;j>=i;j--)       {          printf(" ");       }     for(k=1;k<=2*i-1;k++)       {          printf("*");       }     printf("\n");    }    getchar();    return 0;  }

引用 2 楼 sweetswing 的回复:[quote=引用 1 楼 赵4老师 的回复:]学会单步调试 这个软件不带调试功能[/quote] 不带调试你可以在想调试的地方插入比如 printf("i,j,k:%d,%d,%d\n",i,j,k);getchar(); 调试。 按一次回车，执行一步。

引用 1 楼 赵4老师 的回复:学会单步调试 这个软件不带调试功能

学会单步调试


Question: 结构体问题

引用 3 楼 自信男孩的回复:没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。 谢啦兄弟，差不多懂了

引用 2 楼 focuslight的回复:没有你这种写法的，像是结构体初始化又不规范。带函数的结构体，实际上就是 class. 只不过它的函数 都属 public. 你可以在主函数内建一个 它的 对象。用 对象的成员成员函数调用。struct stu a;      a.fun(1); 谢啦兄弟，差不多懂了

引用 1 楼 user-5的回复:供参考：#include <stdio.h>  struct stu{        int fun (int a)        {            printf("i am fun!\n");        } };  int main() {      struct stu a;      a.fun(1);       } 谢啦兄弟，差不多懂了

引用 6 楼 NorZ 的回复:[quote=引用 5 楼 自信男孩 的回复:][quote=引用 4 楼 NorZ 的回复:][quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf("i am fun!\n");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？[/quote]   楼主的代码[/quote] 楼主代码是语法问题，楼主的问题是结构体。这是两个问题好不好。我回答的是结构体问题～

引用 5 楼 自信男孩 的回复:[quote=引用 4 楼 NorZ 的回复:][quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf("i am fun!\n");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？[/quote]   楼主的代码

引用 4 楼 NorZ 的回复:[quote=引用 3 楼 自信男孩 的回复:]没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...[/quote]  #include <stdio.h>   struct stu{        int fun (int a)        {            printf("i am fun!\n");        } };   int main() {      struct stu a;      a.fun(1);        }  这个是编译过去的，并且还正常运行。你说的不支持，是不支持什么内容？不支持这么定义结构体？

引用 3 楼 自信男孩 的回复:没见过这么写的，C语法不支持，C++支持；况且C语言语法结构体成员也得是;分号结束的。  C++ 也不支持...


Question: 上位机串口通讯的问题，怎么区分我收到的数据？求助

你可以按500ms周期来发送 周期1 查询第一个，收到的数据无论是什么都放在第一个文本框 周期2 查询第二个，放到第二个文本框  这样从全局上看，还是一秒一个周期 需要客户端配合在500ms内可以回复

根据单片机返回的数据格式，进行解析

每秒发送一次 命令查电流 和 命令查电压 ？如果是这样你为了更准确需要定义返回格式来区别，   还是间隔一秒发一次命令（两个命令是轮询模式）  这个模式你可以依据你命令来判断回复，是可以的

要相信对面 你先查的是啥，对面先发的就是啥。

引用 1 楼 focuslight 的回复:你需要和单片机程序定个通讯协议吧，在数据前加上标识 单片机的程序不用改，那个已经有上位机软件了，我只是要重做一个。

你需要和单片机程序定个通讯协议吧，在数据前加上标识


Question: c++新人求教为什么程序报错 如何修改程序

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

没有提供Circle的有参构造函数

供参考：#include <iostream> using namespace std; class Circle {     private:            double r;     public:            void Show()             {                cout<<"面积="<<3.14*r*r<<endl;             }            Circle()//computer()//类构造函数名和类名是一样的             {                r=10;             }            Circle(double a)//computer(double a)             {               r=a;             } };  int main()   {      double r1;      cin>>r1;    Circle a,b(r1);      a.Show();      b.Show();     return 0; }


Question: 关于学生成绩管理系统排序问题

引用 7 楼 user-1 的回复:我算知道毛病了，我改的是： 楼主改的：   我改的： 楼主改的：  两条语句，楼主一句未改？ 哦哦哦，对不起对不起，我看错了，能像你那样子运行了，问题已经解决了，谢谢你！

第114行 ：w=p; 第 130行：for(i=0,k=p; i<n-1; i++,k=k->pNext)

这是按楼主的步骤，按改过的代码运行（ w =p->pNext; //w=p->pNext ;  //这句修改（已改）   for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )（已改）），执行的结果，已经没有楼主讲的问题了：//按楼主讲的步骤： //录入第一个数：                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 1 学生成绩录入成功！ 请按任意键继续. . .   //录入第二个数：                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 2 学生成绩录入成功！ 请按任意键继续. . .   //录入第三个数：                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 3 学生成绩录入成功！ 请按任意键继续. . .   //然后执行排序；                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为：  //这里也正常 1 2 3 请按任意键继续. . .  //选择 2.成绩显示  看看排序     这里没有乱序                       学生成绩表 ======================================================== 总成绩 1 2 3 请按任意键继续. . .    //继续再输入一个新的成绩                       学生成绩表 ======================================================== 总成绩 1 2 3 请按任意键继续. . .                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 1 请输入学生的总成绩： 10 学生成绩录入成功！ 请按任意键继续. . .    //再执行排序 //【前面三个成绩就可以正常排序了，但是第四个录进来的成绩就没有 】？？？？？？？？ //【也就是说每次排序最后一个录入的成绩总是不能参与到排序过程中。】？？？？？？？                          欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为：//这里四个数 1 2 3 10 请按任意键继续. . .    //到这里再多加一步，选择 2.成绩显示 ，第四个也在                     学生成绩表 ======================================================== 总成绩 1 2 3 10 请按任意键继续. . .

引用 3 楼 user-1 的回复:不存在了。表头插入法，就是每次输入一个数据时，在没有排序的情况下，最后这个输入的数据是排在第一位的，也就是倒序（这个倒序是指和输入的顺序相反，先入后出）的，最早输入的显示在最后一个。//这里随便输入三个数字，然后选择2 成绩显示：                       学生成绩表 ======================================================== 总成绩 6 0 3 请按任意键继续. . .  //这里是选择 4 成绩排序                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 请按任意键继续. . .  //这里是先选择 1.成绩录入 ，增加一个数10，然后选择2.成绩显示 ，10是最后加入的数字，在没有排序的时候 //它就是第一个，它就是表头。                       学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .   //这里是选择  4.成绩排序 。如果这时后接下去选择2.成绩显示，它就是显示已经排序好的排列了。                      学生成绩表 ======================================================== 总成绩 10 0 3 6 请按任意键继续. . .                         欢迎使用学生班级成绩管理系统！                 =============================================                 ==                主菜单                   ==                 =============================================                 ==              1.成绩录入                 ==                 ==              2.成绩显示                 ==                 ==              4.成绩排序                 ==                 ==              7.系统退出                 ==                 =============================================                 ===========请选择相应的功能列表============== 4 总成绩由低到高依次排序为： 0 3 6 10 请按任意键继续. . .  啊这。。。是修改了那两处对吧？我是按你标的来改的呀。 #include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>   //定义一个学生的信息 typedef struct _Student {   int total;      //总成绩 }Student;   //定义一个节点 typedef struct _Node {    Student stu;//学生    struct _Node* pNext; }Node;   Node*g_pHead=NULL;             //头结点   void Menu();//菜单界面函数 void Input_m();//成绩录入函数 void Print();//成绩显示函数 void Save();//成绩保存函数 void Order();//成绩排序函数 void Modify();//成绩修改函数 void Sta();//声明成绩统计函数   int main() {     int a;     while(1){  //while循环使程序持续运行              Menu();              scanf("%d",&a);              switch(a)//**用户进行选择**//                    {                       case 1:                            Input_m(); //成绩录入                            break;                       case 2:                            Print();//成绩显示                            break;                       case 4:                            Order();//成绩排序                            break;                       case 7:                           printf("您已成功退出系统，欢迎下次使用！\n");                           return 0;                      default:                           printf("无效选择，请重新输入\n");                           system("pause");                           system("cls");                           break;              }     }     return 0; }   void Menu()//菜单界面函数  {         printf("\t\t\t欢迎使用学生班级成绩管理系统！\n");         printf("\t\t=============================================\n");         printf("\t\t==\t          主菜单                   ==\n");         printf("\t\t=============================================\n");         printf("\t\t==\t\t1.成绩录入                 ==\n");         printf("\t\t==\t\t2.成绩显示                 ==\n");         printf("\t\t==\t\t4.成绩排序                 ==\n");         printf("\t\t==\t\t7.系统退出                 ==\n");         printf("\t\t=============================================\n");         printf("\t\t===========请选择相应的功能列表==============\n");       } void Input_m()//成绩录入函数 {     Node* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点     pNewNode->pNext=NULL;     if(g_pHead==NULL)       {         g_pHead=pNewNode;       }     else       {         pNewNode->pNext=g_pHead;         g_pHead=pNewNode;       }     printf("请输入学生的总成绩：\n");     scanf("%d",&pNewNode->stu.total);     printf("学生成绩录入成功！\n");     system("pause");      //暂停执行     system("cls");        //清屏 }   void Print()//成绩显示函数  {     system("cls");     printf("                     学生成绩表                         \n");     printf("========================================================\n");     printf("总成绩\n");      //遍历链表，一次打印出学生的成绩     Node* p=g_pHead;     while(p!=NULL)      {         printf("%d \n",p->stu.total);         p=p->pNext;//指向下一个，少了这个会无限循环      }     system("pause"); }   int trival(Node*g_pHead) {     Node* p=g_pHead;     int i=0;     Node* w;     w =p->pNext;             //w=p->pNext ;  //这句修改（已改）     while(w!=NULL)     {       w=w->pNext ;       i++;     }     return i; }   void Order()//总成绩排序函数 {     Node* p=g_pHead;     Node* k,*q;     int n,i,j;     Student temp;     n=trival(g_pHead);                    //这句修改     for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )（已改）       {         for(j=i+1,q=k->pNext; j<n ; j++,q=q->pNext ,j++)           {               if(k->stu.total> q->stu.total )                 {                    temp=k->stu ;                    k->stu =q->stu ;                    q->stu =temp;                 }           }       }     printf("总成绩由低到高依次排序为：\n");     while(p!=NULL){          printf("%d\n",p->stu.total);          p=p->pNext;     }     system("pause");     system("cls"); }

上面的描述不规范，应该这么说，表头插入法，每次插入一个新节点时，都是把这个新节点作为头节点，所以头节点head始终指向最后录入的数据节点。你可以实验下，比如输入三个数，1 2 3 ，输入完后，选择2.成绩显示，它就是显示 3 2 1。你的代码里有没有文件保存和打开并读入文件的功能，如果有，你就会发现一个问题，当你这次保存时顺序是 1 2 3退出程序后，下次重新运行代码，文件载入时它显示的就是3 2 1.

引用 1 楼 user-1 的回复:楼主，这个链表是表头插入法，插入的最后一个节点就是表头，所以排序也是从最后一个开始的，而不是k=p->pNext 开始，修改如下见标注，供参考：#include<stdio.h> #include<conio.h> #include<stdlib.h> #include<string.h>  //定义一个学生的信息 typedef struct _Student {   int total;      //总成绩 }Student;  //定义一个节点 typedef struct _Node {    Student stu;//学生    struct _Node* pNext; }Node;  Node*g_pHead=NULL;             //头结点  void Menu();//菜单界面函数 void Input_m();//成绩录入函数 void Print();//成绩显示函数 void Save();//成绩保存函数 void Order();//成绩排序函数 void Modify();//成绩修改函数 void Sta();//声明成绩统计函数  int main() {     int a;     while(1){  //while循环使程序持续运行              Menu();              scanf("%d",&a);              switch(a)//**用户进行选择**//                    {                       case 1:                            Input_m(); //成绩录入                            break;                       case 2:                            Print();//成绩显示                            break;                       case 4:                            Order();//成绩排序                            break;                       case 7:                           printf("您已成功退出系统，欢迎下次使用！\n");                           return 0;                      default:                           printf("无效选择，请重新输入\n");                           system("pause");                           system("cls");                           break;              }     }     return 0; }  void Menu()//菜单界面函数  {         printf("\t\t\t欢迎使用学生班级成绩管理系统！\n");         printf("\t\t=============================================\n");         printf("\t\t==\t          主菜单                   ==\n");         printf("\t\t=============================================\n");         printf("\t\t==\t\t1.成绩录入                 ==\n");         printf("\t\t==\t\t2.成绩显示                 ==\n");         printf("\t\t==\t\t4.成绩排序                 ==\n");         printf("\t\t==\t\t7.系统退出                 ==\n");         printf("\t\t=============================================\n");         printf("\t\t===========请选择相应的功能列表==============\n");      } void Input_m()//成绩录入函数 {     Node* pNewNode =(Node*)malloc(sizeof(Node));//创建一个新节点     pNewNode->pNext=NULL;     if(g_pHead==NULL)       {         g_pHead=pNewNode;       }     else       {         pNewNode->pNext=g_pHead;         g_pHead=pNewNode;       }     printf("请输入学生的总成绩：\n");     scanf("%d",&pNewNode->stu.total);     printf("学生成绩录入成功！\n");     system("pause");      //暂停执行     system("cls");        //清屏 }  void Print()//成绩显示函数  {     system("cls");     printf("                     学生成绩表                         \n");     printf("========================================================\n");     printf("总成绩\n");      //遍历链表，一次打印出学生的成绩     Node* p=g_pHead;     while(p!=NULL)      {         printf("%d \n",p->stu.total);         p=p->pNext;//指向下一个，少了这个会无限循环      }     system("pause"); }  int trival(Node*g_pHead) {     Node* p=g_pHead;     int i=0;     Node* w;     w = p;             //w=p->pNext ;  //这句修改     while(w!=NULL)     {       w=w->pNext ;       i++;     }     return i; }  void Order()//总成绩排序函数 {     Node* p=g_pHead;     Node* k,*q;     int n,i,j;     Student temp;     n=trival(g_pHead);                    //这句修改     for(i=0,k=p ;i<n-1;i++,k=k->pNext )   //for(i=0,k=p->pNext ;i<n-1;i++,k=k->pNext )       {         for(j=i+1,q=k->pNext; j<n ; q=q->pNext ,j++)           {               if(k->stu.total> q->stu.total )                 {                    temp=k->stu ;                    k->stu =q->stu ;                    q->stu =temp;                 }           }       }     printf("总成绩由低到高依次排序为：\n");     while(p!=NULL){          printf("%d\n",p->stu.total);          p=p->pNext;     }     system("pause");     system("cls"); }  按这个改完执行程序后原来的问题还是在的呀


Question: 关于栈和队列

S和Q都是指向NULL的指针，NULL是不可以读写的，所以S->top这样的操作是对S的写操作，会出现多错误；  建议将S和Q先指向一个可以正常读写的位置，这个位置可以是栈上的，也可以是堆上的(malloc/free, new/delete）。

你描述了班长的特征和权限，但你还没有任命任何一个学生做班长。 这时候你就想让班长履行职责了，于是就出错了。

S是类型定义，没有实例化，内存中这样其实还没有实际给分配出空间，不可以给赋值 temp_s=new SeqStack; temp_s->top=0;


Question: 【C语言】请帮忙看一下这段代码，谢谢

引用 2 楼 user-2 的回复：可改作： return p+n-1;谢谢您的指导

可改作： return p+n-1;

第一，你的solve函数return p;而在执行中p没有变过，*solve(nnn)都是p[0]，所以递归那部分不能成立。 第二，这个数列只有前四十多项能用32位整数表示，就算递归弄对了，后面大部分也都是溢出以后没有用的数值了。


Question: 【C语言】请帮忙看一下代码！谢谢

一年了。再看当年那么稚嫩的代码，还真是感叹

引用 1 楼 user-1 的回复：这里的scanf()改为：scanf("%d",&a[i][j]);谢谢

这里的scanf()改为：scanf("%d",&a[i][j]);


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 <string.h> int main() {     char buf[]="123+321";     int num[6];     sscanf(buf,"%1d%1d%1d+%1d%1d%1d",&num[0],&num[1],&num[2],&num[3],&num[4],&num[5]);     for (int i=0;i<6;i++) printf("%d ",num[i]);     return 0; }

就在串口UART中断处理函数，解析一下字符串，放入数组即可。


Question: 小白提问：C++提示interrupted by signal 11: sigsegv

哇原来如此！谢谢你！

越界了 if (range [arr[i]] != -1) { //这句话，因为i最大为6，而arr最多有效元素是6个，所以arr[6]是无效元素，因此越界


Question: c语言

有人吗有人吗

这个文件的格式，存放的是当前时间，打开文件用fopen("time1.txt","r");fscanf()读入文件的信息，然后输入所需时间scanf("%d",&time); 然后该加就加，不是就算出到达时间了。


Question: 这段代码的含义

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

引用 3 楼 自信男孩 的回复:[quote=引用 2 楼 Star-Sum 的回复:][quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？[/quote]  应该是TC的一个非标库函数，读硬件寄存器什么的。

这种一看就是和硬件打交道的函数，都是不讲理的。 你得到帮助里去看它的说明，那里边应该有解释哪一位是干什么的。

哦，那么问题在于编译。 那么编译还有什么错误？我历来主张盯住第一条错误修改，后面的错误回头可能自己就消失了。

引用 2 楼 Star-Sum 的回复:[quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？

引用 1 楼 forever74的回复:你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？

你调用的函数peekb就是做这个用的，读它的说明即可。

引用 6 楼 forever74 的回复:[quote=引用 3 楼 自信男孩 的回复:][quote=引用 2 楼 Star-Sum 的回复:][quote=引用 1 楼 forever74的回复:]你调用的函数peekb就是做这个用的，读它的说明即可。 这个peekb函数是干什么的？而且编译的时候显示该函数未定义是为什么？[/quote] 未定义说明没有把peekb函数加入进来，没找到定义的地方。这函数不是你写的吗？或者代码没有全部导入到编译器里？[/quote]  应该是TC的一个非标库函数，读硬件寄存器什么的。[/quote] 那就是头文件的问题了，没引入头文件？


Question: C语言基础题目

楼主代码没问题，简化下，供参考：#include<stdio.h>  int m_sum(int x) {     int t = 0;     while(x){           t += x % 10;           x /= 10;     }     return t; }   int m_cnt_9(int x) {     int  cnt=0;     while (x){          if((x%10) == 9) cnt++;          x /= 10;     }     return cnt; }  int m_fi(int x)//有几个9： {     int i;     int t = 0;     for(i = 1; i < x ;i++){         t += m_cnt_9(i);     }     return t; }   int m_pow(int x) {     x = x * x * x;     return x; }  int m_narcissistic(int y)//水仙花数：（153=1*1*1+5*5*5+3*3*3） {     int b = y, t = 0;     while(y){           t += m_pow(y % 10);           y /= 10;     }     if(t == b){        return 1;     }else{        return 0;     } }  int main() {     int i,x=1000,y=123;      printf("%d\n",m_sum(y));//位数和      printf("%d\n",m_fi(x)); //1-1000间9的个数      for(i = 100; i < 1000; i++){  //水仙花数         if (m_narcissistic(i) == 1){             printf("%d ", i);         }     }     printf("\n");          return 0; }


Question: MFC项目加速键使用不了小键盘的减号

我去,visual studio风格的MFC项目在用数字键盘的减号做加速键时由Insert键响应怎么回事不知道, 但找到解决的办法了, 在项目的类中增加HACCEL m_haccel变量,加载加速键到变量, 再添加PreTranslateMessage函数, 在函数内加代码 if (m_haccel != NULL) { 	TranslateAccelerator(this->m_hWnd, m_haccel, pMsg); } 翻译消息前,翻译一下加速键,问题就解决了!  初步怀疑是visual studio类型的MFC项目中的类关于加速键的默认Translate功能环节有BUG,自己在之前translateaccelerator一下就好了


Question: 请问一个关于syslog中时间记录的问题

我们使用的操作系统相当有弹性，我的意思是，它们不适合做那种时间精密型操作。 因为缓存的存在，写入个文件还有可能被拖后几秒呢。  所以长期运行的软件系统里几秒这种等级的时间误差很难去较真儿。

原来不是程序问题啊 系统管理员表示一般这种情况不是一段时间没记，而是“那段时间”消失了  一个系统的实时钟随着系统的繁忙程度的提高倾向于偏慢，对表进程拨快时钟的时候看起来就会“消失”一段时间 ntpd或者chronyd之类的进程隔三岔五地修正一下系统时间，你可以对照一下它们的log


Question: 同一线程下两个read读取一个串口

串口数据我记得有中断的，你要不每个函数都用 select 试试？读不到数据就阻塞，等有新数据了，就读，读完，等下一个函数再 select？

一个线程read 你把读到的数据放 到两个list里，然后分别两个线程 处理 不同的list就可以了

引用 7 楼 enthrone的回复:在一个线程里面已经读到数据了。为什么还要再读一边呢？复制不香吗？ 正是因为复制之后对我的程序来说不可靠，所以才来问的，因为在之前公司是用的我说的方法，但是当时没有学那个库函数，难受

在一个线程里面已经读到数据了。为什么还要再读一边呢？复制不香吗？

想读取同样的数据？一波数据读两遍？ 恐怕不行。

引用 4 楼 user-5的回复:读光了数据，一时半会儿没东西可读也很正常啊。 所以我想知道有没有什么方法让两个read都能读取到……

读光了数据，一时半会儿没东西可读也很正常啊。

引用 2 楼 user-5的回复:读呗，还能有啥问题咋的？ 主要是，第一个read读取完之后，为什么第二个read去读取的时候返回值是－1，也就是没东西可读，还有就是这个串口我在读的同时也给里面用write写入数据

读呗，还能有啥问题咋的？

求大佬指点一二，多谢了！！！


Question: 关于声卡采集并显示波形的问题

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


Question: 数据结构

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

多谢大佬解答

还有个6也不见了？感觉在这几个地方有问题：判断条件'<'就可以了，'<='下标越界了。


Question: C语言数组解决问题，刚学

供参考：//产品销售记录包括 产品代码 名称 单价 数量 金额 等信息 //1）编写input函数 输入10个产品销售记录的如上信息 //2）编写sum函数 计算金额 = 单价 * 数量 //3）编写sort函数 按金额从大到小排序  #include<stdio.h> #define PRODUCTS 10 //按题目要求10个产品  void  input(); float sum(float a,int n); void  sort();   typedef struct{ //自定义结构体类型 	int   code; 	char  name[21]; 	float price; 	int   quantity; }PRODUCT;  PRODUCT products[PRODUCTS];//定义10个产品记录的数组  void main() {       input(); //输入       sort();  //排序,从大到小       for(int i = 0; i < PRODUCTS; i++){ //打印输出        printf("code = %d | quantity = %d | price = %.2f | name = %s | sum = %.2f\n",              products[i].code,products[i].quantity,products[i].price,products[i].name,              sum(products[i].price,products[i].quantity));       }        }  void input(){      printf("Enter example:code,quantity,price,name(30)\n");      for(int i = 0; i < PRODUCTS; i++){         scanf("%d %d %f %s", &products[i].code,&products[i].quantity,                                    &products[i].price,products[i].name); 	} }  float sum(float a,int n) {      return a * n; }  void sort(){       PRODUCT temp;       for (int i = 0; i <PRODUCTS -1 ;i++){          for (int k = 0; k < PRODUCTS - 1 -i ;k++){            if((products[k].price * products[k].quantity)<                                   (products[k+1].price * products[k+1].quantity))            {                  temp          = products[k];                  products[k]   = products[k+1];                  products[k+1] = temp;            }          }       } }   //Enter example:code,quantity,price,name(30) //11 20 2.00 aa //22 30 1.00 bb //33 10 3.00 cc //code = 11 | quantity = 20 | price = 2.00 | name = aa | sum = 40.00 //code = 22 | quantity = 30 | price = 1.00 | name = bb | sum = 30.00 //code = 33 | quantity = 10 | price = 3.00 | name = cc | sum = 30.00 //请按任意键继续. . .

你的代码呢？只看到编译error，没看到代码呢，这怎么帮？你的意思按照你的要求写一个？！