一. 堆空間與指針的相愛相殺

1.1 堆上一維空間

1.1.1 返回值返回（一級指針）

1.1.2 參數(shù)返回（二級指針）

1.2 堆上二維空間

1.2.1 指針作返值輸出

1.2.2 空間申請與釋放

1.2.3 多級指針作參數(shù)輸出

1.2.4 具體實例之序列加密

二. const修飾指針

1.1 const 修飾變量

1.2 const 修飾指針

1.3 const 修飾指針指向

1.4 應(yīng)用( 修飾函數(shù)參數(shù))

1.5 const int *pi 與int *const pi的區(qū)別

1.5.1 從const int i 說起

1.5.2 const int *pi 與 int *const pi的纏綿

1.5.3 補充三種情況

三. 函數(shù)與函數(shù)指針

3.1 函數(shù)多參返回

3.1.1 引列

3.1.2 正解

3.2 函數(shù)指針

3.2.1 函數(shù)的本質(zhì)

3.2.2 函數(shù)指針變量定義與賦值

3.2.3 函數(shù)指針類型定義

3.2.4 應(yīng)用場景

3.3 回調(diào)函數(shù)

3.3.1 問題引出

3.3.2 回調(diào)（函數(shù)做參數(shù)）

一. 堆空間與指針的相愛相殺

1.1 堆上一維空間

1.1.1 返回值返回（一級指針）

char * allocSpace(int n)
{
char *p = (char*)malloc(n);
return p;
}

1.1.2 參數(shù)返回（二級指針）

#include <iostream>
#include <stdlib.h>
#include <string>
 
using namespace std;
 
int allocSpace(char **p,int n)
{
*p = (char*)malloc(n);
return *p== NULL?-1:1;
}
 
int _tmain(int argc, _TCHAR* argv[])
{
char *p;
if(allocSpace(&p,100)<0)
{
return -1;
}
strcpy(p,'china');
printf('%s\n',p);
free(p);
system('pause');
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

輸出結(jié)果如下：

1.2 堆上二維空間

二維數(shù)組，是一種二維空間，但是不代表，二維空間就是二維數(shù)組。二維空間，并不一定就是二維數(shù)組，但具有數(shù)組的訪問形式。但己經(jīng)遠遠不是數(shù)組的定義了。

1.2.1 指針作返值輸出

#include <stdio.h>
#include <stdlib.h>
#include <string>
using namespace std;
void * alloc2dSpace(int base,int row,int line)
{
void *p = malloc(base*row*line);
return p;
}
int _tmain(int argc, _TCHAR* argv[])
{
int (*p)[5] = alloc2dSpace(sizeof(int),3,5);
for(int i=0; i<3; i++)
{
for(int j=0; j<5; j++)
{
p[i][j] = i+j;
}
}
for(int i=0; i<3; i++)
{
for(int j=0; j<5; j++)
{
printf('%d ',*(*(p+i)+j));
}
putchar(10);
}
free(p);
system('pause');
return 0;
}

1.2.2 空間申請與釋放

#include <stdio.h>
#include <stdlib.h>
 
void ** alloc2dSpace(int base, int row,int line)
{
  void **p = malloc(row*sizeof(void*));
  for(int i=0; i<row;i++)
  {
   p[i] = malloc(base * line);
  }
  return p;
}
int main(void)
{
  int **p = alloc2dSpace(sizeof(int),3,4);
  for(int i=0; i<3; i++)
  {
    for(int j=0; j<4; j++)
    {
      p[i][j] = i+j;
    }
  }
  for(int i=0; i<3; i++)
  {
    for(int j=0; j<4; j++)
  {
    printf('%d ',p[i][j]);
  }
  putchar('\n');
 }
return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

1.2.3 多級指針作參數(shù)輸出

void alloc2dSpace(void ***p,int base,int row,int line)
{
*p = malloc(row*sizeof(void*));
for(int i=0; i<row;i++)
{
(*p)[i] = malloc(base * line);
}
}

1.2.4 具體實例之序列加密

現(xiàn)有字符序列 char buf[] = “hello everyone”;

按行讀的話，肯定可以讀出數(shù)據(jù)，如果按列來讀的話，則會出再亂碼的現(xiàn)像。正是這種現(xiàn)像可作為一種加密手段，稱為序列加密。

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#if 0
buf[] = 'china is great';
//chi
//na
//is
//gre
//at
 
//cniga
//hasrt
//i e
#endif
char * encode(char *buf, int line)
{
    int len = strlen(buf);
    int nlen;
    if(len%line!=0)
    {
        nlen = len + (line - len%line);
    }
    else
    {
        nlen = len;
    }
    char * tmp = (char *)malloc(nlen+1);
    char * secret = (char*)malloc(nlen+1);
    char *psecret = secret;
    strcpy(tmp,buf);
    int n = strlen(tmp);
    for(; n<nlen; n++)
    {
        tmp[n] = ' ';
    }
    tmp[nlen] = '\0';
    int row = nlen/line;
    char (*ptmp)[line] =tmp;
    int i = 0;
    int j = 0;
    for(; i<line; i++)
    {
        for(; j<row; j++)
        {
            *psecret++ = ptmp[j][i];
        }
    }
    *psecret = '\0';
    free(tmp);
    return secret;
}
char * decode(char* buf, int line)
{
    int len = strlen(buf);
    int nline = len/line;
    int row = line;
    char * desecret = (char*)malloc(len+1);
    char *pd = desecret;
    char (*p)[nline] = buf;
    int i = 0;
    int j = 0;
    for(;i<nline; i++)
    {
        for(; j<row; j++)
        {
            *pd++ = p[j][i];
        }
    }
    *pd= '\0';
    while(*(--pd) == 32)
    {
        *pd= '\0';
    }
 
    return desecret;
}
 
int main(void)
{
    char buf[] = 'china is great';
    printf('%s\n','*****明文*****');
    printf('%s\n',buf);
 
    char * secret = encode(buf,3);
    printf('%s\n','*****密文*****');
    printf('%s\n',secret);
    char * desecret = decode(secret,3);
    printf('%s\n',desecret);
    free(secret);
    free(desecret);
    return 0;
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95

輸出結(jié)果如下：

二. const修飾指針

1.1 const 修飾變量

const 修飾變量，此時稱為常變量。常變量，有常量的屬性，比用宏定義的常量有了類型的屬性。

#include <stdio.h>
#define N 400a
int main(void)
{
// const int a = 400a;
const int a = 200; //定義的時候必須初始化
printf('a = %d\n',a);
// a = 200;
printf('a = %d\n',a);
int *p = &a; //
*p = 300;
printf('a = %d\n',a);
return 0;
}

輸出結(jié)果：

1.2 const 修飾指針

const 修飾指針，表示指針的指向是恒定的，不可更改。

#include <stdio.h>
int main(void)
{
    int a = 2;
    int * const p = &a;
    int b  = 3;
    //p = &b;    //指針常量無法修改，編譯不過
   printf('%d\n',*p);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
1
2
3
4
5
6
7
8
9
10

輸出結(jié)果為：2。

1.3 const 修飾指針指向

#include <stdio.h>
int main(void)
{
int a = 2;
const int * p = &a;
printf('p = %p\n',p);
int b ;
p = &b;
printf('p = %p\n',p);
//*p = 200; //編譯不過
const int *const q = &a;
//q = &b; //編譯不過
// *q = 200; //編譯不過
return 0;
}

1.4 應(yīng)用( 修飾函數(shù)參數(shù))

常用于修飾入?yún)⒅羔槪硎酒渲赶虻膬?nèi)容不可以修改。這樣，可以增加程序的鍵壯性。如果用戶不小心發(fā)生了修改行為，則會用編譯警告來提示，而不是用運行的錯誤來提示。

char * strcpy ( char * destination, const char * source );
char * strcat ( char * destination, const char * source );

1.5 const int pi 與int const pi的區(qū)別

1.5.1 從const int i 說起

你知道我們聲明一個變量時象這樣 int i ；這個 i 是可能在它處重新變賦值的。如下：

int i = 0;

i = 20; /*這里重新賦值了*/
/*不過有一天我的程序可能需要這樣一個變量（暫且稱它變量），在聲明時就賦一個初始值。之后我的程序在其它任何處都不會再去重新對它賦值。那我又應(yīng)該怎么辦呢？用 const */
const int ic =20;

ic = 40; /*這樣是不可以的，編譯時是無法通過，因為我們不能對 const修飾的 ic 重新賦值的。*/
/*這樣我們的程序就會更早更容易發(fā)現(xiàn)問題了。*/
1
2
3
4
5
6
7
8
1
2
3
4
5
6
7
8

有了 const 修飾的 ic 我們不稱它為變量，而稱符號常量，代表著 20 這個數(shù)。這就是 const 的作用。ic 是不能在它處重新賦新值了。

認識了 const 作用之后，另外，我們還要知道格式的寫法。有兩種：

const int ic = 20; 與i nt const ic = 20;

它們是完全相同的。這一點我們是要清楚。

#include <stdio.h>
int main(void)
{
int a = 2;
printf('a = %d\n',a);
a = 3;
printf('a = %d\n',a);
const int i1 = 4;
int const i2 = 5;
printf('const int i1 = %d\n',i1);
printf('int const i2 = %d\n',i2);
//i1 = 6; //編譯不過
//i2 = 7; //編譯不過
return 0;
}

輸出結(jié)果：

1.5.2 const int pi 與 int const pi的纏綿

先看一段代碼：

#include <stdio.h>
 
int main(void)
{
    int a = 20;
    int b = 30;
 
    const int *pi = &a;
    printf('const int *pi = %d\n',*pi);
 
    pi = &b;
    printf('const int *pi = %d\n',*pi);
 
    // *pi = 40;  //注意這里，編譯不過，*pi不能再這樣重新賦值了，*pi是一個常量
 
    int *const pi2 = &a;
    printf('int *const pi2 = %d\n',*pi2);
 
    //pi2 = &b;   //注意這里，pi2不能再這樣重新賦值了，即不能再指向另外一個新地址
 
    *pi2 = 80;
    printf('int *const pi2 = %d\n',*pi2);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24

輸出結(jié)果為：

我們來具體分析下上述代碼中const把指針到底怎么了。我們來看這句代碼：const int *pi = &a;這句代碼中const 修飾的是*pi,將*pi定義為常量，所以給*pi重新賦值是非法的，而pi是普通的變量，可對其進行再賦值，如： pi = &b；我們再來看這句代碼：int *const pi2 = &a;這句代碼中const修飾的是 pi2,將pi2定義為常量，所以給pi2重新賦值是非法的，而*pi2則可以重新賦值。

請大聲讀出下面兩句話并牢牢記?。?/p>

如果 const 修飾在*pi 前，則不能改的是*pi(即不能類似這樣：*pi=50;賦值)而不是指 pi。
如果 const 是直接寫在 pi 前，則 pi 不能改(即不能類似這樣：pi=&i;賦值)。

相信到目前為止你還沒有被 int *const pi和const int *pi搞混。那么請自行分析 int const *pi 和 int *const pi ，它們各自聲明的 pi 分別能修改什么，不能修改什么？如有問題請在下方評論區(qū)留言我們繼續(xù)探討。

1.5.3 補充三種情況

這里，我再補充以下三種情況。其實只要上面的語義搞清楚了，這三種情況也就已經(jīng)被包含了。不過作為三種具體的形式，我還是簡單做以提示：

情況一：int *pi 指針指向 const int i 常量的情況

#include <stdio.h>
int main(void)
{
const int i1 = 40;
int *pi;
//pi = &i1; /* 這樣可以嗎？不行，編譯錯誤
return 0;
}

為啥pi = &il編譯不過，請自行分析。

情況二：const int *pi 指針指向 const int i1 的情況

#include <stdio.h>
 
int main(void)
{
    const int i1=40;
    const int * pi;
 
    pi=&i1;/* 兩個類型相同，可以這樣賦值。很顯然，i1 的值無論是通過 pi 還是 i1 都不能修改的。 */
 
    printf('i1 = %d\n',i1);
    printf('pi = %d\n',pi);
    printf('*pi = %d\n',*pi);
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上述代碼可成功編譯并運行，請自行分析。

情況三：用 const int *const pi 聲明的指針

#include <stdio.h>
int main(void)
{
int i = 20;
const int * const pi=&i;
return 0;
}

上述代碼可成功編譯并運行，請自行分析。

三. 函數(shù)與函數(shù)指針

3.1 函數(shù)多參返回

3.1.1 引列

請寫一個函數(shù)，同時返回兩個正整型數(shù)據(jù)的和與差。但是我們知道函數(shù)只有一個返回值的，該如何實現(xiàn)呢？

int foo(int * sum ,int *diff, int a,int b);
1
1

3.1.2 正解

當我們既需要，通過函數(shù)返回值來判斷函數(shù)調(diào)用是否成功，又需要把數(shù)據(jù)傳遞出來，此時，我們就要用到多參返回，多參返回，都是通過傳遞調(diào)用空間中的空間地址來實現(xiàn)的。比如前面我們講到的，通過參數(shù)，返回堆上的一維空間，二維空間和初始化指針就是如此。

3.2 函數(shù)指針

3.2.1 函數(shù)的本質(zhì)

函數(shù)的本質(zhì)是一段可執(zhí)行性代碼段。函數(shù)名，則是指向這段代碼段的首地址。

#include <stdio.h>
void print()
{
printf('china\n');
}
int main()
{
print();
printf('%p\n',&print);
printf('%p\n',print);
int a;
int *p = &a;
//函數(shù)也是一個指針，應(yīng)當存在一個什么樣的指針變量中呢？
return 0;
}

3.2.2 函數(shù)指針變量定義與賦值

#include <stdio.h>
void print()
{
    printf('china\n');
}
void dis()
{
    printf('china\n');
}
int main()
{
    void (*pf)() = print; //void (*pf)() = &print;
    pf(); //(*pf)();
    pf = dis;
    pf();
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

3.2.3 函數(shù)指針類型定義

#include <stdio.h>
void print()
{
printf('china\n');
}
void dis()
{
printf('china\n');
}
typedef void (*PFUNC)() ;
int main()
{
PFUNC pf= print;
pf();
pf = dis;
pf();
return 0;
}

3.2.4 應(yīng)用場景

函數(shù)指針的一個用法出現(xiàn)在菜單驅(qū)動系統(tǒng)中。例如程序可以提示用戶輸入一個整數(shù)值來選擇菜單中的一個選項。用戶的選擇可以做函數(shù)指針數(shù)組的下標，而數(shù)組中的指針可以用來調(diào)用函數(shù)。

#include <stdio.h>
void function0(int);
void function1(int);
void function2(int);
int main()
{
    void (*f[3])(int) = {function0,function1,function2};
    //將這 3 個函數(shù)指針保存在數(shù)組 f 中
    int choice;
    printf('Enter a number between 0 and 2, 3 to end: ');
    scanf('%d',&choice);
    while ((choice >= 0) && (choice <3))
    {
        (*f[choice])(choice);
        //f[choice]選擇在數(shù)組中位置為 choice 的指針。
        //指針被解除引用，以調(diào)用函數(shù)，并且 choice 作為實參傳遞給這個函數(shù)。
        printf('Enter a number between 0 and 2,3 to end: ');
        scanf('%d',&choice);
    }
    printf('Program execution completed.');
    return 0;
}
void function0(int a)
{
    printf('You entered %d so function0 was called\n',a);
}
void function1(int b)
{
    printf('You entered %d so function1 was called\n',b);
}
void function2(int c)
{
    printf('You entered %d so function2 was called\n',c);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

3.3 回調(diào)函數(shù)

3.3.1 問題引出

當我們要實現(xiàn)排序的時候，升序和降序，都是寫死在程序中的，如果要改只能改動原代碼，那么如果程序是以庫的形式給出的呢？那又如何呢？

#include <stdio.h>
void selectSort(int *p, int n)
{
for(int i=0; i<n-1 ;i ++)
{
for(int j=i+1; j<n; j++)
{
if(p[i] < p[j])
{
p[i] = p[i]^p[j];
p[j] = p[i]^p[j];
p[i] = p[i]^p[j];
}
}
}
}
int main(void)
{
int arr[10] = {6,5,4,3,2,1,7,8,9,0};
selectSort(arr,10);
for(int i=0; i<10; i++)
{
printf('%d\n',arr[i]);
}
return 0;
}

3.3.2 回調(diào)（函數(shù)做參數(shù)）

#include <stdio.h>
int callBackCompare(int a,int b)
{
    return a<b?1:0;
}
void selectSort(int *p, int n,int(*pf)(int,int))
{
    for(int i=0; i<n-1 ;i ++)
    {
        for(int j=i+1; j<n; j++)
        {
            if(pf(p[i],p[j]))
            {
                p[i] = p[i]^p[j];
                p[j] = p[i]^p[j];
                p[i] = p[i]^p[j];
            }
        }
    }
}
int main(void)
{
    int arr[10] = {6,5,4,3,2,1,7,8,9,0};
    selectSort(arr,10,callBackCompare);
    for(int i=0; i<10; i++)
    {
        printf('%d\n',arr[i]);
    }
    return 0;
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

本質(zhì)：回調(diào)函數(shù)，本質(zhì)也是一種函數(shù)調(diào)用，先將函數(shù)以指針的方式傳入，然后，調(diào)用。這種寫法的好處是，對外提供函數(shù)類型，而不是函數(shù)定義。這樣我們只需要依據(jù)函數(shù)類型和函數(shù)功能提供函數(shù)就可以了。給程序的書寫帶來了很大的自由。

【上一篇：】：C/C++指針詳解之基礎(chǔ)篇

本站僅提供存儲服務(wù)，所有內(nèi)容均由用戶發(fā)布，如發(fā)現(xiàn)有害或侵權(quán)內(nèi)容，請點擊舉報。

中文字幕理论片,69视频免费在线观看,亚洲成人app,国产1级毛片,刘涛最大尺度戏视频,欧美亚洲美女视频,2021韩国美女仙女屋vip视频

一. 堆空間與指針的相愛相殺

1.1 堆上一維空間

1.1.1 返回值返回（一級指針）

1.1.2 參數(shù)返回（二級指針）

1.2 堆上二維空間

1.2.1 指針作返值輸出

1.2.2 空間申請與釋放

1.2.3 多級指針作參數(shù)輸出

1.2.4 具體實例之序列加密

二. const修飾指針

1.1 const 修飾變量

1.2 const 修飾指針

1.3 const 修飾指針指向

1.4 應(yīng)用( 修飾函數(shù)參數(shù))

1.5 const int *pi 與int *const pi的區(qū)別

1.5.1 從const int i 說起

1.5.2 const int *pi 與 int *const pi的纏綿

1.5.3 補充三種情況

三. 函數(shù)與函數(shù)指針

3.1 函數(shù)多參返回

3.1.1 引列

3.1.2 正解

3.2 函數(shù)指針

3.2.1 函數(shù)的本質(zhì)

3.2.2 函數(shù)指針變量定義與賦值

3.2.3 函數(shù)指針類型定義

3.2.4 應(yīng)用場景

3.3 回調(diào)函數(shù)

3.3.1 問題引出

3.3.2 回調(diào)（函數(shù)做參數(shù)）

1.5 const int pi 與int const pi的區(qū)別

1.5.2 const int pi 與 int const pi的纏綿