指针

21.1 没有指针的世界

以下不能处理的问题：

 

 

• 在呼叫的函式中修改引数
• 直接复制阵列
• 直接复制字串
• 动态改变阵列长度

在被呼叫的函式中修改引数值

• 函式呼叫时，引数值会复制一份到被呼叫的函式内做参数使用。在函式内部对参数做任何的变动不会改变到原本的引数值

指标型别

指标是一种资料型别，用来储存记忆体位址

 

• 一般情况我们是不需要指针的
• 增加这个型别可以处理的问题

21.2 指标变数宣告

• 指标是C语言的主要特征，是种【储存记忆体位址的资料型别】
• 指标变数宣告语法 

         资料型别    *变数名称

       表示变数内存放的是一个存放这种 【资料型】 值的 【记忆体位址】

取址运算子 

变数 依照资料型别会占据一定的记忆体空间。我们可以利用取址运算子（&）去取得变数开头的记忆体位址

 

int count = 9;

int a;
int *b;

a = count;  // (O) (int)   = (int)
b = count;  // (X) (int *) = (int)

a = &count;  // (X) (int)   = (int *)
b = &count;  // (O) (int *) = (int *)

要记得型别一致

 

 21.3 指标间接运算

间接运算子（*）

相对地，我们可以利用间接运算子（*）从记忆体位址取得开头位于该位址的变数（别跟宣告指标变数时用的*搞混）

 

int count = 9;

int a;
int *b;

a = count;  // (O) (int)   = (int)
b = count;  // (X) (int *) = (int)

a = &count;  // (X) (int)   = (int *)
b = &count;  // (O) (int *) = (int *)


count = *a;  // (X) 型别不一致
count = *b;  // (O) *b 表示记忆体位址的变数是多少，这里相当于复制一份count给count

指标的特殊功能

 

int countA = 9;
int countB = 10;
int *countAddr;

countAddr = &countA;

*countAddr = 0;


countAddr = &countB;
*countAddr = 0;

//相等于

int countA = 9;
int countB = 10;
countA = 0;
countB = 0;

 21.4 更多指标与取址间接运算的细节

指标型别与取址和间接运算

• 指标（type*）：可储存记忆体位址的型别
• 取址运算子（&）：可取得变数的记忆体起始位址   &变数
• 间接运算子（*）：取得以该记忆体位址起始的变数  *记忆体位址

 

 

//取址与间接运算的关系

int count = 9;
int *countAddr = &count;

int result = *&count;

//看到相邻的*&可以抵消

//所以

int result = count;

22 指标与函式呼叫

函式呼叫的特性

• 呼叫函式时，作为引数的变数会被复制一份到函式内成为参数。在被呼叫的函式内对参数做任何变动都不会改变到原本的变数

#include <stdio.h>

void addone(int n) {
    n = n + 1;
}

int main() {
    int a = 3;
    addone(a);
    printf("%d", a);
    return 0;
}


3
Process returned 0 (0x0)   execution time : 0.976 s
Press any key to continue.

函式呼叫时复制记忆体位址

在呼叫函式时，可以将变数的 记忆体位址 作为引数传入函数执行。 此时在函式内部对该参数透过 间接运算子 赋予新的数值时就可以改变原本的变数值。

#include <stdio.h>

void addone(int *n)
{
    *n = *n + 1;
}

int main()
{
    int a = 3;
    addone(&a);  /*复制 a 的记忆体位址给 addone*/
    printf("%d", a); /* 4 */
    return 0;
}


4
Process returned 0 (0x0)   execution time : 7.710 s
Press any key to continue.

22.1 两个变数数值交换（使用函式）

#include <stdio.h>

void swap(int *, int *);

int main()
{
    int a = 3,b =5;
    swap(&a, &b);
    printf("a: %d\n", a);
    printf("b: %d\n", b);
    return 0;
}

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}


a: 5
b: 3

Process returned 0 (0x0)   execution time : 14.025 s
Press any key to continue.

 22.2 两个整数的排序（使用函式）

#include <stdio.h>

void sort(int *, int *);
void swap(int *, int *);

int main()
{
    int a = 5, b = 3;
    sort(&a, &b);
    printf("a : %d\n", a);
    printf("b : %d\n", b);
    return 0;
}

void sort(int *a, int *b)
{
    if (*a > *b)
    {
        swap(&*a, &*b);//swap(a, b)
    }
}

void swap(int *a, int *b) {
    int t = *a;
    *a = *b;
    *b = t;
}


a : 3
b : 5

Process returned 0 (0x0)   execution time : 3.630 s
Press any key to continue.

22.3 该传变数值还是址

基本原则

 

1. 可以传值就传值

 

• 复制一份比较安全，不怕被偷改，确保函式间干净的关系。
• 用起来比较方便，可以传一般常数。

例外规则

• 作为引数的变数在呼叫后值会变动的时候（例如数值交换的范例）
• 无法直接复制值的时候（例如阵列和字串）
• 复制成本太高的时候（例如较复杂的结构）

 

23.1  指标对整数的加减运算

int v[5];

&v[0] + 1 == &v[1];
&v[1] + 1 == &v[2];
&v[1] - 1 == &v[0];

&v[0] + &v[1]    // 编译失败（X）
&v[2] - &v[1] == 1 //从 v[2] 位址到 V[1] 位址距离 1 个元素

 

 

23.2 指标与阵列

指标与阵列的不同

int v[5]; // 宣告定义一个有 5 个元素的 int 阵列， 占据 5 个 int 大小的记忆体

// 阵列型别可转型为指标

int v[5]; // 宣告定义一个有 5 个元素的 int 阵列， 占据 5 个 int 大小的记忆体
int *n;   // 宣告定义一个 int 指标， 占据 1 个 int * 大小的记忆体
n = &v[0];
          //阵列型别可隐性转型成该阵列第一个元素记忆体位址的指标
n = v;    // 相当于 n = &v[0]


// 透过指标运算存取阵列元素

int v[5];
int *n = v;
                         
n   == &v[0];          *n     == v[0];   // *n = 0   等值于 v[0] = 0         
n+1 == &v[1];          *(n+1) == v[1];   // *n(n+1) = 0 等值于 v[1] = 0     
n+2 == &v[2];          *(n+2) == v[2];   // *(n+2)  = 0 等值于 v[2] = 0

 

 23.3 循序存取阵列元素（使用指标）

 

#include <stdio.h>
int main()
{
    int v[5] = {1, 2, 3, 4, 5};
    int *n = v;  // int *n = &v[0];
    int i;
    for (i = 0; i < 5; i++) {
        printf("%d\n", *(n+i));
    }
    return 0;
}

#include <stdio.h>
int main()
{
    int v[5] = {1, 2, 3, 4, 5};
    int *n = v;              // n == &v[0]
    printf("%d\n", *n);
    n++;               // n == &v[1]
    printf("%d\n", *n);
    n++;               // n == &v[2]
    printf("%d\n", *n);
    n++;               // n == &v[3]
    printf("%d\n", *n);
    n++;               // n == &v[4]
    printf("%d\n", *n);
    return 0;


}

1
2
3
4
5

Process returned 0 (0x0)   execution time : 14.484 s
Press any key to continue.


#include <stdio.h>

int main()
{
    int v[5] = {1, 2, 3, 4, 5};
    int *n;
    for (n = v; n != &v[5]; n++) {
        printf("%d\n", *n);
    }
    return 0;
}


1
2
3
4
5

Process returned 0 (0x0)   execution time : 6.158 s
Press any key to continue.

#include <stdio.h>
int main()
{
    int v[5] = {1, 2, 3, 4, 5};
    int *n = v;
    while (n != v+5) {
        printf("%d\n", *n++);
    }
    return 0;
}


1
2
3
4
5

Process returned 0 (0x0)   execution time : 11.702 s
Press any key to continue.

 

23.4 指标与下标运算子（[ ]）

int v[5];
int *n = v;
n[0] == *n;          n[0] == *v;
n[1] == *(n+1);      n[1] == *(v+1);
n[2] == *(n+2);      n[2] == *(v+2);

 

23.5 在函式间传递阵列（使用指标）

#include <stdio.h>
int maxv(int *, int N);

int main()
{
    int a[3] = {3, 8, 7};
    printf("Max: %d\n", maxv(a, 3)); // 阵列当引数传
    int b[5] = {3, 9, 7, 1, 2};
    printf("Max: %d\n", maxv(b, 5));
    return 0;
}

int maxv(int *v, int N) {  // 起始位置
    int max = v[0], i;     // 参数是个指标
    for (i = 1; i < 3; i++) {
        if (v[i] > max) {
            max = v[i];
        }
    }
    return max;  // 在函式内部指标当作一个阵列在用
}

Max: 8
Max: 9

Process returned 0 (0x0)   execution time : 0.817 s
Press any key to continue.

23.6 指标与阵列的关系

指标存储某阵列元素位址时的特殊性

• 可以透过加减整数算出同阵列其他元素的记忆体位址

1. 加 N 等同于向后移动 N 个元素后的记忆体位址
2. 减 N 等同于往回移动 N 个元素后的记忆体位址

• a[b]运算等同于*（a+b），反之亦同

1. 在该阵列中从 a 开始往后移动 b 所在的阵列元素
2. 当指标储存某阵列第一个元素的记忆体位址后， 用起来就跟该阵列没什么两样了

阵列可以隐性转型成该阵列第一个元素的记忆体位址