C++ 指针(不论什么一个指针本身的类型都是unsigned long int型)
2018-01-12 19:14
309 查看
1.指针数组: 即 数组的元素是指针型;
例:int*pa[2];
明明是一维的指针数组。竟当作二维数组用。
[cpp] view
plain copy
//利用指针数组存放单位矩阵
#include <iostream>
using namespace std;
void main()
{
int line1[]={1,0,0}; //声明数组,矩阵的第一行
int line2[]={0,1,0}; //声明数组,矩阵的第二行
int line3[]={0,0,1}; //声明数组。矩阵的第三行
int* p_line[3];//声明整型指针数组
//对指针数组元素赋初值
p_line[0]=line1;
p_line[1]=line2;
p_line[2]=line3;
//输出单位矩阵
cout<<"Matrix test:"<<endl;
for(int i=0;i<3;i++) //对矩阵每一行循环
{
for(int j=0;j<3;j++)//对数组元素循环
{
//明明是一维的指针数组。竟当作二维数组用
cout<<p_line[i][j]<<" ";
}
cout<<endl;
}
}
输出结果:
Matrix test:
1 0 0
0 1 0
0 0 1
2.指针型函数
当函数的返回值是地址时,该函数就叫指针形函数,又叫返回指针的函数。
声明形式:数据类型* 函数名( )
指针型函数的使用(串连接)
[cpp] view
plain copy
//指针型函数的使用(串连接)
#include <stdio.h>
char *my_cat(char *p1, char *p2)
{
static char a[160],*p;
p=a;
while (*p1 != '\0') *p++=*p1++;
while (*p2 != '\0') *p++=*p2++;
*p=*p2;
return a;
}
void main()
{
char s1[80],s2[80];
printf("\n请输入第一串字符: ");
//注意:scanf和cin在输入字符串时,遇到空格就终止,而gets 不会。
gets(s1);
//cin >> s1;
//scanf("%s", s1);
fflush(stdin);
printf("\n请输入第二串字符: ");
gets(s2);
//cin >> s2;
//scanf("%s", s2);
printf("\n连接结果: \n");
printf("\n第一串在前第二串在后: %s \n",my_cat(s1,s2));
printf("\n第二串在前第一串在后: %s \n",my_cat(s2,s1));
}
执行结果:
请输入第一串字符: dalian
请输入第二串字符: i love you
连接结果:
第一串在前第二串在后: daliani love you
第二串在前第一串在后: i love youdalian
3.指向函数的指针
3.1指向函数的指针
声明形式: 数据类型 (*函数指针名) ( 形參表);
含义: 数据指针指向的是数据存储区;而函数指针指向的是程序代码存储区。函数名就是地址。
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/abb4ba1bc6d22b1dfbb5d87e14ef810f.gif)
3.2 指向函数的指针数组: 指向函数的指针可组成数组。
声明形式; 数据类型 (*函数指针名[ ] )( 形參表);
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/dcc38b93cfe12f77cac5f2d2d7cb49d2.gif)
[cpp] view
plain copy
/************************************************************************
练习:写一个程序,依据用户的输入数据算出结果:
仅仅写出四种运算就能够。
比如:
1 + 2 = 3
1 * 2 = 2
1 –2 = -1
1 / 2 = 0
**************************************************************************/
#include <stdio.h>
#include <stdlib.h>
typedef int (*pFun[])(int,int);
int add(int,int);
int sub(int,int);
int mul(int ,int);
int divide(int,int);
void main()
{
pFun pfun = {mul,add,NULL,sub,NULL,divide};
//也能够这样:int (*pfun[])(int,int) ={mul,add,NULL,sub,NULL,divide};
int item1,item2;
int result;
char op;
do
{
printf("Please input :\n");
fflush(stdin);
scanf("%d %c %d",&item1,&op,&item2);
result = pfun[op-'*'](item1,item2); //用到了是 + - * / 的ASCII特性
printf("%d %c %d = %d \n",item1,op,item2,result);
printf("try again ? please input y\\n\n");
fflush(stdin);
scanf("%c",&op);
} while(op == 'y');
}
int add(int a,int b)
{
return (a+b);
}
int sub(int a,int b)
{
return (a-b);
}
int mul(int a,int b)
{
return a*b;
}
int divide(int a,int b)
{
if (b == 0)
{
exit(-1);
}
else
return a/b;
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/b0d8af1e7814874a06301bb182cc0a49.gif)
这个样例用到了+ - * / 的ASCII码
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/8e728aebd70e814eeef07a58fbee4ec6.gif)
4.this指针
隐含于类中的每个非静态成员函数中的特殊指针。
明白地指出了成员函数当前所操作的数据所属的对象。
–当通过一个对象调用成员函数时。系统先将该对象的地址赋给this指针。然后调用成员函数。成员函数对对象的数据成员进行操作时。
就隐含使用了this指针。(this是函数的第一个形參。)
5. 关于指向类成员的指针
5.1 指向类的非静态成员的指针
通过指向成员的指针仅仅能訪问公有成员
声明指向成员的指针
–声明指向公有数据成员的指针
类型说明符 类名::*指针名。
–声明指向公有函数成员的指针
类型说明符 (类名::*指针名)(參数表)。
注意:应当知道,指向成员的指针名曰指针。实则非也。它是个偏移量,记录着该成员距离对象的首址的距离。
故定义它时,总要前缀着类名(类名::),以便于编译器识别后予以特别处理。
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/f047a27872313bf2b33d7fd32a6f243e.gif)
使用指向数据成员的指针
对指向数据成员的指针赋值: –说明指针应该指向哪个成员 指针名=&类名::数据成员名;
使用指向数据成员的指针: –通过对象名(或对象指针)与成员指针联手来訪问数据成员
对象名.* 类成员指针名 或: 对象指针名->*类成员指针名
使用指向函数成员的指针
指向函数成员的指针
–初始化指针名=类名::函数成员名;
–通过对象名(或对象指针)与成员指针结合来訪问函数成员
(对象名.* 类成员指针名)(參数表) 或: (对象指针名—>*类成员指针名)(參数表)
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point
{
public:
Point();
Point(int xx,int yy);
Point(const Point &ref);
~Point();
void Move(int x,int y);
int GetX() {return X;}
int GetY() {return Y;}
void Print() const
{cout << "X=" << X <<", "<< "Y=" << Y << endl;}
private:
int X,Y;
};
Point::Point()
{
X=Y=0;
}
Point::Point(int xx,int yy)
{
X = xx;
Y = yy;
}
Point::Point(const Point &ref)
{
X = ref.X;
Y = ref.Y;
}
Point ::~Point()
{
}
void Point ::Move(int x,int y)
{
X+=x; Y+=y;
}
void main()
{
Point A(4,5);
//声明对象指针并初始化
Point *p1=&A;
//声明成员函数指针并初始化
int(Point::*p_GetX)()=Point::GetX;
//(1)使用成员函数指针訪问成员函数
cout<<(A.*p_GetX)()<<endl;
//(2)使用对象指针訪问成员函数
cout<<(p1->GetX)()<<endl;
//(3)使用对象名訪问成员函数
cout<<A.GetX()<<endl;
}
5.2 指向类的静态成员的指针
对类的静态成员(类共享)的訪问不依赖于对象,能够用普通的指针来指向和訪问静态成员
通过指针訪问类的静态数据成员
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point//Point类声明
{
public://外部接口
Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
Point(Point &p);//拷贝构造函数
int GetX() {return X;}
int GetY() {return Y;}
static int countP;//静态数据成员引用性说明
private://私有数据成员
int X,Y;
};
Point::Point(Point &p)
{
X=p.X; Y=p.Y; countP++;
}
int Point::countP=0;//静态数据成员定义性说明
void main()
{
//声明一个int型指针,指向类的静态成员
int*count = &Point::countP;
Point A(4,5);
cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
//直接通过指针訪问静态数据成员
cout<<" Object id="<<*count<<endl;
Point B(A);//声明对象B
cout<<"Point B,"<<B.GetX() <<","<<B.GetY();
//直接通过指针訪问静态数据成员
cout<<" Object id="<<*count<<endl;
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/4d52390e45076aea25ac00e8834b6407.gif)
通过指针訪问类的静态函数成员
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point//Point类声明
{
public://外部接口
Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
Point(Point &p);//拷贝构造函数
int GetX() {return X;}
int GetY() {return Y;}
static void GetC() //静态函数成员
{cout<<" Object id="<<countP<<endl;}
private://私有数据成员
int X,Y;
static int countP;//静态数据成员引用性说明
};
Point::Point(Point &p)
{X=p.X; Y=p.Y; countP++; }
int Point::countP=0;//静态数据成员定义性说明
void main()//主函数
{
//指向类的静态成员函数的指针,
void (*gc)()=Point::GetC;
Point A(4,5);//定义对象A
cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
gc();//通过指针訪问静态函数成员,输出对象序号
Point B(A);//定义对象B
cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
gc();//通过指针訪问静态函数成员
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/4d52390e45076aea25ac00e8834b6407.gif)
6.指针与数组的差别
数组名是静态的,一旦定义,其值就固定不变了。
而指针是动态的。可随时变化。
数组名是常量,不可作为算术运算的左值。指针是变量,可作为算术运算的左值。
在訪问速度上。用数组表达式慢,用指针快。
指针比数组有更大的灵活性。
如:
char a[10] [20]; //这是个固定了行和列的矩阵
char * b[10]; //有10行,但每行可长短不等
数组有更好的可读性,可随机訪问各元素;指针可读性差,更适合顺序訪问。
例:int*pa[2];
明明是一维的指针数组。竟当作二维数组用。
[cpp] view
plain copy
//利用指针数组存放单位矩阵
#include <iostream>
using namespace std;
void main()
{
int line1[]={1,0,0}; //声明数组,矩阵的第一行
int line2[]={0,1,0}; //声明数组,矩阵的第二行
int line3[]={0,0,1}; //声明数组。矩阵的第三行
int* p_line[3];//声明整型指针数组
//对指针数组元素赋初值
p_line[0]=line1;
p_line[1]=line2;
p_line[2]=line3;
//输出单位矩阵
cout<<"Matrix test:"<<endl;
for(int i=0;i<3;i++) //对矩阵每一行循环
{
for(int j=0;j<3;j++)//对数组元素循环
{
//明明是一维的指针数组。竟当作二维数组用
cout<<p_line[i][j]<<" ";
}
cout<<endl;
}
}
输出结果:
Matrix test:
1 0 0
0 1 0
0 0 1
2.指针型函数
当函数的返回值是地址时,该函数就叫指针形函数,又叫返回指针的函数。
声明形式:数据类型* 函数名( )
指针型函数的使用(串连接)
[cpp] view
plain copy
//指针型函数的使用(串连接)
#include <stdio.h>
char *my_cat(char *p1, char *p2)
{
static char a[160],*p;
p=a;
while (*p1 != '\0') *p++=*p1++;
while (*p2 != '\0') *p++=*p2++;
*p=*p2;
return a;
}
void main()
{
char s1[80],s2[80];
printf("\n请输入第一串字符: ");
//注意:scanf和cin在输入字符串时,遇到空格就终止,而gets 不会。
gets(s1);
//cin >> s1;
//scanf("%s", s1);
fflush(stdin);
printf("\n请输入第二串字符: ");
gets(s2);
//cin >> s2;
//scanf("%s", s2);
printf("\n连接结果: \n");
printf("\n第一串在前第二串在后: %s \n",my_cat(s1,s2));
printf("\n第二串在前第一串在后: %s \n",my_cat(s2,s1));
}
执行结果:
请输入第一串字符: dalian
请输入第二串字符: i love you
连接结果:
第一串在前第二串在后: daliani love you
第二串在前第一串在后: i love youdalian
3.指向函数的指针
3.1指向函数的指针
声明形式: 数据类型 (*函数指针名) ( 形參表);
含义: 数据指针指向的是数据存储区;而函数指针指向的是程序代码存储区。函数名就是地址。
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/abb4ba1bc6d22b1dfbb5d87e14ef810f.gif)
3.2 指向函数的指针数组: 指向函数的指针可组成数组。
声明形式; 数据类型 (*函数指针名[ ] )( 形參表);
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/dcc38b93cfe12f77cac5f2d2d7cb49d2.gif)
[cpp] view
plain copy
/************************************************************************
练习:写一个程序,依据用户的输入数据算出结果:
仅仅写出四种运算就能够。
比如:
1 + 2 = 3
1 * 2 = 2
1 –2 = -1
1 / 2 = 0
**************************************************************************/
#include <stdio.h>
#include <stdlib.h>
typedef int (*pFun[])(int,int);
int add(int,int);
int sub(int,int);
int mul(int ,int);
int divide(int,int);
void main()
{
pFun pfun = {mul,add,NULL,sub,NULL,divide};
//也能够这样:int (*pfun[])(int,int) ={mul,add,NULL,sub,NULL,divide};
int item1,item2;
int result;
char op;
do
{
printf("Please input :\n");
fflush(stdin);
scanf("%d %c %d",&item1,&op,&item2);
result = pfun[op-'*'](item1,item2); //用到了是 + - * / 的ASCII特性
printf("%d %c %d = %d \n",item1,op,item2,result);
printf("try again ? please input y\\n\n");
fflush(stdin);
scanf("%c",&op);
} while(op == 'y');
}
int add(int a,int b)
{
return (a+b);
}
int sub(int a,int b)
{
return (a-b);
}
int mul(int a,int b)
{
return a*b;
}
int divide(int a,int b)
{
if (b == 0)
{
exit(-1);
}
else
return a/b;
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/b0d8af1e7814874a06301bb182cc0a49.gif)
这个样例用到了+ - * / 的ASCII码
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/8e728aebd70e814eeef07a58fbee4ec6.gif)
4.this指针
隐含于类中的每个非静态成员函数中的特殊指针。
明白地指出了成员函数当前所操作的数据所属的对象。
–当通过一个对象调用成员函数时。系统先将该对象的地址赋给this指针。然后调用成员函数。成员函数对对象的数据成员进行操作时。
就隐含使用了this指针。(this是函数的第一个形參。)
5. 关于指向类成员的指针
5.1 指向类的非静态成员的指针
通过指向成员的指针仅仅能訪问公有成员
声明指向成员的指针
–声明指向公有数据成员的指针
类型说明符 类名::*指针名。
–声明指向公有函数成员的指针
类型说明符 (类名::*指针名)(參数表)。
注意:应当知道,指向成员的指针名曰指针。实则非也。它是个偏移量,记录着该成员距离对象的首址的距离。
故定义它时,总要前缀着类名(类名::),以便于编译器识别后予以特别处理。
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/f047a27872313bf2b33d7fd32a6f243e.gif)
使用指向数据成员的指针
对指向数据成员的指针赋值: –说明指针应该指向哪个成员 指针名=&类名::数据成员名;
使用指向数据成员的指针: –通过对象名(或对象指针)与成员指针联手来訪问数据成员
对象名.* 类成员指针名 或: 对象指针名->*类成员指针名
使用指向函数成员的指针
指向函数成员的指针
–初始化指针名=类名::函数成员名;
–通过对象名(或对象指针)与成员指针结合来訪问函数成员
(对象名.* 类成员指针名)(參数表) 或: (对象指针名—>*类成员指针名)(參数表)
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point
{
public:
Point();
Point(int xx,int yy);
Point(const Point &ref);
~Point();
void Move(int x,int y);
int GetX() {return X;}
int GetY() {return Y;}
void Print() const
{cout << "X=" << X <<", "<< "Y=" << Y << endl;}
private:
int X,Y;
};
Point::Point()
{
X=Y=0;
}
Point::Point(int xx,int yy)
{
X = xx;
Y = yy;
}
Point::Point(const Point &ref)
{
X = ref.X;
Y = ref.Y;
}
Point ::~Point()
{
}
void Point ::Move(int x,int y)
{
X+=x; Y+=y;
}
void main()
{
Point A(4,5);
//声明对象指针并初始化
Point *p1=&A;
//声明成员函数指针并初始化
int(Point::*p_GetX)()=Point::GetX;
//(1)使用成员函数指针訪问成员函数
cout<<(A.*p_GetX)()<<endl;
//(2)使用对象指针訪问成员函数
cout<<(p1->GetX)()<<endl;
//(3)使用对象名訪问成员函数
cout<<A.GetX()<<endl;
}
5.2 指向类的静态成员的指针
对类的静态成员(类共享)的訪问不依赖于对象,能够用普通的指针来指向和訪问静态成员
通过指针訪问类的静态数据成员
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point//Point类声明
{
public://外部接口
Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
Point(Point &p);//拷贝构造函数
int GetX() {return X;}
int GetY() {return Y;}
static int countP;//静态数据成员引用性说明
private://私有数据成员
int X,Y;
};
Point::Point(Point &p)
{
X=p.X; Y=p.Y; countP++;
}
int Point::countP=0;//静态数据成员定义性说明
void main()
{
//声明一个int型指针,指向类的静态成员
int*count = &Point::countP;
Point A(4,5);
cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
//直接通过指针訪问静态数据成员
cout<<" Object id="<<*count<<endl;
Point B(A);//声明对象B
cout<<"Point B,"<<B.GetX() <<","<<B.GetY();
//直接通过指针訪问静态数据成员
cout<<" Object id="<<*count<<endl;
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/4d52390e45076aea25ac00e8834b6407.gif)
通过指针訪问类的静态函数成员
[cpp] view
plain copy
#include <iostream>
using namespace std;
class Point//Point类声明
{
public://外部接口
Point(int xx=0, int yy=0) {X=xx;Y=yy;countP++;} //构造函数
Point(Point &p);//拷贝构造函数
int GetX() {return X;}
int GetY() {return Y;}
static void GetC() //静态函数成员
{cout<<" Object id="<<countP<<endl;}
private://私有数据成员
int X,Y;
static int countP;//静态数据成员引用性说明
};
Point::Point(Point &p)
{X=p.X; Y=p.Y; countP++; }
int Point::countP=0;//静态数据成员定义性说明
void main()//主函数
{
//指向类的静态成员函数的指针,
void (*gc)()=Point::GetC;
Point A(4,5);//定义对象A
cout<<"Point A,"<<A.GetX()<<","<<A.GetY();
gc();//通过指针訪问静态函数成员,输出对象序号
Point B(A);//定义对象B
cout<<"Point B,"<<B.GetX()<<","<<B.GetY();
gc();//通过指针訪问静态函数成员
}
执行结果:
![](https://oscdn.geek-share.com/Uploads/Images/Content/201110/4d52390e45076aea25ac00e8834b6407.gif)
6.指针与数组的差别
数组名是静态的,一旦定义,其值就固定不变了。
而指针是动态的。可随时变化。
数组名是常量,不可作为算术运算的左值。指针是变量,可作为算术运算的左值。
在訪问速度上。用数组表达式慢,用指针快。
指针比数组有更大的灵活性。
如:
char a[10] [20]; //这是个固定了行和列的矩阵
char * b[10]; //有10行,但每行可长短不等
数组有更好的可读性,可随机訪问各元素;指针可读性差,更适合顺序訪问。
相关文章推荐
- C++ 指针(任何一个指针本身的类型都是unsigned long int型)
- C++ 指针(任何一个指针本身的类型都是unsigned long int型)
- 练一练思维缜密程度。有程式xyz+yzz=532,其中x、y、z都是整数,用c++编写一个程序,求x、y、z分别代表什么数字
- C++输出时指针类型自动转换为bool类型输出的一个小疑问
- 函数的返回类型可以为值、指针、引用,这三种返回类型有什么不同,各有什么好处?(c++)
- ##(两个井号)和#(一个井号)都是什么意思C and C++ 2008-09-23 21:18:27 阅读1106 评论0 字号:大中小 订阅 .
- C/C++—— 写一个函数,它的参数为指向函数的指针,返回类型也为指向函数的指针
- 编写程序定义一个vector 对象,其每个元素都是指向string 类型的指针,读 取该vector 对象,输出每个string 的内容及其相应的长度。
- go语言笔记——切片底层本质是共享数组内存!!!绝对不要用指针指向 slice切片本身已经是一个引用类型就是指针
- C++学习笔记二 —— 3.3 指针类型
- 22、C++用指针作函数参数,定义一个函数,并用函数交换两个整型变量的值
- C/C++语言中的void及void指针类型
- Java的引用和C++的指针有什么区别?
- C++:delete不完整类型的指针
- C++中的const关键字系列——常类型与常指针之间的纠缠
- C#中调用C++的dll的参数为指针类型的导出函数(包括二级指针的情况)
- C++多重继承下的指针类型转换
- [Boolan] C++第二周(创建一个带指针成员变量的类)[注意事项]
- 如何检测或判断一个文件或字节流(无BOM)是什么编码类型
- C++回顾(二)——C++数据类型及指针