指针的概念与应用

Posted 2020-10-15 lemongirl

1.内存按区域分类存放数据

　　栈区（stack）:存放函数的参数值、返回值、局部变量等。

　　堆区（heap）:用于动态内存分配。

　　未初始化静态全局区（bss）:全局未初始化、静态未初始化数据。

　　初始化静态全局区（data）:全局初始化、静态初始化数据。

　　文字常量区（rodata）:字符串常量。

　　代码区（text）:可执行文件的二进制代码（函数）。

#include <stdio.h>
#include <stdlib.h>

int e;
static int f;
int g = 10;
static int h = 10;

int main(int argc,char *argv[])
{
    int a;
    int b = 10;
    static int c;
    static int d = 10;
    char *i = "test";
    char *k = NULL;

    printf("&a = %p\\t  //局部未初始化变量\\n",&a);
    printf("&b = %p\\t  //局部初始化变量\\n",&b);

    printf("&c = %p\\t  //静态局部未初始化变量\\n",&c);
    printf("&d = %p\\t  //静态局部初始化变量\\n",&d);

    printf("&e = %p\\t  //全局未初始化变量\\n",&e);
    printf("&f = %p\\t  //全局静态未初始化变量\\n",&f);

    printf("&g = %p\\t  //全局初始化变量\\n",&g);
    printf("&h = %p\\t  //全局静态初始化变量\\n",&h);

    printf("&i = %p\\t  //只读数据（文字常量区）\\n",&i);

    k = (char *)malloc(10);
    printf("k = %p\\t  //动态分配的内容\\n",k);
    return 0;  
}

2.指针与指针变量

　　指针：内存区的每一个字节都有一个编号，这就是地址。指针的实质就是内存地址。

　　指针变量：用来存放指针（地址）的变量，它的值通常是一个变量的地址。

　　1.float score;

　　　float *p = &score;　　//指向float型变量的指针变量

　　2.int a[5];

　　　int * p = a;　　//指向数组第0个元素的指针变量。

　　3.char *string = "hello";　　//指向字符串的指针变量

　　4.int (*fun) (int x,int y);　　//指向函数的指针变量

　　5.struct student *boy;　　//指向结构体的指针变量

3.变量与指针

　• 指针变量的定义格式

　　类型标识符 *变量名；　　例如：int *point;

#include <stdio.h>
#include <stdlib.h>

int main(int argc,char *argv[])
{
    int a = 100,b = 200;
    int *p_1,*p_2 = &b;   
　　//int *p_1中*表示该变量的类型是一个指针变量，指针变量名是p_1而不是*p_1
　　//*p_2 = &b表示指针变量可以在定义的时候初始化
    p_1 = &a;    //指针变量也可以先定义在初始化
    printf("a = %d\\n",a);     //100
    printf("*p_1 = %d\\n",*p_1);     //100,*p_1是p_1指向的变量的值
    printf("a = %d\\n",b);    //200 
    printf("*p_2 = %d\\n",*p_2);     //200,一个指针变量只能指向同一个类型的变量
    return 0;
}    

//指针变量的引用
#include <stdio.h>

int main(int argc,char[])
{
    int *p1,*p2,temp,a,b;
    p1 = &a;
    p2 = &b;
    printf("input a and b:");
    scanf("%d %d",p1,p2);    //a = 200,b = 100
    if(*p1 > *p2)
    {
        temp = *p1;
        *p1 = *p2;
        *p2 = temp;
    }
    printf("a = %d,b = %d\\n",a,b);    //a = 100,b = 200
    printf("*p1 = %d,*p2 = %d\\n",*p1,*p2)    //*p1 = 100,*p2 = 200
    return 0;
} 

　不同类型的指针相互赋值，需要强制类型转换。

#include <stdio.h>

int main(int argc,char *argv[])
{
    int a = 0x1234,b = 0x5678;
    char *p1,*p2;
    printf("a = %0x,b = %0x",a,b);

    p1 = (char *)&a;
    p2 = (char *)&b;
    printf("*p1 = %0x,*p2 = 0x",*p1,*p2);    //*p1 = 34,*p2 = 78

    p1++;
    p2++;
    printf("*p1 = %0x,*p2 = 0x",*p1,*p2);    //*p1 = 12,*p2 = 56
    return 0;
}

　• 指针变量的大小：使用sizeof()测量指针的大小，得到的总是4或8.

　　char *p;short *p; int *p; struct stu *p;　　//均为4

　　1.sizeof()测的是指针变量指向存储地址的大小。

　　2.在32位平台，所有的指针（地址）都是32位；在64位平台，所有的指针都是64位。

4.字符串与指针

　　(1).字符串的存储形式：数组、字符串指针、堆

　　　　• 字符数组：在内存（栈、全局区）开辟了一段空间存放字符串。

　　　　　char str[] = "I love C";

　　　　　• 字符串指针：在文字常量区开辟了一段空间存放字符串，将字符串的首地址赋给str。

　　　　　　char *str = "I love C";

　　　　　• 堆：使用malloc函数在堆区申请空间，将字符串拷贝到堆区。

　　　　　　char *str = (char *)malloc(10*sizeof(char));

　　　　　　strcpy(str,"I love C");

　　(2).初始化

　　　　• 字符数组、指针指向的字符串：定义时直接初始化。

　　　　　char buf_aver[] = {"hello world"};

　　　　　char *buf_point = "hello world";

　　　　• 堆中存放的字符串：不能初始化，只能使用strcpy、scanf赋值。

　　　　　char *buf_heap;

　　　　　buf_heap = (char *)malloc(10);

　　　　　strcpy(buf_heap,"hello world");

　　(3).使用时赋值

　　　• 字符数组：使用scanf或strcpy

　　　　　char buf_aver[] = {"hello world"};

　　　　　buf_aver = "hello kitty";　　　　　　

　　　　　strcpy(buf_aver,"hello kitty");　　　 正确

　　　　　scanf("%s",buf_aver);　　　　　　  正确

　　　•指向字符串的指针

　　　　　char *buf_point = "hello world";

　　　　　buf_point = "hello kitty";　　　　　　正确，改为指向另一个字符串

　　　　　strcpy(buf_point,"hello kitty");　　　 错误，只读

　　(4).可修改性

　　　　• 数组和堆中的字符串：可读可写，存储在栈区、堆区、全局区。

　　　　• 指针指向的字符串：只读，存储在文字常量区。 

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

int main(int argc,char *argv[])
{
    char str_array[] = "I love c_avr!";
    char *str_point = "I love c_point!";
    char *str_head = NULL;
    
    str_heap = (char *)malloc(20);
    strcpy(str_heap,"I love c_heap");

    printf("str_array = %s,str_point = %s,str_head = %s\\n",str_array,str_point,str_heap);
    printf("str_array = %p,str_point = %p,str_head = %p\\n",str_array,str_point,str_heap);
   printf("str_array = %d,str_point = %d,str_head = %d\\n",sizeof(str_array),sizeof(str_point),sizeof(str_heap));      //str_array =  14,str_point = 4,str_heap = 4
   printf("str_array = %d,str_point = %d,str_head = %d\\n",strlen(str_array),strlen(str_point),strlen(str_heap));    //str_array =  13,str_point = 15,str_heap = 14

    str_arrray[0] = \'y\';    //可自由修改变量内容
    printf("str_array = %s\\n",str_array);

    //*(str_point+0) = \'y\';    //不可修改变量内容
    //printf("str_point = %s\\n",str_point);
    return 0;  
}

5.

• int a[] = {1,2,3};

　　   a++　　//错误，a代表数组首地址是个常量，不能进行++操作

• 任何指针都不能指向一个常量。
• 两指针相减表示元素个数，两指针之间不能进行加法运算。