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行，但每行可长短不等

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

原文地址：https://www.cnblogs.com/llguanli/p/8277361.html

时间： 2024-10-19 13:29:41

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

【c语言】写一个宏定义，实现的功能是将一个int型的数的奇偶位互换

// 写一个宏定义,实现的功能是将一个int型的数的奇偶位互换,例如6的二进制为0110,第一位与第二位互换, // 第三位与第四位互换,得到1001,输出应该为9 #include <stdio.h> // 取出奇数位与偶数位,奇数位左移1位,偶数位一位,相加或者相或 #define EXCHANGE(num) (((0x55555555 & num) << 1) + ((0xaaaaaaaa & num) >> 1)) int main() { pr

编写Java应用程序。首先，定义一个时钟类——Clock，它包括三个int型 成员变量分别表示时、分、秒，一个构造方法用于对三个成员变量（时、分、秒） 进行初始化，还有一个成员方法show()用于显示时钟对象的时间。其次，再定义 一个主类——TestClass，在主类的main方法中创建多个时钟类的对象，使用这 些对象调用方法show()来显示时钟的时间。

package com.homework.zw; public class Clock { String hour; String minute; String second; Clock(String h,String m, String s) { hour=h; minute=m; second=s; } void show() { System.out.println("时间为:"+hour+"时"+minute+"分"+second+&q

定义一个时钟类——Clock，它包括三个int型 成员变量分别表示时、分、秒，一个构造方法用于对三个成员变量（时、分、秒） 进行初始化，还有一个成员方法show()用于显示时钟对象的时间。其次，再定义 一个主类——TestClass，在主类的main方法中创建多个时钟类的对象，使用这 些对象调用方法show()来显示时钟的时间

package java1; public class Clock { int hhh; int mmm; int sss; Clock(int h,int m,int s) { hhh=h; mmm=m; sss=s; } void show() { System.out.println(hhh+":"+mmm+":"+sss); } } Clock c1=new Clock(11,23,45); c1.show(); Clock c2=new Clock(12,

再谈指针数组与数组指针

经常遇到这两个概念,很容易混淆,这里细细总结一下. 指针数组:是一个数组,数组的元素是指针.数组占多少个字节由数组本身决定. 数组指针:是一个指针,它指向一个数组.在32位系统下永远是占4 个字节. 举例说明: 1)int *p1[n]; 2)int (*p2)[n]; 1)"[]"的优先级比"*"要高.p1 先与"[]"结合,构成一个数组的定义,数组名为p1,int *修饰的是数组的内容,即数组的每个元素.即p1是指针数组,其包含n个指向int

指针数组，数组指针，指针函数，函数指针，二级指针详解

先看个简单的:char *p,这定义了一个指针,指针指向的数据类型是字符型,char  *(p)定义了一个指针P: char *p[4], 为指针数组,由于[]的优先级高于*,所以p先和[]结合,p[]是一个数组,暂时把p[]看成是q,也就是char *(q),定义了一个指针q,只不过q是一个数组罢了,故定义了一个数组,数组里面的数据是char *的,所以数组里面的数据为指针类型.所以char *p[4]是四个指针,这四个指针组成了一个数组,称为指针数组,既有多个指针组成的数组. char(*p

深入理解C指针之一：初识指针

简单来说,指针包含的就是内存地址.理解指针关键在于理解C的内存管理模式.C里面有三种内存: ①.静态全局内存(生命周期从程序开始到程序结束,全局变量作用域是全局,静态变量作用域在定义它们的函数内部): ②.自动内存(在函数内部声明的变量,在函数被调用时创建,作用域和生命周期都在函数内部): ③.动态内存(内存分配在堆上,根据需要释放,通过指针引用,作用域局限于引用的指针): 下面先来生命一个指针并打印其地址和值,这里p%指的是以十六进制的形式返回数据: #include <stdio.h> m

C++数组指针、指针数组、函数指针的核心概念

1.什么叫数组指针? 数组指针:一个指向一维或者多维数组的指针. 比如:int * b=new int[10];指向一维数组的指针b ; 注意,这个时候释放空间一定要delete [] ,否则会造成内存泄露,b 就成为了空悬指针.         int (*b2)[10]=new int[10][10]; 注意,这里的b2指向了一个二维int型数组的首地址.         注意:在这里,b2等效于二维数组名,但没有指出其边界,即最高维的元素数量,但是它的最低维数的元素数量必须要指定!就像指向

校招笔试复习——指针数组与数组指针

一.先看一组定义 1.一个整型数   int a; 2.一个指向整型数的指针    int *a; 3.一个指向指针的指针,它指向的指针指向一个整型数    int **a; 4.一个有5个整型数的数组    int a[5]; 5.一个有5个指针的数组,该指针指向一个整型数    int *a[5]; 6.一个指向有5个整型数数组的指针   int (*a)[5]; 7.一个指向函数的指针,该函数有一个整型参数并返回一个整型数    int (*a)(int); 8.一个有5个指针的数组,该指

解析 指针数组，数组指针，函数指针

一 :关于指针和堆的内存分配 指针数组 : 一个数组里放的都是指针,我们把他叫做指针数组 int * a[10]; 由于它是一个数组,他是不能从堆空间里申请空间的. 只能做个循环,每个元素去申请空间,或者每个元素去指向另外的地址空间. 数组指针 : 一个指向一唯或者多唯数组的指针: int * b=new int[10]; 指向一唯数组的指针b ; 一些例子: int (*b2)[10]=new int[10][10]; 注意,这里的b2指向了一个二唯int型数组的首地址. 注意,这里的b2的类