首页 > 其他分享 >指针进阶4

指针进阶4

时间：2022-10-23 16:39:52浏览次数：34  
标签：return 进阶 int void ADD printf 函数指针 指针 

#define _CRT_SECURE_NO_WARNINGS 1
  //实列2：分析以下代码
//代码1
  //(*(viod(*)())0)();
//解释如下：
// 现有一个数为：0，将0的类型强制转化为void(*)()的函数指针类型：（void(*)（））0，调用0这个地址处的该函数（*（void(*）())0）（）
  //代码2
  //void (*signa1(int, void(*)(int)))(int);
  // 
//解释如下：
// 1.整体解释
//有一个名为signa1(int, void(*)(int))的函数指针，元素类型为int,返回值为void.
// 2.函数指针名解释：
// 有一个名为signal的函数，元素类型为int和void(*)(int)(函数指针类型)
// 简写：
//typedef void(*pfun_t)(int);
//pfun_t signal(int,pfun_t);
//解释如下：
//将void(*)(int)返回值为void的函数指针类型且元素类型为int的函数指针类型通过typedef对整体重新命名为pfun_t：typedef void(*pfun_t)(int);
//用通过typedef整体重新命名为pfun_t的函数指针类型，带入函数名为signal的函数且函数的元素类型为int和通过typedef整体重新命名为pfun_t的函数指针类型；
//#include<stdio.h>
//int ADD(int z, int y)
//{
//  return z + y;
//}
//int main()
//{
//  int (*pa)(int, int) = ADD;
//  printf("%d\n", (pa)(2, 3));
//  printf("%d\n", (*pa)(2, 3));//"*"作用不大可省略，若要用必须加上“（）”
//  return 0;
//}
// 
// 
//函数指针数组
//列题1：
//#include<stdio.h>
//int ADD(int z, int y)
//{
//  return z + y;
//}
//#include<stdio.h>
//int SUB(int z, int y)
//{
//  return z -y;
//}
//#include<stdio.h>
//int MUL(int z, int y)
//{
//  return z * y;
//}
//#include<stdio.h>
//int DIV(int z, int y)
//{
//  return z / y;
//}
//int main()
//{
//  //指针数组
//  int* arr[5];
//  //pa存放的是一个函数指针
//  int (*pa)(int, int) = ADD;
////函数指针数组：若需要存放多个函数指针既要用到数组形式如下
//  //注意：数组是存放相同类型数据的存储空间；
//  int(*parr[4])(int, int)={ADD,SUB,MUL,DIV};//函数指针数组
//  int i = 0;
//  for(i = 0; i < 4; i++)
//  {
//    printf("%d\n", parr[i](2, 3));
//  }
//  return 0;
//}
//列题2：
//char* my_strcpy(char* dest, const char* src);
////1.通过上面函数写一个函数指针pf,能够指向my_strcpy；
//
////2.写一个函数指针数组，能够存放四个my_strcpy函数的地址；
//#include<stdio.h>
//int main()
//{
//  //1.答
//  char* （*pf）(char*,const char*) = my_strcpy;
//  //2.答
//  char* (*pfArr[4])(char*, const char*) = { my_strcpy,my_strcpy,my_strcpy,my_strcpy };
//  return 0;
//}
//列题3：函数指针数组的用途：转移表
//列子：计算机
//1.普通输出
//#include<stdio.h>
//
//int ADD(int x, int y)
//{
//  return x + y;
//}
//int SUB(int x, int y)
//{
//  return x - y;
//}
//int MUL(int x, int y)
//{
//  return x * y;
//}
//int DIV(int x, int y)
//{
//  return x / y;
//}
//void menu()
//{
//  printf("***************************\n");
//  printf("*****1.ADD*******2.SUB*****\n");
//  printf("*****3.DIV*******4.MUL*****\n");
//  printf("***********0.退出**********\n");
//  printf("***************************\n");
//}
//int main()
//{
//  int input = 0;
//  int x, y;
//  do {
//    menu();
//    printf("请输入数据：\n");
//    scanf("%d", &input);
//    switch (input)
//    {
//      case 1:
//        printf("请输入两个数据：\n");
//        scanf("%d%d", &x, &y);
//      printf("%d\n",ADD(x,y));
//      break;
//      case 2:
//        printf("请输入两个数据：\n");
//        scanf("%d%d", &x, &y);
//      printf("%d\n", SUB(x, y));
//      break;
//      case 3:
//        printf("请输入两个数据：\n");
//        scanf("%d%d", &x, &y);
//      printf("%d\n", MUL(x, y));
//      break;
//      case 4:
//        printf("请输入两个数据：\n");
//        scanf("%d%d", &x, &y);
//      printf("%d\n", DIV(x, y));
//      break;
//      case 0:
//      printf("退出\n");
//      break;
//      default:
//        printf("输入错误，请重新输入：");
//          break;
//    }
//  } while (input);
//  return 0;
//}
//2.利用函数指针数组的形式解决：
//#include<stdio.h>
//
//int ADD(int x, int y)
//{
//  return x + y;
//}
//int SUB(int x, int y)
//{
//  return x - y;
//}
//int MUL(int x, int y)
//{
//  return x * y;
//}
//int DIV(int x, int y)
//{
//  return x / y;
//}
//void menu()
//{
//  printf("***************************\n");
//  printf("*****1.ADD*******2.SUB*****\n");
//  printf("*****3.DIV*******4.MUL*****\n");
//  printf("***********0.退出**********\n");
//  printf("***************************\n");
//}
//int main()
//{
//  int input=0,x=0,y=0;
//  int (*pfARR[5])(int, int) = { 0,ADD,SUB,MUL,DIV};//这样的函数指针数组被称为转移表
//  do
//  {
//    menu();
//    printf("请输入选择：\n");
//    scanf("%d", &input);
//    if (input >= 1&&input <= 4)
//    {
//      
//      printf("请输入两个数据：\n");
//      scanf("%d%d", &x, &y);
//      printf("%d\n", (*pfARR[input])(x, y));
//    }
//    else if (input == 0)
//    {
//      printf("退出\n");
//    }
//    else
//      printf("输入错误请从新输入：");
//  } while (input);
//  return 0;
//}

//3.回调函数；观察可知case:以下的多条语句形式一致则可建立一个函数进行回调
//回调函数就是一个通过函数指针调用的函数.如果你把函数的指针（地址）作为参数传递给另一个函数，当这个指针被用来调用其所指向的函数时，
// 我们说它就是回调函数。回调函数不是有函数的实现方直接调用，而是在特定的事件或者条件时由；另外的一方调用的。用于对该事件或条件进行响应；
// （1）列1：
//#include<stdio.h>
//
//int ADD(int x, int y)
//{
//  return x + y;
//}
//int SUB(int x, int y)
//{
//  return x - y;
//}
//int MUL(int x, int y)
//{
//  return x * y;
//}
//int DIV(int x, int y)
//{
//  return x / y;
//}
//void menu()
//{
//  printf("***************************\n");
//  printf("*****1.ADD*******2.SUB*****\n");
//  printf("*****3.DIV*******4.MUL*****\n");
//  printf("***********0.退出**********\n");
//  printf("***************************\n");
//}
//void Cale(int (*pf)(int, int))//回调函数
//{
//  int x = 0, y = 0;
//  printf("请输入两个数据：\n");
//  scanf("%d%d", &x, &y);
//  printf("%d\n", (*pf)(x, y));
//}
//int main()
//{
//  int input = 0;
//  int x, y;
//  do {
//    menu();
//    printf("请输入数据：\n");
//    scanf("%d", &input);
//    switch (input)
//    {
//      case 1:
//        Cale(ADD);
//      break;
//      case 2:
//        Cale(SUB);
//      break;
//      case 3:
//        Cale(MUL);
//      break;
//      case 4:
//        Cale(DIV);
//      break;
//      case 0:
//      printf("退出\n");
//      break;
//      default:
//        printf("输入错误，请重新输入：");
//          break;
//    }
//  } while (input);
//  return 0;
//}
// （2）列2:冒泡排序
//1>普通冒泡排序
//了解qosort
#include<stdio.h>
void sort(int arr[], int M)
{
  int i, iTemp;
  for (i = 0; i < M - 1; i++)
  {
    int j;
    int DUI = 1;
    for (j = 0; j < M - i - 1; j++)
    {
      if (arr[j] > arr[j + 1])
      {
        iTemp = arr[j];
        arr[j] = arr[j + 1];
        arr[j + 1] = iTemp;
        DUI = 0;
      }
    }
    if (DUI == 1)
    {
      break;
    }
  }
}
int main()
{
  int arr[] = { 3,4,1,2,6,5,8,7,9,10 };
  int sz = sizeof(arr) / sizeof(arr[0]);

  sort(arr, sz);
  for (int i = 0; i < sz; i++)
  {
    printf(" %d ", arr[i]);
  }
  return 0;
}

//4.指向函数指针数组的指针
//#include<stdio.h>
//int ADD(int x, int y)
//{
//  return x + y;
//}
//int main()
//{
//  int arr[10] = { 0 };
//  int(*p)[10] = &arr;//指向数组指针的指针
//
//  int(*pf)(int, int) = &ADD;//指向函数指针的指针
//  int (*pfArr[4])(int, int)={ADD,ADD,ADD,ADD};//函数指针数组
//  int * (*ppfArr[4])(int, int) = &pfArr;//指向函数指针数组的指针
//
//  return 0;
//}

标签：return,进阶,int,void,ADD,printf,函数指针,指针
From： https://blog.51cto.com/u_15812356/5787347

相关文章

  • 实验三：数组、指针与现代C++
    实验任务五task.cpp#include"info.h"#include<iostream>#include<string>#include<vector>usingnamespacestd;intmain(){constintcapacity=100;v......
  • 实验3 数组、指针与现代C++标准库
    任务五info.hpp1#pragmaonce2#include<iostream>3#include<string>4#include<iomanip>5usingnamespacestd;6classinfo7{8public:9......
  • 实验三 数组、指针与现代C++标准库
    实验五代码：Info.hpp1#pragmaonce23#include<iostream>4#include<string>5#include<iomanip>67usingstd::string;8usingstd::cout;9us......
  • 进阶篇：软件测试工程师的岗位职责
    转载：https://www.cnblogs.com/imyalost/p/8613501.html一、需求1、需求评审为什么要需求评审？原因有下面几点：①、熟悉业务，由产品或者业务讲解需求，好做到心中有数，不至于......
  • Kubernetes架构分析介绍篇（进阶篇）
    Kubernetes设计理念与分布式系统分析和理解Kubernetes的设计理念可以使我们更深入地了解Kubernetes系统，更好地利用它管理分布式部署的云原生应用，另一方面也可以让我们......
  • 实验3 数组、指针与现代C++标准库
    5.实验任务5info.hpp#pragmaonce#include<iostream>#include<string>#include<iomanip>usingstd::string;usingstd::cout;usingstd::endl;classinfo{......
  • C#进阶
    未完成，不定时更新一、进程与线程平时写简单程序的时候都是单线程，编译器只给程序分配一个主线程。但是后续随着难度增加，程序功能的复杂，主线程一拳难敌四手，容易造成程序......
  • # yyds干货盘点 # 盘点JavaScript中那些进阶操作知识（下篇）
    大家好，我是Python进阶者。一、前言前几天在Python钻石交流群【海南菜同学】问了一个​​Python​​列表合并的问题，提问截图如下：原始代码如下：defcp_pi():list1=[1,2,3......
  • C++ 函数返回指针
    C++中返回值为指针或者引用的时候，不可以返回局部变量的指针或者引用，因为当此段代码块执行完之后，相应的局部变量，就会被系统释放，指针所指向的那块内存会被操作系统用来做其......
  • 实验三 数组、指针与现代c++标准库
    task5#pragmaonce#include<iostream>#include<string>#include<vector>#include<iomanip>usingnamespacestd;classInfo{public:Info(string......

赞助商

阅读排行

网站主页关于我们联系我们网站地图

本网站内容转载自其他媒体，侵权联系[admin##ips99.com]。

Copyright © 2020-2023 IPS99 版权所有 IPS99