十年开发的C++工程师给大家全面总结知识点指针

一、绪论

指针也就是内存地址,指针变量是用来存放内存地址的变量,不同类型的指针变量所占用的存储单元长度是相同的,而存放数据的变量因数据的类型不同,所占用的存储空间长度也不同。有了指针以后,不仅可以对数据本身,也可以对存储数据的变量地址进行操作。

指针相对于一个内存单元来说,指的是单元的地址,该单元的内容里面存放的是数据。在C语言中,允许用指针变量来存放指针,因此,一个指针变量的值就是某个内存单元的地址或称为某内存单元的指针。
十年开发的C++工程师给大家全面总结知识点指针_第1张图片

二、指针的定义与使用

变量的指针与指针变量:
在C语言中,允许用一个变量来存放指针,这种变量称为指针变量。指针变量的值就是某份数据的地址,这样的一份数据可以是数组、字符串、函数,也可以是另外的一个普通变量或指针变量。
变量的指针就是变量的存储地址,指针变量就是存储指针的变量。指针变量是存放一个变量地址的变量,不同于其他类型变量,它是专门用来存放内存地址的,也称为地址变量。定义指针变量的一般形式为:类型说明符 变量名 类型说明符表示指针变量所指向变量的数据类型; 表示这是一个指针变量;变量名表示定义的指针变量名,其值是一个地址,例如:char p1;表示p1是一个指针变量,它的值是某个字符变量的地址:

//定义指针变量与定义普通变量非常类似,不过要在变量名前面加星号*,格式为:
int fp;//表示这是一个指针变量,fp是一个指向int数据类型的指针
float a,b; //表示a和b都是指针变量,都指向一个为float数据类型的指针
指针变量的使用:
取地址运算符&:单目运算符&是用来取操作对象的地址。 例:&i 为取变量 i 的地址。对于常量表达式、寄存器变量不能取地址(因为它们存储在存储器中,没有地址)。 指针运算符 (间接寻址符):与&为逆运算,作用是通过操作对象的地址,获取存储的内容。例:x = &i x 为 i 的地址,x 则为通过 i 的地址,获取 i 的内容。

//赋值
int a = 100;//定义了一个a的整形变量
int *p_a = &a;//将一个int类型的指针p_a,p_a指向了a(也叫p_a指向了a的地址)
在定义指针变量 p_a 的同时对它进行初始化,并将变量 a 的地址赋予它,此时 p_a 就指向了 a。
值得注意的是,p_a 需要的一个地址,a 前面必须要加取地址符&,否则是不对的。 

和普通变量一样,指针变量也可以被多次写入,只要你想,随时都能够改变指针变量的值:

//定义普通变量
float a = 99.5, b = 10.6;
char c = '@', d = '#';
//定义指针变量
float *p1 = &a;//P1指向a的地址
char *p2 = &c;//p2指向c的地址
//修改指针变量的值
p1 = &b;//将p1改变指向为b
p2 = &d;//将p2改变指向为a 

是一个特殊符号,表明一个变量是指针变量,定义 p1、p2 时必须带 。而给 p1、p2 赋值时,因为已经知道了它是一个指针变量,就没必要多此一举再带上 ,后边可以像使用普通变量一样来使用指针变量。也就是说,定义指针变量时必须带 *,给指针变量赋值时不能带。

//注意
不允许把一个数赋予指针变量
int *p;
p = &a;
*p = 100;//这样是错误的

或者:
int b=200;
int *a;
a=b; //这样也错误,因为没有加上取地址符& 

指针变量存储了数据的地址,通过指针变量能够获得该地址上的数据:

#include 
int main(){
    int a = 66;//定义整形变量
    int *p = &a; //定义int的指针变量并指向a变量的地址
    printf("%d, %dn", a, *p);  //两种方式都可以输出a的值
    return 0;
}

//假设 a 的地址是 0X1000,p 指向 a 后,p 本身的值也会变为 0X1000,*p 表示获取地址 0X1000 上的数据,
也即变量 a 的值。所以从运行结果看,*p 和 a 是等价的。

CPU 读写数据必须要知道数据在内存中的地址,普通变量和指针变量都是地址的助记符,虽然通过 *p 和 a 获取到的数据一样,
但它们的运行过程稍有不同:a 只需要一次运算就能够取得数据,而 *p 要经过两次运算,多了一层“间接”。

//程序被编译和链接后,a、p 被替换成相应的地址。使用 *p 的话,要先通过地址 0XF0A0 取得变量 p 本身的值,
这个值是变量 a 的地址,然后再通过这个值取得变量 a 的数据

也就是说,使用指针是间接获取数据,使用变量名是直接获取数据,前者比后者的代价要高。 

可以用指针来改变被指向那个变量的值 如:

#include 
int main(void){
    int a = 1, b = 66, c = 2;//定义普通变量
    int *p = &a;  //定义指针变量并指向a的地址
    *p = b;  //通过指针变量将a的值改变了 (因为在这里,*p指向了a 就等于*p和a身处同一个内存空间了,
                                                                所以对*p修改 就相当于对a修改)
    c = *p;  //把指针p的值的赋值给了C (根据前面说的,相当于将a赋值给了C)
    printf("%d, %d, %d, %dn", a, b, c, *p);//所以他们的值都是同一个了
    return 0;
}
*在不同的场景下有不同的作用:*可以用在指针变量的定义中,
表明这是一个指针变量,以和普通变量区分开;使用指针变量时在前面加*表示获取指针指向的数据,或者说表示的是指针指向的数据本身。 

也就是说,定义指针变量时的_和使用指针变量时的_意义完全不同。

以下面的语句为例:

int *p = &a;//这里表示指向a的地址
*p = 100;  //这里表示获取指针所指向的数据 

其他一些骚操作:

int x, y, *px = &x, *py = &y;
y = *px + 5;  //表示把x的内容加5并赋给y,*px+5相当于(*px)+5
y = ++*px;  //px的内容加上1之后赋给y,++*px相当于++(*px)
y = *px++;  //相当于y=(*px)++
py = px;  //把一个指针的值赋给另一个指针 

关于“&”和“*”

“&”和“ ”都是右结合的。假设有变量 x = 10,则&x 的含义是,先获取变量 x 的地址,再获取地址中的内容。因为“&”和“ * ”互为逆运算,所以 x = _&x。
假设有一个 int 类型的变量 a, pa 是指向a的指针,那么_&a和&_pa分别是什么意思呢?
_&a可以理解为_(&a),&a表示取变量 a 的地址(等价于 pa),_(&a)表示取这个地址上的数据(等价 pa),绕来绕去,又回到了原点,&a仍然等价于 a。
&pa可以理解为&(pa),pa表示取得 pa 指向的数据(等价于 a),&(pa)表示数据的地址(等价于 &a),所以&*pa等价于 pa。
十年开发的C++工程师给大家全面总结知识点指针_第2张图片
看这里点击这里直接进群

三、野指针与空指针

空指针是说,这个指针没有指向一块有意义的内存,比如说:char k; 这里这个k就叫空指针.我们并未让它指向任意点. 又或者char k = NULL; 这里这个k也叫空指针,因为它指向NULL 也就是0,注意是整数0,不是’0’ 一个空指针我们也无法对它进行取内容操作,空指针只有在真正指向了一块有意义的内存后,我们才能对它取内容.也就是说要这样 k = “hello world!”; 这时k就不是空指针了.
对于空指针值,一般的文档中倾向于用 NULL 表示,而没有直接说成 0。但是我们应该清楚:对于指针类型来说,返回 NULL 和 返回 0 是完全等价的,因为 NULL 和 0 都表示 “null pointer”(空指针)。一句话, 空指针是什么,就是一个被赋值为0的指针,在没有被具体初始化之前,其值为0.(百度解释)
如 :

int *a;//定义一个指针a=NULL;//让这个指针指向空a =0;//这样也是让一个指针指向空的方式​ 

注意:void 这不叫空指针,这叫无确切类型指针.这个指针指向一块内存,却没有告诉程序该用何种方式来解释这片内存.所以这种类型的指针不能直接进行取内容的操作.必须先转成别的类型的指针才可以把内容解释出来. 还有’0’,这也不是空指针所指的内容. '0’是表示一个字符串的结尾而已,并不是NULL的意思 void因为是表示不知道要指向什么东西的指针,计算时于char相同(但不相通)

野指针不同于空指针,空指针是指一个指针的值为null,而野指针的值并不为null,野指针会指向一段实际的内存,只是它指向哪里我们并不知情,或者是它所指向的内存空间已经被释放,所以在实际使用的过程中,我们并不能通过指针判空去识别一个指针是否为野指针。避免野指针只能靠我们自己养成良好的编程习惯。
野指针就是指针指向的位置是不可知的(随机的、不正确的、没有明确限制的)指针变量在定义时如果未初始化,其值是随机的,指针变量的值是别的变量的地址,意味着指针指向了一个地址是不确定的变量,此时去解引用就是去访问了一个不确定的地址,所以结果是不可知的。(百度解释)下面说说哪些情况下会产生野指针,以及怎样避免。

1、指针变量的值未被初始化: 声明一个指针的时候,没有显示的对其进行初始化,那么该指针所指向的地址空间是乱指一气的。如果指针声明在全局数据区,那么未初始化的指针缺省为空,如果指针声明在栈区,那么该指针会随意指向一个地址空间。所以良好的编程习惯就是在声明指针的时候就对其进行初始化,如果暂时不知道该初始化成什么值,就先把指针置空。

int main(void){
int *a;//野指针

if(a!=NULL){
....
}

/*
int *a; 
a=NULL/0;  正确的引用
*/
} 

2、指针所指向的地址空间已经被free或delete:在堆上malloc或者new出来的地址空间,如果已经free或delete,那么此时堆上的内存已经被释放,但是指向该内存的指针如果没有人为的修改过,那么指针还会继续指向这段堆上已经被释放的内存,这时还通过该指针去访问堆上的内存,就会造成不可预知的结果,给程序带来隐患,所以良好的编程习惯是:内存被free或delete后,指向该内存的指针马上置空。

void func()
{
    int *ptr = new int[5];
    delete [ ]ptr;
    // 执行完delete后,ptr野指针

    //还应该这样做:ptr=NULL; 正确

} 

3、指针操作超越了作用域,如果在一个程序块中让一个指针指向那个块中的某个变量,但是那个变量只是在块中有效,出了那个程序块,此变量就无效了,此时指向它的指针也就变成了野指针。

void func()
{
    int *ptr = nullptr;
    {
        int a = 10;
        ptr = &a;
    } // a的作用域到此结束

    int b = *ptr;    // ptr指向的a,但是a已经被回收,所以ptr变成野指针
    //还应该这样做:ptr=NULL; 正确
} 

所以 使用指针时应当注意”规避“:初始化时置 NULL,释放时置 NULL。

四、指针的运算

C 指针是一个用数值表示的地址。因此,您可以对指针执行算术运算。可以对指针进行四种算术运算:++、–、+、-。递增递减加减,两个指针相减。

#include
int main(void) {
    int a=10; 
    int *pa = &a,*pA=&a;

    double b = 22.2;
    double *pb = &b;

    char c = 'C';
    char *pc = &c;

    //最初的值
    printf("1- %#x %#x %#x n", &a, &b, &c);//%#x表示 转换成十六进制带格式输出地址,
                                                 //效果为在输出前加0x
    printf("2- %#x %#x %#x n", pa, pb, pc);

    //指针加法
    pa += 2; pb += 2; pc += 2;
    printf("3- %#x %#x %#x n", pa, pb, pc);

    //指针减法
    pa -= 2; pb -= 2; pc -= 2;
    printf("4- %#x %#x %#xn", pa, pb, pc);

    //指针的比较
    if (pa == pA) {
        printf("5=%dn", *pA);

    }
    else {
        printf("6=%dn", *pa);
    }

    return 0;

}

//从运算结果可以看出:pa、pb、pc 每次加 1,它们的地址分别增加 4、8、1,正好是 int、double、char 类型的长度;
                            减 2 时,地址分别减少 8、16、2,正好是 int、double、char 类型长度的 2 倍。

/*简单的概括就是:
指针的每一次递增,它其实会指向下一个元素的存储单元。
指针的每一次递减,它都会指向前一个元素的存储单元。
指针在递增和递减时跳跃的字节数取决于指针所指向变量数据类型长度,比如 int 就是 4 个字节。


指针变量除了可以参与加减运算,还可以参与比较运算。当对指针变量进行比较运算时,比较的是指针变量本身的值,也就是数据的地址。
如果地址相等,那么两个指针就指向同一份数据,否则就指向不同的数据。当然还有其他逻辑运算符

上面的代码(第一个例子)在比较 pa 和 pA 的值时,pa 已经指向了 a 的上一份数据,所以它们不相等。而 a 的上一份数据又不知道是什么,
所以会导致 printf() 输出一个没有意义的数,这正好印证了上面的观点,不要对指向普通变量的指针进行加减运算

注意:不能对指针变量进行乘法、除法、取余等其他运算,除了会发生语法错误,也没有实际的含义。 
#include//指针的加减法其实上的地址上的移动
int main(void) {
    char a[] = {2,3,4,5,6};
    char *p = &a[0];
    char *p1 = &a[10];

    printf("p1-p=%dn", p1 - p);
    printf("p=%pn", p);
    printf("p1=%pn", p1);

    //这里如果运算为大于零,就是真 输出 0
    //如果运算为小于零,就是假 输出   -1
    int *t = a[0];
    int *k = a[3];
    printf("* %dn", t-k);

    int b[] = { 1,2,3,4,5,6 };
    int *q = &b[0];
    int *q1 = &b[6];
    printf("q1-q=%dn", q1 - q);
    printf("%pn", q1);
    printf("%pn", q);

    return 0;
} 

常见的指针运算:
*(++p): 先移动指针,取下一个单元的值
*(p++): 先取出当前单元的值,再移动指针
( * p)++ : 先取出当前单元的值,再使当前单元的值加1 (指针不移动)
++( * p) : 先使当前单元的值加1,再取出当前单元的值 (指针不移动)

指针的类型转换:
int p=&i; void q=(void )p; 这并没有改变p所指向的变量的类型,而是让后人用不同的眼光通过p看它所指的变量 意思是:这里的p我不再当你是int了,认为你就是个void类型的。注意由于优先级的问题 p++和 * (p++)是等价的取地址符 &补充: 获得变量的地址,它的操作必须是变量, int i,printf("%x",&i); 取得i的地址并输出。 int i,printf("%p",&i); 取得i的地址并输出。 地址的大小是否于int相同取决于编译器。注意 使用指针的时候的类型,无论指向什么类型,所有的指针的大小都是一样的,因为都是地址,但是指向不同类型的指针是不能相互赋值的,这是为了避免用错指针。

五、字符串与指针、数组与指针

定义数组时,要给出数组名和数组长度,数组名可以认为是一个指针,它指向数组的第 0 个元素。在C语言中,我们将第 0 个元素的地址称为数组的首地址,数组名的本意是表示整个数组,也就是表示多份数据的集合,但在使用过程中经常会转换为指向数组第 0 个元素的指针,所以上面使用了“认为”一词,表示数组名和数组首地址并不总是等价。

#include
int main(void) {

    int a[] = {1,2,3,4,5,6};
    int line = sizeof(a) / sizeof(a[0]);//计算数组长度
    int i;

    for (i = 0; i < line; i++) {

        printf("%d  ", *(a + i));  //这里的*(a + i)相当于a[i]
    }
    return 0;
}

我们使用的*(a+i)这个表达式,a 是数组名,指向数组的第 0 个元素,表示数组首地址,
 a+i 指向数组的第 i 个元素,*(a+i) 表示取第 i 个元素的数据,它等价于 a[i]。 

我们也可以定义一个指向数组的指针,例如:

int a[]={1,2,3,4,5,6};
int *p=a;

a 本身就是一个指针,可以直接赋值给指针变量 p。a 是数组第 0 个元素的地址,所以int *p = a;
也可以写作int *p = &a[0];。也就是说,a、p、&a[0] 这三种写法都是等价的,
它们都指向数组第 0 个元素,或者说指向数组的开头。

注意  :a 本身就是一个指针”这种表述并不准确,严格来说应该是“a 被转换成了一个指针,
            如果一个指针指向了数组,我们就称它为数组指针(Array Pointer) 

数组指针指向的是数组中的一个具体元素,而不是整个数组,所以数组指针的类型和数组元素的类型有关,上面的例子中,p 指向的数组元素是 int 类型,所以 p 的类型必须也是int *。 反过来想,p 并不知道它指向的是一个数组,p 只知道它指向的是一个整数,究竟如何使用 p 取决于程序员的编码。
数组在内存中只是数组元素的简单排列,没有开始和结束标志,在求数组的长度时不能使用指针p来sizeof§ / sizeof(int)这样来求,因为 p 只是一个指向 int 类型的指针,编译器并不知道它指向的到底是一个整数还是一系列整数(数组),所以 sizeof§ 求得的是 p 这个指针变量本身所占用的字节数,而不是整个数组占用的字节数。如果不知道数组的长度,那么就无法遍历整个数组
引入数组指针后,我们就有两种方案来访问数组元素了,一种是使用下标,另外一种是使用指针: 1) 使用下标 也就是采用 arr[i] 的形式访问数组元素。如果 p 是指向数组 arr 的指针,那么也可以使用 p[i] 来访问数组元素,它等价于 arr[i]。
使用指针 也就是使用 (p+i) 的形式访问数组元素。另外数组名本身也是指针,也可以使用 (arr+i) 来访问数组元素,它等价于 *(p+i)。
不管是数组名还是数组指针,都可以使用上面的两种方式来访问数组元素。不同的是,数组名是常量,它的值不能改变,而数组指针是变量(除非特别指明它是常量),它的值和它的所指向可以任意改变。也就是说,数组名只能指向数组的开头,而数组指针可以先指向数组开头,再指向其他元素。

//利用自增来遍历数组
#include
int main(void) {

    int a[] = { 1,2,3,4,5,6 };
    int line = sizeof(a) / sizeof(a[0]);
    int i;
    int *p = a;//指针p指向数组首地址

    for (i = 0; i < line; i++) {

        printf("地址a[%d]:%pn ",i,p);
        printf("值a[%d]:%d n", i, *p);

            //指针自增移动
            p++;
    }

    return 0;
} 


/*自减也是同样的效果
  递增递减需要注意的:
 *p++;表示取出p所指向的那个数据来,完事后顺便把p移动到下一个地址位置去 , * 的优先级虽然高,但是没
有++高,这个是常用于数组之类的连续空间中,

    注意:

    //int b[ ] = a;   不可以做
    //int *p = a;    可以做
    //    b = a;       不可以做
    //int b[ ] = -- > int * const b;  因为const表示b常量的数不能改变 

另外 : const int a[ ]={1,2,3,4,5,6}; 数组变量已经是const的指针了,这里的const表示数组的每个单元都是const int 所以必须通过初始化进行赋值。 数组变量是特殊的指针,数组变量本身表达地址,所以 int a[10];int *p=a //不用取地址值, ​但是数组的单元表达的是变量,需要用&取地址, int b==&a[0]; [ ]运算符可以对数组做,也可以对指针做:p[0]=a[0];
C语言中没有特定的字符串类型,我们通常是将字符串放在一个字符数组中,所以字符数组归根结底还是一个数组,上节讲到的关于指针和数组的规则同样也适用于字符数组。更改上面的代码,使用指针的方式来输出字符串:

#include
#include

int main(void) {
    char s[] = "hello world";
    char *p = s;
    int len = strlen(s);//获得字符串长度函数
    int i;
    //使用指针遍历字符串输出
    for (i = 0; i < len; i++) {
        printf("%c", *(p + i));
    }
    printf("n");

    //使用数组的方式遍历输出
    for (i = 0; i < len; i++) {
        printf("%c", p[i]);
    }
    printf("n");

    //使用指针的形式输出
    for (i = 0; i < len; i++) {
        printf("%c", *(s + i));
    }

    printf("n");
    return 0;

} 

除了字符数组,C语言还支持另外一种表示字符串的方法,就是直接使用一个指针指向字符串,例如:

char *str;
str = "hello world";
/*字符串指针指向的是一个字符串,str是一个char类型的指针变量,
指向字符串"hello world",指针变量str存放的是这个字符串的首地址。
所以输出的是一个字符串,应改写成printf(“%sn”,str); 

字符串中的所有字符在内存中是连续排列的,str 指向的是字符串(字符数组)的第 0 个字符;我们通常将第 0 个字符的地址称为字符串的首地址。字符串中每个字符的类型都是char,所以 str 的类型也必须是char _。
这一切看起来和字符数组是多么地相似,它们都可以使用%s输出整个字符串,都可以使用_或[ ]获取单个字符,这两种方式的区别如下:
它们最根本的区别是在内存中的存储区域不一样,字符数组存储在全局数据区或栈区,第二种形式的字符串存储在常量区。全局数据区和栈区的字符串(也包括其他数据)有读取和写入的权限,而常量区的字符串(也包括其他数据)只有读取权限,没有写入权限。 内存权限的不同导致的一个明显结果就是,字符数组在定义后可以读取和修改每个字符,而对于第二种形式的字符串,一旦被定义后就只能读取不能修改,任何对它的赋值都是错误的。
我们将第二种形式的字符串称为字符串常量,意思很明显,常量只能读取不能写入:

char *str = "Hello World!";//这里是字符常量是指针
    str = "I love C!";  //正确  让常量字符串指针重新指向一个字符串
    str[3] = 'P';  //错误   这个是想通过一个字符常量指针让一个字符数组赋值 

六、指针做函数参数,指针做函数返回类型

有时候我们可以使用函数的返回值来回传数据,在简单的情况下是可以的,但是如果返回值有其它用途(例如返回函数的执行状态量),或者要回传的数据不止一个,返回值就解决不了了。所以要引用上指针来传递
指针做函数参数:
在C语言中,函数的参数不仅可以是整数、小数、字符等具体的数据,还可以是指向它们的指针。用指针变量作函数参数可以将函数外部的地址传递到函数内部,使得在函数内部可以访问到函数外部的数据,并且这些数据不会随着函数的结束而被销毁。 像数组、字符串、动态分配的内存等都是一系列数据的集合,没有办法通过一个参数全部传入函数内部,只能传递它们的指针,在函数内部通过指针来影响这些数据集合。 有的时候,对于整数、小数、字符等基本类型数据的操作也必须要借助指针,一个典型的例子就是交换两个变量的值:

#include 
void swap(int a, int b){
    int temp;  //临时变量
    temp = a;
    a = b;
    b = temp;
}
int main(){
    int a = 66, b = 99;
    swap(a, b);
    printf("a = %d, b = %dn", a, b);
    return 0;
}

/*
    从结果可以看出,a、b 的值并没有发生改变,交换失败。
这是因为 swap() 函数内部的 a、b 和 main() 函数内部的 a、b 是不同的变量,
占用不同的内存,它们除了名字一样,没有其他任何关系,swap() 交换的是它内部 a、b 的值,
不会影响它外部(main() 内部) a、b 的值。他们会随着函数段的结束而失去了作用域 

利用指针:

#include 
void swap(int *p1, int *p2){//这里接收到的是a和b的地址
    int temp;  
    temp = *p1;//利用地址将值做修改
    *p1 = *p2;
    *p2 = temp;
}
int main(){
    int a = 66, b = 99;
    swap(&a, &b);//这里将a和b的地址获取传入
    printf("a = %d, b = %dn", a, b);
    return 0;
}

//函数运行结束后虽然会将 p1、p2 销毁,但它对外部 a、b 造成的影响是“持久化”的,
不会随着函数的结束而“恢复原样”。因为我们对它做的是进入到地址的修改 

用数组做函数参数:
如果一个函数按值传递数组,则必须分配足够的空间来存储原数组的副本,然后把原数组的所有数组拷贝到新的数组中去,如果把数组的地址传递给函数,让函数来直接处理原来数组则效率要高。 但是 传递地址的时候,总会导致一些问题,C通常安值传递数据,因为这样做可以保证数据的完整性,如果函数使用的是原始的数组的副本,就不会发生修改原始数据,但是,处理数组的函数通常都需要使用原始数据,因此这样的函数可以修改原数组,有时,这正是我们需要的:void add(double a[ ],int n,int b); 调用此函数,将可以将原来数组的值进行修改,也可以说是函数通过指针,直接将原数组做修改了
数组是一系列数据的集合,无法通过参数将它们一次性传递到函数内部,如果希望在函数内部操作数组,必须传递数组指针。下面的例子定义了一个函数 max(),用来查找数组中值最大的元素:

#include
int max(int len, int a[]);//声明  注意这里的a[ ] 里边没有任何东西,其实也可以放东西也可以不放的

/*实际上这种形式的数组定义都是假象,不管是int a[100]还是int a[]都不会创建一个数组出来,编译器也不会为它们分配内存,实际的数组是不存在的,它们最终还是会转换为int *intArr这样的指针。这就意味着,两种形式都不能将数组的所有元素“一股脑”传递进来,大家还得规规矩矩使用数组指针。*/
//真正传递的数组可以有少于或多于 100 个的元素。
int main(void) {

    int n;
    int a[100];
    int i;

    scanf("%d", &n);
    for (i = 0; i < n; i++) {
        scanf("%d", a+i);//给数组里边的值初始化
    }                //这个a的原型是 int *a 
                    //所以这里可以使用 &a[i] 或者 a+i
    printf("max=%d", max(n,&a));
    return 0;
}

int max(int len, int a[]) {//定义
    int t = a[0];
    int i;

    for (i = 1; i < len; i++) {//依次比较
        if (t < a[i]) {
            t = a[i];
        }

    }

    return t;//返回max
}

注意 不管使用哪种方式传递数组,都不能在函数内部求得数组长度,因为 intArr 仅仅是一个指针,
     而不是真正的数组,所以必须要额外增加一个参数来传递数组长度。

//有时候,因为把数组传入函数时传递的是地址,所以那个函数内部可以修改数组的值,
  为了保护数组的值不被函数修改破坏,可以设置参数为const:
int sum (const int a[ ],int b); 

C语言为什么不允许直接传递数组的所有元素,而必须传递数组指针呢? 参数的传递本质上是一次赋值的过程,赋值就是对内存进行拷贝。所谓内存拷贝,是指将一块内存上的数据复制到另一块内存上。
对于像 int 等基本类型的数据,它们占用的内存往往只有几个字节,对它们进行内存拷贝非常快速。而数组是一系列数据的集合,数据的数量没有限制,可能很少,也可能成千上万,对它们进行内存拷贝有可能是一个漫长的过程,会严重拖慢程序的效率,为了防止技艺不佳的程序员写出低效的代码,C语言没有从语法上支持数据集合的直接赋值。

指针的函数返回类型: 程序编译后,每个函数都有执行第一条指令的地址即首地址,称[函数指针。函数指针即指向函数的指针变量,要间接调用函数可以使用指针变量来实现。
int (_pf)(int, int);
通过将pf与括号中的“_”强制组合组合在一起,表示定义的pf是一个指针,然后与下面的“()”再次组合,表示的是该指针指向一个函数,括号里表示为int类型的参数,最后与前面的int组合,此处int表示该函数的返回值。因此,pf是指向函数的指针,该函数的返回值为int。函数指针与返回指针的函数的含义大不相同。函数指针本身是一个指向函数的指针。指针函数本身是一个返回值为指针的函数。

#include
#include

char *strs(char *strl1, char *strl2);//声明一个char*类型的指针函数
int main(void) {

    char str1[50];//定义字符串
    char str2[50];
    char *str;//定义字符指针

    gets(str1);//输入
    gets(str2);

    str = strs(str1, str2);
    printf("%s", str);

    return 0;

}
char *strs(char *strl1, char *strl2) {

    if (strlen(strl1) > strlen(strl2)) {//比较长度   谁长返回谁
        return strl1;
    }
    else {
        return strl2;
    }
} 

用指针作为函数返回值时需要注意的一点是,函数运行结束后会销毁在它内部定义的所有局部数据,包括局部变量、局部数组和形式参数,函数返回的指针请尽量不要指向这些数据,C语言没有任何机制来保证这些数据会一直有效,它们在后续使用过程中可能会引发运行时错误 , 但是,这里所谓的销毁并不是将局部数据所占用的内存全部抹掉,而是程序放弃对它的使用权限,弃之不理,后面的代码可以随意使用这块内存 , 如果使用及时也能够得到正确的数据,如果有其它函数被调用就会覆盖这块内存,得到的数据就失去了意义。而覆盖它的究竟是一份什么样的数据我们无从推断(一般是一个没有意义甚至有些怪异的值)。

#include 
int *func(){
    int n = 100;
    return &n;
}
int main(){
    int *p = func(), n;
    n = *p;
    printf("value = %dn", n);//因为前面没有覆盖,所以还是能得到之前的值
    return 0;
}

            ******与下面比较:******

#include 
int *func(){
    int n = 100;
    return &n;
}
int main(){
    int *p = func(), n;
    printf("c.biancheng.netn");//这里会覆盖掉
    n = *p;
    printf("value = %dn", n);//所以输出的值会无从得知
    return 0;
} 

还应该注意函数指针变量的调用:
分析函数指针变量不能进行算术运算,这是与数组指针变量不同的。数组指针变量加减一个整数可使指针移动指向后面或数组元素,而函数指针的移动是毫无意义的。函数调用中“( 指针变量名)”的两边的括号不可少,其中的“”不应该理解为求值运算,在此处只是一种表示符号。要把“z= pomax(x,y);”改成“z=(pomax)(x,y);”。
十年开发的C++工程师给大家全面总结知识点指针_第3张图片

你可能感兴趣的