指针与内存(一)

1.指针与内存(一)　　
(1)动态分配也许可以算是指针的关键技术了。它被用于在没有定义变量的情况下分配内存，然后由一个指针指向这段内存。虽然这个概念好像很让人糊涂，其实它很简单。以下的代码解说了如何为一个整数分配内存空间： 　　
int *pNumber; 　　pNumber = new int;
double *pDouble; 　　pDouble = new double;

动态分配和本地变量的不同点是：你分配的内存在函数返回和语句块结束的时候不会被释放.
问题是你分配的内存在离开的时候虽然仍然完好，但是这段内存永远也不会自动销毁。这就是说，如果你不通知电脑结束使用的话，这段内存就会一直存在下去，这样做的结果就是内存的浪费。最终，系统就会因为内存耗尽而崩溃。所以，这是相当重要的一个问题。当你使用完内存之后，释放它的代码非常简单： 　　delete pPointer; 　　这一切就这么简单。不管怎样，在你传递一个有效的指针——亦即一个指向一段你已经分配好的内存指针，而不是那些老旧的垃圾内存——的时候，你都需要无比细心。尝试delete一段已经释放的内存是十分危险的，这可能会导致你的程序崩溃。

(2)你亦可以在函数中返回指针，像下面这个样子： 　　
int * MyFunction(); 　　
在这个例子中，MyFunction返回了一个指向整数的指针

(3)指向类的指针:
关于指针，我还有还有两点需要提醒你。其中之一是指向结构或类的指针。你可以像这样定义一个类：

　　class MyClass

　　{

　　public:

　　 int m_Number;

　　 char m_Character;

　　};
你可以这样定义一个指向MyClass的指针：

　　MyClass *thing;

　　就像你期望的一样。然后，你可以为这个指针分配一些内存：

　　thing = new MyClass;

(4)指向数组的指针
int *pArray;

　　pArray = new int[6];

　　这将创建一个指针pArray，它会指向一个6个元素的数组。另一种不使用动态分配的方法如下：

　　int *pArray;

　　int MyArray[6];

　　pArray = &MyArray[0];

　　请注意，你可以只写MyArray来代替&MyArray[0]。当然，这种方法只适用于数组，是C/C++语言的实现使然（译注：你也可以把函数名赋值给一个相应的函数指针）。通常出现的错误是写成了“pArray = &MyArray;”，这是不正确的。如果你这么写了，你会获得一个指向数组指针的指针（可能有些绕嘴吧？），这当然不是你想要的。

(5)使用指向数组的指针

　　如果你有一个指向数组的指针，你将如何使用它？呃，假如说，你有一个指向整数数组的指针吧。这个指针最初将会指向数组的第一个值，看下面这个例子：

　　#include

　　void main()

　　{

　　 int Array[3];

　　 Array[0] = 10;

　　 Array[1] = 20;

　　 Array[2] = 30;

　　 int *pArray;

　　 pArray = &Array[0];

　　 printf("pArray points to the value %d/n", *pArray);

　　　}

　　要想使指针移到数组的下一个值，我们可以使用pArray++。我们也可以——当然你们有些人可能也猜到了——使用pArray + 2，这将使这个数组指针移动两个元素。要注意的一点是，你必须清楚数组的上界是多少（在本例中是3），因为在你使用指针的时候，编译器不能检查出来你是否已经移出了数组的末尾。所以，你可能很容易地使系统崩溃。下面仍然是这个例子，显示了我们所设置的三个值：

　　#include

　　void main()

　　{

　　 int Array[3];

　　Array[0] = 10;

　　Array[1] = 20;

　　Array[2] = 30;

　　 int *pArray;

　　 pArray = &Array[0];

　　 printf("pArray points to the value %d/n", *pArray);

　　 pArray++;

　　 printf("pArray points to the value %d/n", *pArray);

　　 pArray++;

　　 printf("pArray points to the value %d/n", *pArray);

　　}

　　同样，你也可以减去值，所以pArray - 2就是pArray当前位置的前两个元素。不过，请确定你是在操作指针，而不是操作它指向的值。这种使用指针的操作在循环的时候非常有用，例如for或while循环。
请注意，如果你有了一个指针（例如int* pNumberSet），你也可以把它看作一个数组。比如pNumberSet[0]相当于*pNumberSet，pNumberSet[1]相当于*(pNumberSet + 1)。

　　关于数组，我还有最后一句警告。如果你用new为一个数组分配空间的话，就像下面这个样子：

　　int *pArray;

　　pArray = new int[6];

　　那么必须这样释放它：

　　delete[] pArray;

　　请注意delete之后的[]。这告知编译器它正在删除一个整个的数组，而不是单独的一个项目。你必须在使用数组的时候使用这种方法，否则可能会获得一个内存泄漏。

最后的话

　　最后要注意的是：你不能delete掉那些没有用new分配的内存，像下面这个样子：

　　void main()

　　{

　　　int number;

　　　int *pNumber = number;

　　　delete pNumber; // 错误：*pNumber不是用new分配的

　　}

(6)Q:new和malloc的区别是什么？

　　A：new是C++特有的关键词，并且是标准的分配内存方法（除了Windows程序的内存分配方法之外）。你绝不能在一个C C++程序中使用malloc，除非绝对必要。由于malloc并不是为C++面向对象的特色设计的，所以使用它为类对象分配内存就不会调用类的构造函数，这样就会出现问题。由于这些原因，本文并不对它们进行讨论，并且只要有可能，我亦会避免使用它们。

Q：我能一并使用free和delete吗？

　　A：你应该使用和分配内存相配套的方法来释放内存。例如，使用free来释放由malloc分配的内存，用delete来释放由new分配的内存。

有些初涉C++的程序员，常常会写出这样的程序：

char *pChar = new char;

char chs;

pChar = &chs;

delete pChar;

　　他们的目的是想将chs内容传递给pChar指针指向的内存。但这样写，将会使pChar先前指向的空间编程垃圾地址，因为地址无法再获取了。俗称野指针。将会导致内存泄漏。而且，在调用delete pChar时，也会发生异常错误。因为不是new的空间是不能使用delete删除的。因为pChar已经转到指向chs这个变量的地址了。

(7)指针赋值及转换：
        a.同类型直接赋值，异类型要进行转换。

　　b.强制转换：可以把表达式结果硬性转换为指定类型

　　c.char * p;(int *)p 把p强制转换为int型，记住转换过程中要注意两个类型的大小，大转小时可能会有数据丢失（如int到double）

　　d.涉及void *的:

　　c 中void *类型可赋值给任何类型的指针，反之亦然

　　c++ 中都需要强制转换

　　void *　可看作无穷大能接纳任何类型赋值，反之不行int * p =9;void * t= p（正确）;p=t(错误)

　　e.不涉及void *的都要强制转换

(8)指针和数组
不带下标的数组名返回数组的起始地址，即数组首元素的地址，所以对数组的访问可有两种方式：数组下标和指针算术。例如：

char* pChar;

char chs[100];

pChar = chs;这样pChar就指向chs数组的首地址。

(9)我们来仔细说明一下字符指针数组和指向指针的指针，段1中的程序是下面的样子：

char *a[]={"abc","cde","fgh"};
char* *b=a;
cout<<*b<<"|"<<*(b+1)<<"|"<<*(b+2)...;

　　char *a[]定义了一个指针数组,注意不是char[], char[]是不能同时初始化为三个字符的,定义以后的a[]其实内部有三个内存位置,分别存储了abc/0,cde/0,fgh/0,三个字符串的起始地址,而这三个位置的内存地址却不是这三个字符串的起始地址,在这个例子中a[]是存储在栈空间内的,而三个字符串却是存储在静态内存空间内的const区域中的,接下去我们看到了char* *b=a;这里是定义了一个指向指针的指针,如果你写成char *b=a;那么是错误的,因为编译器会返回一个无法将char* *[3]转换给char *的错误,b=a的赋值,实际上是把a的首地址赋给了b,由于b是一个指向指针的指针,程序的输出cout<<*b<<"|"<<*(b+1)<<"|"<<*(b+2)...;

　　结果是

abc
cde
fgh
　　可以看出每一次内存地址的+1操作事实上是一次加sizeof(char*)的操作,我们在32位的系统中sizeof(char*)的长度是4,所以每加1也就是+4,实际上是*a[]内部三个位置的+1,所以*(b+1)的结果自然就是cde了,我们这时候可能会问,为什么输出是cde而不是c一个呢?答案是这样的,在c++中,输出字符指针就是输出字符串,程序会自动在遇到/0后停止.

//-----------------------------段2-----------------------------------------
char* test[]={"abc","cde","fgh"};//注意这里是引号,表示是字符串,以后的地址每加1就是加4位(在32位系统上)
int num=sizeof(test)/sizeof(char*);//计算字符串个数
print_char(test,num);
cin.get();
//-------------------------------------------------------------------------
}

void print_char(char* array[],int len)//当调用的时候传递进来的不是数组,而是字符指针他每加1也就是加上sizeof(char*)的长度
{
for(int i=0;i<len;i++)
{
cout<<*array++<<endl;
}
}

段2中我们调用了print_array()这个函数,这个函数中形式参数是char *array[]和代码中的char *test[]一样,同为字符指针,当你把参数传递过来的时候,事实上不是把数组内容传递过来,test的首地址传递了进来,由于array是指针,所以在内存中它在栈区,具有变量一样的性质,可以为左值,所以我们输出写成了,cout<<*array++<<endl;当然我们也可以改写为cout< <&array[0]++<<endl;