指针-02
1. 指针的指针
语法:
数据类型 **p;
示例:
#include <stdio.h>
int main(int argc, char const *argv[])
{
int num = 10;
int *p1 = &num;
int **p2 = &p1;
printf("*p1是: %dn", *p1); //*p1是: 10
printf("p1的值是: %pn", p1); //p1的值是: 0x7ffd1a6bff0
printf("p1的地址是: %pn", &p1); //p1的地址是: 0x7ffd1a6bff08
printf("p2的值是: %pn", p2); //p2的值是: 0x7ffd1a6bff08
printf("p2的地址是: %pn", &p2); //p2的地址是: 0x7ffd1a6bff10
return 0;
}
2. 指针与const
2.1 指针常量 – (int * const p)
概念:
语法:
数据类型 * const 指针名称
例:
void fun01()
{
int num = 10;
// int *p = &num;
// int num02 = 20;
// p = &num02;
// printf("p = %pn", p);
//指针常量
//p被const修饰,
int * const p = &num;
int num03 = 30;
// p = &num03; //指针指向的地址不可修改
*p = 40; //但是指针指向的地址的值可以修改
printf("*p = %dn", *p); //*p = 40
}
2.2 常量指针 – (const int *p)
概念:
例:
void fun02()
{
int num = 10;
//常量指针
//指针被const修饰,
// int const *p = &num;
const int *p = &num;
printf("p修改前的地址%pn", p); //p修改前的地址0x7fff0b95ff58
int num04 = 30;
p = &num04; //指针指向的地址可以修改
// *p = 40; //但是指针指向的地址的值不可以修改
printf("p修改后的地址%pn", p); //p修改后的地址0x7fff0b95ff5c
}
2.3 常量指针常量 – (const int * const p)
概念:
指向的
地址
和 只想地址中的值
都不可以修改
语法:
数据类型 const * const 指针名称
或
const 数据类型 * const 指针名称
例:
void fun03()
{
int num = 10;
//常量指针常量
//指针和指针变量p都被const修饰,
const int * const p = &num;
int num02 = 40;
// p = &num02; //指针指向的地址不可以被修改
// *p = 50; //指针指向的地址的值也不可以修改
}
3. 指针与数组元素
概述:
注意:
示例1:
void fun01()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
int *p = &nums[3];
printf("*p = %dn", *p); //*p = 7
printf("*(p+1) = %dn", *(p+1)); //*(p+1) = 9
printf("*(p+2) = %dn", *(p+2)); //*(p+2) = 2
printf("*(p-1) = %dn", *(p-1)); //*(p-1) = 5
printf("*(p-2) = %dn", *(p-2)); //*(p-2) = 3
for (int i = 0; i < 10; i++)
{
printf("%pn", &nums[i]);
}
}
/*
0x7ffc007c1610
0x7ffc007c1614
0x7ffc007c1618
0x7ffc007c161c
0x7ffc007c1620
0x7ffc007c1624
0x7ffc007c1628
0x7ffc007c162c
0x7ffc007c1630
0x7ffc007c1634
*/
示例2:
void fun02()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
int *p = &nums[0];
for (int i = 0; i < 10; i++)
{
printf("nums[%d] = %dn", i, *(p++));
}
}
/*
nums[0] = 1
nums[1] = 3
nums[2] = 5
nums[3] = 7
nums[4] = 9
nums[5] = 2
nums[6] = 4
nums[7] = 6
nums[8] = 8
nums[9] = 10
*/
示例3:
void fun03()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
int *p1 = &nums[0];
int *p2 = &nums[1];
if (p1 < p2)
{
printf("p1在p2的前面n");
}
else{
printf("p1在p2的后面n");
}
}
//p1在p2的前面
示例4:
void fun04()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
//数组名就是数组中存储的第一个元素的地址
printf("nums = %pn",nums); //nums = 0x7ffe6b558c30
printf("nums[0]= %pn",&nums[0]); //nums[0]= 0x7ffe6b558c30
}
示例5:
void fun05()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
int *p = nums;
for (int i = 0; i < 10; i++)
{
// printf("nums[%d] = %dn", i, *(p++));
// printf("nums[%d] = %dn", i, *(p+i));
// printf("nums[%d] = %dn", i, nums[i]);
// printf("nums[%d] = %dn", i, p[i]);
printf("nums[%d] = %dn", i, *(nums+i));
//c语言中数组的本质是一个 指针常量
//不可以修改指针的地址,但是可以修改该指针指向地址的值
// printf("nums[%d] = %dn", i, *(nums++)); //报错
}
}
4. 指针与数组
4.1 数组名
例:
void fun04()
{
int nums[] = {1,3,5,7,9,2,4,6,8,10};
//数组名就是数组中存储的第一个元素的地址
printf("nums = %pn",nums); //nums = 0x7ffe6b558c30
printf("nums[0]= %pn",&nums[0]); //nums[0]= 0x7ffe6b558c30
}
4.2 数组指针
数组名可以赋值给一个指针变量,此时该指针指向一个数组,被称为 数组指针,其本质是一个 指针
语法:
示例:
void fun06()
{
//数组指针
//概念:指向数组的指针,本质是一个指针
int nums[] = {1,3,5,7,9,2,4,6,8,10};
int *p1 = nums;
int nums02[2][4] = {1,2,3,4,5,6,7,8};
int (*p2)[4] = nums02;
int nums03[2][3][4] = {0};
int (*p3)[3][4] = nums03;
}
4.3 指针数组
指针变量是一个变量,数组是可以存储多个类型形容的变量的勇容器,故 数组可以存储多个指针变量,此时该数组
被称为 指针数组,其本质是一个 数组。
语法:
数据类型 * 数组名[长度];
例:
void fun07()
{
int a = 10,b = 20,c = 30;
int *p1 = &a;
int *p2 = &b;
int *p3 = &c;
//指针数组
//存储指针的数组,本质是一个数组
int *nums[3] = {p1, p2, p3};
}
4.4 字符数组与字符串指针的区别
字符数组:在内存(栈、静态全局区)
中开辟了一段空间存放字符串
,将其首元素地址赋值给 数组名,是个 指针常量
字符串指针:
void fun08()
{
//str01的内存地址在栈区
//str01是一个数组,所以是一个指针常量
//指针常量可以修改其地址中的值
//指针常量不可以修改其指向的地址
char str01[] = "hello";
str01[0] = 'H';
printf("str01=%sn",str01); //str01=Hello
//str01 = "world"; //报错,不能指向另外的地址
//str02的内存地址在文字常量区
//常量指针
//指针指向的地址可以修改
//指针指向的地址中的元素不可修改
char * str02 = "hello";
printf("str02修改前的地址%pn",str02); //str02修改前的地址0x400d28
str02 = "world";
printf("str02修改后的地址%pn",str02); //str02修改后的地址0x400d4
//str02[0] = 'W'; //段错误 (核心已转储)
}
示例2:
void fun09()
{
//字符数组
char str01[] = "hello";
//指向 栈、静态全局 区中存放的字符数组
char *str03 = str01;
printf("str03修改内容前%sn",str03); //tr03修改内容前hello
str03[0] = 'H';
printf("str03修改内容后%sn",str03); //str03修改内容后Hello
str03 = "world";
printf("str03修改地址后%sn",str03); //str03修改地址后world
}
示例3:
void fun10()
{
char names[][50] = {"boboy","tom","jerry","zhangsan","lisi"};
//指针数组:存储的是这些值的首地址
char *ns[50] = {"boboy","tom","jerry","zhangsan","lisi"};
//数组指针
// char (*nss)[50] = names;
char (*nss)[50] = {"boboy","tom","jerry","zhangsan","lisi"};
}
5. 函数与指针
5.1 函数名就是函数地址
函数名
本身就是函数在代码区
存储该函数的地址
,故 可以赋值给一个指针变量,但是因为其在代码区的地址不可修改,所以该指针是一个指针常量
语法:
示例1:函数名
本身就是函数在代码区存储 该函数的地址
#include <stdio.h>
void test01()
{
printf("test01被调用了!");
}
void fun01()
{
printf("%pn", test01); //0x400526
}
int main(int argc, char const *argv[])
{
fun01();
return 0;
}
示例2:调用其指向的函数
#include <stdio.h>
void test01()
{
printf("test01被调用了!n");
}
void fun02()
{
/*
函数指针的书写方式
返回值类型 (*指针变量名)(形参列表)
*/
//p1 == test01
//调用函数:test01(实参列表);
void (*p1)() = test01;
p1(); //test01被调用了!
}
int main(int argc, char const *argv[])
{
fun02();
return 0;
}
示例3:指向的函数的形参列表的数据类型可以忽略不写
void add(int a, int b)
{
printf("sum = %dn", a+b);
}
void fun03()
{
void (*p1)(int, int) = add;
p1(10, 20); //sum = 30
}
示例4:
int sub(int a, int b)
{
return a-b;
}
void fun04()
{
int (*p1)(int, int) = sub;
int num = p1(10,3);
printf("num = %dn", num); //num = 7
}
5.2 指针变量作为函数的参数 (传递指针变量的地址 )
指针变量是一个变量,故可以作为 函数的形参
,此时传递的是指针变量的地址
示例:
- 指针变量作为形参在函数中定
- 指针变量作为实参,在调用函数时传递
//指针变量作为形参在函数中定义
void setNum(int *num, int i)
{
num[i] = 10;
}
void fun05()
{
int ns[5] = {0};
// int *p = ns;
//指针变量作为实参,在调用函数时传递
//本次传递的是指针变量的地址
setNum(ns, 0);
printf("ns[0] = %dn", ns[0]); //ns[0] = 10
}
5.3 字符串指针作为实参
字符串指针作为实参,将指针指向常量区的内容传递函数。函数内部修改指针内容
时,不会影响函数外部的值
。
void setStr(char *str)
{
str = "world";
}
void fun06()
{
char *s = "hello";
setStr(s);
printf("s=%sn", s); //s=hello
}
示例2:
void setchar(char *str, int i)
{
str[0] = 'H';
}
void fun07()
{
//字符数组是指针常量,可改值不可该地址
char str[] = "hello";
char *p = str;
//setchar函数修改的是地址中的值,所以传入该指针会出现段错误
// char *p = "hello"; //常量指针,可改地址不可改值
setchar(p, 0);
printf("str=%sn", str); //str=Hello
}
5.4 字符串指针的指针作为函数参数
将字符指针的指针
作为函数的实参
,函数的形参使用 **q(指针的指针),函数 内部修改字符指针地址
,就可以 修改 函数外部的结果
示例:函数内部修改字符指针地址,就可以 修改 函数外部的结果
void setName(char **name)
{
*name = "李四";
}
void fun09()
{
char *n = "张三";
char **p = &n;
setName(p);
printf("n=%sn",n);
}
void setName(char **name)
{
printf("name---->%pn", name); //name---->0x7ffd94285208
*name = "李四";
printf("*name改变后---->%pn", *name); //*name改变后---->0x400a53
}
void fun09()
{
char *n = "张三";
printf("n---->%pn", n); //n---->0x400a71
printf("*n---->%pn", &n); //*n---->0x7ffd94285208
char **p = &n;
printf("p---->%pn", p); //p---->0x7ffd94285208
printf("*p---->%pn", *p); //*p---->0x400a71
setName(p);
printf("n修改后---->%pn", n); //n修改后---->0x400a53
printf("*p修改后---->%pn", *p); //*p修改后---->0x400a53
printf("n=%sn",n); //n=李四
}
图示:
5.5 指针作为返回值
函数中局部指针变量做为函数的返回值,函数执行完毕后,其局部指针变量指向的地址也将被释放,外部无法使用,导致段错误
示例:
int* my01()
{
/*
静态局部变量生命周期:
随着所在函数第一次调用而生成,随着所在进程的执行完毕而销毁
*/
static int num[5] = {1,2,3,4,5};
return num;
}
void fun11()
{
int *ns = my01();
printf("%dn",ns[0]); //1
}
原文地址:https://blog.csdn.net/zhb_feng/article/details/134757961
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。
如若转载,请注明出处:http://www.7code.cn/show_32318.html
如若内容造成侵权/违法违规/事实不符,请联系代码007邮箱:suwngjj01@126.com进行投诉反馈,一经查实,立即删除!