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
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
#include <iostream>


int show(int);

int a = 111;
int b = 222;
int c = 333;
int* pp1[3]{&a, &b, &c};

decltype(pp1)* Fun1(int nNum);

typedef int int_array_t[3];
typedef int (*int_array_ptr_t)[3];
typedef int (*int_array_ptr_t2[3]);

int_array_t obj = {7, 8, 9};
int_array_ptr_t p_obj;
int_array_ptr_t2* p_obj2 = &pp1;

int_array_t* fun0(int n);
int_array_ptr_t fun1(int n);
int_array_ptr_t2* fun3(int);


int main() {

    // 1. 普通指针
    int nNum = 6;
    int* p0 = &nNum;

    std::cout << *p0 << std::endl;

    int p1[3]{1, 2, 3};

    // 2. 由n个int型指针组成的数组;数组的元素是指针类型
    int a = 1;
    int b = 2;
    int c = 3;
    int *p2[3]{&a, &b, &c};

    std::cout << std::defaultfloat;
    std::cout << std::hex << std::showbase;

    std::cout << "&a:\t" << (size_t)&a << std::endl;
    std::cout << "p3[0]:\t" << (size_t)p2[0] << std::endl;

    std::cout << "&b:\t" << (size_t)&b << std::endl;
    std::cout << "p3[1]:\t" << (size_t)p2[1] << std::endl;

    std::cout << "&c:\t" << (size_t)&c << std::endl;
    std::cout << "p3[2]:\t" << (size_t)p2[2] << std::endl;

    // 3. 一个指向由n个元素的数组的指针，数组元素的值为int型
    std::cout << std::dec;

    int(*p3)[3] = &p1;
    std::cout << (*p3)[0] << std::endl;
    std::cout << (*p3)[1] << std::endl;
    std::cout << (*p3)[2] << std::endl;

    // 4. 指向int型指针的指针
    int** p4 = &p0;
    **p4 = 123456;
    std::cout << **p4 << std::endl;

    // 5. 函数指针
    int (*p5)(int) = show;                  // 一个指向有一个整型参数, 返回值为整型的函数的指针
    p5(1);
    (*p5)(1);

    // 6. 带一个int型参数返回值为指向n个int型指针元素的数组的函数
    int*(*p6(int))[3];                      // p是一个函数, 函数的参数为int型;函数的返回值为指针;指针指向是一个数组;数组的元素为指针;数组的元素指针为int型指针
    decltype(pp1)* pPP1 = Fun1(0);
    std::cout << *((int*)((*pPP1)[0])) << std::endl;
    std::cout << *((int*)((*pPP1)[1])) << std::endl;
    std::cout << *((int*)((*pPP1)[2])) << std::endl;

    int_array_ptr_t2* pAray3 = fun3(0);
    std::cout << *((int*)((*pAray3)[0])) << std::endl;
    std::cout << *((int*)((*pAray3)[1])) << std::endl;
    std::cout << *((int*)((*pAray3)[2])) << std::endl;

    // int (*func)(int *p, int (*f)(int*));
    // 7. func是一个指向函数的指针，这类函数具有int *和int (*)(int*)这样的形参，返回值为int类型

    // int (*func[3])(int);
    // 8. func数组的元素是函数类型的指针，它所指向的函数具有int类型的形参，返回值类型为int
    int (*func[3])(int) = {show, show, show};

    func[0](0);
    func[1](0);
    func[2](0);
    
    // int (*(*func)[3])(int);
    // 9. func是一个指向数组的指针，这个数组的元素是函数指针，这些指针指向具有int形参，返回值为int类型的函数。
    int (*(*func9)[3])(int) = &func;
    (*func9)[0](0);
    (*func9)[1](0);
    (*func9)[2](0);
 
    // int (*(*func)(int))[3];
    // 10. func是一个函数指针，这类函数具有int类型的形参，返回值是指向数组的指针，所指向的数组的元素是具有3个int元素的数组
    int(*(*func10)(int))[3] = fun1;
    int_array_ptr_t p10 = func10(0);

    std::cout << (*p10)[0] << std::endl;
    std::cout << (*p10)[1] << std::endl;
    std::cout << (*p10)[2] << std::endl;

    return 0;
}

int show(int) {
    std::cout << "show function." << std::endl;
    return 0;
}

decltype(pp1)* Fun1(int nNum) {
    return &pp1;
}

int_array_t* fun0(int n) {
    p_obj = &obj;
    return &obj;
}

int_array_ptr_t fun1(int n) {
    p_obj = fun0(n);
    return p_obj;
}

int_array_ptr_t2* fun3(int) {
    return p_obj2;
}
阅读全文
C++深入浅出系列 C++指针详解