c++那些事儿9 0指针-CSDN博客

###知识点综述：

指针：地址。
    1.0在32位的cpu上，cpu一般由32根地址线组成，所以地址大小为32位
	即4byte，同理可得指针大小为4byte；
	
	2.0指针是有类型的，和它指向的数据类型相同;
	double p1=11,*p2;  p2=&p1;//p2为double型指针 
	 
	3.0数组名是一个const指针。
	   int arr[6]; arr是常量指针。
	   二维数组名是指向行的指针，它指向一整行元素而非个别元素
	   array[m][n] array代表第0行首地址,array+1代表第一行首地址地址
	   其每一元素的地址访问有5中方式：
	   &a[m][n];  a[m]+n;  *(a+m)+n;  &a[0][0]+4*m+n; a[0]+4*m+n;
	   指向二维数组行的指针变量
	    类型说明符 (*指针变量名)[长度]  int (*p)[n];


	4.0 指针可以和整数进行加减运算.指向同一个数组的2个指针可以
	进行大小比较，二个指针变量可以相减其结果是数组相隔元素的个数。
	5.0 指针与动态分配:
	   动态开辟空间后，需要指针指向这片空间。
	  int *p=new int[8];
    6.0 指向对象的指针。
	  可以用指针的方式访问数据成员和成员函数。
	7.0空指针;指针变量赋予0值得到的。
	   int *p; p=null;
	8.0 指针的指针。
	  指针也是一个变量，当然也有地址。
	  指针的转换.
	    int *p1; 
		double *p2=(double *)p2;
		
	9.0指针函数。//指向指针的函数。
	  int fun(char *,int);
	  int (*pfun)(char*,int);
	  pfun1=fun;
  10.0 C/C++函数参数分为传值和传地址二种。
       指针作为参数传递地址，原来值被改变。
	   值作为参数，函数形参的值只是原值的复制，不会改变原值。

复制代码

###相关代码：

#include<iostream> 
#include<string>
using namespace std;
class Student {
public:
	string name;
	int age;
	void display();
};

void Student::display() {
	cout << "name:"<<name<<" " << "age:" << age << endl;
}

template<typename T>
void exchange(T *t1, T *t2) {
	T temp;
	temp = *t2;
	*t2 = *t1;
	*t1 = temp;
}

template<typename T>
void exchange(T t1, T t2) {
	T temp;
	temp = t2;
	t2 = t1;
	t1 = temp;
}

int main() {
	int var = 66;
	int *p;  //定义一个int指针
	p = &var; //p指向int
	cout << "var的地址为:" << p << endl;
	cout << "指针的大小为:" << sizeof(p) << endl;
	cout << "var的值为：" << *p << endl;
	int arr[6], *p1;
	//数组名，是数组的首地址。 
	cout << "数组的首地址为:" << arr << endl;
	cout << "数组第一个元素的首地址：" << &arr[0] << endl;
	for (int i = 0; i<6; i++) {
		arr[i] = i + 1;
	}
	p1 = arr;
	//采用数组名作为指针访问 
	cout << "数组的第1个元素" << *arr << endl;
	cout << "数组的第2个元素" << *(arr + 1) << endl;
	//采用指针访问 
	cout << "数组的第3个元素" << *(p1 + 2) << endl;
	cout << "数组的第4个元素" << *(p1 + 3) << endl;
	cout << "第4个元素和第1个元素的差值:" << &arr[3] - &arr[0] << endl;
	/*这二种访问方式有什么区别吗？
	数组名是const指针，不能改变指向
	*/
	  //动态申请空间
	int *p2 = new int[8];
	cout << "动态分配空间的首地址:" <<p2<< endl;
	delete[]p2;
	//指向对象的指针。
	Student stu,*pstu;
	pstu = &stu;
	pstu->name = "张三"; //(*pstu).name = "张三"; 也行
	pstu->age = 28;
	pstu->display();

	//空指针
	int num1 = 0, *p3;
	p3 = NULL;
	cout << "值为NULL的指针的地址:" << p3 << endl;

	int arr1[6][6];
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 6; j++)
			arr1[i][j] = (i + 1)*(j + 1);
	}

	//二维数组 看成数组的数组，其每一行元素的地址是其第一个元素的地址。
	cout << "二维数组名的值:" << arr1 << endl;
	cout << "第0行元素的首地址：" << arr1[0] << endl;
	int(*p4)[6];
	p4 = arr1;
	for (int i = 0; i < 6; i++) {
		for (int j = 0; j < 6; j++)
			cout << "  " << (*p4)[j];
		p4++;
		cout << endl;
	}

	int *p5,num2;
	double *p6;
	num2 = 8;
	p5 = &num2;
	p6 = (double*)p5;
	cout << "int型指针转换成double:" << *p6 << endl;
	//好像产生了溢出。

	int num3 = 6, num4 = 8;
	cout << "交换前的数据:" << "num3=" << num3 << " " << "num4=" << num4 << endl;

	exchange(num3, num4);
	cout << "传值交换后的数据:" << "num3=" << num3 << " " << "num4=" << num4 << endl;

// 传地址交换数据
	exchange(&num3, &num4);
	cout << "传地址交换后的数据:" << "num3=" << num3<<" " << "num4=" << num4 << endl;
	 system("pause");
	 return 0;


}
复制代码

###结果如下

###指向对象成员的指针，指向对象成员函数的指针，指向对象数组的指针。

指向对象的指针的用法与指向其他任何数据类型的指针的语法相同。所以指向对象数组的指针和指向数组的指针用法一样。但是指向类成员的指针就有点不同了，类内部没有地址，选择一个类的成员就是指定这个成员在类中的偏移。

###相关代码:


#include<iostream> 
#include<string>
using namespace std;
class Student {
public:
    string name;
    int age;
   void display();
};

void Student::display() {
    cout << "name:"<<name<<" " << "age:" << age << endl;
}

int main()
{
	
Student s;
 s.name="TOM";
 s.age=22;	
 
 
 s.display();
 
 //一个指向类Studnt 的name指针 
  string Student::*st;
  //指针变量指向数据成员。 
  st=&Student::name;
  
  //通过指针改变数据成员。 
  s.*st="JACK"; 
  
 // fun是一个指向类成员函数的指针 
  void(Student::*fun)();
  //fun指向成员函数 
  fun=Student::display;
//注解函数名 是函数的首地址。

//调用成员函数 
(s.*fun)();

//指向对象数组的指针。 
Student stu[2],*pst;
  pst=stu;
 pst[0].age=222;
 pst[0].name="AAA";
 pst[0].display();
 
  pst[1].age=333;
  pst[1].name="BBB";
  pst[1].display();

	return 0;
}

复制代码