【黑马程序员】iOS学习之路——C语言之指针

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ -------

一、学前准备

1.指针的重要性

指针是C语言中非常重要的数据类型，如果你说C语言中除了指针，其他你都学得很好，那你干脆说没学过C语言。

2.小需求

void change(int  n)函数调用完毕后，改变实参的值

分析：修改实参的值->找到存储空间->地址

#include 

void change(int *n);

int main()
{
    int a = 90;
    
    printf("a = %d\n", a);

    change(&a);
    
    printf("a = %d\n", a);
    
    return 0;
}

void change(int *n)
{
    *n = 10;
}

 二、指针变量的定义

1.定义的格式
类名标识符 *指针变量名
int *p;
2.先定义后赋值

//简单取值
int a = 10;
int *p;
p = &a;
printf(“%d”, *p);



//简单改值
*p = 9;

3.定义的同时赋值

int a = 10;
int *p = &a;


 4.举例

    // 变量类型  变量名;
    // 格式：变量类型 *变量名;
    // 定义了一个指针变量p
    // 指针变量只能存储地址
    // 指针就一个作用：能够根据一个地址值，访问对应的存储空间
    // 指针变量p前面的int：指针变量p只能指向int类型的数据
    int *p;
    
    int a = 90;
    
    // 指针变量p指向了变量a
    p = &a;
    
    *p = 10;

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

 5.清空指针

    p = 0;
    p = NULL;


 6.指针的练习

#include 
void swap(int *v1, int *v2);

int main()
{
    /*
    int a = 10;
    int b = 11;
    
    swap(&a, &b);
    */
    
    
    int a2 = 90;
    int b2 = 89;
    
    swap(&a2, &b2);
    
    printf("a2=%d, b2=%d\n", a2, b2);
    return 0;
}

/* 不能交换外面实参的值，仅仅是交换了内部指针的指向
void swap(int *v1, int *v2)
{
    int *temp;
    temp = v1;
    v1 = v2;
    v2 = temp;
}*/

// 完成两个整型变量值的互换
void swap(int *v1, int *v2)
{
    int temp = *v1;
    *v1 = *v2;
    *v2 = temp;
}

/* 交换的只是内部v1、v2的值
void swap(int v1, int v2)
{
    int temp = v1;
    v1 = v2;
    v2 = temp;
}*/

 三、指针的探究


1.    指针变量所占用的存储空间
任何指针都占用8个字节的存储空间

2.    为何指针变量要分类型？
不用类型的指针，读取内存的大小不同
四、指针与数组
1.指向一维数组的指针

    int ages[5] = {10, 9, 8, 67, 56};
    
    int *p;
    // 指针变量p指向了数组的首元素
    p = &ages[0];
2.用指针遍历一维数组的元素

    
    int ages[5] = {10, 9, 8, 67, 56};
    
    int *p;
    // 指针变量p指向了数组的首元素
    p = &ages[0];
    // 数组名就是数组的地址，也是数组首元素的地址
    //p = ages;
    
    /*
     p ---> &ages[0]
     p + 1 ---> &ages[1]
     p + 2 ---> &ages[2]
     p + i ---> &ages[i]
     */
    
    //printf("%d\n",  *(p+2));
    
    printf("%d\n",  p[2]);
    
    
    for (int i = 0; i<5; i++) {
     	printf("ages[%d] = %d\n", i, *(p+i));
    }
3.指针访问数组元素

    1.数组元素的访问方式
 	int ages[5];
 	int *p;
 	p = ages;
    1> 数组名[下标]  ages[i]
    2> 指针变量名[下标] p[i]
    3> *(p + i)
 
    2.指针变量+1，地址值究竟加多少，取决于指针的类型
      int *   4
      char *  1
      double * 8
五、指针与字符串
1.字符串回顾

char s[] = “mj”;
2.利用指针定义字符串

char *s = “mj”;
或者
char *s;
s = “mj”;
3.两种定义方式的比较

 定义字符串的2种方式
 1> 利用数组
 char name[] = "itcast";
  * 特点：字符串里面的字符是可以修改的
  * 使用场合：字符串的内容需要经常修改
 
 2> 利用指针
  char *name = "itcast";
  * 特点：字符串其实是一个常量字符串，里面的字符是不能修改
  * 使用场合：字符串的内容不需要修改，而且这个字符串经常使用
4.举例

#include 

int main()
{
    char name[20];
    
    printf("请输入姓名：\n");
    
    scanf("%s", name);
    
    // 'j' 'a' 'c' 'k' '\0'
    
    //printf("%c\n", name[3]);
    
    //printf("刚才输入的字符串是：%s\n", name);
    
    return 0;
}

// 定义字符串数组
void test2()
{
    char *name = "jack";
    
    //int ages[5];
    
    // 指针数组（字符串数组）
    char *names[5] = {"jack", "rose", "jake"};
    
    // 二维字符数组（字符串数组）
    char names2[2][10] = {"jack", "rose"};
}

// 定义字符串
void test()
{
    // 字符串变量
    char name[] = "it";
    name[0] = 'T';
    
    //printf("%s\n", name);
    
    
    // "it" == 'i' + 't' + '\0'
    // 指针变量name2指向了字符串的首字符
    
    // 字符串常量
    char *name2 = "it";
    
    char *name3 = "it";
    
    //*name2 = 'T';
    
    //printf("%c\n", *name2);
    
    printf("%p\n%p\n", name2, name3);
    
    //printf("%s\n", name2);
}
5.练习

#include 
/*
 (不包括\0)
 编写一个int string_len(char *s)，返回字符串s的字符长度
 
 */
int string_len(char *s);

int main()
{
    //char *name = "itcast";
    
   // 男 \u434\u4343\u434
    
    int size = string_len("tre777");
    
    printf("%d\n", size);
    return 0;
}

int string_len(char *s)
{
    // 1.定义一个新的指针变量指向首字符
    char *p = s;
    
    /*
    while ( *s != '\0' )
    {
        s++;
    }*/
    
    while ( *s++ ) ; 
    
    return s - p - 1;
}
六、返回指针的函数


指针也是C语言中的一种数据类型，因此一个函数的返回值肯定可以是指针类型的
返回指针的函数的一般形式为：类型名 * 函数名(参数列表)

#include 
char *test();

/*
 只要求能看懂
 */

int main()
{
    char *name = test();
    
    printf("name=%s\n", name);
    
    return 0;
}

char *test()
{
    return "rose";
}

 七、指向函数的指针
1.为什么指针可以指向一个函数
函数作为一段程序，在内存中也要占据部分存储空间，它也有一个起始地址，即函数的入口地址。函数有自己的地址，那就好办了，我们的指针变量就是用来存储地址的。因此，可以利用一个指针指向一个函数。其中，函数名就代表着函数的地址。
 2.指向函数指针的定义
定义的一般形式：函数的返回值类型 (*指针变量名)(形参1, 形参2, ...);
3.使用注意
由于这类指针变量存储的是一个函数的入口地址，所以对它们作加减运算(比如p++)是无意义的
指向函数的指针变量主要有两个用途：
4.举例

#include 


double haha(double d, char *s, int a)
{
    
}

/*
 掌握：
 1.看懂语法
 2.定义指向函数的指针
    double (*p)(double, char *, int);
    p = haha;
    或者
    double (*p)(double, char *, int) = haha;
 3.如何间接调用函数
 1> p(10.7, "jack", 10);
 2> (*p)(10.7, "jack", 10);
 */

void test()
{
    printf("调用了test函数\n");
}

int sum(int a, int b)
{
    return a + b;
}

int main()
{
    // 定义指针变量指向sum函数
    // 左边的int：指针变量p指向的函数返回int类型的数据
    // 右边的(int, int)：指针变量p指向的函数有2个int类型的形参
    int (*p)(int, int);
    
    p = sum;
    
    //int c = p(10, 11);
    
    //int c = (*p)(10, 11);
    
    int c = sum(10, 9);
    
    printf("c is %d\n", c);
    
    
    return 0;
}


void test1()
{
    // (*p)是固定写法，代表指针变量p将来肯定是指向函数
    // 左边的void：指针变量p指向的函数没有返回值
    // 右边的()：指针变量p指向的函数没有形参
    void (*p)();
    
    // 指针变量p指向了test函数
    p = test;
    
    p();
    //(*p)(); // 利用指针变量间接调用函数
    
    //test(); // 直接调用函数
}