動態建立二維vector數組 C和C++ 及指針與引用的區別

二維vector
vector<vector <int> > ivec(m ,vector<int>(n));    //m*n的二維vector

動態建立m*n的二維vector
方法一：
vector<vector <int> > ivec;
ivec.resize(m);
for(int i=0;i<m;i++) ivec[i].resize(n);

方法二：
vector<vector <int> > ivec;
ivec.resize(m,vector<int>(n));

動態建立二維數組a[m][n]
C語言版：
#include<malloc.h>
int **a=(int **)malloc(m*sizeof(int *));
for(int i=0;i<m;i++)
a[i]=(int *)malloc(n*sizeof(int));

C++版：
int **a=new int*[m];
for(int i=0;i<m;i++) a[i]=new int[n]; 

初始化二維數組

vector<vector <int> > ivec(m ,vector<int>(n,0));    //m*n的二維vector，全部元素爲0

 

C++中用new動態建立二維數組的格式通常是這樣：
TYPE (*p)[N] = new TYPE [][N];
其中，TYPE是某種類型，N是二維數組的列數。採用這種格式，列數必須指出，而行數無需指定。在這裏，p的類型是TYPE*[N]，便是指向一個有N列元素數組的指針。
還有一種方法，能夠不指定數組的列數：
int **p;
p = new int*[10];    //注意，int*[10]表示一個有10個元素的指針數組
for (int i = 0; i != 10; ++i)
{
    p[i] = new int[5];
}
這裏是將p做爲一個指向指針的指針，它指向一個包含10個元素的指針數組，而且每一個元素指向一個有5個元素的數組，這樣就構建了一個10行5列的數組。

當數組使用完畢，釋放空間的代碼是：
for(int i = 0; i != 5; i++)
{
    delete[] p[i];
}
 delete[] p;
處理二維數組，能夠用降維或是二維法。
降維法是用一位數組來接受二維數組，將二維元素的首地址&a[0][0]做爲參數，傳遞給函數，函數用int *接受。
二維法就直接用二維數組來接受，可是須要指定列數。
 
 
 
 
如要想建立一個[m][n]的二維數組。
下面爲經過動態建立一個指針數組的方法來動態建立二維數組的方法。
C版本：
 double **data;
 data = (double **)malloc(m*sizeof(double *));
 for(int j=0;j<m;j++)
 {
  data[j] = (double*)malloc(n*sizeof(double));  //這個指針數組的每一個指針元素又指向一個數組。
 }
 
 for (int i=0;i<m;i++)
 {
  for (int j=0;j<n;j++)
  {
   data[i][j]=i*n+j;//初始化數組元素
  }
 }
 for (i=0;i<m;i++)
 {
  free(data[i]); //先撤銷指針元素所指向的數組
 }              
 free(data);
 
C++版本：
double **data;
data = new double*[m]; //設置行 或直接double **data=new double*[m]; 一個指針指向一個指針數組。
for(int j=0;j<m;j++)
{
data[j] = new double[n];        //這個指針數組的每一個指針元素又指向一個數組。
}
for (int i=0;i<m;i++)
{
   for (int j=0;j<n;j++)
   {
    data[i][j]=i*n+j;//初始化數組元素
   }
}
for (i=0;i<m;i++)
{
 delete[] data[i]; //先撤銷指針元素所指向的數組
}                     
delete[] data; 
 
這種方法是經過先動態建立一個指針數組，而後爲指針數組的每一個元素再動態指向一個數組的辦法來完成的。其建立過程與銷燬過程兩樣重要。
在銷燬的過程，先銷燬指針數組每一個元素指向的數組，而後再銷燬這個指針數組。

 

1.使用數組指針，分配一個指針數組，將其首地址保存在b中，而後再爲指針數組的每一個元素分配一個數組
              
           int **b=new int*[row];       //分配一個指針數組，將其首地址保存在b中                                                    
           for(i=0;i<row;i++)             //爲指針數組的每一個元素分配一個數組
               b[i]=new int[col];
          
        該方法定義的動態二維數組的釋放需先釋放指針數組的每一個元素指向的數組，而後再釋放該指針數組：
           for(i=0;i<row;i++)
           {
                 delete [col]b[i];
                 b[i]=NULL;
           }
           delete [row]b;
           b=NULL;
int _tmain(int argc, _TCHAR* argv[])  
{  
    int row,column;  
    cin>>row>>column;  
   
    //方法一  
    //申請空間  
    int ** a = new int *[row];  
    for(int i = 0;i < row;i++)  
        a[i] = new int[column];  
   
    //使用空間  
    for(int j = 0;j < row;j++)  
        for(int k = 0;k< column;k++)  
            a[j][k] = rand()%100;  
   
    for(int j = 0;j < row;j++)  
    {  
        cout<<endl;  
        for(int k = 0;k< column;k++)  
        {  
            a[j][k] = rand()%100;  
            cout<<a[j][k]<<"     ";  
        }  
    }  
           
    //釋放空間  
    for(int i = 0;i < row;i++)  
    {  
        delete a[i];  
        a[i] = NULL;  
    }  
    delete [row]a;  
    a = NULL;     
   
    return 0;  
       
}

用vector
int _tmain(int argc, _TCHAR* argv[])  
{  
    int row,column;  
    cin>>row>>column;  
   
    //方法二  
    //申請空間  
    vector<vector<int> > a(row,vector<int>(column));  
       
   
    //使用空間  
    for(int j = 0;j < row;j++)  
        for(int k = 0;k< column;k++)  
            a[j][k] = rand()%100;  
   
    for(int j = 0;j < row;j++)  
    {  
        cout<<endl;  
        for(int k = 0;k< column;k++)  
        {  
            a[j][k] = rand()%100;  
            cout<<a[j][k]<<"     ";  
        }  
    }         
       
    return 0;  
       
}  

 

 

    首先，要認識到在任何狀況下都不能用指向空值的引用。一個引用必須老是指向某些對象。所以若是你使用一個變量並讓它指向一個對象，可是該變量在某些時候也可能不指向任何對象，這時你應該把變量聲明爲指針，由於這樣你能夠賦空值給該變量。相反，若是變量確定指向一個對象，例如你的設計不容許變量爲空，這時你就能夠把變量聲明爲引用。

char *pc = 0; // 設置指針爲空值 char& rc = *pc; // 讓引用指向空值

　　 這是很是有害的，毫無疑問。結果將是不肯定的（編譯器能產生一些輸出，致使任何事情都有可能發生），應該躲開寫出這樣代碼的人除非他們贊成改正錯誤。若是你擔憂這樣的代碼會出如今你的軟件裏，那麼你最好徹底避免使用引用，要否則就去讓更優秀的程序員去作。咱們之後將忽略一個引用指向空值的可能性。

　　由於引用確定會指向一個對象，在C裏，引用應被初始化。

string& rs; // 錯誤，引用必須被初始化 string s("xyzzy"); string& rs = s; // 正確，rs指向s

　　指針沒有這樣的限制。

string *ps; // 未初始化的指針 // 合法但危險

　　不存在指向空值的引用這個事實意味着使用引用的代碼效率比使用指針的要高。由於在使用引用以前不須要測試它的合法性。

void printDouble(const double& rd) { cout << rd; // 不須要測試rd,它 } // 確定指向一個double值

　　相反，指針則應該老是被測試，防止其爲空：

void printDouble(const double *pd) { if (pd) { // 檢查是否爲NULL cout << *pd; } }

　　指針與引用的另外一個重要的不一樣是指針能夠被從新賦值以指向另外一個不一樣的對象。可是引用則老是指向在初始化時被指定的對象，之後不能改變。

string s1("Nancy"); string s2("Clancy"); string& rs = s1; // rs 引用 s1 string *ps = &s1; // ps 指向 s1 rs = s2; // rs 仍舊引用s1, // 可是 s1的值如今是 // "Clancy" ps = &s2; // ps 如今指向 s2; // s1 沒有改變

　　總的來講，在如下狀況下你應該使用指針，一是你考慮到存在不指向任何對象的可能（在這種狀況下，你可以設置指針爲空），二是你須要可以在不一樣的時刻指向不一樣的對象（在這種狀況下，你能改變指針的指向）。若是老是指向一個對象而且一旦指向一個對象後就不會改變指向，那麼你應該使用引用。

　　還有一種狀況，就是當你重載某個操做符時，你應該使用引用。最普通的例子是操做符[]。這個操做符典型的用法是返回一個目標對象，其能被賦值。

vector v(10); // 創建整形向量（vector），大小爲10; // 向量是一個在標準C庫中的一個模板 v[5] = 10; // 這個被賦值的目標對象就是操做符[]返回的值

　　若是操做符[]返回一個指針，那麼後一個語句就得這樣寫：

*v[5] = 10;

　　可是這樣會使得v看上去象是一個向量指針。所以你會選擇讓操做符返回一個引用。　　當你知道你必須指向一個對象而且不想改變其指向時，或者在重載操做符併爲防止沒必要要的語義誤解時，你不該該使用指針。而在除此以外的其餘狀況下，則應使用指針。