C++ 指针（不论什么一个指针本身的类型都是unsigned long int型）

1.指针数组： 即 数组的元素是指针型;

例：int*pa[2];

明明是一维的指针数组。竟当作二维数组用。

[cpp] view
plain copy

1. //利用指针数组存放单位矩阵
2. #include <iostream>
3. using namespace std;
4. void main()
5. {
6. int line1[]={1,0,0}; //声明数组，矩阵的第一行
7. int line2[]={0,1,0}; //声明数组，矩阵的第二行
8. int line3[]={0,0,1}; //声明数组。矩阵的第三行
9. int* p_line[3];//声明整型指针数组
10. //对指针数组元素赋初值
11. p_line[0]=line1;
12. p_line[1]=line2;
13. p_line[2]=line3;
14. //输出单位矩阵
15. cout<<"Matrix test:"<<endl;
16. for(int i=0;i<3;i++) //对矩阵每一行循环
17. {
18. for(int j=0;j<3;j++)//对数组元素循环
19. {
20. //明明是一维的指针数组。竟当作二维数组用
21. cout<<p_line[i][j]<<" ";
22. }
23. cout<<endl;
24. }
25. }

输出结果：

Matrix test:

1 0 0

0 1 0

0 0 1

2.指针型函数

当函数的返回值是地址时，该函数就叫指针形函数，又叫返回指针的函数。

声明形式：数据类型* 函数名( )

指针型函数的使用（串连接）

[cpp] view
plain copy

1. //指针型函数的使用（串连接）
2. #include <stdio.h>
3. char *my_cat(char *p1, char *p2)
4. {
5. static char a[160],*p;
6. p=a;
7. while (*p1 != '\0') *p++=*p1++;
8. while (*p2 != '\0') *p++=*p2++;
9. *p=*p2;
10. return a;
11. }
12. void main()
13. {
14. char s1[80],s2[80];
15. printf("\n请输入第一串字符: ");
16. //注意：scanf和cin在输入字符串时，遇到空格就终止，而gets 不会。
17. gets(s1);
18. //cin >> s1;
19. //scanf("%s", s1);
20. fflush(stdin);
21. printf("\n请输入第二串字符: ");
22. gets(s2);
23. //cin >> s2;
24. //scanf("%s", s2);
25. printf("\n连接结果: \n");
26. printf("\n第一串在前第二串在后: %s \n",my_cat(s1,s2));
27. printf("\n第二串在前第一串在后: %s \n",my_cat(s2,s1));
28. }

执行结果：

请输入第一串字符: dalian

请输入第二串字符: i love you

连接结果:

第一串在前第二串在后: daliani love you

第二串在前第一串在后: i love youdalian

3.指向函数的指针

3.1指向函数的指针

声明形式：  数据类型 (*函数指针名) ( 形參表);

含义： 数据指针指向的是数据存储区；而函数指针指向的是程序代码存储区。函数名就是地址。

3.2  指向函数的指针数组:   指向函数的指针可组成数组。

声明形式;   数据类型 (*函数指针名[ ] )( 形參表);

[cpp] view
plain copy

1. /************************************************************************
2. 练习：写一个程序，依据用户的输入数据算出结果：
3. 仅仅写出四种运算就能够。
4. 比如：
5. 1 + 2 = 3
6. 1 * 2 = 2
7. 1 –2 = -1
8. 1 / 2 = 0
9. **************************************************************************/
10. #include <stdio.h>
11. #include <stdlib.h>
12. typedef int (*pFun[])(int,int);
13. int add(int,int);
14. int sub(int,int);
15. int mul(int ,int);
16. int divide(int,int);
17. void main()
18. {
19. pFun pfun = {mul,add,NULL,sub,NULL,divide};
20. //也能够这样：int (*pfun[])(int,int) ={mul,add,NULL,sub,NULL,divide};
21. int item1,item2;
22. int result;
23. char op;
24. do
25. {
26. printf("Please input :\n");
27. fflush(stdin);
28. scanf("%d %c %d",&item1,&op,&item2);
29. result = pfun[op-'*'](item1,item2);    //用到了是 + - * /  的ASCII特性
30. printf("%d %c %d = %d \n",item1,op,item2,result);
31. printf("try again ? please input y\\n\n");
32. fflush(stdin);
33. scanf("%c",&op);
34. } while(op == 'y');
35. }
36. int add(int a,int b)
37. {
38. return (a+b);
39. }
40. int sub(int a,int b)
41. {
42. return (a-b);
43. }
44. int mul(int a,int b)
45. {
46. return a*b;
47. }
48. int divide(int a,int b)
49. {
50. if (b == 0)
51. {
52. exit(-1);
53. }
54. else
55. return a/b;
56. }

执行结果：

这个样例用到了+ - * / 的ASCII码

4.this指针

隐含于类中的每个非静态成员函数中的特殊指针。

明白地指出了成员函数当前所操作的数据所属的对象。

–当通过一个对象调用成员函数时。系统先将该对象的地址赋给this指针。然后调用成员函数。成员函数对对象的数据成员进行操作时。

就隐含使用了this指针。（this是函数的第一个形參。）

5. 关于指向类成员的指针

5.1 指向类的非静态成员的指针

通过指向成员的指针仅仅能訪问公有成员

声明指向成员的指针

–声明指向公有数据成员的指针

类型说明符 类名::*指针名。

–声明指向公有函数成员的指针

类型说明符 (类名::*指针名)(參数表)。

注意：应当知道，指向成员的指针名曰指针。实则非也。它是个偏移量，记录着该成员距离对象的首址的距离。

 故定义它时，总要前缀着类名（类名::）,以便于编译器识别后予以特别处理。

使用指向数据成员的指针

对指向数据成员的指针赋值：  –说明指针应该指向哪个成员     指针名=&类名::数据成员名；

使用指向数据成员的指针：     –通过对象名（或对象指针）与成员指针联手来訪问数据成员

对象名.* 类成员指针名    或：  对象指针名->*类成员指针名

使用指向函数成员的指针

指向函数成员的指针

–初始化指针名=类名::函数成员名；

–通过对象名（或对象指针）与成员指针结合来訪问函数成员

(对象名.* 类成员指针名)(參数表)    或： (对象指针名—>*类成员指针名)(參数表)

[cpp] view
plain copy

1. #include <iostream>
2. using namespace std;
3. class Point
4. {
5. public:
6. Point();
7. Point(int xx,int yy);
8. Point(const Point &ref);
9. ~Point();
10. void Move(int x,int y);
11. int GetX() {return X;}
12. int GetY() {return Y;}
13. void Print() const
14. {cout << "X=" << X <<", "<< "Y=" << Y << endl;}
15. private:
16. int X,Y;
17. };
18. Point::Point()
19. {
20. X=Y=0;
21. }
22. Point::Point(int xx,int yy)
23. {
24. X = xx;
25. Y = yy;
26. }
27. Point::Point(const Point &ref)
28. {
29. X = ref.X;
30. Y = ref.Y;
31. }
32. Point ::~Point()
33. {
34. }
35. void Point ::Move(int x,int y)
36. {
37. X+=x; Y+=y;
38. }
39. void main()
40. {
41. Point A(4,5);
42. //声明对象指针并初始化
43. Point *p1=&A;
44. //声明成员函数指针并初始化
45. int(Point::*p_GetX)()=Point::GetX;
46. //（1）使用成员函数指针訪问成员函数
47. cout<<(A.*p_GetX)()<<endl;
48. //（2）使用对象指针訪问成员函数
49. cout<<(p1->GetX)()<<endl;
50. //（3）使用对象名訪问成员函数
51. cout<<A.GetX()<<endl;
52. }

5.2 指向类的静态成员的指针

对类的静态成员(类共享)的訪问不依赖于对象,能够用普通的指针来指向和訪问静态成员

通过指针訪问类的静态数据成员

[cpp] view
plain copy

1. #include <iostream>
2. using namespace std;
3. class Point//Point类声明
4. {
5. public://外部接口
6. Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
7. Point(Point &p);//拷贝构造函数
8. int GetX() {return X;}
9. int GetY() {return Y;}
10. static int countP;//静态数据成员引用性说明
11. private://私有数据成员
12. int X,Y;
13. };
14. Point::Point(Point &p)
15. {
16. X=p.X; Y=p.Y; countP++;
17. }
18. int Point::countP=0;//静态数据成员定义性说明
19. void main()
20. {
21. //声明一个int型指针，指向类的静态成员
22. int*count = &Point::countP;
23. Point A(4,5);
24. cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
25. //直接通过指针訪问静态数据成员
26. cout<<" Object id="<<*count<<endl;
27. Point B(A);//声明对象B
28. cout<<"Point B,"<<B.GetX() <<","<<B.GetY();
29. //直接通过指针訪问静态数据成员
30. cout<<" Object id="<<*count<<endl;
31. }

执行结果：

通过指针訪问类的静态函数成员

[cpp] view
plain copy

1. #include <iostream>
2. using namespace std;
3. class Point//Point类声明
4. {
5. public://外部接口
6. Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
7. Point(Point &p);//拷贝构造函数
8. int GetX() {return X;}
9. int GetY() {return Y;}
10. static void GetC() //静态函数成员
11. {cout<<" Object id="<<countP<<endl;}
12. private://私有数据成员
13. int X,Y;
14. static int countP;//静态数据成员引用性说明
15. };
16. Point::Point(Point &p)
17. {X=p.X; Y=p.Y; countP++; }
18. int Point::countP=0;//静态数据成员定义性说明
19. void main()//主函数
20. {
21. //指向类的静态成员函数的指针，
22. void (*gc)()=Point::GetC;
23. Point A(4,5);//定义对象A
24. cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
25. gc();//通过指针訪问静态函数成员，输出对象序号
26. Point B(A);//定义对象B
27. cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
28. gc();//通过指针訪问静态函数成员
29. }

执行结果：

6.指针与数组的差别

数组名是静态的，一旦定义，其值就固定不变了。

而指针是动态的。可随时变化。

数组名是常量，不可作为算术运算的左值。指针是变量，可作为算术运算的左值。

在訪问速度上。用数组表达式慢，用指针快。

指针比数组有更大的灵活性。

如：

char a[10] [20]; //这是个固定了行和列的矩阵

char * b[10]; //有10行，但每行可长短不等

数组有更好的可读性，可随机訪问各元素；指针可读性差，更适合顺序訪问。