第八章、指针（中）

已于 2022-10-29 20:14:41 修改
阅读量58 收藏 1
点赞数
分类专栏： c语言入门到精通 文章标签： 1024程序员节 c语言
于 2022-10-25 19:00:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45728746/article/details/127498438
版权

文章目录

8.3 数组的指针和指向数组的指针变量

8.3.1 指向数组元素的指针变量的定义和赋值

eg:

int a[5];  // 在内存中是连续存储的，能引用的是 a[0] - a[4]
//数组指针：是指数组的开始地址，数组元素的指针就是数组元素的地址。
a[3] = 5;  //下标法引用数组元素，也可以用指针引用数组元素。

数组名就是数组起始地址，也就是a[0]的地址 → a == &a[0]

int a[5]; //只要是数组，那么数组元素的内存一定是挨着的；
a[0] = 5; a[1] = 6; a[2]= 8; a[3] = 9;

a == &a[0]

int main() {
int a[5];
int *p;  //指针变量，整形指针变量，和数组a类型相同
p = &a[0];  // 把a的首地址赋值给指针变量p。即p指向数组a。
p = a;

}

定义指针时也可以给指针变量赋予初值：

int *p = &a[0];  //定义且赋初值才能这样做

int *p;
p = &a[0];

int *p = a;

8.3.2 通过指针引用数组元素

int a[5];
a[0] = 1; a[1]=2,a[2]=3,a[3]=4,a[4]=5;
int *p = &a[0];
int *p = a;
int *p;
p = &a[0];

例如：

a)

*p = 19;  //对当前p所指向的数组元素赋值为19.  =>  a[0] = 19;

b)

p = p + 1; // 是将这个指针变量所指向的地址按照类型再加1，

c)

i 指向下标 0-4
p+i; 或者 i + p;

假如p指向数组首地址，a是数组名。那么p + i 或 i +p就是数组元素a[i]的地址，
也就是说他们指向了数组a的第i个元素。

也就是说 p + 3 ，和 a + 3的值就是 &a[3] ， 也就是都指向 a[3] 。

如果是整形 ——> &a + i*4 就是 p+3或a + 3的地址。

p = a;

结论：

p + i 或者 i + p 都是地址，既然是地址，就可以赋给指针变量。

int a[5]; int *p;
a[0] = 1; a[1]=2,a[2]=3,a[3]=4,a[4]=5;
p = a;
*p = 19;    // *p = 19    --> &a[0] = 19; 
p = a+3;    // a+3        --> a + i * 4(int型*4);  --> &a[3]
*p = 13;    // *p = 13;   --> 和 a[3] = 13;

d)
*(p + i ) 或者 * (a + i)

通过c知道d，这两个是 p + i 或 a + i所指向的数组元素，也就是 a[i]

*(p+2) = 14; <--> a[2] = 14;
*(a+4) = 20; <--> a[4] = 20;
*(p+3) = 10; <--> a[3] = 10;

e)
i 为数组元素下标。

p[i]

p[i] 与 *(p + i) 等价， 也就是跟 a[i]等价

当a[5]中的元素出现在等号左边的时候就是变量，在右边的时候代表其元素值。

p[3] = 155;  <==>  a[3] = 155

说明：

引用数组元素的方式很多。 例如：

  • a[i]

  • p[i]

  • *(p + i)

  • *(a+i)

int a[5];  //能够引用的下标是 0-4
int *p;
int i;
a[0] = 1; a[1]=2,a[2]=3,a[3]=4,a[4]=5;
printf("1.------------\n");
//带入了一个i，还要算地址。速度自然慢
for(i=0;i<5;i++){
	printf("%d\n",a[i]);
}
printf("2.-----------\n");
for(i=0;i<5;i++) {

	printf("%d\n",*(a+i));
}

printf("3.------------\n");
//效率最高的,它是直接操作内存的。
for(p=a;p<(a+5);p++){  // p 得到的是a的地址, a有4个地址，所以可以进行循环。
										//然后得到了4次指针变量。
    printf("%d\n",*p);  //  用*p来得到其变量值。
}


注意事项：

1. 数组首地址（数组名）++是不行的，指针变量++可以，
2. 第三个for循环是直接操作内存的且速度最快，p++循环指向到&a[5]这个地址了，指向是可以的，但是却不代表你能够使用。你不能用它。非法使用。

f)

**P++ —>优先级相同，都是从右到左的结合。所以是 (P++)

作用：

p++是先用后加，所以(p++)整个作用是： 得到p指向的变量的值（P），然后再使p指针自加1，指向下一个数组元素。

int a[5];
int *p;
a[0] = 0,a[1]=1,a[2] = 2,a[3]= 3,a[4] = 4;
p = a;
// printf("%d",*p++);   //先用后加，*p++  <==> a[0] = 0  打印完之后*P++ 指向a[1]

g)

++P 相当于(++p) . 先加后用。

int a[5];
int *p;
a[0] = 0,a[1]=1,a[2] = 2,a[3]= 3,a[4] = 4;
p = a;
printf("%d\n",*++p);  **//先加后用，*++p <==>  a[1] = 1; 打印完之后*++P指向了a[1],**

先加后用，++p <==> a[1] = 1; 打印完之后++P指向了a[1],

h)

(*p)++ ; 与 (*p)++; 表示p所指向的元素加1，如果p指向数组首地址，就等价于a[0]++ .

实际上就是数组元素值+1，不是指针+1；

(*p)++ ;  //相当于a[0]++ ; -> a[0] =0
p++ ;  // a[1]++;   ->  a[1] = 2;
*p++; //相当于a[1]++ ;  a[1] = 2;

8.3.3 数组名作为函数参数

数组名代表数组首地址。

如果一个实参的数组，想在函数中改变此数组的元素的值，实参和形参的对应关系可以有4种。

(1)

void changevalue(int ba[]){
	ba[3] = 25;
	ba[4] = 42;
	return;
}
int main(){
int a[5]; //引用的下标为0-4;
a[0]=0;a[1]=1;a[2]=2;a[3]=3;a[4]=4;
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]);
changevalue(a);
printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]); // //使用自定义函数之后

总结： a和ba共用这一段内存，且指向同一个数组。

a是实参数组首地址，ba是形参数组首地址，a和ba共用一段内存。也就是说，在调用changevalue期间，a和ba指的是同一个数组。

（2）
实参用数组名，形参用指针变量。

void changevalue(int *p){

	*(p+2) = 888; //等价于给a[2]赋值。
//这里要注意：一定要知道数组a的数组元素范围。在此处只能引用到 *(p+4)
}
int main(){
	int a[5];
	a[0]=0;a[1]=1;a[2]=2;a[3]=3;a[4]=4;
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]);  //未使用自定义函数之前
	changevalue(a);
printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]); //使用自定义函数之后
}

(3)
实参和形参都用指针变量，这个和（2）很相似

void changevalue(int *p){

	*(p+2) = 888; //等价于给a[2]赋值。
//这里要注意：一定要知道数组a的数组元素范围。在此处只能引用到 *(p+4)
}
int main(){
	int a[5];
	a[0]=0;a[1]=1;a[2]=2;a[3]=3;a[4]=4;
	int *pa = a; //把数组a的首地址给pa，传递pa过去
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]);
	changevalue(pa);  //实参是指针变量，则该指针变量必须有确定的值；
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]); // //使用自定义函数之后
}

（4）
实参为指针，形参为数组名

把指针传递给数组名，那这个数组名就相当于这个数组的首地址。

换个理解： 把形参数组名当成指针看待，是一个指向数组a的首地址的指针。

void changevalue(int ba[]){
//注意，ba引用数组下标时，也不能超过main中定义的a数组。
	ba[3] = 24;
	ba[4] = 34;
return;
}
int main(){
	int a[5];
	a[0]=0;a[1]=1;a[2]=2;a[3]=3;a[4]=4;
	int *pa = a; //把数组a的首地址给pa，传递pa过去
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]);
	changevalue(pa);  //实参是指针变量，则该指针变量必须有确定的值；
	printf("a[0]=%d,a[1]=%d,a[2]=%d,a[3]=%d,a[4]=%d\n",a[0],a[1],a[2],a[3],a[4]); // //使用自定义函数之后
}

**实参或形参是数组名还是指针都可以，**间接的通过一个函数改变数组a的内容，也就是值。

8.3.4 回顾二维数组和多维数组的概念

例如：

int a[3][4] ；
//第一维 0-2 ， 第二维0-3

请添加图片描述

请添加图片描述

多维数组

eg:

int a[2][3][4];
// 第一维0-1，第二维0-2， 第三维0-3；

a[0][0][0]; a[0][0][1]; a[0][0][2]; a[0][0][3];
a[0][1][0]; a[0][1][1]; a[0][1][2]; a[0][1][3];
a[0][2][0]; a[0][2][1]; a[0][2][2]; a[0][2][3];

a[1][0][0]; a[1][0][1]; a[1][0][2]; a[1][0][3];
a[1][1][0]; a[1][1][1]; a[1][1][2]; a[1][1][3];
a[1][2][0]; a[1][2][1]; a[1][2][2]; a[1][2][3];

8.3.5 指向多维数组的指针和指针变量探究

探究地址是从1000开始的。
请添加图片描述
例如：
a[3]

a[0],a[1],a[2];

a[3][4]

a[0][0],a[0][1],a[0][2],a[0][3]
a[1][0],a[1][1],a[1][2],a[1][3] 
a[2][0],a[2][1],a[2][2],a[2][3]

a[3][4]

以下：

a[3] //这个是行

a[0]
a[1]
a[2]

a[4] //这个是列

a[0] a[1] a[2] a[3]

则有：

a[0]a[0],a[0]a[1],a[0]a[2],a[0]a[3]
a[1]
a[2]

则有： （先写行的a[3] ,在直接填列的a[4] ）

a[0][0] a[0][1] a[0][2] a[0][3]
a[1]
a[2]

可以理解为有3页，每一页有4个元素

二维数组名，也是整个二维数组的首地址。我们可以认为第0行的首地址是1000.

int a[3][4]; //数组名a同样代表数组的首地址

int a[3][4];
int *p;
// p = a;  //这个不行，
p = (int *)a; //硬指向

请添加图片描述

  1. a+1, a+2 分别代表 a[1] ,a[2]的地址 ,也就是第一行和第二行的首地址。

所以a+1跳过16个字节的，也就是a = 1000, a + 1 = 1016, a[2] = 1032;

int a[3][4]
int *p;                // a     1000
p = (int *)(a+1);      // a+1   1016
p = (int *)(a+2);      // a+2   1032

a[3][4] 代表的是3行4列。

  1. 行就代表的是数组名，

c语言规定数组名代表数组的首地址，

a[0] => &a[0][0]  // 首地址为1000， 是第0行元素首地址。
a[1] => &a[1][0]  // 首地址为1016， 是第1行元素首地址。 int为4个字节，列为4列，则第1行首地址为 第0行地址 +(4*4)
a[2] => &a[2][0]  // 首地址为1032， 是第2行元素首地址。 int为4个字节，列为4列，则第2行首地址为 第1行地址 + (4*4)

int a[3][4];
int *p;
p=a[0];
p = &a[0][0];  //地址为 0x061fde0
p = a[1];      //地址为 0x061fdf0

fdd0

fde4

  1. 第0行第一列元素的地址表示：
&a[0][1];   
a[0] + 1 表示跳过一个元素. 1004 
a[0] + 2 表示跳过两个元素. 1008
*a + 1  也是表示跳过一个元素， 1004

p = &a[0][1];  // 1004为地址
p = a[0] + 1;  // 1004为地址
  1. 二维数组推论 （拿到的都是其地址）
a[0] == *a
&a[0][1] == a[0] + 1 ==  *a + 1

a[1] == *(a+1) 
&a[1][2] == a[1] + 2 == *(a+1) + 2 
//注意： 不要把 *(a+1)+2写成*(a+3),那就变成a[3]了
  1. a[0] + 1 == *a + 1 == a[0][1] ⇒ 1004
*(a[0] + 1)  => 代表a[0][1]的值
*(*a+1) 
a[0][1] 

*(a[1] + 2)  =>代表第一行第二列的值
*(*(a+1) +2 )  =>也是
*(&a[1][2])  => 也是

a[i] 的性质问题： 如果a是一维数组，

a[i] 和 &a[i] 地址值是一样的。

a[i][j] ⇒

实践

int a[3][4];
int i,j;
for(i=0;i<3;i++) {
	for(j=0;j<4;j++)
		{
			a[i][j] = 86;
		}
}
int *p;
p = (int *)(a+1);  //第一行首地址； 
*p = 56;
p++; //走4个字节；
*p = 78; //相当于 a[1][1] = 78; //再次赋值78给到p，此时证明p++之后确实为78；

8.3.6 指针数组和数组指针

int *p[10]; //指针数组，能引用的下标是0-9*

理解：

这是个数组，数组中有10个元素，每个元素都是指针，所以相当于定义了10个指针变量，也即是p[0] - p[9] ;

定义了10个指针变量，都可以指向某一个地址 。

请添加图片描述

int *p[4]; //能引用的下标是  0-3
int i,j;
int a[3][4];
for(i=0;i<3;i++)
{
		for(j=0;j<4;j++)
			{a[i][j] = 87;}
}
a[0][1] = 98;
p[0] = &a[0][0];
p[1] = &a[0][1];
p[2] = &a[0][2];
p[3] = &a[0][3];
for(j = 0;j<4;j++)
{
printf("%d\n",*p[j]);

数组指针

数组指针： 用的不多，

int (*p)[10];  //加了括号之后就是数组指针,这个
							 //指针变量用来指向 含有10个元素的一维数组。
此处就是定义了一个数组有10个元素，然后将这个数组指针指向第0个数组元素
也就是指向这个数组的首地址，然后在一个一个的对应。

例如：

int (*p)[10];
int a[10];
int i,j;
for(i=0;i<10;i++)
{
a[i] = i;
}
p = &a; //得用地址符号。 其实&a和a的值应该相同。
//例如： int *p; p=a; 这样就可以，
//这里应该是为了区分数组指针和普通指针。 

int *q;
q = (int *)p;  //指向指针的指针变量q，
//这里使用的是强制转换，原因猜测是：
//  我们定义的是一个数组指针，而这个数组指针用来指向含有10个元素的
// 一维数组。
//那q到底指向哪个呢？ q也不确定，但是我们人知道这个这样做是对的，
// 也可以是这样 q=(*p); 这个整体就是数组首地址。但是这样又跟前面
// *p单独成行=元素值 冲突，所以为了方便就使用强制转换。
// 测试 q = &(*p)[10]； 这样是不行的，指针变量特殊一点，这样写不行
// 本来就是个指针，这个指针有10个元素，所以不能再用&
for(i=0;i<10;i++)
{
	printf("%d\n",*q);
	q++;
}

int i,j;
int (*p)[10];
int a[3][10];
for(i=0;i<3;i++)
{
	for(j=0;j<10;j++)
	{
		a[i][j] = i+j;
	}
}
p = a;  //二维数组名可以直接赋值给数组指针。
int *q;
q = (int *)p;
for(i=0;i<3;i++)
{
	for(j=0;j<10;j++)
{
	printf("%d  ",*q);
	q++;
}
printf("\n----------");
**p++;
q=(int *)p;**
}

int i,j;
int (*p)[10];
int a[3][10];
for(i=0;i<3;i++)
{
	for(j=0;j<10;j++)
	{
		a[i][j] = i+j;
	}
}
p = a;  //二维数组名可以直接赋值给数组指针。
int *q;
q = (int *)p;
for(i=0;i<3;i++)
{
	**q = *(p+i);  //每次指向一个新行**
	for(j=0;j<10;j++)
{
	printf("%d  ",*q);
	q++;
}
printf("\n----------");

}

int i,j;
int (*p)[10];
int a[3][10];
for(i=0;i<3;i++)
{
	for(j=0;j<10;j++)
	{
		a[i][j] = i+j;
	}
}
p = a;  //二维数组名可以直接赋值给数组指针。
int *q;
q = (int *)p;
for(i=0;i<3;i++)
{
	for(j=0;j<10;j++)
{
	**printf("%d  ",*((*p+i)+j));**
	
}
printf("\n----------");

}

多维数组指针做函数参数
int (*p)[3][4][5];

8.3.7 多维数组的指针做函数参数

8.4 字符串的指针和指向字符串的指针变量

8.4.1字符串表示形式

一： 字符串表示形式

char mystr1[] = "I love you "; //直接拷贝 
char mystr2[] = "I love you ";
//虽然这两个打印的东西是一样的，但是他们两个变量的地址却是不同的。
printf("%s\n",mystr);

char *pmystr1 = "I love you"; //不是拷贝，本行相当于把内存中这个字符串常量
															//的首地址赋给了指针变量pmystr1;

char *pmystr2 = "I love you"; //把内存中这个字符串常量
															//的首地址赋给了指针变量pmystr2;

//c语言中对字符串常量 有特殊的处理，会在内存中开辟出一段类似字符数组
//的东西来存放字符串常量。 所以 “I love you” 是存在于内存中，并且有一个
//内存地址的。
//这个常量定义完了只能读，不能改。

字符数组是拷贝，字符指针是给到首地址。

// mystr1 == &mystr1[0];

// mystr2 == &mystr2[0];

如何实现对字符串的存取呢？

1.方法

char a[] = "I love china!";
char b[100];
int i ;
for(i=0; *(a+i) != '\0';i++) // *(a+i) 相当于 a[i]
{
	 *(b+i) = *(a+i);    // b[i] = a[i];
}
*(b+i) ='\0'; // b[i] = '\0';
printf("string a is %s\n",a);
printf("string b is %s\n",b);

2.方法

char a[] = "I love china!";
char b[100];
char *p1,*p2;
int i;
p1 = a;
p2 = b;
for(;*p1 != '\0';p1++,p2++)
{
	*p2 = *p1;
}
*p2 = '\0';
printf("string a is %s\n",a);
printf("string b is %s\n",b);
return 0;
}

8.4.2 字符串指针做函数参数

用字符数组名做参数

#include <stdio.h>

void copystr(char from[], char to[]) { // 字符数组名做参数，将实参首地址传递给form， to 就和实参指向同一个单元
    int i = 0;
    while (from[i] != '\0')
    {
        to[i] = from[i]; //逐个字符拷贝，必须保证to比from大。
        i++;
    }
    to[i] = '\0';
}
    int main() {

        char a[] = "this is source content";
        char b[] = "this is a special test hehe,look carefully";
        printf("a=%s\n", a);
        printf("b=%s\n", b);

        copystr(a, b);
        printf("a=%s\n", a);
        printf("b=%s\n", b);

}

换个写法：

#include <stdio.h>

void copystr(char* from, char* to) { **// 字符数组名做参数，将实参首地址传递给form， to 就和实参指向同一个单元**
    int i = 0;
    while (from[i] != '\0')
    {
        to[i] = from[i]; //逐个字符拷贝，必须保证to比from大。
        i++;
    }
    to[i] = '\0';
}
    int main() {

        char a[] = "this is source content";
        char b[] = "this is a special test hehe,look carefully";
        printf("a=%s\n", a);
        printf("b=%s\n", b);

        copystr(a, b);
        printf("a=%s\n", a);
        printf("b=%s\n", b);

}

再换

#include <stdio.h>

void copystr(char* from, char* to) { // 字符数组名做参数，将实参首地址传递给form， to 就和实参指向同一个单元
    int i = 0;

    for (; *from != '\0'; from++, to++)
    {
        *to = *from; //b[i] = a[i]
    }
    to[i] ='\0';
}
    int main() {

        char a[] = "this is source content";
        char b[] = "this is a special test hehe,look carefully";
        printf("a=%s\n", a);
        printf("b=%s\n", b);

        copystr(a, b);
        printf("a=%s\n", a);
        printf("b=%s\n", b);

}

再换：

#include <stdio.h>

void copystr(char* from, char* to) { // 字符数组名做参数，将实参首地址传递给form， to 就和实参指向同一个单元
    int i = 0;
while(*from){
    *to++ = *from++;  //优先级相同。char型占用一个字节，所以就是一个一个走的。
}
    *to = '\0';
}
    int main() {

        char a[] = "this is source content";
        char b[] = "this is a special test hehe,look carefully";
        printf("a=%s\n", a);
        printf("b=%s\n", b);

        copystr(a, b);
        printf("a=%s\n", a);
        printf("b=%s\n", b);

}

8.4.3 字符指针变量与字符数组

  1. 字符数组是由若各干元素组成，每个元素中存放一个字符；

  2. 字符指针变量中存放的是字符串的首地址 。仅仅是首地址。

  3. 赋值方式：

    char str[100] = “I love China!”;

    //定义时初始化，相当于拷贝字符串内容到str中

    //str = “I love china!” 这是错的

    想要拷贝只能使用拷贝函数 strcpy

    char str[100] = "I love china!";
strcpy(str,"I love China!");

char *a;
a = "I love China"; 
// 字符串常量在内存中是有固定地址的，
//这里的赋值只是让字符指针a指向这个地址。

  4. 指针变量的值可以改变

char *a = "I love china!"; //字符指针变量仅仅存放的是这个常量的首地址。
a = a + 7; //跳过7个字节之后a指向了c  , 指针变量值可以改变。
printf("%s\n",a);  //打印的值为 china!
  1. 数组首地址不能变
char a[] = "I love china!";
a = a+7;  //这个是错的.
杨优秀&
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【C语言学习总结】——第八章 指针
qq_53721621的博客
05-25 238
第八章 指针 指针变量定义 指针变量永远占2个字节 定义的格式：类型名 *指针变量名; （此种格式定义的为列指针或者叫元素指针或者叫普通指针） 注意： 1.定义变量（普通变量、指针变量）都必须在前面有类型名 2. 在定义指针变量时，指针变量名前的“*”表示现定义的是一个指针类型的变量。星号并不是指针变量名的一部分，只有一个标志 3. 指针变量专门用来存地址，禁止将一个整型值直接赋给一个指针变量 指针变量的引用 1. “＆”取地址运算符，通过＆运算符可以取出普通变量的地址 2. “*” 指针运算符，
C语言程序设计第8章善于利用指针.pptx
11-15
C语言程序设计第8章善于利用指针 本章节主要介绍了指针的概念、指针变量的定义和使用、指针的引用、通过指针引用数组和字符串、返回指针值的函数、指针数组和多重指针、动态内存分配与指向它的指针变量等内容。 ...
c语言第八章指针答案,c语言第8章_指针答案.pdf
weixin_39690105的博客
05-21 232
c语言第8章_指针答案第8 章 指针8.1 教学要点本章主要介绍指针的基本概念、指针变量的定义、指针变量的基本运算、指针作为函数的参数、指针和数组、指针和字符串、动态内存分配和使用等知识。首先要把基本概念讲清，一定要结合图例来说明变量、内存单元和地址之间的关系；本章重点难点较多，讲解时注意趣味性激发学生兴趣，通过对比演示来分析指针和普通变量的区别。8.1 节通过示例程序“寻找保险箱密码”引出指针的...
c语言第八章指针上机作业,c语言第8章指针
weixin_39637646的博客
05-20 257
c语言第8章指针Tag内容描述：1、第八章 指 针,关键： (1)变量使用的两种方式 (2)指针定义与使用时形式相同但含义不同 (3)指针的各种运算 (4)数组名与指针变量的区别 (5)要通过一个函数改变多个值的方法,预 备 知 识,内存：就是内部存储器，是由存储单元组成 的。它的特点是存储单元是线性连续 的。存储单元的最小单位是字节。,1. 内存的概念,地址：为了访问内存中的某个存储单元，我们 ...
C语言第八章指针,C语言第八章指针
weixin_32641435的博客
05-19 278
C语言第八章指针Tag内容描述：1、第八章 指针 l 主要内容 8.1地址和指针的概念 8.2指针与数组 8.3指针与函数 8.4 main函数中的参数 8.1地址和指针的概念 内存区的每一个字节有一个编号，这就是“地址” 。 如果在程序中定义了一个变量，在对程序进行编译时 ，系统就会给这个变量分配内存单元。 .按变量地址存取变量值的方式称为“直接访问”方式 int i; 取出i 中的内容,只需要...
C语言第八章指针,c语言第八章指针概述.pptx
weixin_28993425的博客
05-19 115
第8章 指 针;;指针就是存储单元的地址。一个变量的指针就是该变量在内存中的存储单元的地址。存取变量中的数据 直接引用: 按变量名称存取变量值的方式。间接引用: 将某变量 a 的指针(地址)放在另一个变量pa中, 通过对变量pa的值(a变量的地址),由此地址存取变量 a的方式。;;一般形式： 类型标识符 *指针名；;指针变量的初始化一般形式：数据类型 *指针名=初始地址值；;8.1.3 指...
c语言第八章指针上机作业,C语言 第八章指针2.ppt
weixin_36124888的博客
05-20 121
C语言 第八章指针2第八章 指针(第十四讲);指针;§8.3 指针与数组;举例 (Eg8-4);举例 (Eg8-4-2);举例 (Eg8-4-3);举例 (Eg8-4-3);举例 (Eg8-4-3);指针与数组;Eg:void sort (int * x ) { int i , j , k , t ; for ( i =0; i <9; i ++) {k = i ; ...
c语言程序设计第八章指针,c语言程序设计第八章指针
weixin_39610366的博客
05-18 257
c语言程序设计第八章指针Tag内容描述：1、第八章 指针,8.1 概 述,C程序设计中使用指针可以: 使程序简洁、紧凑、高效 有效表示复杂的数据结构 动态分配内存 方便使用字符串 有效使用数组 调用函数时可以得到多于1个的值 直接处理内存地址,8.2 指针的概念,一、数据的存取,1、内存地址,内存的每个字节都有一个编号，这个编号称为“内存地址”。,程序中的每个数据都对应着内存中的一个地址，从该地址...
c语言程序设计第8章指针答案,C语言程序设计第8章指针.pptx-资源下载在线文库www.lddoc.cn...
weixin_34466671的博客
05-17 109
C语言程序设计第8章 指针.pptx定义学生信息管理系统中的某个子模块的功 能，实现从键盘输入一个班级中所有学生的某 门课程的成绩，通过调用函数实现统计,按规 定格式输出最高分、最低分、平均分，同时输 出优秀人数、良好人数、及格人数、不及格人 数以及所占比例。 1地址及取地址运算符 在程序中定义了一个变量，系统会根据变量的类型为变量分配 相应字节的存储空间，用于存放数据，存放的数据称为内存单元内存...
c语言程序设计第八章指针,C语言程序设计第八章：指针.ppt
weixin_28221255的博客
05-18 146
C语言程序设计第八章：指针.ppt指针的概念,内存,5,int i,2000,地址变量,数据,2000,int p,指针,指针p 指向变量 i,4000,指针变量的定义和初始化,定义指针变量的一般形式如下 数据类型 *指针变量名1，*指针变量名2，；该指针变量可以指向何种数据类型的变量,说明符，说明其后是指针变量名例如 int *p; 定义指向整型变量的指针变量p。 float *fp; 定义指向...
谭浩强c语言第八章指针ppt,谭浩强c语言第八章_指针.ppt
weixin_29233857的博客
05-24 160
谭浩强c语言第八章_指针第八章 8.1地址和指针的概念 8.2 变量的指针和指向变量的指针变量 8.7 指针数组和指向指针的指针 8.7.1 指针数组的概念 一个数组，若其元素均为指针类型数据，称为指针数组，也就是说，指针数组中的每一个元素都相当于一个指针变量。 一维指针数组的定义形式为: 类型名数组名［数组长度］； 例如： ｉｎｔ*ｐ[４]； 例8.２6 将若干字符串按字母顺序(...
第八章指针.rar
12-01
"第八章指针.rar"这个压缩包文件很可能包含了一整章关于指针的详细教学材料，旨在帮助学习者深入理解并掌握指针的使用。 指针是一个变量，它存储的是内存地址，这个地址指向另一个变量。在C/C++中，我们可以通过...
第8章 指针程序.rar
11-09
第8章的内容很可能是关于深入理解和应用指针的教程。在这个压缩包中，我们期待找到一系列有关指针程序的示例和讲解，这些可能涵盖了指针的基本概念、操作以及其在实际编程中的应用。 首先，指针是一个变量，它存储...
第8章指针.mhtml
12-21
第8章指针.mhtml
第8章 指针-8函数指针1
08-03
本章主要探讨了函数指针的概念、定义以及其在编程中的实用价值。 首先，我们需要了解函数指针的定义语法。例如，如果有一个函数原型`int Fun(int a, int b)`，我们可以定义一个函数指针`int (*f)(int, int)`，这个...
高并发服务器-使用多进程（Multi-Process）实现【C语言】
qq_42037383的博客
07-17 309
初始化服务器创建监听套接字（socket绑定套接字到指定地址和端口（bind开始监听连接请求（listen等待连接进入一个无限循环，等待并接受客户端连接（accept创建子进程每当接受到一个新的客户端连接，创建一个子进程（fork子进程负责与客户端通信，处理请求并发送响应。父进程继续监听父进程关闭与客户端通信的套接字，继续监听新的连接请求。处理子进程结束信号（可选）注册信号处理函数，处理子进程结束信号，避免僵尸进程。
三、初识C语言（3）
m0_56351488的博客
07-16 1627
例：#define MAX 100例：#define MAX (x,y) (x>y?x:y)（无参数类型）宏模块之间不能有空格调用：定义了一个MAX(x,y)的宏//#define定义宏x:y)int main()int a = 0;int b = 0;int c = 0;printf("最大值是：%d\n",c);return 0;
C语言之2048小游戏理解分析
m0_65146517的博客
07-20 580
按键W --------------- 向上按键A --------------- 向左按键S --------------- 向下按键D --------------- 向右按键P --------------- 开始游戏按键L --------------- 结束游戏按键其他 ---------- 提示有错。
E16.【C语言】练习：输入一个正的整数，逆序打印这个整数的每一位
最新发布
2401_85828611的博客
07-20 185
分析：123%10=3-->123/10=12(3被去除了)-->12%10=2-->12/10=1(2被去除了)-->1%10=1(取出最后一位)->1/10=0-->停止循环。输入一个正的整数，逆序打印这个整数的每一位。步骤：1.取出整数的每一位 2.倒序打印。
"C语言程序设计第8章：善于利用指针
总的来说，第八章的内容主要围绕指针展开，通过对指针的定义、使用和相关概念的学习，我们可以更好地理解和掌握指针在C语言程序设计中的重要性和作用，提高编程效率和质量。希望通过本章内容的学习和实践，能够让...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

杨优秀&

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值