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

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

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

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

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

#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)//判断是否队空
{
printf("%d\n", sizeof(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;
printf("in\n");
if(is_empty(qu))
{
printf("2\n");
qu->front = qu->rear = s;
}
else
{
printf("3\n");
qu->rear->next = s;
printf("4\n");
qu->rear = s;
}
printf("in2\n");
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 *tmp = &qu;
printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
init(&qu);
printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
printf("*******************************\n");
qu.front = NULL;
qu.rear = NULL;
printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
exit(1);
printf("1\n");
in_qu(&qu, 1);
printf("12\n");
out_qu(&qu);
return 0;
}

复制代码

front:CCCCCCCC, rear:CCCCCCCC
初始化成功!
front:CCCCCCCC, rear:CCCCCCCC
*******************************
front:00000000, rear:00000000
请按任意键继续. . .

复制代码

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

复制代码

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

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

#include <stdio.h>
void Fun1(int *n)
{
n = 0;
}
void Fun2(int *n)
{
*n = 0;
}
int main()
{
int a = 10;
printf("%.8X\n", a);
Fun1(&a);
printf("%.8X\n", a);
printf("\n");
printf("%.8X\n", a);
Fun2(&a);
printf("%.8X\n", a);
return 0;
}

复制代码

0000000A
0000000A
0000000A
00000000
请按任意键继续. . .

复制代码

人造人 · 发表于 2018-10-4 16:06:05

我们遇见过发表于 2018-10-4 15:55
我明白了引用是直接对本身的。然后我就想..因为你看直接init（&qu）不对，但是int*p=&qu，init（p）就是 ...

引用和指针有区别吗？

#include <stdio.h>
void Fun1(int &n)
{
n = 100;
}
void Fun2(int *n)
{
*n = 100;
}
int main()
{
int a = 10;
int b = 10;
Fun1(a);
Fun2(&b);
return 0;
}

复制代码

int a = 10;
0023175E C7 45 F8 0A 00 00 00 mov dword ptr [a],0Ah
int b = 10;
00231765 C7 45 EC 0A 00 00 00 mov dword ptr [b],0Ah
Fun1(a);
0023176C 8D 45 F8 lea eax,[a]
0023176F 50 push eax
00231770 E8 30 F9 FF FF call Fun1 (02310A5h)
00231775 83 C4 04 add esp,4
Fun2(&b);
00231778 8D 45 EC lea eax,[b]
0023177B 50 push eax
0023177C E8 3D F9 FF FF call Fun2 (02310BEh)
00231781 83 C4 04 add esp,4

复制代码

void Fun1(int &n)
{
002316C0 55 push ebp
002316C1 8B EC mov ebp,esp
002316C3 81 EC C0 00 00 00 sub esp,0C0h
002316C9 53 push ebx
002316CA 56 push esi
002316CB 57 push edi
002316CC 8D BD 40 FF FF FF lea edi,[ebp-0C0h]
002316D2 B9 30 00 00 00 mov ecx,30h
002316D7 B8 CC CC CC CC mov eax,0CCCCCCCCh
002316DC F3 AB rep stos dword ptr es:[edi]
n = 100;
002316DE 8B 45 08 mov eax,dword ptr [n]
002316E1 C7 00 64 00 00 00 mov dword ptr [eax],64h
}
002316E7 5F pop edi
}
002316E8 5E pop esi
002316E9 5B pop ebx
002316EA 8B E5 mov esp,ebp
002316EC 5D pop ebp
002316ED C3 ret

复制代码

void Fun2(int *n)
{
00231700 55 push ebp
00231701 8B EC mov ebp,esp
00231703 81 EC C0 00 00 00 sub esp,0C0h
00231709 53 push ebx
0023170A 56 push esi
0023170B 57 push edi
0023170C 8D BD 40 FF FF FF lea edi,[ebp-0C0h]
00231712 B9 30 00 00 00 mov ecx,30h
00231717 B8 CC CC CC CC mov eax,0CCCCCCCCh
0023171C F3 AB rep stos dword ptr es:[edi]
*n = 100;
0023171E 8B 45 08 mov eax,dword ptr [n]
00231721 C7 00 64 00 00 00 mov dword ptr [eax],64h
}
00231727 5F pop edi
00231728 5E pop esi
00231729 5B pop ebx
0023172A 8B E5 mov esp,ebp
0023172C 5D pop ebp
0023172D C3 ret

复制代码

#include <stdio.h>
void Fun1(int *&n)
{
static int test = 0;
n = &test;
}
void Fun2(int **n)
{
static int test = 0;
*n = &test;
}
int main()
{
int *a = NULL;
int *b = NULL;
Fun1(a);
Fun2(&b);
return 0;
}

复制代码

int *a = NULL;
00A3175E C7 45 F8 00 00 00 00 mov dword ptr [a],0
int *b = NULL;
00A31765 C7 45 EC 00 00 00 00 mov dword ptr [b],0
Fun1(a);
00A3176C 8D 45 F8 lea eax,[a]
00A3176F 50 push eax
00A31770 E8 83 FB FF FF call Fun1 (0A312F8h)
00A31775 83 C4 04 add esp,4
Fun2(&b);
00A31778 8D 45 EC lea eax,[b]
00A3177B 50 push eax
00A3177C E8 31 FB FF FF call Fun2 (0A312B2h)
00A31781 83 C4 04 add esp,4

复制代码

void Fun1(int *&n)
{
00A316C0 55 push ebp
00A316C1 8B EC mov ebp,esp
00A316C3 81 EC C0 00 00 00 sub esp,0C0h
00A316C9 53 push ebx
00A316CA 56 push esi
00A316CB 57 push edi
00A316CC 8D BD 40 FF FF FF lea edi,[ebp-0C0h]
00A316D2 B9 30 00 00 00 mov ecx,30h
00A316D7 B8 CC CC CC CC mov eax,0CCCCCCCCh
00A316DC F3 AB rep stos dword ptr es:[edi]
static int test = 0;
n = &test;
00A316DE 8B 45 08 mov eax,dword ptr [n]
00A316E1 C7 00 38 91 A3 00 mov dword ptr [eax],offset test (0A39138h)
}
00A316E7 5F pop edi
}
00A316E8 5E pop esi
00A316E9 5B pop ebx
00A316EA 8B E5 mov esp,ebp
00A316EC 5D pop ebp
00A316ED C3 ret

复制代码

void Fun2(int **n)
{
00A31700 55 push ebp
00A31701 8B EC mov ebp,esp
00A31703 81 EC C0 00 00 00 sub esp,0C0h
00A31709 53 push ebx
00A3170A 56 push esi
00A3170B 57 push edi
00A3170C 8D BD 40 FF FF FF lea edi,[ebp-0C0h]
00A31712 B9 30 00 00 00 mov ecx,30h
00A31717 B8 CC CC CC CC mov eax,0CCCCCCCCh
00A3171C F3 AB rep stos dword ptr es:[edi]
static int test = 0;
*n = &test;
00A3171E 8B 45 08 mov eax,dword ptr [n]
00A31721 C7 00 3C 91 A3 00 mov dword ptr [eax],offset test (0A3913Ch)
}
00A31727 5F pop edi
00A31728 5E pop esi
00A31729 5B pop ebx
00A3172A 8B E5 mov esp,ebp
00A3172C 5D pop ebp
00A3172D C3 ret

复制代码

在汇编语言层，引用和指针没有区别
普通变量的引用就是一级指针
一级指针的引用就是二级指针

要修改普通变量，要用一级指针（普通引用）
要修改一级指针，要用二级指针（引用一级指针）

人造人 · 发表于 2018-10-4 16:36:29

我们遇见过发表于 2018-10-4 16:17
不是我感觉我现在迷惑的是如果 int*p=&qu；那么p和&pu有什么区别啊，应该有区别吧，如果没有怎么会init（ ...

放下这个问题继续向后学吧，因为现在不管怎么解释，你也应该还是无法理解
想要理解这个，你一定要学习汇编语言
在汇编语言层，指针就是引用

人造人 · 发表于 2018-10-4 16:38:18

我们遇见过发表于 2018-10-4 16:17
不是我感觉我现在迷惑的是如果 int*p=&qu；那么p和&pu有什么区别啊，应该有区别吧，如果没有怎么会init（ ...

站在汇编语言的角度看引用，你会看到它和指针是多么的相似，甚至于找不到区别
引用就是指针
指针就是引用

人造人 · 发表于 2018-10-4 16:40:18

我们遇见过发表于 2018-10-4 16:17
不是我感觉我现在迷惑的是如果 int*p=&qu；那么p和&pu有什么区别啊，应该有区别吧，如果没有怎么会init（ ...

现在你要想理解这个，那就只能看我上面的那个代码了，如果看不懂，那就暂时放下这个问题吧
之后你还会遇到的，带上汇编语言再来看这个问题好吗？

引用就是指针
指针就是引用
没有区别

人造人 · 发表于 2018-10-4 17:06:20

我们遇见过发表于 2018-10-4 16:43
不是啊。。我感觉现在不是引用的问题...是为什么int*p=&qu，引用p是对的，引用（&qu）就是错的...

把你现在的问题完整的说一下，要完整的
上面太乱了
重新，完整的，说一下

人造人 · 发表于 2018-10-4 18:50:15

我们遇见过发表于 2018-10-4 18:39
就是我代码里有一个函数
void init（Lq*&qu）//Lq是一个结构体
然乎main{

你都不愿意详细描述一下你的问题吗？我还特别强调了详细描述
我整理了一下代码，你现在的问题是不是
这两个代码为什么第一个可以通过编译，第二个无法通过编译？

#include <cstdio>
#include <cstdlib>
typedef struct Qnode
{
int data;
Qnode *next;
}Qnode;
typedef struct Lq
{
Qnode *front;
Qnode *rear;
}Lq;
void init(Lq *&qu)
{
qu = (Lq *)malloc(sizeof(Lq));
(*qu).front = (*qu).rear = NULL;
printf("初始化成功!\n");
}
int main()
{
Lq qu;
Lq *p;
p = &qu;
init(p);
return 0;
}

复制代码

#include <cstdio>
#include <cstdlib>
typedef struct Qnode
{
int data;
Qnode *next;
}Qnode;
typedef struct Lq
{
Qnode *front;
Qnode *rear;
}Lq;
void init(Lq *&qu)
{
qu = (Lq *)malloc(sizeof(Lq));
(*qu).front = (*qu).rear = NULL;
printf("初始化成功!\n");
}
int main()
{
Lq qu;
init(&qu);
return 0;
}

复制代码

人造人 · 发表于 2018-10-4 19:35:42

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

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

int main()
{
int a = 100;
int &r1 = a;
const int &r2 = 3;
return 0;
}

复制代码

&qu

复制代码

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

#include <cstdio>
#include <cstdlib>
typedef struct Qnode
{
int data;
Qnode *next;
}Qnode;
typedef struct Lq
{
Qnode *front;
Qnode *rear;
}Lq;
void init(Lq *const &qu)
{
/*qu = (Lq *)malloc(sizeof(Lq));
(*qu).front = (*qu).rear = NULL;
printf("初始化成功!\n");*/
}
int main()
{
Lq qu;
init(&qu);
return 0;
}

复制代码

人造人 · 发表于 2018-10-4 20:00:02

claws0n 发表于 2018-10-4 19:57
那样是可以编译通过，不过就废了

?

#include <cstdio>
#include <cstdlib>
typedef struct Qnode
{
int data;
Qnode *next;
}Qnode;
typedef struct Lq
{
Qnode *front;
Qnode *rear;
}Lq;
void init(Lq *const &qu)
{
qu->front = NULL;
qu->rear = NULL;
/*qu = (Lq *)malloc(sizeof(Lq));
(*qu).front = (*qu).rear = NULL;
printf("初始化成功!\n");*/
}
int main()
{
Lq qu;
Lq *tmp = &qu;
printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
init(&qu);
printf("front:%.8X, rear:%.8X\n", tmp->front, tmp->rear);
return 0;
}

复制代码

人造人 · 发表于 2018-10-4 20:00:54

claws0n 发表于 2018-10-4 19:57
那样是可以编译通过，不过就废了

引用了一个指针
这个引用是const的，指针又不是

账号		自动登录	找回密码
密码			立即注册

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

浏览过的版块