C----------------LessonPointerHigher

#import <Foundation/Foundation.h>

//交换 两个数的值

void swap(int *a, int *b)

{

    int temp = *a;

    *a = *b;

    *b = temp;

}

//p --- 接收数组的首地址

//count --- 接收数组的元素个数

//1.给数组元素赋值

void assignArr(int *p,const int count)

{

    for (int i = 0; i < count; i++) {

        *(p + i) = arc4random() % (60 -20 + 1) + 20;

        printf("%d ", *(p + i));

    }

}

//2.对数组进行降序排序

void sortArr(int *p,const int count)

{

    for (int i = 0; i < count - 1; i++) {

        for (int j =0; j < count - 1 - i; j++) {

            if(*(p + j) < *(p + j + 1)){

                int temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

}

//3.输出数组元素

void outputArr(constint *p, const int count)

{

    for (int i = 0; i < count; i++) {

        printf("%d ", *(p + i));

    }

}

//取一个数组中最大的元素.

int maxValue(const int *p, const int count);

int maxValue(const int *p, const int count)

{

    int max = 0;

    for (int i = 0; i < count; i++) {

        if (max < *(p + i)) {

            max = *(p + i);

        }

    }

    return max;

}

//有一个整型数组,把大于27的清零.

void clearArr(int a[],const int count);

void clearArr(int a[],const int count)

{

    int *p = a;

    for (int i = 0; i < count; i++) {

        if (*(p + i) > 27) {

            *(p + i) = 0;

        }

    }

}

//求字符串中空格的个数

int spaceCount(constchar *p)

{

    int i = 0, countSpace =0;

    while (*(p + i) != '\0') {

        if (*(p + i) == ' ') {

            countSpace++;

        }

        i++;

    }

    return countSpace;

}

//求字符串中a字符的个数,并且将a转为A

int aCount(char str[])

{

    char *p = str;

    int i = 0, count =0;

    while (*(p + i) != '\0') {

        if (*(p + i) == 'a') {

            *(p + i) = 'A';

            count++;

        }

        i++;

    }

    return count;

}

struct studen {

    char *name;//存储地址,拷贝的是地址,指向常量区,不能修改内容,直接通过赋值符号给name赋值即可.

    //char name[10];  //存储字符,拷贝的字符串中的字符,操作的是数组,数组内容可以被修改,给字符数组赋值要使用strcpy函数.

    int age;

    float score;

};

typedef struct studen Student;

//输出所有学生的信息

void allStudentInfo(constStudent *p, const int count)

{

    for (int i = 0; i < count; i++) {

        printf("name = %s age = %d score = %.2f\n", (p + i)->name, (p + i)->age, (p + i)->score);

    }

}

//按学生的年龄进行升序排序

void sortStudentAscByAge(Student stu[],const int count)

{

    Student *p = stu;

    for (int i = 0; i < count - 1; i++) {

        for (int j =0; j < count - 1 - i; j++) {

            if ((p + j)->age > (p + j +1)->age) {

                Student temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

}

//按姓名进行升序排序

void sortStudentAscByName(Student *p,const int count)

{

    for (int i = 0; i < count - 1; i++) {

        for (int j =0; j < count - 1 - i; j++) {

            if (strcmp((p + j)->name, (p + j +1)->name) > 0) {

                Student temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

}

//按成绩进行降序排序

void sortStudentDescByScore(Student *p,const int count)

{

    for (int i = 0; i < count - 1; i++) {

        for (int j =0; j < count - 1 - i; j++) {

            if ((p + j)->score > (p + j +1)->score) {

                Student temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

}

int main(int argc, const char * argv[])

{

    //指针与结构体的关系

    /*

    Student xiaoMing = {"doudou", 18, 90};

    printf("name = %s\n", xiaoMing.name);

    Student *p = &xiaoMing;

    //如何通过结构体指针变量访问结构体成员.

    printf("name = %s\n", p->name);

    printf("score = %.2f\n", p->score);

    printf("age = %d\n", (*p).age);

     */

    //指针与结构体数组之间的关系.

    

    Student stu[5] = {

        {"xiaohong", 20,100},

        {"xiaoming", 18,59.9},

        {"xiaopeng", 38,99},

        {"xiaomou", 60,10},

        {"xiaocai", 17,80},

    };

    Student *p = stu;

    //输出所有学生的信息

//    for (int i = 0; i < 5; i++) {

//        printf("name = %s age = %d score = %.2f\n", (p + i)->name, (p + i)->age, (p + i)->score);

//    }

    //按学生的年龄进行升序排序

    /*

    for (int i = 0; i < 5 - 1; i++) {

        for (int j = 0; j < 5 - 1 - i; j++) {

            if ((p + j)->age > (p + j + 1)->age) {

                Student temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

    for (int i = 0; i < 5; i++) {

        printf("name = %s age = %d score = %.2f\n", (p + i)->name, (p + i)->age, (p + i)->score);

    }

     */

    sortStudentAscByAge(stu,5);

    allStudentInfo(stu, 5);

    //按姓名进行升序排序

    for (int i = 0; i < 5 - 1; i++) {

        for (int j =0; j < 5 - 1 - i; j++) {

            if (strcmp((p + j)->name, (p + j +1)->name) > 0) {

                Student temp = *(p + j);

                *(p + j) = *(p + j + 1);

                *(p + j + 1) = temp;

            }

        }

    }

    

    

    

    

    /*

    printf("age = %d\n", (p + 3)->age);

    printf("name = %s\n", (*(p + 4)).name);

    //1.将xiaomou改成Duck

    strcpy((p + 3)->name, "Duck");

    printf("name = %s\n", (p + 3)->name);

    //2.将xiaoming的年龄改成50

    (p + 1)->age = 50;

    printf("age = %d\n", (p + 1)->age);

    //3.将xiaohong的成绩改成59.9

    p->score = 59.9;

    printf("score = %.2f\n", p->score);

    */

    

    

    

    /*

    //初始化,变量定义时赋值是初始化过程.

    int a = 20;

    //a = 30; //给变量重新赋值,不是初始化过程.

    int *p = &a;

    //1.直接访问

    printf("a = %d\n", a);

    //2.间接访问(通过地址)

    printf("a = %d\n", *p);

     */

    

    //定义两个变量,交换变量a与b的值.

    /*

    int a = 10;

    int b = 20;

     */

    /*

    int temp = a;

    a = b;

    b = temp;

     */

    /*

    a = a ^ b;

    b = a ^ b;

    a = a ^ b;

     */

    /*

     a = a ^ b;

     b = a ^ b;

     a = a ^ b;

     */

    /*

    int *p = &a;

    int *q = &b;

     */

    /*

    int *temp = 0;

    temp = p;

    p = q;

    q = temp;

    a = *p;

    b = *q;

     */

    /*

    swap(&a, &b);

    printf("a = %d, b = %d\n", *p, *q);

    */

    /**

     *  实参到形参的传递是一个拷贝的过程,传递有两种方式.

     1.传值:传递的是变量中的内容.函数内部改变不会影响外部的变量.

     2.传址:传递的是变量的地址.函数内部改变会影响外部的变量.

     */

    //求两个数的最大值.(传值)

    //求两个数的和.(传值)

    //给数组进行赋值.(传址)

    

    //指针与数组的关系

//    int a[10] = {0};

//    int b[10] = {0};

//    for (int i = 0; i < 10; i++) {

//        *(p + i) = arc4random() % (50 - 20 + 1) + 20;

//        printf("%d ", *(p + i));

//    }

//    printf("\n");

//    //降序排序

//    for (int i = 0; i < 10 - 1; i++) {

//        for (int j = 0; j < 10 - 1 - i; j++) {

//            if (*(p + j) < *(p + j + 1)) {

//                int temp = *(p + j);

//                *(p + j) = *(p + j + 1);

//                *(p + j + 1) = temp;

//            }

//        }

//    }

//    for (int i = 0; i < 10; i++) {

//        printf("%d ", *(p + i));

//    }

    //数组作为函数参数传递时,传递的是数组名,也就是数组的首地址.

//    assignArr(a, 10);

//    printf("\n");

//    sortArr(a, 10);

//    outputArr(a, 10);

    /*

    assignArr(b, 10);

    printf("\n");

    printf("maxValue = %d\n", maxValue(b, 10));

    printf("%d\n", b[0]);

    clearArr(b, 10);

    outputArr(b, 10);

     */

    //指针与字符数组(字符串)之间的关系

//    char str[] = "I l aoaa va eaa i aOaa Sa";

//    char *p = str;

//    *(p + 6) = '\0';

//    printf("%s\n", p + 2);

    //在一个已知的字符串中查找空格个数.(通过指针操作)

//    int count = 0;

//    int i = 0;

//    while (*(p + i) != '\0') {

//        if (*(p + i) == ' ') {

//            count++;

//        }

//        i++;

//    }

//    printf("count = %d\n", count);

//    int count = 0;

//    int i = 0;

//    while (*(p + i) != '\0') {

//        if (*(p + i) == ' ') {

//            count++;

//        }

//        i++;

//    }

//    printf("count = %d\n", count);

    /*

    int count1 = spaceCount(str);

    printf("count1 = %d\n", count1);

    int count2 = aCount(str);

    printf("count2 = %d\n", count2);

    printf("%s\n", str);

     */

//    char str[] = "fan test";

//    char *p1 = str;

//    p1++;       //p1的值改变了

//    (p1 + 1);   //p1的值没有改变

//    char *p2 = "fan test";

    //p1与p2的区别?p1指向str在栈区,内容可以通过p1更改readwrite(可读可写);p2指向常量区的字符串,内容不能通过p2更改readly(只读).

    

    //const 安全性

    //const 修饰的变量是read-only,只能读取数据,不能修改.

    /*

    const int a = 20, b = 5;

    int *p = &a;

    a = 30;

     */

//    int a = 20, b = 5;

    //const 面试题,请问const修饰的谁不可改变?

//    int去掉,const修饰谁谁不能变

    //p   是指针变量,存储地址.

    //*p  是指针变量存储的空间,也就是变量a的空间.

//    const int *p = &a;  //修饰*p

    //*p不可变,p可变,不能通过指针变量p修改指向空间的内容,但是指针变量p可以重新赋值,重指向.

//    a = 30;  //可以通过a修改

//    *p = 10;

//    p = &b;

//    int const *p = &a;  //修饰*p

    //*p不可变,p可变,不能通过指针变量p修改指向空间的内容,但是指针变量p可以重新赋值,重指向.

//    a = 30;  //可以通过a修改

//    *p = 10;

//    p = &b;

//    int * const p = &a;  //修饰p

    //*p可变,p不可变,能通过指针变量p修改指向空间的内容,指针变量p不可以重新赋值,重指向.

//    *p = 10;

//    p = &b;

//    const int * const p = &a;  //修饰*p以及p

    //*p不可变,p不可变,不能通过指针变量p修改指向空间的内容,指针变量p也不可以重新赋值,重指向.

//    *p = 10;

//    p = &b;

    

    

    //指针与结构体的关系

    

    

    

    

    

    

    return 0;

}