[已解决]链式队列的一个问题，为什么第一种可以运行，第二种没有报错但是运行会中断

我们遇见过

第一种：
typedef struct Qnode//队列结点定义
{
  int data;
  Qnode * next;
}Qnode;

typedef struct Lq//链队类型定义
{
  Qnode * front;
  Qnode * rear;
}Lq;

bool is_empty(Lq *qu)//判断是否队空
{
  if(qu->front==NULL||qu->rear==NULL)
  {
          
         
          return true;
  }
  else
          return false;
}

void init(Lq * &qu)//初始化
{
  qu=(Lq *)malloc(sizeof(Lq));
  (*qu).front=(*qu).rear=NULL;
  printf("初始化成功!\n");
}


void in_qu(Lq * qu,int a)//入队
{
  Qnode *s;
  s=(Qnode*)malloc(sizeof(Qnode));
  s->next=NULL;
  s->data=a;

          if(is_empty(qu))
          {
                  qu->front=qu->rear=s;

          }
          else
          {
            qu->rear->next=s;
                qu->rear=s;
          }
          return;
}
void out_qu(Lq *  qu)//出队
{
  Qnode * p;
  int a;
  if(is_empty(qu))
  {
    printf("队空不能出队!\n");
        return;
  }
  p=qu->front;
  a=qu->front->data;
  qu->front=p->next;
  if(qu->front==NULL)//即队列中只有一个元素
          qu->rear=NULL;
  free(p);
  printf("出队的元素是:%d\n",a);
  return;
}

void out_qu(Lq *  qu);
void in_qu(Lq * qu,int a);
bool is_empty(Lq *qu);
void init(Lq * & qu);

int main()
{
  Lq qu;
  Lq * p;
  p=&qu;
  init(p);
  in_qu(p,1);
  out_qu(p);
  return 0;

}



第二种：
typedef struct Qnode//队列结点定义
{
  int data;
  Qnode * next;
}Qnode;

typedef struct Lq//链队类型定义
{
  Qnode * front;
  Qnode * rear;
}Lq;

bool is_empty(Lq *qu)//判断是否队空
{
  if(qu->front==NULL||qu->rear==NULL)
  {
          
         
          return true;
  }
  else
          return false;
}

void init(Lq * &qu)//初始化
{
  qu=(Lq *)malloc(sizeof(Lq));
  (*qu).front=(*qu).rear=NULL;
  printf("初始化成功!\n");
}


void in_qu(Lq * qu,int a)//入队
{
  Qnode *s;
  s=(Qnode*)malloc(sizeof(Qnode));
  s->next=NULL;
  s->data=a;

          if(is_empty(qu))
          {
                  qu->front=qu->rear=s;

          }
          else
          {
            qu->rear->next=s;
                qu->rear=s;
          }
          return;
}
void out_qu(Lq *  qu)//出队
{
  Qnode * p;
  int a;
  if(is_empty(qu))
  {
    printf("队空不能出队!\n");
        return;
  }
  p=qu->front;
  a=qu->front->data;
  qu->front=p->next;
  if(qu->front==NULL)//即队列中只有一个元素
          qu->rear=NULL;
  free(p);
  printf("出队的元素是:%d\n",a);
  return;
}
void out_qu(Lq *  qu);
void in_qu(Lq * qu,int a);
bool is_empty(Lq *qu);
void init(Lq * & qu);

int main()
{
  Lq qu;
  init(&qu);
  in_qu(&qu,1);
  out_qu(&qu);
  return 0;

}

最佳答案

月排行榜 / 总排行榜

人造人

2018-10-4 19:35:42

我们遇见过 发表于 2018-10-4 19:11
嗯。。对对，我想着应该就只出在实参和形参那。。所以就说了那么多，就是第一个可以编译，第二个不可以

r1是一个引用，引用了变量a
r2是一个const引用，引用了常量3
如果不加const会报错，因为引用的是右值，常量是右值

1. int main()
   
2. {
   
3.         int a = 100;
   
4.         int &r1 = a;
   
5.         const int &r2 = 3;
   
6. 
   
7.         return 0;
   
8. }
   

复制代码

1. &qu

复制代码

一个&和qu组成的表达式的值是一个右值
要引用这个右值，需要const引用
下面代码可以通过编译

1. #include <cstdio>
   
2. #include <cstdlib>
   
3. 
   
4. typedef struct Qnode
   
5. {
   
6.         int data;
   
7.         Qnode *next;
   
8. }Qnode;
   
9. 
   
10. typedef struct Lq
    
11. {
    
12.         Qnode *front;
    
13.         Qnode *rear;
    
14. }Lq;
    
15. 
    
16. void init(Lq *const &qu)
    
17. {
    
18.         /*qu = (Lq *)malloc(sizeof(Lq));
    
19.         (*qu).front = (*qu).rear = NULL;
    
20.         printf("初始化成功!\n");*/
    
21. }
    
22. 
    
23. int main()
    
24. {
    
25.         Lq qu;
    
26.         init(&qu);
    
27. 
    
28.         return 0;
    
29. }
    

复制代码

跳转到最佳答案楼层

claws0n

呃，有点长……没仔细看
第二种 Lq qu; 本身是一个结构体，不是指针，而你在 init 的时候却把它当指针使用
第一种的 qu 没有实质的作用吧

我们遇见过

claws0n 发表于 2018-10-3 23:37
呃，有点长……没仔细看
第二种 Lq qu; 本身是一个结构体，不是指针，而你在 init 的时候却把它当指针使用 ...

第二种里面 直接用&取地址不是一样吗..我看视频的时候记得那老师说指针就是地址- -

claws0n

我们遇见过 发表于 2018-10-3 23:42
第二种里面 直接用&取地址不是一样吗..我看视频的时候记得那老师说指针就是地址- -

你什么编译器？
typedef struct Qnode//队列结点定义
{
  int data;
  struct Qnode * next;
}Qnode;

不一样哦，取址只有右值，指针参考的是左值，可以解引用得到右值
指针、取址、数组，很多时候可以互换，但是它们是不一样的东西

我们遇见过

claws0n 发表于 2018-10-3 23:58
你什么编译器？
typedef struct Qnode//队列结点定义
{

好晕- -我之前typedef那个是你写的那样定义的，后来看课本里这样定义了就用这个了，我上面那个第二种贴错了，那个编译器会报错，但是
void out_qu(Lq *  qu);
void in_qu(Lq * qu,int a);
bool is_empty(Lq *qu);
void init(Lq *  qu);

int main()
{
  Lq qu;
  init(&qu);
in_qu(&qu,1);
  out_qu(&qu);
  return 0;

}
这个不会报错，但是运行会中断，但是，我把 in 和 out那个注释之后，只有init这一句就不会中断..这种情况他们不是都一样的吗..为什么一个会中断一个不会。。

我们遇见过

claws0n 发表于 2018-10-3 23:58
你什么编译器？
typedef struct Qnode//队列结点定义
{

用的vc6.0- -考试要求用这个

claws0n

我们遇见过 发表于 2018-10-4 00:07
好晕- -我之前typedef那个是你写的那样定义的，后来看课本里这样定义了就用这个了，我上面那个第二种贴错 ...

vc6.0 ...... 加油
编译器：MinGW GCC 8.10 64位   状态：没问题
编译器：Borland C++ 64位         状态：没问题
编译器：TDM GCC 4.9.2  64位    状态：没问题
编译器：TDM GCC 4.9.2  32位    状态：卡……
问题：is_empty 判断错误，去到 else
原因不明
还是那一句，不是指针就不要当指针用，也许 64 位的指针有 8 个字节，刚好够装你的单一测试数据

@人造人 ，反编译能看出吗？

我们遇见过

claws0n 发表于 2018-10-4 00:48
vc6.0 ...... 加油
编译器：MinGW GCC 8.10 64位   状态：没问题
编译器：Borland C++ 64位  ...

其实还有个题，就是我调试的时候也发现那个isempty莫名其妙跳到else了，然后我看答案，答案里那个init里的参数用的引用型，然后用引用型的话...我都不知道咋说了。。就是用引用型的话，主函数里的那个，该传入什么类型啊。。就是说函数定义是void init(Lq * & qu)，那么主函数里写成init(&qu)为什么会报错啊，如果函数定义成void init(Lq * qu)，主函数里那样写就不会报错。。

人造人

claws0n 发表于 2018-10-4 00:48
vc6.0 ...... 加油
编译器：MinGW GCC 8.10 64位   状态：没问题
编译器：Borland C++ 64 ...

claws0n

人造人 发表于 2018-10-4 01:39

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct Qnode//队列结点定义
   
5. {
   
6.         int data;
   
7.         Qnode* next;
   
8. }Qnode;
   
9. 
   
10. typedef struct Lq//链队类型定义
    
11. {
    
12.         Qnode* front;
    
13.         Qnode* rear;
    
14. }Lq;
    
15. 
    
16. bool is_empty(Lq *qu)//判断是否队空
    
17. {
    
18.         printf("%d\n", sizeof(qu));
    
19.         if (qu->front == NULL || qu->rear == NULL)
    
20.                 return true;
    
21.         else
    
22.                 return false;
    
23. }
    
24. 
    
25. void init(Lq * qu)//初始化
    
26. {
    
27.         qu = (Lq *)malloc(sizeof(Lq));
    
28.         (*qu).front = (*qu).rear = NULL;
    
29.         printf("初始化成功!\n");
    
30. }
    
31. 
    
32. 
    
33. void in_qu(Lq *qu, int a)//入队
    
34. {
    
35.         Qnode *s;
    
36.         s = (Qnode*)malloc(sizeof(Qnode));
    
37.         s->next = NULL;
    
38.         s->data = a;
    
39.         printf("in\n");
    
40.         if (is_empty(qu))
    
41.         {
    
42.                 printf("2\n");
    
43.                 qu->front = qu->rear = s;
    
44.         }
    
45.         else
    
46.         {
    
47.                 printf("3\n");
    
48.                 qu->rear->next = s;
    
49.                 printf("4\n");
    
50.                 qu->rear = s;
    
51.         }
    
52.         printf("in2\n");
    
53.         return;
    
54. }
    
55. 
    
56. void out_qu(Lq *qu)//出队
    
57. {
    
58.         Qnode *p;
    
59.         int a;
    
60.         if (is_empty(qu))
    
61.         {
    
62.                 printf("队空不能出队!\n");
    
63.                 return;
    
64.         }
    
65.         p = qu->front;
    
66.         a = qu->front->data;
    
67.         qu->front = p->next;
    
68.         if (qu->front == NULL)//即队列中只有一个元素
    
69.                 qu->rear = NULL;
    
70.         free(p);
    
71.         printf("出队的元素是:%d\n", a);
    
72.         return;
    
73. }
    
74. 
    
75. void out_qu(Lq *qu);
    
76. void in_qu(Lq *qu, int a);
    
77. bool is_empty(Lq *qu);
    
78. void init(Lq *qu);
    
79. 
    
80. int main()
    
81. {
    
82.         Lq qu;
    
83.         init(&qu);
    
84.         printf("1\n");
    
85.         in_qu(&qu, 1);
    
86.         printf("12\n");
    
87.         out_qu(&qu);
    
88.         return 0;
    
89. 
    
90. }

复制代码

人造人

claws0n 发表于 2018-10-4 02:05

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. 
   
4. typedef struct Qnode//队列结点定义
   
5. {
   
6.         int data;
   
7.         Qnode* next;
   
8. }Qnode;
   
9. 
   
10. typedef struct Lq//链队类型定义
    
11. {
    
12.         Qnode* front;
    
13.         Qnode* rear;
    
14. }Lq;
    
15. 
    
16. bool is_empty(Lq *qu)//判断是否队空
    
17. {
    
18.         printf("%d\n", sizeof(qu));
    
19.         if(qu->front == NULL || qu->rear == NULL)
    
20.                 return true;
    
21.         else
    
22.                 return false;
    
23. }
    
24. 
    
25. // 初始化
    
26. void init(Lq *qu)
    
27. {
    
28.         qu = (Lq *)malloc(sizeof(Lq));
    
29.         (*qu).front = (*qu).rear = NULL;
    
30.         printf("初始化成功!\n");
    
31. }
    
32. 
    
33. 
    
34. void in_qu(Lq *qu, int a)//入队
    
35. {
    
36.         Qnode *s;
    
37.         s = (Qnode*)malloc(sizeof(Qnode));
    
38.         s->next = NULL;
    
39.         s->data = a;
    
40.         printf("in\n");
    
41.         if(is_empty(qu))
    
42.         {
    
43.                 printf("2\n");
    
44.                 qu->front = qu->rear = s;
    
45.         }
    
46.         else
    
47.         {
    
48.                 printf("3\n");
    
49.                 qu->rear->next = s;
    
50.                 printf("4\n");
    
51.                 qu->rear = s;
    
52.         }
    
53.         printf("in2\n");
    
54.         return;
    
55. }
    
56. 
    
57. void out_qu(Lq *qu)//出队
    
58. {
    
59.         Qnode *p;
    
60.         int a;
    
61.         if(is_empty(qu))
    
62.         {
    
63.                 printf("队空不能出队!\n");
    
64.                 return;
    
65.         }
    
66.         p = qu->front;
    
67.         a = qu->front->data;
    
68.         qu->front = p->next;
    
69.         if(qu->front == NULL)//即队列中只有一个元素
    
70.                 qu->rear = NULL;
    
71.         free(p);
    
72.         printf("出队的元素是:%d\n", a);
    
73.         return;
    
74. }
    
75. 
    
76. void out_qu(Lq *qu);
    
77. void in_qu(Lq *qu, int a);
    
78. bool is_empty(Lq *qu);
    
79. void init(Lq *qu);
    
80. 
    
81. int main()
    
82. {
    
83.         Lq qu;
    
84. 
    
85.         Lq *tmp = &qu;
    
86.         printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
    
87.         init(&qu);
    
88.         printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
    
89.        
    
90.         printf("*******************************\n");
    
91.         qu.front = NULL;
    
92.         qu.rear = NULL;
    
93.         printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
    
94.         exit(1);
    
95.        
    
96.         printf("1\n");
    
97.         in_qu(&qu, 1);
    
98.         printf("12\n");
    
99.         out_qu(&qu);
    
100.         return 0;
     
101. 
     
102. }
     

复制代码

1. front:CCCCCCCC, rear:CCCCCCCC
   
2. 初始化成功!
   
3. front:CCCCCCCC, rear:CCCCCCCC
   
4. *******************************
   
5. front:00000000, rear:00000000
   
6. 请按任意键继续. . .

复制代码

1. // 初始化
   
2. void init(Lq *qu)
   
3. {
   
4.         qu = (Lq *)malloc(sizeof(Lq));
   
5.         (*qu).front = (*qu).rear = NULL;
   
6.         printf("初始化成功!\n");
   
7. }

复制代码

人造人

claws0n 发表于 2018-10-4 02:05

1. #include <stdio.h>
   
2. 
   
3. void Fun1(int *n)
   
4. {
   
5.         n = 0;
   
6. }
   
7. 
   
8. void Fun2(int *n)
   
9. {
   
10.         *n = 0;
    
11. }
    
12. 
    
13. int main()
    
14. {
    
15.         int a = 10;
    
16.        
    
17.         printf("%.8X\n", a);
    
18.         Fun1(&a);
    
19.         printf("%.8X\n", a);
    
20.         printf("\n");
    
21. 
    
22.         printf("%.8X\n", a);
    
23.         Fun2(&a);
    
24.         printf("%.8X\n", a);
    
25. 
    
26.         return 0;
    
27. 
    
28. }
    

复制代码

1. 0000000A
   
2. 0000000A
   
3. 
   
4. 0000000A
   
5. 00000000
   
6. 请按任意键继续. . .

复制代码

我们遇见过

claws0n 发表于 2018-10-4 02:05

这个不还是不能运行吗。。可能编译器问题？

我们遇见过

人造人 发表于 2018-10-4 02:28

没看明白..是第一个函数没有改变a吗..

我们遇见过

人造人 发表于 2018-10-4 02:19

这个执行init后front，rear为什么没改变啊..传入的是地址不应该改变了吗..

我们遇见过

看了在csdn别人的解答，感觉相对清楚点吧，但还是没完全搞懂。。。有相同问题的朋友自行理解吧，同时谢谢楼上的两位大佬不辞辛苦大半夜在帮我解答，万分感谢

楼主，你要注意了。对于c++来说，除非传递引用（也就是你所谓正确的方式），否则在函数内修改一个变量，永远无法作用到实参上。
void init(Lq * qu)//初始化
{
qu=(Lq *)malloc(sizeof(Lq));
(*qu).front=(*qu).rear=NULL;
printf("初始化成功!\n");
}
这段代码，你虽然修改了qu，让qu指向你分配的内存。但是退出函数，
init(&qu);
这里的qu并不会改变。

请注意以下两个的区别：
（1）修改一个指针，让它指向另一个地址，这个不会作用到实际参数
（2）通过指针，修改其指向的内容。这个会作用到实际参数指向的内容，因为两者共享的是相同的内容。

因此，如果你要在函数内改变指针指向的内容，那么用指针就可以。要改变指针的指向，让它指向另一个地址，那么必须用指针的指针（2个指针）
此时对于第二个指针，它指向实际的内容，第一个指针，指向第二个指针，而你可以修改第一个指针的指向，从而将第二个指针指向的内容作用到调用者。

修改以后的程序：

#include "stdio.h"
#include "stdlib.h"

typedef struct Qnode//队列结点定义
{
int data;
Qnode * next;
}Qnode;

typedef struct Lq//链队类型定义
{
Qnode * front;
Qnode * rear;
}Lq;

bool is_empty(Lq *qu)//判断是否队空
{
if(qu->front==NULL||qu->rear==NULL)
{

  return true;
}
else
return false;
}

void init(Lq ** qu)//初始化
{
*qu=(Lq *)malloc(sizeof(Lq));
(*qu)->front=(*qu)->rear=NULL;
printf("初始化成功!\n");
}

void in_qu(Lq * qu,int a)//入队
{
Qnode * s;
s=(Qnode *)malloc(sizeof(Qnode));
s->next=NULL;
s->data=a;

  if(is_empty(qu))
  {
      qu->front=qu->rear=s;

  }
  else
  {
    qu->rear->next=s;
    qu->rear=s;
  }
  return;
}
void out_qu(Lq * qu)//出队
{
Qnode * p;
int a;
if(is_empty(qu))
{
printf("队空不能出队!\n");
return;
}
p=qu->front;
a=qu->front->data;
qu->front=p->next;
if(qu->front==NULL)//即队列中只有一个元素
qu->rear=NULL;
free(p);
printf("出队的元素是:%d\n",a);
return;
}
void out_qu(Lq * qu);
void in_qu(Lq * qu,int a);
bool is_empty(Lq *qu);
void init(Lq * qu);

int main()
{
Lq * qu;
init(&qu);
in_qu(qu,1);
out_qu(qu);
return 0;

}


注意我对main和init的修改。

claws0n

我们遇见过 发表于 2018-10-4 10:55
看了在csdn别人的解答，感觉相对清楚点吧，但还是没完全搞懂。。。有相同问题的朋友自行理解吧，同时谢谢楼 ...

嗯，合理使用指针。
Lq *qu; //在 main 函数里，这个是重点
因为 void init(Lq **qu); 所以 init(&qu); 如果不是空型，可以用单指针。
之后所有的函数调用，数据类型吻合，都是指针
init 定义对，但声明错了，是双指针。

我们遇见过

claws0n 发表于 2018-10-4 11:43
嗯，合理使用指针。
Lq *qu; //在 main 函数里，这个是重点
因为 void init(Lq **qu); 所以 init(&qu); ...

我又有问题了。。这个双指针这个我明白了，但是没明白引用。。
void init(Lq * & qu);
init(&qu);main函数中只运行这一句，这个会直接报错，，错误信息cannot convert parameter 1 from 'struct Lq *' to 'struct Lq *& '，
用这个是正确的Lq qu; Lq * p; p=&qu; init(p);，正确的这个里面不也是 from 'struct Lq *' to 'struct Lq *& '吗，，为什么一个可以一个不可以啊。。

claws0n

我们遇见过 发表于 2018-10-4 12:57
我又有问题了。。这个双指针这个我明白了，但是没明白引用。。
void init(Lq * & qu);
init(&qu);main ...

你说的是第一种和第二种吗？
数据类型不匹配。第一种正确，p 是指针，你引用了，那个 & 不是取址。
第二种，qu 不是指针，函数不会帮你转

我们遇见过

claws0n 发表于 2018-10-4 13:17
你说的是第一种和第二种吗？
数据类型不匹配。第一种正确，p 是指针，你引用了，那个 & 不是取址。
第 ...

不明白...抛开这道题int*p=&q，将p作为一个参数传入另一个函数，与，直接将&q作为一个参数传入另一个函数不一样吗