【C语言基本知识——指针和结构体】

指针

指针是什么？

在计算机科学中，指针是编程语言中的一个对象，利用地址，他的值直接指向存在电脑存储器另一个地方的值，由于用过地址能找到所需的变量单位，可以说地址指向该单元，因此，将地址形象化的称为指针，意思也就是通过他能找到以他为地址的内存单元

指针就是一个变量，存放内存单元的地址(编号)

#include <stdio.h>
int  main()
{
  int a = 10;//在内存中开辟一块空间
  int* p = &a;//这里我们对变量a，取出其地址，使用&
  //将a的地址存放在p的变量中，p就是一个指针变量
  return 0;
}

总结 ：指针就是变量，用来存放地址的变量(存放在指针中的值都被当成地址处理)

• 一个小的单元有多大？ (一个字节)

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

• 指针是用来存放地址的，地址就是唯一标示一块地址空间的

• 指针的大小在32平台上是4个字节，在64平台上就是8个字节

指针和指针类型

指针类型决定了指针进行解引用操作的时候能够访问空间的大小

指针类型	访问空间的大小
int* p	*p能够访问4个字节的大小
char* p	*p能够访问1个字节的大小
double* p	*p能够访问8个字节的大小

指针类型	指针走一步走多远
int* p	p+1–>4
char* p	p+1–>1
double* p	p+1–>8

野指针

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

1. 指针的初始化

#include <stdio.h>
int main()
{
  int a;
  int* p;
  *p = 20;
  return 0;
}
//局部变量初始化，默认是随机值，局部的指针变量初始化，默认也是随机值

2. 指针的越界访问

#include <stdio.h>
int main()
{
  int arr[10] = {0};
  int* p = arr;
  for(int i = 0;i < 12;i++)
  {
    *(p+1) = i;
  }
  return 0;
}
//当指针指向的范围超出arr数组的范围是，p就是野指针

3. 指针指向的空间释放

具体后面动态内存说明

如何规避野指针

1. 指针的初始化
2. 小心指针越界
3. 指针指向的空间是释放即使置NULL
4. 指针使用之前检查有效性

指针运算

指针±整数

#include <stdio.h>
int main()
{
  int arr[10] = {1,2,3,4,5,6,7,8,9,10};
  int i = 0;
  int sz = sizeof(arr)/sizeof(arr[0]);
  int* p = arr;
  for(i = 0;i < sz;i++)
  {
    printf("%d\t",*p);
    p+=1;
  }
  return 0;
}

指针-指针

//strlen-求字符串的长度
#include <stdio.h>
int my_strlen(char* str)
{
  char* start = str;
  char* end = str;
  while(*end != '\0')
  {
    end++
  }
  return end-start
}
int main()
{
  char arr[] = "bit";
  int len = my_strlen(arr);
  printf("%d\n",len);
  return 0;
}

指针的关系运算

//一个数组的比较
#define VALUE 5
#include <stdio.h>
int main()
{
  float values[VALUE];
  float* vp;
  for(vp = &values[VALUE];vp > &values[0];)
  {
    *--vp = 0;
  }
}
//标准规定：允许指向数组元素的指针与指向数组最后一个元素后面的那个内存位置的指针比较，但是不允许与指向第一个元素之前的那个内存位置的指针进行比较

指针和数组

#include <stdio.h>
int main()
{
  int arr[10] = {1,2,3,4,5}
  printf("%p\n",arr);
  printf("%p\n",arr+1);
  printf("%p\n",&arr[0]);
  printf("%p\n",&arr[0]+1);
  printf("%p\n",&arr);
  printf("%p\n",&arr+1);
  return 0;
}
//1.&arr ——&数组名，数组名就不是瘦元素的地址，取出来的就是整个数组的地址
//2.sizeof(arr) ——sizeof(数组名)，这个时候计算的就是整个数组的大小

二级指针

#include <stdio.h>
int main()
{
  int a = 10;
  int* pa = &a;
  int* *ppa = &pa;
}
//a的地址存放在pa中，pa的地址存放在ppa中，pa是一级指针，ppa是二级指针

指针数组

int* arr[5];

结构体

结构体类型的声明

结构体的基本知识

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

结构的声明

struct tag
{
  member-list;
}variable-list

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

结构体定义和初始化

//eg:描述一个学生
typeof struct Stu
{
  char name[20];
  int age;
  char sex[5];
  char id[20];
}Stu;

int  main()
{
  Stu s1 = {"张三",20,"143567853345","男"};
  struct Stu s2 = {"旺财",18,"18729723287","保密"};
  
}

//typeof是重新给这个结构体命名，在函数创建当中就会简单一些，Stu就是新的结构体的名字，两者都可以用，只是这个要更简洁一些

struct S
{
  int a;
  char c;
  char arr[20];
  double d;
};

struct T
{
  char ch[10];
  struct S s;
  char *pc;
};

int main()
{
  char arr[] = "hello\n";
  struct T t = {"hehe",{100,'w', "hello world",3.14,},arr};
  printf("%s\n",t.ch);
  printf("%s\n",t.s.arr);
  printf("%lf\n",t.s.d);
  printf("%s\n",t.pc);

  return 0;
}

结构体成员的访问

• 结构体变量访问成员，结构变量的成员是通过点操作符(.)访问的，点操作符接受两个操作数

• 结构体变量访问成员，结构变量的成员是通过点操作符(->)访问的，点操作符接受两个操作数

结构体传参

//eg:描述一个学生
typeof struct Stu
{
  char name[20];
  short age;
  char tele[15];
  char sex[5];
}Stu;

void Print1(Stu temp)
{
  printf("name: %s\n",temp.name);
  printf("age: %d\n",temp.age);
  printf("tele: %s\n",temp.tele);
  printf("sex: %s\n",temp.sex);
}

void Print2(stu* ps)
{
  printf("name: %s\n",temp->name);
  printf("age: %d\n",temp->age);
  printf("tele: %s\n",temp->tele);
  printf("sex: %s\n",temp->sex);
}

int main()
{
  Stu s = {"李四",40,"155937559","男"};
  Print1(s);
  Print2(&s);
  return 0;
}

函数在传参的时候，参数是需要压线的，如果传递一个结构体对象的时候，结构体过大，参数压线的系统开销过大，所以就会导致性能下降。结构体传参的时候，要传结构体的地址。

栈区	堆区	静态区
局部变量，函数的形式参数，函数的调用开辟空间	动态内存的分配，malloc/free realloc calloc	全局变量，静态变量