C语言 13 指针进阶 壹

#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()
{
  char ch = 'w';
  char* pc = &ch;
  char arr[] = "abcdef";
  const char* p = "abcdef";
  printf("%p\n", p);
  char* p1 = arr;//数组的地址
  char* p2 = &arr[0];//数组首元素的地址
  printf("%p\n", p1);//000000906378FAD4
  printf("%p\n", p2);//000000906378FAD4
  printf("%c\n", "abcdef"[3]);//d 想象成地址，访问数组中下标为3的元素
  //首字符a的地址赋给了p
  return 0;
}

int main()
{
  char str1[] = "hello bit.";
  char str2[] = "hello bit.";
  const char* str3 = "hello bit.";//const+变量：该变量里的数据只能被访问，不能被修改，意味只读
  const char* str4 = "hello bit.";
  if (str1 == str2)//not same 两个数组地址不相同
    printf("same\n");
  else
    printf("not same\n");
  if (str3 == str4)//same 两个常量字符串比较 常量字符串不能被修改 内容相同时，只会保存一份
    printf("same\n");
  else
    printf("not same\n");
  if (&str3 == &str4)//no
    printf("same\n");
  else
    printf("not same\n");
  return 0;
}

int main()
{
  int a = 1;
  int b = 2;
  int c = 3;
  int d = 4;
  //不会这样使用
  int* arr[] = { &a,&b,&c,&d };
  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* int* int*
  int *arr[] = { arr1,arr2,arr3 };
  for (int i = 0; i < 3; i++)
  {
    for (int j = 0; j < 5; j++)
    {
      printf("%d ", arr[i][j]);//通过访问数组下标来访问每一个元素
    }
    printf("\n");
  }
  return 0;
}

int main()
{
  //指针数组的应用场景之一
  const char* arr[5] = { "hello bit ","hehe ","zezeze ","ijij ","666 " };
  for (int i = 0; i < 5; i++)
  {
    printf("%s\n", arr[i]);
  }
  return 0;
}

int main()
{
  int a = 10;
  int* p1 = &a;
  char ch = 'c';
  char* p2 = &ch;
  float f = 3.14;
  float* p3 = &f;
  return 0;
}

int main()
{
  int arr[10];
  printf("arr:  %p\n", arr);
  printf("arr+1:%p\n", arr+1);
  printf("\n");
  printf("&arr:  %p\n", &arr);//它们的值相同
  printf("&arr+1:%p\n", &arr+1);//它们的值相同
  printf("\n");
  printf("&arr[0]:  %p\n", &arr[0]);
  printf("&arr[0]+1:%p\n", &arr[0]+1);
  //指针类型决定了指针+1，到底+几个字节
  return 0;
}

int main()
{
  int arr[10] = { 0 };
  //数组指针的写法:
  int (*p)[10] = &arr;//p是用来存放数组的地址的，p就是数组指针
  //eg、1
  char* arr1[5];
  char* (*pc)[5] = &arr1;
  //eg、2
  int* arr2[7];
  int* (*p)[7] = &arr2;
  return 0;
}

int main()
{
  //法1：
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int(*p)[10] = &arr;
  for (int i = 0; i < 10; i++)
  {
    printf("%d ", (*p)[i]);
  }
  return 0;
}

int main()
{
  //法2: 一维数组正确访问方式：
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = arr;
  int i = 0;
  for (i = 0; i < 10; i++)
  {
    printf("%d ", p[i]);
  }
  return 0;
}

void print(int arr[3][5], int r, int c)
 //       (int (*P)[5],int r,int c) 二维数组传参 形参的部分写的是指针
{
  for (int i = 0; i < 3; i++)
  {
    for (int j = 0; j < 5; j++)
    {
      printf("%d ", arr[i][j]);
    }
    printf("\n");
  }
}
int main()
{
  int arr[3][5] = { {1,2,3,4,5},{2,3,4,5,6},{3,4,5,6,7} };
  print(arr, 3, 5);//数组名，行数，列数 二维数组传参
  return 0;//arr是二维数组的数组名，是首元素的地址，
 //二维数组首元素的地址是第一行的地址，第一行的地址是第一行首元素的地址
}

void print(int *arr, int sz)//形式参数指针的形式 本质是指针
 //void print(int arr[], int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", arr[i]);//arr[i]===>*(arr+i)
  }
}
int main()
{
  int arr[] = { 1,2,3,4,5,6,7,8,9,10 };
  int sz = sizeof(arr) / sizeof(arr[0]);
  print(arr, sz);
    //一维数组传参
  return 0;
}

int arr[5];//arr是一个能够存放5个整形数据的数组
int* parr1[10];//parr1是一个数组，数组10个元素，每个元素的类型是int*
int(*parr2)[10];//parr2是一个数组指针，该指针指向数组，指向的数组有10个元素，每个元素的类型是int
int(*parr3[10])[5];//parr3是一个数组，是存放数组指针的数组，存放的这个数组指针，指向的数组有5个元素，每个元素是int类型

void test(int arr[])
{}y
void tst(int arr[10])
{}y
void test(int* arr)
{}y
void test2(int *arr[20])
{}y
void test2(int **arr)//传过去一级指针的地址，所以可以写成二级指针
{}y
数组名表示首元素的地址 每个元素都是int * 类型地址 数组名表示首元素的地址是int * 地址
二维数组传参
void test(int arr[3][5])
{}y
void test(int arr[][])
{}N 行可以省略，列不可以省略
void test(int arr[][5])
{}y
void test(int *arr)
{}N
void test(int* arr[5])
{}N 要么写成指针，要么写成数组
void test(int (*arr)[5])
{}y
void test(int **arr)
{}N
二维数组传参 : 行可以省略 列不能省略
数组名传参传地址传的是第一行的地址

void print(int* p, int sz)
{
  int i = 0;
  for (i = 0; i < sz; i++)
  {
    printf("%d ", *(p + i));
  }
}
int main()
{
  int arr[10] = { 1,2,3,4,5,6,7,8,9,10 };
  int* p = arr;
  int sz = sizeof(arr) / sizeof(arr[0]);
  //一级指针p,传给函数
  print(p, sz);
  return 0;
}

void test(int* p)
{
}
int main()
{
  int a = 10;
  int* ptr = &a;
  int arr[5];
  test(arr);//传整形一维数组的数组名
  test(&a);//传整型变量的地址
  test(ptr);//传整形指针
}

#include <stdio.h>
void test(int** ptr)
{
  printf("num = %d \n", **ptr);
}
int main()
{
  int n = 10;
  int* p = &n;
  int** pp = &p;
  //二级指针变量等于一级指针变量的地址
  //当一个二级指针变量int **p接收，可以传一个一级指针变量地址，可以传一个二级指针变量
  //还可以传一个数组首元素的地址  如:int* arr[6]
  test(pp);
  test(&p);
  return 0;
}

int Add(int x, int y)
{
  return x + y;
}
int main()
{
 //&函数名和函数名代表的都是函数的地址
  int a, b;
  printf("请您输入两个值\n");
  scanf("%d%d", &a, &b);
  int c = Add(a, b);
  printf("%p\n", &Add);
  printf("%p\n", Add);
  printf("%d", c);
  int (*pf1)(int, int) = Add;
  int (*pf2)(int, int) = &Add;
//int* pf2(int,int);函数的声明
  //由此可见类型相同，两种写法皆可
  int ret = (*pf2)(2, 3);
  int ret1 = Add(2, 3);
  printf("%d\n", ret);
  printf("%d\n", ret1);
  return 0;
}

//代码1
int main()
{
  //void(*)()函数指针类型
  //int a=(int)3.14;
  //下面的代码是在调用0地址处的函数，这个函数没有参数，返回类型是void
  ( *(void (*)( ))0)();
//返回类型void 强转 调用函数无参数
}

//代码2：
int main()
{
    //对一个类型重新起名
    //typedef unsigned int uint
    //类型重命名 复杂类型 重命名
  void(* signal(int, void(*)(int)))(int);
  //void(*)(int) signal(int, void(*)(int));//不支持
    //signal函数 两参数:int类型 函数指针类型 参数是int，返回类型是void
  //这个代码是一次函数声明，声明的是signal函数，
  //signal函数参数有两个，第一个是int类型，第二个是函数指针类型，该类型是void(*),
  //signal函数的返回类型也是函数指针类型，该类型是void(*)(int)
  //该函数指针指向的函数，参数是int,返回类型是void
  return 0;
}

typedef unsigned int uint;//类型重命名
int main()
{
  uint a;
  unsigned int b;
  return 0;
}