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

第一种：
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;

}

楼主，你要注意了。对于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的修改。

运行：

当然。程序还有一种改法，（只有c++可以，c不可以）就是用引用。

你说的中断是什么意思，我这里第二种完全就没法运行，你的函数定义有问题，还是说你已经改掉了？麻烦发一下你现在的代码

运行成功的代码2

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

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

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

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

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

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

#include
#include

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;

}

引用的写法

 #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;

}