c++數組,引用和指針

引用數組和指針這一章學完,難啊...

繞頭的東西,學了半年都用的不熟練.

一:  符号  " &"

       1.用在類型和名字中間,為引用.比如:

           int a = 1;

           int& b = a;

           a.引用必須初始化,指向的對象初始後不能再指向别的對象.

           b.改變實參,要傳引用,因為函數return隻能傳回一個值,但是我有2個,甚至更多的值要傳回呢?例如

              bool Add(int& a, int& b,int& sum)

              {

                   a+=3;b-=2;    //會改變傳進來的實參 a和b,因為是 引用&

                   sum = a+b;

                   return true;

              }

         2.直接在名字前加,為取位址,例如:

            int  a = 1;

            int* b = &a;

        3.作為操作符,按位與,例如:

           int flag = 1;

           if((flag & 1) == true){ //... }

二.指針

     1. int* a,b;    //等價于 int * a; int b; 

         int* a,* b;  //才是定義兩個指向int 的指針

     2. 指針進行初始化和指派隻能是下列四種類型

         a.0值常量表達式(const int a = 0; int* sp = a(或者直接 int* sp = 0/Null))

         b. 類型比對的對象位址

         c.另一對象之後的下一個位址

         d.同類型的另一個有效指針

         例如:

         int  a = 0; 

        const int ca = 0;

        // int* b = a;   //錯誤

        //int* b2 = ca;//正确

        c++從c語言繼承下來的Null,等效于 0 ,  int* b3 = NULL; //正确

        3.const 指針要初始化

       注意:const int* a 和 int const* a 和int* const  a 和const int* const a 的差別!!! 

       解: const int* a 和 int const* a 是雙胞胎,本質一模一樣, 可改變指針(a能變), 不能改變所指的對象(*a不能變)

             int* const a 指針不可改變(a不能變),但能改變a所指向的對象(*a能變)

             const int* const a  既不能改變指針(a不能變),也不能改變指針所指向的對象(*a 也不能變)

三.數組

       形如 int arr[10];

       注意:數組的三個重要限制:

       a. 數組長度固定不變,(不能動态加長,隻能建立一個更大的數組,然後一個個複制進去)

       b. 在編譯的時候必須要直到長度,(int arr[x.getsize()] //錯誤!!!,getsize隻能在程式運作時才知道長度,但是它編譯的時候就要知道.)

       c. 數組隻能在它語句塊記憶體在(出了作用域就不可用了.)

現在,才是重頭戲:

      問題1.建立動态數組:

         int num;

        cin >> num;//輸入數組個數

        int* arr = new arr[num]; //直到delete才會消失

        .....

       delete [ ] arr;   //new出來的東西都要delete,注意别忘記 空 [ ],否則錯誤很嚴重

     指針就 new delete ,難就難在不知道什麼時候delete!!!

     問題2. 多元數組.

                一定程度上,數組就是指針,指針就是數組.

                int*  a[4]  和 int  (*a) [4]   分别代表了什麼意思 ,有什麼差別?

                解: int* a[4]  是 4個指向 int 類型的指針.

                      int  (*a)[4]   ,我們不妨 就把     *a   看成是A,  即 int  A[4]  表示四個int類型元素的數組     a就是指向A的指針

                      換句話說相當于: int  arr[4];   int* sp = arr;   指針指向arr,看出來沒?

解決一個很嚴重的問題.(關于記憶體釋放的問題!!!)

我在一個函數裡,new了一個指針,但是,該函數裡分支結構假如很多很多很多.....假設一萬個吧.每個return 之前,都要delete來釋放記憶體,但是我有一萬處returned,難道真的要delete一萬次嗎......

解決方法:

template<typename T>
class AutoRelease
{
public:
	AutoRelease(T* sp)
	{
		m_SP = sp;
	}
	~AutoRelease()
	{
		//對象除了作用域或者删除後,自動調用該對象的析構函數
		if (m_SP != nullptr)
		{
			delete m_SP;
		}
	}

private:
	T* m_SP;
};

int _tmain(int argc, _TCHAR* argv[])
{
	int* sp = new int();
	AutoRelease<int> atr(sp);

	//此時,無限多的分支,無限多的return的時候,不用手動delete sp了
	//atr對象出了作用域,自動調用其西溝函數,自動釋放sp了,
	//哈哈哈...

	return 0;
}
           

此處應該有掌聲~!!!