C语言 12 指针初阶

#define _CRT_SECURE_NO_WARNINGS 1
#include <stdlib.h>
#include <time.h>
#include <string.h>
#include <stdio.h>
#include <limits.h>
#include <ctype.h>
#include <math.h>

int main()
{
  int* p;//创建一个指针变量
  int a = 10;//创建一个a变量 向内存中的栈区空间申请4个字节的空间 这4个字节用来存放10这个数值
  //在内存中开辟一块空间
    //内存中每个字节都是地址
  int *pa = &a;//这里我们对变量a，取出它的地址，可以使用&操作符，表示pa指向的是a，a的类型是int
  //a变量占用4个字节的空间，这里是将a的4个字节的第一个字节的地址存放在p变量中，p就是一个指针变量 
  //存放在指针变量中的值都会被当作地址处理
  *pa = 0x00112233;
  return 0;
}

int main()
{
  int a = 10;
  int* pa = &a;
  *pa = 20;
  printf("a = %d\n", a);
  return 0;
}

int main()
{
  printf("%d\n", sizeof(char*));
  printf("%d\n", sizeof(short*));
  printf("%d\n", sizeof(int*));
  printf("%d\n", sizeof(double*));
  //只要是指针变量，大小都只能是：x86是4，x64是8
  //指针的类型不同类型的指针用于存放不同类型的变量
  return 0;
}

int main()
{
  int a = 0x11223344;
  int* pa = &a;
  printf("%d\n", *pa);
  *pa = 0;
  printf("%d\n", *pa);
  return 0;
}

int main()
{
  int a = 0x11223344;
  char* p = &a;//类型有警告
  char* p = (char*) & a;
  //*p = 0;
  printf("%d", *p);
  return 0;
}  //指针类型是有意义的，指针类型决定了指针进行解引用操作的时候，访问几个字节
int* 4个字节 char* 1个字节 short* 2个字节

int main()
{
  int a = 0;
  int* pa = &a;
  char* pc = (char*) & a;
  printf("pa = %p\n", pa);
  printf("pa+1=%p\n", pa + 1); //int *+1类型跳过4个字节 因为是int*类型
  printf("pc = %p\n", pc);
  printf("pc+1=%p\n", pc + 1);//char *类型+1跳过1个字节 因为是char*类型
  return 0;
}

int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%d\n", arr[5]);
  double l = 11.4;
  double* pa = &l;
  printf("%p\n", *pa);
  printf("%p\n", *pa + 1);
  return 0;
 }

int main()
{
  int arr[10] = { 0x11223344,0x11223344,0x11223344,0x11223344,0x11223344,
    0x11223344,0x11223344,0x11223344,0x11223344,0x11223344 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *p = 0;
    p++;
  }
  return 0;
}

int main()
{
  int* p = (int*)0x11223344;
  *p;//随机找了个地址，没有确定目标对象
  return 0;
}

int main()
{
  int* p;//使用了未初始化的指针 当一个变量不进行初始化的时候 给的地址是随机值 随机值不能作为一个地址
  *p = 10;
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 11; i++)
  {
    *p = -1;
    p++;
  }
  return 0;
}

int* test()
{
  int a = 48; //局部变量，有自己的地址
  return &a;
}
int main()
{
  //0x0012ff40
  int* p = test();
  //*p是野指针 非法访问
  printf("%d\n", *p);//返回了地址，但是占空间回收了，所以p是野指针，一旦访问就是非法访问
  printf("%p\n", &p);
  return 0;
}

int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  //使用指针打印数组的内容
  int* p = arr;//数组首元素的地址
  //arr -> p
  //arr == p
  //arr+i == p+i
  //*(arr+i) == *(p+i) == arr[i]
  //*(arr+i) == arr[i]
  //*(i+arr) == i[arr] 数组括号内括号外两元素可以省略
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", *(p + i));//整形指针一次跳过一个元素
    printf("%d ", i[arr]);//数组名是首元素的地址，当知道首元素地址时，可以访问数组所有元素
    printf("%d ", arr[i]);
    printf("%d ", *(arr + i));
    printf("%d ", *(p + i));
    //以上五种方法，本质是通过首元素的地址加上偏移量，找到数组中的内容
    //指针+-整数：通过首元素地址加减偏移量，找到数组中的元素 
    //指针+-整数：指针的关系运算
    //p指向的是数组首元素的地址
    //p+i指向的是数组中下标为i的元素的地址
  }
  return 0;
}

int main()
{
  float values[N_VALUES];
  float* vp;
  for (vp = &values[0]; vp < &values[N_VALUES];)//指针的关系运算
  {
    *vp++ = 0;//指针加减整数
  }
  for (vp = &values[N_VALUES]; vp > &values[0];)//指针的关系运算
  {
    --vp = 0;//指针加减整数
  }
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  //指针-指针的前提是两个指针类型必须相同，两个指针指向同一块区域
  //指针-指针得到的是指针和指针之间的元素个数
  printf("%d\n", &arr[9] - &arr[0]);//指针-指针
  printf("%d\n", &arr[0] - &arr[9]);//小地址减去大地址
  return 0;
}

size_t my_strlen(char* str)
{
  char* start = str;
  while (*str != '\0')//'\0'是一个字符 while(*str)
  {
    str++;
  }
  return str - start;//指针-指针
}
int main()
{
  char arr[] = "abcdef";
  size_t len = my_strlen(arr);
  printf("%zd\n", len);
  return 0;
}

int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  printf("%p\n", arr);
  printf("%p\n", &arr[0]);
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  printf("%p\n", arr);//int*
  printf("%p\n", arr + 1);//跳过4个字节
  printf("%p\n", &arr[0]);//int*
  printf("%p\n", &arr[0] + 1);//跳过4个字节
  printf("%p\n", &arr);//类型不同，所以+1操作跳过字节数不同
  printf("%p\n", &arr + 1);
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%p === %p\n", arr + i, p + i);//两地址相同
  }
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    *(p + i) = i;
  }
  for (i = 0; i < 10; i++)
  {
    printf("%d ", *(arr + i));
  }
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  int* p = arr;
  p++;
  return 0;
}

int main()
{
  int a = 10;
  int* p = &a;//p是指针变量，也叫一级指针变量
  int** pp = &p;//pp是指针变量，也叫二级指针变量
    //int *是类型 p是指针变量
  int*** ppp = &pp;//ppp是指针变量，也叫三级指针变量
  printf("%p\n", p);
  printf("%p\n", *p);
  printf("%p\n", pp);
  printf("%p\n", *(*pp));
  printf("%p\n", ppp);
  printf("%p\n", *(*(*ppp)));//解引用a
  printf("%d\n", *(*(*ppp)));//a = 10;
  return 0;
}

int main()
{
  //使用指针数组，模拟一个二维数组
  int arr1[] = { 1,2,3,4,5 };
  int arr2[] = { 2,3,4,5,6 };
  int arr3[] = { 3,4,5,6,7 };
  //指针数组
  int* arr[] = { arr1,arr2,arr3 };
  int i = 0;
  for (i = 0; i < 3; i++)
  {
    int j = 0;
    for (j = 0; j < 5;j++)
    {
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
  return 0;
}