C语言(指针)

//  main.m

//  1-22课堂笔记

// 讲师: 小辉

// 笔者: 王学文

//  Created by lanouhn on 15/1/22.

//  Copyright (c) 2015年 lanouhn. All rights reserved.

// pointer(指针)

 

#import <Foundation/Foundation.h>

 

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

    /*

    //指针:地址编号(类似于门牌号)

    int a = 10;

    //用&(取地址符号)来获取变量所分配内存的首地址编号

    

    printf("%p\n", &a);

    

    //指针变量:用于存储地址编号的变量

    //定义格式

    //数据类型 + 变量名 = 初值;

    //注: 数据类型决定*p去内容是,取多少字节

    

    //整形指针变量

    //在定义指针变量时,*告诉编译器,这是一个指针变量

    int *p = NULL;

    printf("%p\n", p); //0x0

    

    p = & a;

    

    //直接访问: 通过变量a获取内存中的数据

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

    

    //间接访问: 通过指针p获取内存中的数据

    //通过内存地址编号,找到内存,用*取出内存中的数据

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

    */

    

    //当指针变量别重新赋值,意味着指针重定向

//    int a = 10, b = 5;

//    int *p1 = &a;

//    int *p2 = &b;

//    p1 = p2;

//    printf("%d\n", *p1);

    

//    int a = 15, b = 10;

//    int * x = &a;

//    int * y = &b;

//    *x = 11;

//    int *p = &a;

//    p = y;

//    *y = 8;

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

    

//    int a = 4, b = 8, c = 10;

//    int * x = &a;

//    x = &c;

//    int *y = &b;

//    int *z = &c;

//    *z = 5;

//    *x = 12;

//    x = y;

//    *y = *z + *x;

//    printf("a: %d, b: %d, c: %d\n", a, b, c);

    

    

    //内存地址编号比较低的存储单元 有操作系统控制,不允许访问

//    int *p =NULL;

//    *p = 100; //error

    

    //2. 野指针, 定义指针变量没有赋初值

    

//    int *p;

//    *p = 5;

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

 

    //3.指针变量定义时, *怎么写

//    int *p1 = NULL;//推荐

//    int* p2 = NULL;

//    int*p3 = NULL;

//    int * p4 = NULL;

    

    //指针变量所占的字节数

    //1. 与数据类型无关

    //2. 与操作系统的尾数有关, 32位下指针变量站4字节, 64位下指针变量占8字节

    /*

    printf("%lu\n", sizeof(char *));

    printf("%lu\n", sizeof(short *));

    printf("%lu\n", sizeof(int *));

    printf("%lu\n", sizeof(long *));

    printf("%lu\n", sizeof(float *));

    

    int a = 130;

    char *p = &a;

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

    

    //位运算

    

    //&: 按位与

    //同1为1,否则为0

    printf("%d\n", 9 & 5);

    

    // | : 按位或

    //同0为0, 否则为1

    printf("%d\n", 9 | 5);

    

    //^ 按位异或

    //不同为1, 相同为0

    printf("%d\n", 9 ^ 5);

    

    //~: 取反

    // 1变0, 0变1

    printf("%d\n", ~9);

    

    //<< : 左移

    //向左移动,高位丢弃,地位补0

    printf("%d\n", 3 << 4);

    

    //右移

    //向右移动, 符号位也移动,正数高位补0,负数高位补1;

    printf("%d\n", 16 >> 3);

    

    //注: 按位与, 按位或, 按位异或要求参与运算的数以 补码 形式 出现;

    

    //原码: 是本身

    

    //反码:

    //1. 正数的反码是它本身

    //2. 负数的反码是符号位不变,数值部分取反

    

    //补码:

    //数据是以补码的形式存储到内存中

    //1. 正数补码是他本身

    //2. 负数的补码: 符号位不变, 数值部分取反再加1

    

    

    //数组在内存中是连续存储的

    int  array[5] = {1, 2, 3, 4, 5};

    

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

        printf("%p\n", &array[i]);

    }

    

    //数组名字, 其实就是数组的首地址

    //array 恒等于 & array[0]

    printf("%p\n", array);

    printf("%p\n", &array[0]);

    

    int *p = array;

    printf("%d\n", array[1]);

    printf("%d\n", p[1]);

    printf("%d\n", *(p + 1));

    printf("%d\n", *(array + 1));

    printf("%d\n", *(1 + array));

    printf("%d\n", 1[array]);

    

    

    //指针运算

    //数据变量的数据类型还决定了 指针进行加1操作 跳转几个字节

    int *p1 = NULL;

    printf("%p\n", p1);

    printf("%p\n", p1 + 1);

  

    

    int array[5] = {1, 2, 3, 4, 5};

    int *p = array;

    *(p++) = 3;

    *p = 5;

    *(p + 1) = 8;

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

        printf("%d", array[i]);

    }

    printf("\n");

     

    

    //p + 1

    //p++ 或者 ++p

    //相同: 取到的都是下一个元素的首地址

    //不同: ++p 或者 p++, 会让指针重定向

    

    int array[5] = {1, 2, 3, 4, 5};

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

//        printf("%d", array[i]);

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

    } printf("\n");

    

    //有10个元素的数组, 随机赋值,取值范围[22, 33]

    int arr[10] = {0};

 

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

        *(arr + i) = arc4random() % 12 + 22;

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

    } printf("\n");

    BOOL flag = YES;

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

        flag = NO;

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

            

            if ((*(arr + j) > *(arr+ j + 1))) {

                int temp = *(arr + j);

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

                *(arr + j +1) = temp;

                flag = YES;

            }

        }

    }

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

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

    }

    printf("\n");

    */

    

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

//    int *p = array;

    

    //数组的名字(数组的首地址) 和 指向数组首地址的指针变量 的区别

    //1. 数组名(数组首地址)是一个常量地址, 不能够修改

//    int a = 5;

//    array = &a;

 

    //2. sizeof(), 如果是数组名(数组首地址), 计算的是数组所占的字节数; 如果是指针变量, 计算的是指针变量所占的字节数

//    printf("%lu\n", sizeof(array));

//    printf("%lu\n", sizeof(p));

 

    

    //指针与字符串

    

    //字符数组

    //字符串

    //字符串数组

    

//    char string[] = "iphone";

//    printf("%s\n", string);

//    printf("%s\n", string + 3);

    

//    char string[] = "I LOVE U!";

//    *(string + 1) = '\0';

//    *(string + 7) = '\0';

//    printf("%s\n", string);

//    printf("%s\n", string + 3);

//    printf("%s\n", string + 7);

//    printf("%s\n", string + 8);

    

    

//    char string[] = "iPhone";

//    *(string + 1) = 'p';

//    char str[] = "HAHA"; //数组名是常量地址, 不能够重定向

//    string = str; 

    

    

    char *p = "iPhone";

//    *(p + 1) = 'p'; //p指向常量区, 常量区的内容不能够修改

    p = "HAHA";

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

    

 

 

return 0;

}

 

转载于:https://www.cnblogs.com/xiaoxuetongxie/p/4242688.html