p10 指针 简单赋值与三个数算最大值

#include
void main( )
{
  int x=10,y=5,*px,*py; 
  px=&x;  //初始化
  py=&y;
  px=py;  //初始化以后才能赋值
  printf("*px=%d,*py=%d\n",*px,*py);
}

这里像scanf(“px”,&x),但是指针同于把px值的位置取得是变量x,这就是为什么指针是初始化才能赋值,指针变量在声明时并没有被赋予任何的初值,它的初始值是不确定的,可能指向任意一个地址

因此下面的这段代码中,只有先赋值才能,更改指针里面的值

int a = 100;
int* p;       // 声明指针变量p,但没有初始化
*p = 200;     // 错误的赋值操作,p未初始化
p = &a;       // 对p进行初始化,使其指向变量a
*p = 200;     // 正确的赋值操作,将变量a的值改为20

注意:int 是不能赋值给int*的

指针加 * 与不加 * 的区别在于其语义和操作。

1. 指针加 *:当指针前面加上 * 运算符时,表示对指针所指向的内存地址进行解引用操作,即获取指针指向的内存中的值。

示例: ```c++ int a = 10;

int* p = &a; // 将指针 p 指向变量

a int b = *p; // 通过 *p 取得指针 p 所指向的内存中的值

``` 在上述示例中,通过 *p 取得了指针 p 所指向的内存中的值,并将其赋值给了变量 b。

2. 指针不加 *:当指针不加 * 运算符时,表示指针本身的地址或值。注意,此时指针的值是一个内存地址。 示例:

```c++ int a = 10;

int* p = &a; // 将指针 p 指向变量

a int* q = p; // 将指针 p 的值赋给指针 q

``` 在上述示例中,指针 p 不加 * 表示指针 p 的地址,而不是指针所指向的内存中的值。

通过将指针 p 的值赋给指针 q,实际上是将指针 p 的地址赋给了指针 q。 因此,指针加 * 和不加 * 的区别在于对指针的操作方式。

加 * 表示取得指针所指向的内存中的值,不加 * 表示指针本身的地址或值。

这里算三个数字最大值

#include 
void swap(int* p1, int* p2)
{
	int t;
	t = *p1;
	*p1 = *p2;
	*p2 = t;
}
int main()
{
	int a, b, c;
	printf("请输入三个整数a,b,c:");
	scanf("%d%d%d", &a, &b, &c);
	if (a > b) swap(&a, &b);
	if (a > c) swap(&a, &c);
	if (b > c) swap(&b, &c);
	printf("由小到大的顺序为%d,%d,%d\n", a, b, c);
	return 0;
}

这里相当于有个*P1=&a/&b/&c导致在函数中就可以直接把变量传给a,b,c,就不需要再输出函数算出结果

用指针法在一维有序数组中插入数据。输入一个含有5个整数的升序数列,存储在一维数组中,要求在其中插入任意一个整数后数列仍然有序。

#include 
void prin(int *p,int n)
{   int i;
    for(i=0;i*(p+i)) continue;
           j=4;
           while(j>=i)
           { 
             *(p+j+1)=*(p+j);
             j--;
           }  
           *(p+i)=x;
           break;
        }
        if(i==5)  *(p+5)=x;
	printf("插入数据后的数列:");
        prin(p,6);
	printf("\n");
        return 0;
}

这里这里p=a 相当于把a的数组全部给了p,*(p+i)等同于a[0+i] ,所以*(p)等价于a[0],即通过指针p来访问数组a中的第一个元素。

 假设原始数列为 {5, 10, 15, 20, 25},我们要插入的数为 13。

首先,循环遍历数列,i 从 0 开始,逐个比较数列中的元素和插入数 13 的大小。

1. 当 i = 0,比较 13 和 5,13 大于 5,继续下一个元素。
2. 当 i = 1,比较 13 和 10,13 大于 10,继续下一个元素。
3. 当 i = 2,比较 13 和 15,13 小于 15,找到插入点。

此时,将插入点之后的元素依次后移一位,即将 15 后移,得到 {5, 10, 15, 15, 20, 25}。

然后,将插入数 13 赋值给插入点的位置,即将 13 赋值给 a[2],得到 {5, 10, 13, 15, 20, 25}。

最终,输出插入数据后的数列,得到 {5, 10, 13, 15, 20, 25}。

所以这里while就是确定位置后一直往后移动

编程,从键盘上输入一个3╳3的矩阵,求矩阵的两条对角线元素之和,要求:用函数实现,在函数中使用指针。

输入输出示例:

8  6  12

5  9  10

7  11  5

sum=50

#include 
int sum(int (*p)[3],int n,int m)  
{   int i,j,s=0;
    for(i=0;i

下面就是简单循环就不讲解了,讲解下上面计算对角线方式:

假设输入的二维数组为:
```
2 4 6
1 3 5
7 9 8
```

首先,在第一个循环中,`i`从0到2,`n`为3,执行以下操作:
- `i=0`时,`*(*(p+i)+i)`对应元素为`*(*(p+0)+0)`,即`p[0][0]`,将其加到`s`中,此时`s=0+2=2`;
- `i=1`时,`*(*(p+i)+i)`对应元素为`*(*(p+1)+1)`,即`p[1][1]`,将其加到`s`中,此时`s=2+3=5`;
- `i=2`时,`*(*(p+i)+i)`对应元素为`*(*(p+2)+2)`,即`p[2][2]`,将其加到`s`中,此时`s=5+8=13`;

接着,在第二个循环中,`i`从0到2,`m`为3,执行以下操作:

- `i=0`时,`j=m-1-i`计算得到`j=3-1-0=2`,则`*(*(p+i)+j)`对应元素为`*(*(p+0)+2)`,即`p[0][2]`,将其加到`s`中,此时`s=13+6=19`;

- `i=1`时,`j=m-1-i`计算得到`j=3-1-1=1`,则`*(*(p+i)+j)`对应元素为`*(*(p+1)+1)`,即`p[1][1]`,将其加到`s`中,此时`s=19+3=22`;

- `i=2`时,`j=m-1-i`计算得到`j=3-1-2=0`,则`*(*(p+i)+j)`对应元素为`*(*(p+2)+0)`,即`p[2][0]`,将其加到`s`中,此时`s=22+7=29`。

*(*(p+i)+i)第一层里面指针,指得是列,而第二层外面的指针,指的是行


`p++` 和 `*p++` 是两个不同的操作。

- `p++` 是先取指针 `p` 的值,然后将指针的值加一。它会返回指针 `p` 在加一前的值,并将 `p` 的值加一。这个操作会移动指针的位置,但返回的是移动前的指针值。
- `*p++` 是先取指针 `p` 指向的值,然后将指针的值加一。它会返回指针 `p` 在取值前的位置的值,并将 `p` 的值加一。这个操作会移动指针的位置,并返回移动前的指针所指向的值。

实际上,`*p++` 将先执行 `*p`,然后执行 `p++`。

 

你可能感兴趣的:(c语言基础,算法,数据结构)