C语言_指针

#include <stdio.h>

//宏定义常量
#define  ROWS 3
#define  COLS 4

void swapValue(int x,int y);

void swapValue1(int *x ,int *y);

int main(int argc, const char * argv[]) {
    
    /*
     为什么需要指针？
     1.使用指针处理数组中存储的数据，它的执行速度要比使用，下标快很多。因为下标需要进行位移量偏转，而指针是直接使用内存地址。
     2.对于基本数据类型来书，我们在函数中无法更改函数调用处之前的局部变量，使用指针就可以做到。
     ...
     
     指针：
     一个变量的地址为该变量的"指针"，它是个常量
     
     指针变量：
     指针变量是一个变量，用于存储地址的值
     
     指针变量的声明:
     
        数据类型 *指针变量名;
     
     下面的声明中的 *号表示后面的变量名 p 为一个指针变量，前面的 int 类型表示该指针变量所存储的地址指向的存储单元上是存放一个整型的数据。
     
     简要的说，就是上面的格式定义了一个指向 "数据类型" 的 "指针变量"
     
     */
    int *p;
    
    //指针的使用
    //对指针赋值
    int i = 10;
    int *p1 ;       //可以将int *看做是一个整体，然后p1中需要存储的是地址类型的数据
    p1 = &i;        //&是取值(地址)运算符
    
    //等价于
//    int *p1 = &i;
    
    int *p2;
//    *p2 = &i;
    
    /*
     错误原因：
     *运算符优先级是大于 = ，首先 *p2进行运算，而*p2运算是求出p2所存储地址指向的内存的值，而此时p2内没有数据，所以*p2找不到相应的结果，所以这样是错误的。
     
     注意： *号称为取值运算符
     */
    
    /*
     * 号的用法
     1.表达式中，*两边都有表达式的话，*号是四则运算的乘法运算
     2.在声明语句中，*表明后面的变量为一个指针形式的变量
     3.*号如果不在声明语句中，而只是在右边的表达式的话，表明取*号右边变量中所存地址对应内存中的数据(取值)
     */
    
    int *p3;
    p3 = &i;    //p3中就有了地址数据
//    *p3 = &i;
    //等价于 i = &i
    
    //通过指针取值
    int i1 = 100;
    int *p4 ;
    p4 = &i1;
    printf("%d \n",*p4);
    
//    printf("%d \n",p4);     //打印结果是十进制的
    //在C语言中提供了另一个控制字符串%p，专门用于打印指针的内存地址值，使得所打印的地址是十六进制的
    printf("%p\n",p4);
    
    //例子
    int m  = 10;
    int n = 20;
    //声明两个指针变量
    int *p_i;
    int *p_j;
    p_i = &m;
    p_j =&n;
    
    printf("m = %d,n = %d\n",m,n);
    
    //通过变量改变数据
    m = 1000;
    n = 2000;
    printf("通过变量修改数据后的值:m = %d, n =%d\n",m,n);
    
    //通过指针修改数据
    *p_i = 100;
    *p_j = 200;
    printf("通过指针修改数据后的值:m = %d,n = %d\n",m,n);
    printf("通过指针修改数据后的值:*p_i = %d,*p_j = %d\n",*p_i,*p_j);
    
    
    //指针使用进阶
    int i2 = 10;
    int *p5;
    int *p6;
    p5 = &i2;
    
    //
    &*p5 ;
    /*
     表达式的含义?
     &和*运算符的优先级相等，且是从右到左的顺序结合的
     *p5 等于 i2
     &*p5 等于 &i2
     */
    
    printf("&i2 = %p\n",&i2);
    printf("&*p5 = %p\n",&*p5);
    
    //
//    *&i2;      //实际上就是i2的值
    printf("*&i2 = %d\n",*&i2);
    
    //
    (*p5)++;
    //先找出p5所存储地址指向的存储单元的值，把值进行自加，p5的地址不变
    
    //
//    *p5++;
    //++ 与 * 同一优先级，结合方向是从右向左，所以先找出p5所存储地址的值，然后把该值加一，那么现在p5就不再指向变量i2了。
    
    //值传递
    int a1 = 10;
    int b1 = 20;
    printf("函数外，交换前:a1 = %d,b1 = %d\n",a1,b1);
    swapValue(a1, b1);
    printf("函数外,交换后:a1 = %d, b1 = %d\n",a1,b1);
    
    /*
     如果想像数组作为函数参数那样，在函数内改变传入局部变量的值后，在函数外部的局部变量的值对应改变，那么应该怎么做?
     我们可以通过指针来做参数，因为指针中存放的同样是地址。在C语言中，地址传递也称为引用传递
     */
    
    //指针作为函数参数
    int a2 = 10;
    int b2 = 20;
    int *p_a2 = &a2;
    int *p_b2 = &b2;
    printf("函数外,交换前:*p_a2 = %d,*p_b2 = %d\n",*p_a2,*p_b2);
    swapValue1(p_a2, p_b2);
    printf("函数外,交换后:*p_a2 = %d,*p_b2 = %d\n",*p_a2,*p_b2);
    
    /*
     理解 课本p168页的话
     */
    
    
    //指向二维数组的指针
    int array[3][4] = {
    
        {1,2,3,4},
        {11,12,13,14},
        {111,112,113,114}
    };
    
    //array[0]、array[1]、array[2]分别代表了各自对应的一维数组的首元素地址,它是一个地址并不是一个数组元素
    
    // array[0][0]  //使用下标访问数组元素
    //如何使用指针访问数组元素?
//    *(array)  相当于 array[0]
    //*(array+1)  相当于 array[1] ,array[1]是一个地址，对应着第二行的一个一维数组的首个元素地址
    //*(array+1)+1 是第二行第二个元素的地址，然后继续使用*号，即可取出其对应的值了
    
    printf("array[1][1] = %d\n",*(*(array+1)+1));
    printf("array[2][3] = %d\n",*(*(array+2)+3));
    //使用指针遍历二维数组
    for (int i=0; i<3; i++)
    {
        for (int j=0; j<4; j++)
        {
            printf("*(*(array+%d)+%d)=%d\n",i,j,*(*(array+i)+j));
        }
    }
    
    
    //声明一个指针变量让它指向二维数组
    int *p9;
    //    p9 = array;
    
    //这样是不可以的的，因为p9中的值指向的内存单元的值的数据类型是整型的。我们知道，array代表的是二维数组的第一行元素的地址，第一个元素又是一个一维数组。那么， p9 = array，就相当于让p指针存放了了一个地址，而这个地址所对应的存储单元中存储的又是一个地址。所以是不可以的。
    
    p9 = array[0];
    p9 = &array[0][0];
    printf("*p9 = %d\n",*p9);
    
    
    
    
    
    int value;
    
    
    
    return 0;
}


void swapValue(int x,int y)
{
    int tmp ;
    printf("函数内,交换前:x = %d, y = %d\n",x,y);
    tmp = x;
    x = y;
    y = tmp;
    printf("函数内,交换后:x = %d, y = %d\n",x,y);
}

void swapValue1(int *x ,int *y)
{
    int tmp;
    printf("函数内,交换前: *x = %d ,*y = %d\n",*x,*y);
    tmp = *x ;
    *x = *y;
    *y = tmp;
    printf("函数内，交换后: *x = %d,*y = %d\n",*x,*y);
}

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

typedef struct {

    int num ;
    char *name;
    char sex;
    float score;
}Student;

int *getArray();

void printBookName(char *name[],int count);

void sortBookName(char *name[],int count);

void print(Student *stu);

int main(int argc, const char * argv[]) {
    
    /*
     1.动态内存
     2.字符串与指针
     3.指针作为函数返回值
     4.指针数组
     5.数组指针
     6.指针的指针
     7.结构体指针
     */
    
    int i = 10;
    int *p = &i;
    
    /*
     动态分配内存
        就是跟系统申请一块内存，然后将该块内存的起始地址给了p。而这个地址不是固定 的，所以称为动态分配内。
     动态分配内存涉及到几个常用函数:malloc(),free(),calloc()
     这些函数声明放在stdlib.h头文件中
     */
    
    /*
     malloc 函数
     该函数用于跟系统申请一块内存，这块内存的大小由参数决定，而参数的单位为字节(Byte)。然后将申请后的内存起始地址返回，我们就可以使用指针变量来接收这个地址，我们建议将这个地址强制转换为对应的指针类型。
     
     */
    int *p1 = (int *)malloc(sizeof(int));
    
    //申请一个占100个float变量的内存空间
    float *p2 = (float *)malloc(sizeof(float)*100);
    
    //申请内存空间，需要判断成功与否，如果不成功，就会返回空指针(NULL)
    if (p1 != (int *)NULL)
    {
        printf("动态内存申请成功\n");
    }
    else
    {
        printf("动态内存申请失败\n");
    }
    
    //我们使用malloc函数申请内存后，一旦使用完毕，需要释放内存，否则那块内存就成为了垃圾内存。
    //使用free()函数释放内存，它里面有个参数，这个参数就是我们需要释放的内存区域的起始地址
    free(p1);
    free(p2);
    
    //在控制台输入几个数，然后对这些数字进行倒序排序
    /*
    int count;
    printf("请输入要输入的数字的个数:\n");
    scanf("%d",&count);
    
    int *p3 = (int *)malloc(sizeof(int)*count);
    
    if (p3 == (int *)NULL)
    {
        printf("分配内存失败\n");
        return 0;
    }
    else
    {
        printf("请输入%d个数字，空格隔开\n",count);
        for (int i =0; i < count; i++)
        {
            scanf("%d",(p3+i));
        }
        printf("数组原顺序为: ");
        for (int i = 0; i< count; i++)
        {
            printf("%d ",*(p3+i));
        }
        printf("\n");
        
        //使用指针倒序排序
        for (int i = 0; i < count/2; i++)
        {
            int tmp = *(p3+i);
            *(p3 +i) = *(p3+count -1-i);
            *(p3+count-1-i) = tmp;
        }
        
        printf("倒序排序后数组元素的顺序为: ");
        for (int i = 0; i < count; i++)
        {
            printf("%d ",*(p3+i));
        }
        printf("\n");
        
        free(p3);
    
    }
    */
    
    /*
     calloc()函数
     它有两个参数，一个参数用于输入分配的单元个数，第二参数用于指定单元大小。如果分配不成功也会返回空指针(NULL)。malloc函数分配内存之后，该区域的数值并不初始化为0，如果分配的内存之前被使用过，那么使用malloc()分配之后有可能还保留之前的数据。而calloc()分配完毕后，会将该区域的数值初始化为0
     
     P176,具体例子
     */
    
    //字符串与指针
    char str[] = "Hello world!";
    
    //指针变量可以指向一个字符数组
    char *p4;
    p4 = str;
    printf("p4 = %s\n",p4);
    
    /*
     注意：
     printf()函数中控制字符串%s,代表要打印一个字符串，后面传入的参数需要的是字符数组的名称(其实就是字符数组首元素地址),p4中存放的就是这个字符数组的首元素地址。printf()函数会一直将该字符串打印到结尾，直到遇到末端字符'\0'
     */
    
    //例子
    char *p5;
    //如果想要存储20个字符，那么它的长度应该是21个字节。因为还有一个末端字符。
    
    p5 = (char *) malloc(sizeof(char)*21);
    
    printf("请输入一个字符串，字符控制在20个以内:\n");
    
    char c ;
    int countNum = 0 ;
    while ((c = getchar()) != '\n')
    {
        //输入
        *(p5+countNum) = c;
        countNum++;
    }
    
    *(p5 +countNum) = '\0';
    
    printf("字符串为:%s\n",p5);
    
    //将字符串倒序排序
    char *start = p5;
    char *end = (p5+countNum -1);
    
    for (int i = 0; i < (countNum )/2; i++)
    {
        int tmp = *(start +i);
        *(start + i) = *(end - i);
        *(end - i) = tmp;
    }
    
    printf("倒序排序后字符串为:%s\n",p5);
    free(p5);
    
    //如何使用指针处理二维字符数组
    char strings[3][20] = {
    
        "Hello World!",
        "Hello Coder!",
        "Hello Youths"
    };
    
    
    for (int i = 0; i<3; i++) {
        for (int j = 0; j<20; j++) {
            printf("%c",*(*(strings+i)+j));
        }
        printf("\n");
    }
    
    char *p6 ;
    p6 = strings[0];
    for (int i = 0; i < 3; i++)
    {
        printf("%s\n",p6+i*20);
    }
    
//    free(p6);
    //因为free()函数只能释放动态分配的内存空间，不能释放任意的内存。
    
    //指针作为函数返回值
    /*
     指针除了可以作为函数参数外，也可以作为函数的返回值
     使用指针，可以返回一个数组，因为数组名就是一个地址，我们可以使用指针来代替
     
     指针作为函数返回值基本形式如下:
     类型标志符 *函数名(参数列表)
     
     上述格式中函数返回指针指向的"数据类型" 是 "类型标志符" 所标志的类型(int,float,double,char)
     */
    
    int *p7 = getArray();
    
    for (int i = 0; i < 10; i++)
    {
        printf("%d ",*(p7+i));
    }
    printf("\n");
    
    
    /*
     指针数组
        指针数组是一个数组，该数组中的每一个元素还是一个指针，而这些指针可以继续指向其他的地址
     
     例如,定义一个指针数组
     int *p[4];
     
     这里的中括号优先级比*高，先结合p[4],这是一个数组形式，有4个元素，然后再与前面的 * 结合，表示是指针类型。所以p这个数组中有四个元素，每一个元素都是指向整型的指针。
     */
    
    int arr1[3][4] = {
    
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    
    int *p8[3];
    for (int i = 0; i< 3; i++)
    {
        p8[i] = arr1[i];
        
        for (int j = 0; j<4; j++)
        {
            printf("%d ",*(p8[i] + j));
        }
        printf("\n");
    }
    
    //列子2，对指针数组的元素进行排序
    char *bookName[5] = {
    
        "C Primer Plus",
        "Object-C Basic",
        "Visual C++ 2010",
        "Lear Objective-C on the Mac",
        "Beginning iphone5s Development"
    };
    
    //声明和实现一个函数，对指针数组的数据进行输出
    //void printBookName(char *name[],int count);
    
    //声明和实现一个函数，对指针数组里的地址指向的数据进行一个冒泡排序，并且，顺序是从小到大的。
    //void sortBookName(char *name[],int count);
    
    //最后再用void printBookName(char *name[],int count);去重新输出排序后的数组
    
    printf("排序前:\n");
    printBookName(bookName, 5);
    
    printf("冒泡排序后:\n");
    sortBookName(bookName, 5);
    printBookName(bookName, 5);
    
    
    /*
     数组指针(行指针)
     数组指针是一个指针变量，我们定义出来的指针变量中存放的地址必须是数组的地址才行，其他的数据类型的地址不可以存放到这个指针变量中。
     
     定义代码如下:
     (*p)[4];
     
     注意：(*p)的括号不能省略,如果省略就成了*p[4],就是一个指针数组了。我们使用括号提升前面*号优先级，表示*p对应一个4个元素的整型数组。该指针只能指向一个包含4个整型元素的一维数组，不能单独指向数组中的某一元素。如果要赋值可以使用二维数组的名称为该变量进行赋值。
     */
    
    int arr2[][4] = {
    
        {1,2,3,4},
        {5,6,7,8},
        {9,10,11,12}
    };
    
    int (*p9)[4];
    p9 = arr2;
    
    for (int i = 0; i <3; i++)
    {
        for (int j = 0 ; j < 4; j++)
        {
            printf("%d ",*(*(p9+i)+j));
        }
        printf("\n");
    }
    
    /*
     指向指针的指针
     定义一个指针变量，指向一个地址，而这个地址上存储的又是一个指针数据，而该指针数据指向的才是实际的数据。
     
     指针的指针 定义形式:
     int **p;
     */
    
    int **p10;
    int i1 = 10;
    int *p11 ;
    p11 = &i1;
    p10 = &p11;
    
    //例子
    char **p12 ;
    
    for (int i = 0; i < 5; i++)
    {
        p12 = bookName +i;
        printf("%s\n",*p12);
    }
    
    /*
     结构体指针变量
        指针变量指向的是一个结构体。
     结构体指针变量中的值是指向 结构体变量的首地址。
     
     结构体指针变量声明的一般形式:
     struct 结构体名 *结构体指针变量
     或者
     typedef struct 定义的结构体名 *结构体指针变量名  (一般使用这种形式)
     
     通过结构体访问结构体变量的成员的一般形式:
     (*结构体指针变量).成员变量
     或者
     结构体指针变量->成员名
     
     */
    
    Student stu ;    //结构体变量
    Student *pStu ;  //结构体指针变量
    
    pStu = &stu;
    
    stu.num = 1;
    stu.name = "Rick";
    stu.sex = 'M';
    stu.score = 99.9;
    
    printf("我们使用结构体变量打印信息如下:学号 = %d,姓名 = %s,性别 = %c,分数 = %f\n",stu.num,stu.name,stu.sex,stu.score);
    
    printf("我们使用结构体指针变量打印信息如下:学号 = %d,姓名 = %s,性别 = %c,分数 = %f\n",(*pStu).num,(*pStu).name,(*pStu).sex,(*pStu).score);
    
    printf("我们使用结构体指针变量打印信息如下:学号 = %d,姓名 = %s,性别 = %c,分数 = %f\n",pStu->num,pStu->name,pStu->sex,pStu->score);
    
    //结构体指针作为函数参数
    //如果我们要对结构体内成员像上面那样一个一个进行赋值，即费时间又费空间，开销大，程序效率大大降低。那么在这情况下，可以使用结构体指针作为函数参数，以提高程序的效率。
    
    Student student = {1,"Rick",'M',99.9};
    
    Student *studnetBianliang;
    studnetBianliang = &student;
    
    print(studnetBianliang);
    return 0;
}


int *getArray()
{
    static int array[10] = {1,2,3,4,5,6,7,8,9,10};
    for (int i = 0; i < 10; i++)
    {
        array[i] += 10;
    }
    return array;
//    return &array[0];
}

void printBookName(char *name[],int count)
{
    for (int i = 0; i < count; i++)
    {
        printf("%s\n",name[i]);
    }
}


void sortBookName(char *name[],int count)
{
    //使用冒泡排序
    char *tmp;
    for (int i = 0; i< count-1; i++)
    {
        for (int j = 0; j < count -1- i; j++)
        {
            if (strcmp(name[j], name[j+1]) > 0)
            {
                //交换地址
                tmp = name[j];
                name[j] = name[j+1];
                name[j+1] = tmp;
            }
        }
    }
}


void print(Student *stu)
{
    printf("学号 = %d,姓名 = %s,性别 = %c,分数 = %f\n",stu->num,stu->name,stu->sex,stu->score);
}