c++数组

一、c++数组及初始化

  （1）一维数组

1.    静态 int array[100]; 　　定义了数组array，并未对数组进行初始化
2.    静态 int array[100] = {1，2}；　　定义并初始化了数组array
3.    动态 int* array = new int[100];  delete []array;　　分配了长度为100的数组array 
4.    动态 int* array = new int[100](1，2); 　delete []array;　为长度为100的数组array初始化前两个元素

 

（2）二维数组

1. 静态 int array[10][10];　　定义了数组，并未初始化
2. 静态 int array[10][10] = { {1,1} , {2,2} };　　数组初始化了array[0][0,1]及array[1][0,1]
3. 动态 int (*array)[n] = new int[m][n]; delete []array;
4. 动态 int** array = new int*[m];　for(i) array[i] = new int[n];  for(i) delete []array[i]; delete []array;    多次析构
5. 动态 int* array = new int[m][n];  delete []array;      数组按行存储

 

（3）多维数组

　　int* array = new int[m][3][4];    只有第一维可以是变量，其他维数必须是常量，否则会报错

      delete []array;       必须进行内存释放，否则内存将泄漏

 

 

（4）数组作为函数形参传递

 

1. 一维数组传递：

        void func(int* array);

        void func(int array[]);　　　　

   2.二维数组传递：

　　void func(int** array);

　　void func(int (*array)[n]);　　　　　　　　　　　　　　　　　　

数组名作为函数形参时，在函数体内，其失去了本身的内涵，仅仅只是一个指针，而且在其失去其内涵的同时，它还失去了其常量特性，可以作自增、自减等操作，可以被修改。

 

 

（5）字符数组

char类型的数组被常委字符数组，在字符数组中最后一位为转移字符'\0'（也被成为空字符），该字符表示字符串已结束。在C++中定义了string类，在Visual C++中定义了Cstring类。

字符串中每一个字符占用一个字节，再加上最后一个空字符。如：

char array[10] = "cnblogs";

虽然只有7个字节，但是字符串长度为8个字节。

 

也可以不用定义字符串长度，如：

char array[] = "cnblogs";

 

（6）strlen函数是测试字符串实际长度（不包含‘\0’在内）的函数。

  char c[10]=”Hello”’

  printf(“%d”,strlen(c)); 或者Printf(“%d”,“Hello”);  输出为5

二、c++数组取地址

#include<iostream>
using namespace std;
int main(){
    int array[6] = { 1,2,3,4,5,'\0'};
    cout<<array<<endl;
    cout<<&array<<endl;
    return 0;
}

我定义了一个长度为6的int型数组（注意，如果你要亲自试一试，不要用char型，因为char型数组会被当作字符串处理，这可能会给你带来新的困惑，这个我们以后再谈。），数组的第六个元素是一个终止符。

cout<<array<<endl;　　默认会输出数组array的首地址，即第一个元素的地址。

cout<<&array<<endl;　&是取地址符，这里取的也是第一个元素的地址。

我们可以看到结果如下：

结果确实是相等的。

---

 

我们再来看下面的代码：

#include<iostream>
using namespace std;
int main(){
    int array[6] = { 1,2,3,4,5,'\0'};
    cout<<&array<<endl;
    cout<<&array[0]<<endl;
    cout<<&array[1]<<endl;
    return 0;
}

 

我们可以通过给出数组下标来查找特定元素的地址，比如&array[0]，就是取数组第一个元素的地址，&array[1]取的就是第二个元素的地址。我们知道，一个int型元素占4个字节，所以第一个元素和第二个元素的地址应该相差4，我们看看运行结果：

前两行都是第一个元素的地址，第三行是第二个元素的地址，二者的确相差4个字节。

---

我们接着看下面的代码：

#include<iostream>
using namespace std;
int main(){
    int array[6] = { 1,2,3,4,5,'\0'};
    cout<<&array[1]<<endl;
    cout<<&array[0]+1<<endl;
    cout<<&array[0]<<endl;
    return 0;
}

这里的&array[0]+1，意思是取第一个元素的地址，然后加上一个int型的长度，也就是加4个字节，而不是真的加1。加4个字节后其实就等价于取第二个元素的地址，我们来看看运行结果：

前两个结果是一样的，对应第二个元素的地址。第三行是&array[0]的结果，可以看到&array[0]+1比&array[0]大了4，而不是1，这点一定要注意。

---

最后我们来看：

#include<iostream>
using namespace std;
int main(){
    int array[6] = { 1,2,3,4,5,'\0'};
    cout<<&array<<endl;
    cout<<&array+1<<endl;
    return 0;
}

 

前面我们提到过，&array和&array[0]取的都是第一个元素的地址，而&array[0]+1取的是第二个元素的地址，+1加的其实是4个字节。但这里的&array+1可不再是加4个字节了，加的是整个数组的长度。+1的尺度和+1前面的操作数息息相关，array指代的是整个array数组，而array[0]指代的只是一个元素，所以二者+1时增加的字节是完全不一样的，这点希望大家能有所体会。由于array是一个长度为6的int型数组，所以+1加的应该是6*4=24个字节，我们来看结果：

可以看到二者相差18，18是十六进制表示，转化成十进制就是24。