2. 程式人生 > >函式指標，函式指標陣列的學習

函式指標，函式指標陣列的學習

阿新 • • 發佈：2018-12-21

#define _CRT_SECURE_NO_WARNINGS 1
#include<stdio.h>

//函式指標的學習
//11_4_1
//11_4-2

//void test()
//{
// printf(“hehe\n”);
//}
//int add(int a, int b)
//{
// return a + b;
//}
//int main()
//{
// int (*p)(int, int) = &add;
// //int(*p)[10] = &arr;
// printf("%d\n", (*add)(1, 2));
// system(“pause”);
//}
//int main()
//{
// //printf("%p\n", &test);
// //(*test)();
// //test();
// printf("%d\n", (*add)(2, 3));
// system(“pause”);
// return 0;
//}

//((void()())0)()
//呼叫0地址處的無參返回型別是void的函式

//void(signai(int, void()(int)))(int)
//signal是一個函式的宣告
//函式的引數有兩個，該指標指向的函式有一個引數，型別為int，函式的返回型別為void
//signal函式的返回型別為函式指標
//該指標指向的函式有一個引數，型別為int，函式的返回型別為void

//int(arr[10])();
//函式指標陣列
//arr先和[]結合，所以它是陣列，去掉arr[10],剩下的int（）（）是函式指標，這個指標指向的函式沒有引數，返回型別是int

//void menu()
//{
// printf("*********************************************\n");
// printf("********* 1.add 2.sub \n");
// printf("

3.mul 4.div \n");
// printf(" 0.exit \n");
// printf("*********************************\n");
//}
//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;
//}
//int main()
//{
// int input = 0;
// int x = 0;
// int y = 0;
// int ret = 0;
// do
// {
// menu();
// printf(“請選擇:>”);
// scanf("%d", input);
// if (input >= 1 && input <= 4)
// {
// printf(“請輸入兩個運算元：>”);
// scanf("%d%d",&x,&y);
// }
// switch (input)
// {
// case 1:
// ret = Add(x, y);
// break;
// case 2:
// ret = Sub(x, y);
// break;
// case 3:
// ret = Mul(x, y);
// break;
// case 4:
// ret = Div(x,y);
// break;
// case 0:
// printf(“退出\n”);
// break;
// default:
// printf(“輸入錯誤\n”);
// break;
// }
// printf("%d\n", ret);
// } while (input);
// system(“pause”);
// return 0;
//}

//改造後
//轉移表
//int main()
//{
// int input = 0;
// int x = 0;
// int y = 0;
// int ret = 0;
// int(*pfun[5])(int, int) = {0, Add, Sub, Mul, Div};//利用函式指標陣列提高程式碼的效率，減少了程式碼量
// do
// {
// menu();
// printf(“請選擇:>”);
// scanf("%d", input);
// if (input >= 1 && input <= 4)
// {
// printf(“請輸入兩個運算元：>”);
// scanf("%d%d",&x,&y);
// ret = pfun[input](x, y);
// printf("%d\n", ret);
// }
// } while (input);
// system(“pause”);
// return 0;
//}

//利用函式指標不斷地提高程式碼的效率
//提高程式碼的可讀性

//enum option //利用列舉
//{
// EXIT,//0
// ADD,//1
// SUB,//2
// MUI,//3
// DIV//4
//
//};
//void Calc(int(pfun)(int, int))
//{
// int x = 0;
// int y = 0;
// int ret = 0;
// printf(“請輸入兩個運算元：”);
// ret = pfun(x, y);
// printf("%d\n", ret);
//
//}
//int main()
//{
// int input = 0;
// int x = 0;
// int y = 0;
// int ret = 0;
// do
// {
// menu();
// printf(“請選擇:>”);
// scanf("%d", input);
// if (input >= 1 && input <= 4)
// {
// printf(“請輸入兩個運算元：>”);
// scanf("%d%d",&x,&y);
// }
// switch (input)
// {
// case ADD: //利用列舉，從這就可以看到函式呼叫的函式，更直觀一些
// Calc(Add); //f防止出錯
// break;
// case SUB:
// Calc(Sub);
// break;
// case MUI:
// Calc(Mul);
// break;
// case DIV:
// Calc(Div);;
// break;
// case EXIT:
// printf(“退出\n”);
// break;
// default:
// printf(“輸入錯誤\n”);
// break;
// }
//
// } while (input);
// system(“pause”);
// return 0;
//}
//char my_strcpy(chardst, const charsrc)
//{
// //…
//}
//int main()
//{
// int arr[6] = { 0 };
// int (parr)[6] = &arr;//parr陣列指標
// char(pfun)(char, const char*) = my_strcpy;
// return 0;
//}

//int ADD(int x, int y)
//{
// return x + y;
//}
//int SUB(int x, int y)
//{
// return x - y;
//}
//chartest1(int a, intb)
//{
//
//}
//chartest2(int a, intb)
//{
//
//}
//int main()
//{
// char*(pfun)(int,int) = test1; //函式指標
// char*(pfun[2])(int,int) = { test1, test2 }; //函式指標陣列
// char*((pfun)[2])(int , int) = &pfun; //指向函式指標陣列的指標
//
// //int(pfun[2])(int, int) = { ADD, SUB };
// //int((*p)[2])(int,int) = &pfun;
// return 0;
//}

//回撥函式
//qsort函式

//void qsort(void base, size_t num, size_t width,
// int(__cdecl compare)(const void eleml,const void elem2))
//
//__cdecl–函式的呼叫約定
//
//void bubble_sort(int arr,int sz)
//{
// int i = 0;
// //趟數
// for (i = 0; i < sz-1; i++)
// {
// //每一趟的比較
// int j = 0;
// for (j = 0; j < sz - 1 - i; j++)
// {
// int tmp = 0;
// if (arr[j]>arr[j + 1])
// {
// tmp = arr[j + 1];
// arr[j] = arr[j + 1];
// arr[j] = tmp;
// }
// }
// printf("\n");
// }
// for (i = 0; i < sz; i++)
// {
// printf("%d ", arr[i]);
// }
//}
//int main()
//{
// int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1 };
// int sz = sizeof(arr) / sizeof(arr[0]);
// bubble_sort(arr,sz);
// system(“pause”);
// //size_t 無符號整型
//
// return 0;
//}
//
//int cmp_int(const voide1, const voide2)
//{
// return (int)e1 - (int)e2;
//}
//
//struct Stu
//{
// char name[20];
// int age;
//};
//
//int cmp_stu_by_age(const voide1, const voide2)
//{
// return ((struct Stu)e1)->age - ((struct Stu*)e2-)>age);
//}
//int cmp_stu_by_name(const voide1, const voide2)
//{
// return strcmp(((struct Stu*)e1)->name ,( (struct Stu*)e2)->name);
//}
//void test1()
//{
// struct Stu s[3] = { {“zhangsan”,20}, {“lisi”,10}, {“wangwu”,15} };
// int sz = sizeof(s) / sizeof(s[0]);
// qsort(s, sz, sizeof(s[0], cmp_stu_by_age));
//}
//
//void test2()
//{
// int a = 10;
// void* p = &a; //void就像一個垃圾桶，可以接收其他型別的傳遞
// int arr[] = { 9, 8, 7, 6, 5, 4, 3, 2, 1, 0 };
// int sz = sizeof(arr) / sizeof(arr[0]);
// qsort(arr, sz, sizeof(arr[0]), cmp_int);
//}
//void Swap(charbuf1, charbuf2, int width)
//{
// int i = 0;
// for (i = 0; i < width; i++)
// {
// char tmp = buf1;
// buf1 = buf2;
// buf2 = tmp;
// buf1++;
// buf2++;
// }
//}
//void bubble_sort(voidbase,int sz,int width,int(cmp)(const voide1,const voide2) ) //用qsort實現氣泡排序
//{
// int i = 0;
// int j = 0;
// for (i = 0; i < sz - 1; i++)
// {
// for (j = 0; j < sz - 1 - i; j++)
// {
// if ((cmp((char)base + jwidth, (char*)base + (j + 1)width))>0)
// {
// Swap((char)base + jwidth, (char)base + (j + 1)*width,width);
// }
// }
// }
//}
//int main()
//{
// //sizeof(陣列名)
// //&陣列名 只有這兩種情況代表的是整個陣列
// int a[] = { 1, 2, 3, 4 };
// printf("%d\n", sizeof(a)); //求陣列大小（即位元組）16
// printf("%d\n", sizeof(a + 0)); //首元素地址＋0（即首元素的地址）4
// printf("%d\n", sizeof(a)); //4
// printf("%d\n", sizeof(a + 1)); //4
// printf("%d\n", sizeof(a[1])); //4
// printf("%d\n", sizeof(&a)); //陣列的地址 4
// printf("%d\n", sizeof(&a)); //16 注意這個和上一個的區別
// printf("%d\n", sizeof(&a + 1));//4 跳過整個陣列
// printf("%d\n", sizeof(&a[0])); //4
// printf("%d\n", sizeof(&a[0] + 1));//4 即第二個元素的地址
//}

相關推薦

函式指標，函式指標陣列的學習

#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> //函式指標的學習 //11_4_1 //11_4-2 //void test() //{ // printf(“hehe\n”); //} //

指標陣列，陣列指標，函式指標及應用（回撥函式）

················································索引···························································   當我們在學習指標與陣

深入理解指標陣列 ，陣列指標 ，函式指標 ，函式指標陣列 ，指向函式指標陣列的指標

/指標陣列 示例：char *a[4] 理解：定義了一個數組，而它的每個元素的型別是一個指向字元/字串的指標。 元素表示：char *a[i]   char *(a[i])是一樣的，因為[]優先順序高

20181127（檔案指標，函式相關）

一、檔案內指標的移動f.seek 強調：只有t模式下的read（n），n代表的是字元個數，除此以外都是以位元組為單位。 with open('a.txt',mode='rt',encoding='utf-8') as f: res=f.read(4) # 讀取前四個字元 print(res) &

一級指標，二級指標作為函式輸出形參的正確使用方法

/*data:20181218 /*  * 一級指標函式輸出形參的正確使用方法： *1）用於將函式內部的地址拷貝到函式外部已經分配的地址,有兩種做法，參照test_demo_has_no_ininer_static（)和test_demo_has_local_var（），經過程式碼

C++中仿函式/函式物件，函式指標的用法

研究這個起因是這樣的，就是今天在用priority_queue的時候，需要自定義比較函式，但是此時又不能修改需要比較的類的內容（即不能用過載<的方法），所以只能寫在外面，但是發現這樣並不能編譯通過。報的錯叫cmp（我寫的那個比較函式）不是型別名。後來

12-函式指標，函式回撥，動態記憶體排序

// 函式指標？？？ void fun1(); void fun1() {  // 定義：函式指標是指標，是指向函式的指標  // 函式名稱和陣列名稱一樣，都是代表首地址  printf("fun1 = %p\n", fun1)

函式型別，函式名是函式指標嗎，函式的強制型別轉換

     2      3  typedef int (*funcptr)();      4      5  int func_ptr1(){      6          printf("func_ptr1 is called!\n");      7          return 1;      8

c語言指標做函式引數，使用指標地址（二級指標）在被調函式中修改主調函式的指標。

1.程式碼 #include <stdio.h> #include <stdlib.h> #include <string.h> typedef struct { char *prive; int data; } T_

JS 常用功能函式封裝，繼承、陣列去重、判斷資料型別

繼承方法封裝： var inherit =(function(){ var F = function(){}; return function(a,b){ F.prototype = b.prototype; a.prototype = new

指標，二級指標，指標陣列與陣列指標 練習day—17

1.指標 1）指標就是個變數，用來存放地址，地址唯一標識一塊記憶體空間； 2）指標的大小是固定的4（8）個位元組（32（64）位平臺）； 3）指標是有型別的，指標的型別決定了指標的+/-整數的步長，指標解引用操作時的許可權； int main() { in

一級指標，二級指標，指標和陣列，指標陣列的理解及相關應用

#define _CRT_SECURE_NO_WARNINGS 1 #include<stdio.h> 一級指標 int main() { //字元型指標的一般使用 /*char p = ‘w’; char pc = &p; pc = ‘w’

C++陣列和指標，多維陣列

陣列不是指標，陣列名的值是一個指標常量。 依據《c和指標》《c專家程式設計》上的例子，來總結一下。 int array[10]; int *ap =array + 2; 然後會有以下例子： 在c/c++中，array[2],2[array]是一樣的，源自於同

深入理解：指標陣列，陣列指標，指向指標的指標,陣列名含義

(1)指標陣列是一個數組，裡面包含若干指標，指標陣列名是指向指標的地址，可賦值給指向指標的指標。    如   char* a[]={"hello" ,"world","nihao"};  char**p=a; (2)陣列指標是一個指標，指向整個陣列。    如 int v

一維陣列與指標，二維陣列與指標，指標陣列及陣列指標的概念詳解、例項解析

概念詳解：指標：指標與“int a”,“float b”一樣，也是一種變數，只是指標變數中儲存的是記憶體單元的地址，這是與“int a”和“float b”的本質區別，C語言的精華就在於指標、結構體和連結串列。一維陣列：定義一維陣列之後，即在記憶體中分配一段連續的地址空間，如

黑馬程式設計師----break,continue，函式(方法，第五天學習筆記

------<a href="http://www.itheima.com" target="blank">Java培訓、Android培訓、iOS培訓、.Net培訓</a>、期待與您交流！ ------- 1.      第五天學習內容，迴圈中兩個

C語言結構體內含有陣列，該結構體作為引數傳遞時需用指標，否則對陣列的修改不會被記錄

    在C語言程式設計時，常常會定義結構體，而且結構體裡面常常會有陣列，比如如下所示： typedef struct {int data[MAX_HEAP_SIZE];unsigned int heap_size;}HeapType;     這是一個堆的資料結構，包含堆

Python(六)語法 函式定義，函式引數

函式 Python內建了很多有用的函式，我們可以直接呼叫。 要呼叫一個函式，需要知道函式的名稱和引數，比如求絕對值的函式abs，只有一個引數。可以直接從Python的官方網站檢視文件： http://docs.python.org/3/library/functions.html#abs

函式的文件說明，函式引數，函式返回值

def test(a,b): … “用來完成對2個數求和” … print("%d"%(a+b)) … test(11,22) 33 如果執行，以下程式碼 h

Python記錄6：函式2，函式引數

# 一. 函式引數分為兩大類 # 形參:在函式定義階段括號定義的引數(變數名),稱之為形式引數         #因為函式定義階段只是用一個符號表示表示一個引數，並沒有具體的值，所以稱之為形式引數，形參 # 實參:在函式呼叫階段括號內傳入值