第十一天：指针初阶、结构体初阶

  今天学习的内容与往日相比增加了一点，不过理解起来还是不难的，我感觉知识的学习要高效的话，心理得是一种主动迎接的心态，不懂的东西去学习，如果没有这种心态的话，自己本身潜意识就是在抗拒知识的接受，心里会找很多理由来拒绝新学到的知识；今天也和往常一样学习，但是感觉今天有可能是因为学的多，也有可能是学过的知识重复讲所以心里会厌恶继续学下去，不过还是坚持了下来，争取及时克服种种心理。

指针初阶

指针变量

我们可以通过&（取地址操作符）取出变量的内存其实地址，把地址可以存放到一个变量中，这个变量就是指针变量

#include<stdio.h>


int main()

{

 int a = 10;//在内存中开辟一块空间

 int *p = &a;//这里我们对变量a，取出它的地址，可以使用&操作符。

    //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址
    //存放在p变量中，p就是一个之指针变量。

 return 0;

}

在32位的机器上，地址是32个0或者1组成二进制序列，那地址就得用4个字节的空间来存储，所以一个指针变量的大小就应该是4个字节。

那如果在64位机器上，如果有64个地址线，那一个指针变量的大小是8个字节，才能存放一个地址。

总结： 指针是用来存放地址的，地址是唯一标示一块地址空间的。

指针的大小在32位平台是4个字节，在64位平台是8个字节。

指针和指针类型

指针+-整数

#include <stdio.h>

//演示实例

int main()

{

 int n = 10;

 char *pc = (char*)&n;

 int *pi = &n;

 

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

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

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

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

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

 return  0;

}

总结：指针的类型决定了指针向前或者向后走一步有多大（距离）。

指针的解引用

//演示实例

#include <stdio.h>


int main()

{

 int n = 0x11223344;

 char *pc = (char *)&n;

 int *pi = &n;

 *pc = 0;   //重点在调试的过程中观察内存的变化。

 *pi = 0;   //重点在调试的过程中观察内存的变化。

 return 0;

}

总结：

指针的类型决定了，对指针解引用的时候有多大的权限（能操作几个字节）。

比如： char* 的指针解引用就只能访问一个字节，而 int* 的指针的解引用就能访问四个字节。

野指针

概念： 野指针就是指针指向的位置是不可知的（随机的、不正确的、没有明确限制的）

野指针成因

1. 指针未初始化

#include<stdio.h> 


int main()

{ 

    int *p;//局部变量指针未初始化，默认为随机值

    *p = 20;//非法访问 

 return 0;

}

2. 指针越界访问

#include <stdio.h>


int main()

{

    int arr[10] = {0};

    int *p = arr;

    int i = 0;

    for(i=0; i<=11; i++)

   {

        //当指针指向的范围超出数组arr的范围时，p就是野指针

        *(p++) = i;

   }

    return 0;

}

3. 指针指向的空间释放

如何规避野指针

1. 指针初始化

2. 小心指针越界

3. 指针指向空间释放及时置NULL

4. 避免返回局部变量的地址

5. 指针使用之前检查有效性

#include <stdio.h>
int main()

{

    int *p = NULL;

    //....

    int a = 10;

    p = &a;

    if(p != NULL) //检查有效性

   {

        *p = 20;

   }

    return 0;

}

指针运算

1.指针+-整数

#define N_VALUES 5

float values[N_VALUES];

float *vp;

//指针+-整数；指针的关系运算

for (vp = &values[0]; vp < &values[N_VALUES];)

{

     *vp++ = 0;

}

2.指针-指针

前提：两个指针指向同一块空间

int my_strlen(char *s)

{

       char *p = s;

       while(*p != '\0' )

              p++;

       return p-s;

}//指针减去指针等于指针间的元素个数

3 指针的关系运算

for(vp = &values[N_VALUES]; vp > &values[0];)

{

    *--vp = 0;

}
//优化简化，但是应该避免这样写，因为标准并不保证它可行。

for(vp = &values[N_VALUES-1]; vp >= &values[0];vp--)

{

    *vp = 0;

}

允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较。所以上述代码实际不允许。

指针和数组

#include <stdio.h>

int main()

{

    int arr[10] = {1,2,3,4,5,6,7,8,9,0};

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

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

    return 0;

}
//数组名和数组首元素的地址是一样的。

结论：数组名表示的是数组首元素的地址。

（2种情况除外，数组章节讲解了） 那么这样写代码是可行的：

int arr[10] = {1,2,3,4,5,6,7,8,9,0};

int *p = arr;//p存放的是数组首元素的地址
int i = 0;
for (i = 0; i < 10; i++)
{
    //printf("%p <==> %p", &arr[i], p + i);//两个值是一样的
    *(p + i) = i;
}

二级指针

对于二级指针的运算有：

*ppa 通过对ppa中的地址进行解引用，这样找到的是 pa ， *ppa 其实访问的就是 pa .

**ppa 先通过 *ppa 找到 pa ,然后对 pa 进行解引用操作： *pa ，那找到的是 a .

int b = 20;
int* pa = &a; //pa是指针变量，一级指针
//ppa就是一个二级指针

int* *ppa = &pa;//pa、也是变量，&pa取出pa在内存中的起始地址

指针数组

指针数组是指针还是数组？

答案：是数组。是存放指针的数组。

数组我们已经知道整形数组，字符数组。

int* parr[5];//整型指针数组

结构体初阶

结构是一些值的集合，这些值称为成员变量。结构的每个成员可以是不同类型的变量。

结构的声明

struct tag

{

 member-list;

}variable-list;

例如描述一个学生：

typedef struct Stu

{

 char name[20];//名字

 int age;//年龄

 char sex[5];//性别

 char id[20];//学号

}Stu；//分号不能丢

结构的成员可以是标量、数组、指针，甚至是其他结构体。

结构体变量的定义和初始化

struct Point

{

 int x;

 int y;

}p1; //声明类型的同时定义变量p1


struct Point p2; //定义结构体变量p2

//初始化：定义变量的同时赋初值。
struct Point p3 = {x, y};

 

struct Stu        //类型声明

{

 char name[15];//名字

 int age;      //年龄

};


struct Stu s = {"zhangsan", 20};//初始化


struct Node

{

 int data;

 struct Point p;

 struct Node* next; 

}n1 = {10, {4,5}, NULL}; //结构体嵌套初始化


struct Node n2 = {20, {5, 6}, NULL};//结构体嵌套初始化

结构体成员的访问

结构变量的成员是通过点操作符（.）访问的。点操作符接受两个操作数

struct S s;

strcpy(s.name, "zhangsan");//使用.访问name成员

s.age = 20;//使用.访问age成员

结构体指针访问指向变量的成员

struct Stu

{

 char name[20];

 int age;

};

void print(struct Stu* ps)

{

 printf("name = %s   age = %d\n", (*ps).name, (*ps).age);

    //使用结构体指针访问指向对象的成员

 printf("name = %s   age = %d\n", ps->name, ps->age);

}


int main()

{

    struct Stu s = {"zhangsan", 20};

    print(&s);//结构体地址传参

    return 0;

}

结构体传参

struct S

{

 int data[1000];

 int num;

};

struct S s = {{1,2,3,4}, 1000};


//结构体传参

void print1(struct S s)

{

 printf("%d\n", s.num);

}


//结构体地址传参

void print2(struct S* ps)

{

 printf("%d\n", ps->num);

}


int main()

{

 print1(s);  //传结构体

 print2(&s); //传地址

 return 0;

}

上面的 print1 和 print2 函数哪个好些？

答案是：首选print2函数。

原因： 函数传参的时候，参数是需要压栈的。 如果传递一个结构体对象的时候，结构体过大，参数压栈的的系统开销比较大，所以会导致性能的下降。

结论： 结构体传参的时候，要传结构体的地址。