外观
2.5 传值与传地址
直接传结构体,Init为什么没生效
上一节的五个函数都直接操作全局变量L。这一节把L改成函数的参数。
为什么要改?有三个原因。
第一,全局变量L只有一个,程序里就只能有一个表。第3章的栈和队列,要同时用好几个表。
第二,2.2定义的操作是Init(L)、Insert(L, i, x),表是参数。代码理应和定义长得一样。
第三,全局变量谁都能改。main可以绕过操作,直接改L.length,"只通过操作访问数据"就没有约束力了。
最自然的改法,是给函数加一个参数。从最简单的Init试起:
c
void Init(SeqList L) {
L.length = 0;
}
int main(void) {
SeqList L;
L.length = 5; /* 故意先放个数 */
Init(L);
printf("%d\n", L.length);
return 0;
}期望打印0,实际打印5。
本节问题Init运行了,也没报错,为什么main里的L没有变?
什么是传值
用内存格子图看发生了什么。main里的L是一个结构体,占一段格子。假设它从200号开始,length那一格在300号:
text
main 的 L
┌───┬───┬─────┬─────┐
│ │ │ … │ 5 │
└───┴───┴─────┴─────┘
200 201 300 ← length调用Init(L)时,C语言把main的L这一整段的内容复制一份,放到另一处,比如从500号开始,作为Init的参数L:
text
main 的 L Init 的 L(复制品)
┌───┬───┬─────┬─────┐ ┌───┬───┬─────┬─────┐
│ │ │ … │ 5 │ 复制 ──► │ │ │ … │ 5 │
└───┴───┴─────┴─────┘ └───┴───┴─────┴─────┘
200 201 300 500 501 600Init里的L.length = 0改的是600号,300号纹丝不动。函数一返回,复制品就被丢弃,main里看到的还是5。
调用函数时,把参数的值复制一份交给函数,这叫传值,教材里也叫值传递。函数拿到的是复制品,不是原件。
传值什么时候正合适?比如传一个int进去做计算。复制一个格子不费事,原件也不会被误改。
可这里不行,有两个原因。一是Init要改的是原件,改复制品等于白改。二是结构体有一百多个格子,每次调用都要整段复制,Length、Get这种不改表的操作,也白白复制一遍。
什么是传地址
既然改复制品没用,就不要给函数复制品,而是告诉它原件在哪:只传一个数,200,也就是main的L的起始地址。
Init的参数变成一个格子,里面记着200。Init顺着200找到原件,把300号改成0:
text
main 的 L Init 的参数
┌───┬───┬─────┬─────┐ ┌─────┐
│ │ │ … │ 0 │ ◄────────── │ 200 │
└───┴───┴─────┴─────┘ └─────┘
200 201 300 700把原件的地址交给函数,函数顺着地址去改原件,这叫传地址,教材里也叫地址传递。
要注意,传地址其实也是传值,只不过传的值是一个地址。调用时,复制的是那个装着200的格子;函数顺着这个复制来的地址,改到的是原件。C语言只有传值这一种传法。
这也说明了传地址为什么省事:复制的只是一个数,不是一百多个格子。
要把这个思路写成C代码,还需要两样工具:怎么取到一个变量的地址,怎么顺着地址去访问它。这就是指针。
地址与指针
如果你已经熟悉C语言的指针,可以直接翻到下一页。
2.3说过,内存是一排编了号的格子,编号就是地址。这不是比喻。定义一个变量,打印它的值和它的地址:
c
int a = 10;
printf("%d\n", a);
printf("%p\n", &a);第一行打印10,是a的值。第二行打印类似0x7ffd5a3c9c04的东西,这就是a所在格子的编号。&读作"取地址",%p是打印地址的格式。
地址习惯用十六进制显示,0x是十六进制的标记,0x64就是100。你运行时看到的数字会和这里不同,每次运行也可能变,这没有关系。下面的图里,为了好读,地址都用小的十进制数。
一个int占4个字节,也就是4个格子。图里把这4个格子画成一个框,下面标出起始地址。a从100号开始,&a就是100:
text
a
┌─────┐
│ 10 │
└─────┘
100有了地址,就有了第二种访问变量的办法。除了用名字a,也可以先把它的地址存起来,再顺着地址去找:
c
int *pa = &a;
printf("%d\n", *pa); /* 10 */int *pa定义了一个变量pa,它存放的是一个int变量的地址,这样的变量叫指针。pa自己也住在一个格子里,比如200号,格子里装着100:
text
a pa
┌─────┐ ┌─────┐
│ 10 │ ◄──────── │ 100 │
└─────┘ └─────┘
100 200*pa读作"pa指向的那个变量",也就是顺着箭头找到的a。读*pa就是读a,改*pa就是改a:
c
*pa = 20;
printf("%d\n", a); /* 20 */text
a pa
┌─────┐ ┌─────┐
│ 20 │ ◄──────── │ 100 │
└─────┘ └─────┘
100 200这和上一页的图是同一回事:Init的参数格子里装着200,顺着它找到main的L。
再看指向结构体的指针,这正是下一页要用的:
c
SeqList L;
SeqList *p = &L;
L.length = 5;
printf("%d %d\n", (*p).length, p->length); /* 5 5 */p里装着L的起始地址200,箭头指向L:
text
L p
┌───┬───┬─────┬─────┐ ┌─────┐
│ │ │ … │ 5 │ ◄────────── │ 200 │
└───┴───┴─────┴─────┘ └─────┘
200 201 300 700(*p).length是"p指向的结构体的length成员",也就是顺着箭头找到L,再取它的length。这个写法太啰嗦,C语言提供了等价的简写p->length。后面所有通过指针访问结构体成员的地方,都用箭头。
最后看数组:
c
int b[3] = {1, 2, 3};
int *pb = &b[0];
printf("%d %d %d\n", *pb, *(pb + 1), *(pb + 2)); /* 1 2 3 */数组的三个元素紧挨着。一个int占4个字节,所以它们的起始地址依次加4:
text
b[0] b[1] b[2]
┌─────┬─────┬─────┐
│ 1 │ 2 │ 3 │
└─────┴─────┴─────┘
100 104 108
▲ ▲
pb pb+1pb + 1不是把地址加1,而是往后挪一个元素,也就是加4个字节,指向b[1]。知道第一个元素的地址,就能一步算出任何一个元素的地址。顺序表的Get只要一次计算就能取到第i个元素,原因就在这里。
用传地址实现顺序表的操作
按传地址的思路改Init。参数不再是SeqList,而是指向SeqList的指针SeqList *L。调用时传&L,也就是L的地址。函数体里的L是一个地址,访问它指向的结构体的成员,用箭头L->length:
c
void Init(SeqList *L) {
L->length = 0;
}
int main(void) {
SeqList L;
L.length = 5;
Init(&L);
printf("%d\n", L.length); /* 这次打印 0 */
return 0;
}这次打印0,第一页的问题解决了。想确认改的是原件,可以在main里打印&L,在Init里打印L,它本身就是地址,两个数字相同。
对比两个版本的Init,只有两处变化:参数类型多了一个*,L.变成了L->。最复杂的Insert也一样,函数体里的逻辑一个字不动:
c
int Insert(SeqList *L, int i, char x) {
if (i < 0 || i > L->length) return 0;
if (L->length == MAXSIZE) return 0;
for (int j = L->length; j > i; j--)
L->data[j] = L->data[j - 1];
L->data[i] = x;
L->length++;
return 1;
}只读的操作Length、Get也一律传地址。一是不用复制整个结构体,二是五个函数写法统一。
全局变量SeqList L;删掉。表由使用者自己定义,比如在main里写SeqList L;,然后Init(&L)。
从现在起,本章都用下面这一套:
c
#define MAXSIZE 100
typedef struct {
char data[MAXSIZE];
int length;
} SeqList;
void Init(SeqList *L) {
L->length = 0;
}
int Length(SeqList *L) {
return L->length;
}
char Get(SeqList *L, int i) {
if (i < 0 || i >= L->length) return '\0';
return L->data[i];
}
int Insert(SeqList *L, int i, char x) {
if (i < 0 || i > L->length) return 0;
if (L->length == MAXSIZE) return 0;
for (int j = L->length; j > i; j--)
L->data[j] = L->data[j - 1];
L->data[i] = x;
L->length++;
return 1;
}
int Delete(SeqList *L, int i) {
if (i < 0 || i >= L->length) return 0;
for (int j = i; j < L->length - 1; j++)
L->data[j] = L->data[j + 1];
L->length--;
return 1;
}同时用两个表
把2.4最后那个程序改成传地址,输出应该不变。再加一个表L2放dog,两个表互不干扰。这是全局变量版本做不到的:
c
int main(void) {
SeqList L, L2;
Init(&L);
Insert(&L, 0, 'c');
Insert(&L, 1, 'a');
Insert(&L, 2, 't');
Insert(&L, 2, 'x');
Delete(&L, 2);
Init(&L2);
Insert(&L2, 0, 'd');
Insert(&L2, 1, 'o');
Insert(&L2, 2, 'g');
for (int i = 0; i < Length(&L); i++) printf("%c", Get(&L, i));
printf("\n"); /* cat */
for (int i = 0; i < Length(&L2); i++) printf("%c", Get(&L2, i));
printf("\n"); /* dog */
return 0;
}程序输出两行,cat和dog。五个函数现在可以操作任何一个表,参数和2.2的定义一一对应。
练习1:传值和传地址,a分别变成几?
填空
c
void Inc1(int x) { x = x + 1; }
void Inc2(int *p) { *p = *p + 1; }a原来是5,分别调用两个函数。把结果拖到对应的空里,或者先点结果、再点空。
Inc1(a);之后,a是Inc2(&a);之后,a是
Inc1是传值,改的是复制品x,a不变,还是5。Inc2是传地址,顺着地址改的是a本身,变成6。
练习2:传地址时复制了什么?
单选
调用Init(&L)时,复制给Init的是什么?
A
L的地址这一个数
B
整个结构体L
复制整个结构体是传值,那是第一页没生效的写法。
C
什么都没复制
C语言只有传值。传地址时,复制的是那个地址。
传地址其实也是传值,只不过传的值是一个地址。复制一个数,比复制一百多个格子省事得多。
练习3:通过指针取长度怎么写?
单选
函数的参数是SeqList *L,要取这个表的长度。
A
L->lengthB
L.lengthL是一个地址,不是结构体。点号只能用在结构体本身上。
C
*L.length点号比星号先算,这个写法等于*(L.length),意思不对。要写成(*L).length,简写就是L->length。
通过指针访问结构体的成员,用箭头。
到这里你有了传值和传地址的区别,指针的用法,以及五个操作的传地址版本:它们可以同时操作多个表。下一步用五个操作搭出编辑器1.0。