• 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 != '') *p++=*p1++;  
    8.     while (*p2 != '') *p++=*p2++;  
    9.     *p=*p2;  
    10.     return a;  
    11. }  
    12.   
    13. void main()  
    14. {  
    15.     char s1[80],s2[80];  
    16.     printf(" 请输入第一串字符: ");  
    17.     //注意：scanf和cin在输入字符串时，遇到空格就终止，而gets 不会。  
    18.     gets(s1);  
    19.     //cin >> s1;  
    20.     //scanf("%s", s1);  
    21.     fflush(stdin);  
    22.     printf(" 请输入第二串字符: ");  
    23.     gets(s2);  
    24.     //cin >> s2;  
    25.     //scanf("%s", s2);  
    26.     printf(" 连接结果:  ");  
    27.     printf(" 第一串在前第二串在后: %s  ",my_cat(s1,s2));  
    28.     printf(" 第二串在前第一串在后: %s  ",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 : ");  
    28.         fflush(stdin);  
    29.         scanf("%d %c %d",&item1,&op,&item2);  
    30.         result = pfun[op-'*'](item1,item2);    //用到了是 + - * /  的ASCII特性  
    31.         printf("%d %c %d = %d  ",item1,op,item2,result);  
    32.         printf("try again ? please input y\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行，但每行可长短不等

    数组有更好的可读性，可随机訪问各元素；指针可读性差，更适合顺序訪问。
  • 相关阅读:
    帮Netpole Review了一下RichEditor控件
    WawaKMv1命名空间.rtf
    WawaKMV1需求变更.rtf
    WawaKMV1技术难点.rtf
    WawaKMV1工具栏设计.rtf
    通讯录相关需求分析
    WawaKMV1Urtal Recall分析.rtf
    WawaKM:关于批量抓图的需求分析及设计
    图片相关的需求分析
    蛙蛙郑重推荐您使用firefox浏览器
  • 原文地址：https://www.cnblogs.com/llguanli/p/8277361.html
Copyright © 2020-2023  润新知