C语言指针变量（4.28）

来源：互联网发布：上海软件协会编辑：程序博客网时间：2024/06/04 00:43

一 C语言指针变量(草根派)

1.C语言分配内存

<1>定义变量

<2>malloc函数

2.C语言对内存操作

<1>内存标识符号(变量名)

<2>内存所在的地址

读内存:变量名 , *地址值

写内存:变量名=值,*地址值 = 值

3.C语言的两种变量

<1>普通变量 : 保存数值

定义:

数据类型变量名;

int a;

<2>指针变量 : 保存地址值

定义:

数据类型 *变量名;

int *p;

练习:已知data1 = 200,data2 = 300,要求：通过两个指针变量实现data1和data2的数据交换(之少两种交换方法)?

#include <stdio.h>int main(){    int *p;    int *q;    int *t;    int data1 = 200;    int data2 = 300;    p = &data1;    q = &data2;    t = p;    p = q;    q = t;    printf("data1 = %d,data2 = %d\n",data1,data2);    return 0;}

====================================================================

总结:

通过指针变量，读写一块内存

<1>用指针变量保存对应内存的地址值

<2>读内存: *指针变量(读指针变量保存地址的内容) ,

写内存: *指针变量=值(将值写到指针变量保存的地址)

=====================================================================

练习:定义10个元素的整型数组，然后给数组输入值，用p_max 和 p_min保存最大值和最小值所在的地址，

然后通过p_max 和 p_min 输出最大值和最小值,

最后通过p_max 和 p_min 实现最大值和最小值的交换,然后输出数组的内容

#include <stdio.h>int main(){    int i;    int a[10];    int temp;    int *p_max;    int *p_min;    for(i = 0;i < sizeof(a)/sizeof(a[0]);i ++)    {        scanf("%d",&a[i]);    }    p_max = &a[0];//p_max = a;    p_min = &a[0];//p_min = a;        for(i = 0;i < sizeof(a)/sizeof(a[0]);i ++)    {        if(*p_max < a[i])        {            p_max = &a[i];        }        if(*p_min > a[i])        {            p_min = &a[i];        }    }    printf("max : %d, min : %d\n",*p_max,*p_min);        temp = *p_max;    *p_max = *p_min;    *p_min = temp;    for(i = 0;i < sizeof(a)/sizeof(a[0]);i ++)    {        printf("%d ",a[i]);    }    printf("\n");    return 0;}

二 C语言指针变量的数据类型(草根派)

1. 在C语言指针变量的数据类型决定指针变量的寻址范围(通过不同数据类型的指针变量对一块内存操作的时候，

一次性读和一次性写的字节数将不一样)

int *p1; //每次操作四个字节

short *p2; //每次操作2个字节

char *p3; //每次操作1个字节

2.不同数据类型的指针变量,在加1 和减1的时候，增加的地址不一样

int *p1;

short *p2;

char *p3;

p1 = &data;

p2 = &data;

p3 = &data;

p1 ++; //p1= &data + 4

p2 ++; //p2 = &data + 2

p3 ++; //p3 = &data + 1

总结:指针变量在移动的时候，每次移动的单位是指针变量数据类型的大小

注意:以上的说法只使用于一级指针变量(多级指针变量比较特殊)

练习:

short a[] = {1,2,3,4,5,6,7,8,9};要求通过两个指针变量，实现数组逆置,最后输出数组的内容

提示:

p保存第一个元素的地址，q保存最后一个元素的地址,然后交换p和q保存地址的内容，接着让p向后

走动一步，q指针向前走动一步

#include <stdio.h>int main(){    int i = 0;    short temp;    short *p,*q;    short a[] = {1,2,3,4,5,6,7,8,9};    p = &a[0];    q = &a[sizeof(a)/sizeof(a[0]) - 1];        while(p < q)    {        temp = *p;        *p = *q;        *q = temp;        p ++;        q --;    }    for(i = 0,p = a;i < sizeof(a)/sizeof(a[0]);i ++)    {        printf("%d ",*(p + i));    }    printf("\n");    return 0;}

三多级指针变量(草根派)

C语言指针变量设计规则:

(1)一级指针变量保存普通变量地址

(2)二级指针变量保存一级指针变量地址

(3)三级指针变量保存二级指针变量地址

例如:

int *p;//一级

int **q;//二级指针变量

int ***m;//三级指针变量

总结:多级(>=2)指针变量每次移动的单位是一个地址的大小

四指针数组(草根派)

本质:是一个数组，这个数组用来存放多个地址值,定义一个指针数组的时候，等价于定义多个指针变量

1.定义指针数组

数据类型 *数组名[数组元素的个数];

int *p[3]; => p[0] p[1] p[2] 就是三个int 型的指针变量

问题:如何保存指针数组的首地址?

| | p[0]

| | p[1]

| | p[2]

获得数组的首地址:数组名p , 数组第一个元素的地址&p[0]

int **q;

q = p;或 q = &p[0];

练习:

char a1[] = "abcdef";

char a2[] = "ABCDEF";

char a3[] = "123456";

char buf[1024];

char *p_arry[] = {a1,a2,a3,NULL};

<1>通过一个指针变量，操作指针数组，输出a1,a2,a3数组中的字符串

<2>通过指针数组，将a1,a2,a3连接在一起，存放在数组buf中,

然后输出buf的内容(buf中最后存放的是一个字符串);

<3>将buf数组中的字符串，以从小到大的方式排列，然后输出

#include <stdio.h>int main(){    int j;    int n;    char temp;    char *p;    char **q;    int count = 0;    int i = 0;    char buf[1024];    char a1[] = "abcdef";    char a2[] = "ABCDEF";    char a3[] = "123456";    char *p_arry[] = {a1,a2,a3,NULL};//0    for(q = p_arry; *q != NULL;q ++)    {        printf("%s\n",*q);    }        for(i = 0;p_arry[i] != NULL;i ++)    {        for(p = p_arry[i]; *p != '\0'; p ++)        {            buf[count ++] = *p;        }    }    buf[count] = '\0';   // 0123    //ABC\0    printf("buf : %s\n",buf);        n = count;    for(i = 0;i < n - 1;i ++)    {        for(j = 0;j < n - i - 1;j ++)        {            if(buf[j] > buf[j + 1])            {                temp = buf[j];                buf[j] = buf[j+1];                buf[j+1] = temp;            }        }    }    printf("buf : %s\n",buf);        return 0;}

0 0