C++ 指针（二）--c++

一、内存管理：new和delete

1、new操作符：从操作系统获得内存块，并返回该内存块的首地址。

      delete操作符：将new申请的内存返还给操作系统。

开始一个简单的例子：

#include <iostream>
#include<cstring>
using namespace std;
int main()
{
	char* str="it is a good job!";
	int len=strlen(str);
	char* ptr=new char[len+1];
	strcpy(ptr,str);
	//ptr=str;  //错误，这样是ptr和str都指向字符串。这里ptr和str应该指向不同的地址。
	cout<<"ptr="<<ptr<<endl;
	delete[] ptr;
	return 0;
}

1） new格式：

char*	ptr	=	new	char	[len+1]
	指针	=	关键字	变量的数据类型	char类型变量的数目（方括号）

         new和malloc：new方法可以返回适当的数据类型的指针；而malloc返回的指针是void类型的指针，必须强制转化才能转化成适当的数据类型指针。

C中的realloc函数可以改变已分配内存空间的大小。C++中没有这样的函数，只能通过new重新申请一个更大或者更小的空间。

2） delete格式：delete【】 要删除的指针

如果new创建的是一个简单的对象，则在删除的时候可不加方括号，如果是数组就必须加括号。

2.使用new的类

#include<iostream>
using namespace std;
class String
{
public:
	String(char* s)
	{
		int len=strlen(s);
		str=new char[len+1];
		strcpy(str,s);
	}
	~String()
	{
		cout<<"where?"<<endl;
		delete[] str;
	}
	void display()
	{
		cout<<str<<endl;
	}
private:
	char* str;
};
int main()
{
	String str="hello! word!";
	str.display();
	return 0;	
}

1）在构造函数中使用new获得内存空间。

2）既然使用new来分配内存空间，因而析构函数也变得很重要。（因为在创建对象的时分配了内存空间，则当这些对象不再需要时就很有必要释放这些空间）。析构函数在对象销毁时自动调用的例程，所以放入delete恰好。

问题：如果一个类的两个对象执行了s1=s2这样的操作（即出现两个对象的指针指向同一个内存地址），而此时一个对象被删除（如含有其中一个对象的调用函数结束后返回时），这样申请的内存地址被收回，这样就导致另一个对象的是一个无效的指针了。

    这个错误一定要重视，因为很容易疏忽。怎样才能写一个更聪明的析构函数呢？？   后面揭晓…

二、对象与指针

1、对象指针

有时在程序的编写时并不知道需要创建多少个对象。当出现这中情况时，就可以在程序运行中使用new来穿件对象。这里，new返回的是一个指向未命名对象的指针。

例子：

#include<iostream>
using namespace std;
class Distance
{
public:
	void getdist();
	void showdist();
private:
	int feet;
	float inches;
};
void Distance::getdist()
{
	cout<<"Enter the feet:"; cin>>feet;
	cout<<"Enter the inches:";cin>>inches;
}
void Distance::showdist()
{
	cout<<"The feet:"<<feet<<endl;
	cout<<"The inches:"<<inches<<endl;
}
int main()
{
	Distance dd;
	dd.getdist();
	dd.showdist();
	Distance* ptr=new Distance; // pointer to Distance,points to new Distance object
	ptr->getdist();  //这里如果是点运算符就会出错
	ptr->showdist(); //因为点运算符要求它的左运算符是一个变量，而ptr为一个指针。
	return 0;
}

上面标注的地方除了用成员访问运算符（->）表示之外，我们还可以这样(*ptr).getdist(); //ok，but inelegant （圆括号是必须的，因为点运算符的优先级比间接引用运算符要高）.

2、对象指针数组

	Distance* distptr[100];
	distptr[j]=new Distance;
	//*(distptr+j)=new Distance;
	distptr->getdist();
	distptr->showdist();

注意：数组表示法distptr[j]等价于指正表示法*(distptr+j)，由于是指针数组，上面两种表示的方法的元素还是指针（指向对象的指针）

          distptr->getdist(); 表示执行了由数组distptr的第j个元素 所指向的Distance对象的成员函数。

三、链表

链表提供了一种不使用数组但更为灵活的存储系统，每个数据项都是按照需要通过new来获取的，且数据之间是通过指针链接起来的。

单个数据项之间并不需要和数组元素一样在内存中相邻分配，相反他们可以分散到任何地方。

例子：

#include <iostream>
using namespace std;
struct link
{
	int data;     //表示对象的单个数据项
	link* next;   //指向下一个链接项
};
class linklist
{
public:
	linklist():first(NULL) {}
	void addlist(int d);   //增加链接项
	void display();        //显示链接内容
private:
	link* first;
};
void linklist::addlist(int d)  //增加链接项
{
	link* newptr=new link; //创建一个新的link结构类型
	newptr->data=d;        //将参数的值传递给结构变量data  
	newptr->next=first;    //指针next指向first指向的任何地址（在这里是链表头）
	first=newptr;          //将指针first指向这个新的链接项
}
void linklist::display()
{
	link* nowptr=first;
	while (nowptr!=NULL)
	{
		cout<<nowptr->data<<endl;
		nowptr=nowptr->next;  //指针移动到下一个链表的地址
	}
}
int main()
{
	linklist ll;
	ll.addlist(22);
	ll.addlist(33);
	ll.addlist(44);
	ll.display();
	return 0;
}

注意：在使用link结构的时候含有一个指向同类型结构的指针。同样的在类中也可以这么使用：

class sampleclass
{
	sampleclass* ptr;   //this is fine！
	sampleclass obj;    //can't do this！！
};

但是这里要特别注意：虽然类中可以包含一个指向同类型对象的一个指针，但不能包含一个同类的对象。

四、指向指针的指针

看个例子：

#include<iostream>
#include <string>
using namespace std;
class person
{
public:
	void SetName()
	{
		cout<<"Enter name:"; cin>>name;
	}
	void PrintfName()
	{
		cout<<name;
	}
	string GetName()
	{
		return name;
	}
private:
	string name;
};
int main()
{
	void bsort(person**,int);     //排序
	person* perptr[100];
	int n=0;
	char ch;
	do 
	{
		*(perptr+n)=new person;
		(*(perptr+n))->SetName();
		n++;
		cout<<"Enter another?";
		cin>>ch;
	} while (ch=='y');
	cout<<"姓名排序前：";
	for (int j=0;j<n;j++)
	{
		perptr[j]->PrintfName();
		cout<<" ";
	}
	bsort(perptr,n);
	cout<<"\n姓名排序后：";
	for (int j=0;j<n;j++)
	{
		perptr[j]->PrintfName();
		cout<<" ";
	}
	cout<<endl;
	return 0;
}
void bsort(person** ptr,int n)  //排序
{
	void order(person**,person**);
	int j,k;
	for(j=0;j<n-1;j++)
		for(k=j+1;k<n;k++)
			order(ptr+j,ptr+k);
}
void order(person** ptr1,person** ptr2)  //比较
{
	if((*ptr1)->GetName()>(*ptr2)->GetName()))
	{
		person* tem;
		tem=*ptr1;
		*ptr1=*ptr2;
		*ptr2=tem;
	}
}

1）注意到数据类型person**，表示这些参数被用来传递perptr指针数组的地址。本身perptr数组中存的就是指针，因此指针数组的地址是一个指向指针的指针。

2）因为数组perptr包含的是指针，因而：perptr[j]->PrintfName();  表示执行perptr数组的j号元素所指向的对象的PrintfName()成员函数。

3）(*ptr1)->GetName()；

其中ptr1是一个指向指针的指针，因此(*ptr1)表示指针数组的元素。总体意思就是执行perptr数组的元素(*ptr1)所指向的对象的PrintfName()成员函数。