C++ 指针实例

1、编写程序，使用一维数组读写二维数组的数据，并与普通二维数组直接读写数据的结果进行比较

实例: 使用一维指针数组读写二维数组数据

#include<bits/stdc++.h>
using namespace std;

//使用一维指针数组读写二维数组数据

const int N = 1e4+10;

int *a[N];//指针数组
int b[N][N];//二维数组
int n,m;//n 是行，m 是列

int main()
{
	
	cout<<"请输入二维数组的行"<<endl;
	cin>>n;
	cout<<"请输入二维数组的列"<<endl;
	cin>>m;
	cout<<"请输入数据"<<endl;
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cin>>b[i][j];
		}//把数据先存进二维数组
		a[i]=b[i];//把二维数组每一行的列首地址给指针数组
	}
	
	cout<<"指针数组输出数据为:"<<endl;
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cout<<a[i][j]<<" ";
		}
		cout<<endl;
	}//利用指针数组输出数据	
	
	cout<<"二维数组输出数据为:"<<endl;
	
	for(int i=1;i<=n;i++)
	{
		for(int j=1;j<=m;j++)
		{
			cout<<b[i][j]<<" ";
		}
		cout<<endl;
	}//利用二维数组输出数据	
}

2. 编写具有一定功能的简单程序,要求用到对象指针、this指针、指向类成员的指针(包含类普通数据成员，类函数成员以及静态数据成员、静态函数成员)等语法机制。

对象指针 this指针 指向非静态数据成员的指针 指向非静态函数成员的指针

1.对象指针就是存放指针地址的变量，遵循一般指针变量的各种规则

声明形式：
Point a(1,0);
Point *p=&a;

访问成员的语法形式： 对象指针名->成员名
例:p->getX()

2.this 指针

this 指针用于指向正在被函数成员操作的对象，不咋常用，不详细介绍，有兴趣的同学去看看其他大佬的博客吧；

return x;
return this->x;

3. 指向非静态数据成员的指针

声明形式：
类型说明符  类名::*指针名
例：double Point::*px;

访问成员的语法形式： 
对象名.*类成员指针名
或
对象指针名->*类成员指针名
例:
p->*px;
a.*px;

4.指向静态函数成员的指针

声明形式：
类型说明符 (类名::*指针名)(参数表)
例：double (Point::*gx)();

访问成员的语法形式： 
(对象名.*类成员指针名)(参数表)
或
(对象指针名->*类成员指针名)(参数表)
例:
(p->*gx)();
(a.*gx)();
注意是两个括号很重要！！

5.实例(Point类)

#include<bits/stdc++.h>
using namespace std;

//对象指针
//this指针
//指向数据成员的指针
//指向函数成员的指针

class Point{
	public:
		double x,y;
	public:
		Point(double xx,double yy)
		{
			x=xx;
			y=yy;
		}//构造函数
		~Point(){}//析构函数
		Point(Point &p)
		{
			x=p.x;
			y=p.y;
		}//复制构造函数
		
		double getX(){
			return this->x;
		}//获得横坐标
		double getY(){
			return this->y;//利用this函数获得目的对象的对应数据
		}//获得纵坐标
};

double Point::*px = &Point::x;
double Point::*py = &Point::y;//指向类数据成员的指针

double (Point::*gx)() = &Point::getX;
double (Point::*gy)() = &Point::getY;//指向类函数成员的指针

int main()
{
	Point a(3,2);//构造一个点对象
	Point *b;//创建一个点对象指针
	
	b=&a;//给点对象指针赋值
	cout<<b->getX()<<endl;//利用对象指针获得点的横坐标
	
	cout<<b->*px<<endl;//利用对象指针和指向类数据成员的指针获得横坐标
	cout<<a.*py<<endl;//利用指向类数据成员的指针获得纵坐标
	
	cout<<(a.*gx)()<<endl;//利用指向类函数成员的指针获得横坐标
	cout<<(b->*gx)();//利用对象指针和指向类函数成员的指针获得横坐标
	
}

指向静态数据成员的指针和指向静态函数成员的指针

1.指向静态数据成员的指针

声明形式：
类型说明符  *指针名=&类名::静态数据成员名
例:
int *nums=&Cat::numOfCats;

访问形式：
这样访问要注意要把静态数据成员定义成public类型
cout<<*指针名;

2.指向静态函数成员的指针

声明形式：
类型说明符 (*指针名)(参数表)=类名::静态函数成员名
例:
void (*getnums)() = Cat::getNumOfCats;

访问形式：getnums();
注意声明的时候没有&

3.实例(Cat类)

#include<bits/stdc++.h>
using namespace std;

//静态数据成员指针
//静态函数成员指针

class Cat{
	public:
		Cat(int age1=0)
		{
			age=age1;
			numOfCats++;
		}//构造函数，总数加一
		~Cat()
		{
			numOfCats--;
		}//析构函数，个数减一
		Cat(Cat &p)
		{
			age=p.age;
			numOfCats++;
		}//复制构造函数，个数加一
		void getage()
		{
			cout<<age<<endl;
		}//输出年龄
		static void getNumOfCats()
		{
			cout<<"cat的数量为："<<numOfCats<<endl;
		}//静态成员函数  输出总数
		void reage(int age1)
		{
			age=age1;
		}//修改年龄
		static int numOfCats;//静态数据成员，注意定义成共有的
		
	private:
		int age; 
};

int Cat::numOfCats=0;//外部定义一次，赋初值，开辟单独空间

int main()
{
	Cat a(12);
	int *nums=&Cat::numOfCats;
	cout<<*nums<<endl;//创建对象a 利用构造函数   利用指向静态数据成员指针输出总个数
	Cat b=a;
	cout<<*nums<<endl;//创建对象b 利用复制构造函数 利用指向静态数据成员指针输出总个数
	
	
	void (*getnums)() = Cat::getNumOfCats;
	
	getnums();//利用指向静态函数成员指针输出总个数
	
}