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

Posted llguanli

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了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.     //对指针数组元素赋初值  
  12.     p_line[0]=line1;  
  13.     p_line[1]=line2;  
  14.     p_line[2]=line3;  
  15.   
  16.     //输出单位矩阵  
  17.     cout<<"Matrix test:"<<endl;  
  18.     for(int i=0;i<3;i++) //对矩阵每一行循环  
  19.     {  
  20.         for(int j=0;j<3;j++)//对数组元素循环  
  21.         {   
  22.             //明明是一维的指针数组。竟当作二维数组用  
  23.             cout<<p_line[i][j]<<" ";   
  24.         }  
  25.         cout<<endl;  
  26.     }  
  27. }  

输出结果:

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.   
  13. void main()  
  14. {  
  15.     char s1[80],s2[80];  
  16.     printf("\n请输入第一串字符: ");  
  17.     //注意:scanf和cin在输入字符串时,遇到空格就终止,而gets 不会。  
  18.     gets(s1);  
  19.     //cin >> s1;  
  20.     //scanf("%s", s1);  
  21.     fflush(stdin);  
  22.     printf("\n请输入第二串字符: ");  
  23.     gets(s2);  
  24.     //cin >> s2;  
  25.     //scanf("%s", s2);  
  26.     printf("\n连接结果: \n");  
  27.     printf("\n第一串在前第二串在后: %s \n",my_cat(s1,s2));  
  28.     printf("\n第二串在前第一串在后: %s \n",my_cat(s2,s1));  
  29. }  
执行结果:

请输入第一串字符: 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.   
  13. typedef int (*pFun[])(int,int);  
  14. int add(int,int);  
  15. int sub(int,int);  
  16. int mul(int ,int);  
  17. int divide(int,int);  
  18. void main()  
  19. {  
  20.     pFun pfun = {mul,add,NULL,sub,NULL,divide};  
  21.     //也能够这样:int (*pfun[])(int,int) ={mul,add,NULL,sub,NULL,divide};  
  22.     int item1,item2;  
  23.     int result;  
  24.     char op;  
  25.     do   
  26.     {  
  27.         printf("Please input :\n");  
  28.         fflush(stdin);  
  29.         scanf("%d %c %d",&item1,&op,&item2);  
  30.         result = pfun[op-‘*‘](item1,item2);    //用到了是 + - * /  的ASCII特性  
  31.         printf("%d %c %d = %d \n",item1,op,item2,result);  
  32.         printf("try again ? please input y\\n\n");  
  33.         fflush(stdin);  
  34.         scanf("%c",&op);  
  35.     } while(op == ‘y‘);  
  36. }  
  37.   
  38. int add(int a,int b)  
  39. {  
  40.     return (a+b);  
  41. }  
  42. int sub(int a,int b)  
  43. {  
  44.     return (a-b);  
  45. }  
  46. int mul(int a,int b)  
  47. {  
  48.     return a*b;  
  49. }  
  50. int divide(int a,int b)  
  51. {  
  52.     if (b == 0)  
  53.     {  
  54.     exit(-1);  
  55.     }  
  56.     else  
  57.     return a/b;  
  58. }  
执行结果:

技术分享图片

这个样例用到了+ - * / 的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.   
  19. Point::Point()  
  20. {   
  21.     X=Y=0;  
  22. }  
  23. Point::Point(int xx,int yy)  
  24. {   
  25.     X = xx;  
  26.     Y = yy;  
  27. }  
  28. Point::Point(const Point &ref)  
  29. {  
  30.     X = ref.X;  
  31.     Y = ref.Y;  
  32. }  
  33. Point ::~Point()  
  34. {   
  35. }  
  36. void Point ::Move(int x,int y)  
  37. {   
  38.     X+=x; Y+=y;   
  39. }  
  40.   
  41. void main()  
  42. {  
  43.     Point A(4,5);  
  44.     //声明对象指针并初始化  
  45.     Point *p1=&A;  
  46.   
  47.     //声明成员函数指针并初始化  
  48.     int(Point::*p_GetX)()=Point::GetX;  
  49.     //(1)使用成员函数指针訪问成员函数  
  50.     cout<<(A.*p_GetX)()<<endl;  
  51.     //(2)使用对象指针訪问成员函数  
  52.     cout<<(p1->GetX)()<<endl;  
  53.     //(3)使用对象名訪问成员函数  
  54.     cout<<A.GetX()<<endl;  
  55. }  

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

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

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

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

技术分享图片

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

[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.   
  17.   
  18. Point::Point(Point &p)  
  19. {X=p.X; Y=p.Y; countP++; }  
  20. int Point::countP=0;//静态数据成员定义性说明  
  21.   
  22. void main()//主函数  
  23. {  
  24.     //指向类的静态成员函数的指针,  
  25.     void (*gc)()=Point::GetC;  
  26.     Point A(4,5);//定义对象A  
  27.     cout<<"Point A,"<<A.GetX()<<","<<A.GetY();  
  28.     gc();//通过指针訪问静态函数成员,输出对象序号  
  29.     Point B(A);//定义对象B  
  30.     cout<<"Point B,"<<B.GetX()<<","<<B.GetY();  
  31.     gc();//通过指针訪问静态函数成员  
  32. }  
执行结果:

技术分享图片

6.指针与数组的差别

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

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

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

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

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

如:

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

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

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




























以上是关于C++ 指针(不论什么一个指针本身的类型都是unsigned long int型)的主要内容,如果未能解决你的问题,请参考以下文章

C++指针详解

C++指针详解 (转)

c++指针解析

C++ 指针详解

C++ 指针详解

c++复习篇