1、int二维数组初始化方式
 
int A[2][3] = {1, 2, 3, 4, 5, 6};
对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=5; A[1][2]=6;

int A[2][3] = {1, 2, 3, 4};
其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;

int A[2][3] = {{1, 2, 3}, {4}};
其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;

int A[][3] = {{1, 2, 3}, {4}};
省略行数，切记列数无法省略。其中剩余的未赋值元素编译器自动初始化为0。
数组元素值对应顺序是
A[0][0]=1; A[0][1]=2; A[0][2]=3;
A[1][0]=4; A[1][1]=0; A[1][2]=0;
 
2、char二维数组初始化方式
 
char A[2][3] = {'a', 'b', 'c', 'd'};
其中未初始化的部分，编译器自动初始为'0'（NULL）。
printf("%s\n", A);
输出"abcd"

char A[2][3] =  {{'a'}, {'d', 'e', 'f'}};
其中未初始化的部分，编译器自动初始为'0'（NULL）。
printf("%s\n", A);
输出"a"，输出第一行时遇到结束符导致停止输出。

char A[2][3] = {{'a', 'b', 'c'}, {'d', 'e', 'f'}};
printf("%s\n", A);
输出"abcdef"
    
char A[][3] = {{'a', 'b'}, {'d'}};
省略行数，切记列数无法省略。
printf("%s\n", A);
输出"ab"
 
3、二维数组作为形参
 
想要在函数中传递一个一维数组作为参数，必须以下面三种方式来声明函数形式参数，这三种声明方式的结果是一样的，因为每种方式都会告诉编译器将要接收一个整型指针。
 
方式1，形式参数是一个指针
void myFunction1(int *param)

方式2，形式参数是一个已定义大小的数组
void myFunction2(int param[10])

方式3，形式参数是一个未定义大小的数组
void myFunction3(int param[])

int param[3] = {0};
myFunction1(param);
myFunction2(param);
myFunction3(param);
int *param2;
myFunction1(param2);
myFunction2(param2);
myFunction3(param2);
 
就函数而言，一维数组作为形参时的长度是无关紧要的，因为 C 不会对形式参数执行边界检查。
 
同样的方式也可以传递一个多维数组作为形式参数？
 
方式1，形式参数是一个指针
void myFunction1(int **param)

方式2，形式参数是一个已定义大小的数组
void myFunction2(int param[2][10])
void myFunction2(int param[2][3])

方式3，形式参数是一个未定义一维宽度的数组
void myFunction3(int param[][3])

方式4
void myFunction4(int (*a)[3])

方式5
void myFunction5(int *a[3])

int param[2][3] = {0};
myFunction1(param);
错误，[Error] cannot convert 'int (*)[3]' to 'int**' for argument '1' to 'void myFunction(int**)'
即int param[2][3]中param其实是"int (*)[3]"类型，不是"int**"类型，这两者不能混用
myFunction2(param);
二维宽度为10的错误，[Error] cannot convert 'int (*)[3]' to 'int (*)[10]' for argument '1' to 'void myFunction2(int (*)[10])'，可以理解为"int (*)[3]"和"int (*)[10]"不是一种类型
为3的正确，二维数组作为函数形参会进行边界检查，所以第二个维度必须一致
myFunction3(param);
myFunction4(param);
myFunction5(param);
错误，注意如果是int *a[3]，因为"[]"的优先级比"*"高，所以会导致该形参被编译器识别为"int**"

int **param2 = (int **)malloc(sizeof(int *) * 2);
myFunction1(param);
myFunction2(param);
myFunction3(param);
myFunction4(param);
myFunction5(param);
只有myFunction1和myFunction5正确，其余的形参都不是"int**"类型
注意myFunction5中的"a[3]"类似一维数组作形参的效果，不管数组大小都被当作"int *"
 
4、综合例子
 
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

// 二维数组作为函数的形式参数会进行边界检查，所以第二个维度必须为5 
void example(char acHello[][5])
{
	printf("%d\n", sizeof(char (*)[5])); // 输出8
	printf("%d\n", sizeof(acHello)); // 输出8，为sizeof(char (*)[5])，指针为8 
	printf("%d\n", strlen(acHello[0])); // 输出9，因为acHello[0]并没有'\0'结束符，所以是acHello的总长度 
	acHello[0][0] = 'c';
	return;
}

int main(void)
{
	char str[] = "\\\\";
	printf("%d\n", sizeof(str)); // 输出3，\\其实是转义，所以2个'\'加字符串自带的1个'\0'是3 
	printf("%d\n", strlen(str)); // 输出2，即2个'\' 
	
	char *str2 = "\\\\";
	printf("%d\n", sizeof(str2)); // 输出8，str是char*类型的指针，指针在64位下都是8 
	printf("%d\n\n", strlen(str2)); // 输出2，即2个'\' 

	char str3[2][3] = {"qw", "er"};
	printf("%c ", *(*(str3 + 0) + 0));
	printf("%c ", *(*(str3 + 0) + 1));
	printf("%c ", *(*(str3 + 1) + 0));
	printf("%c\n", *(*(str3 + 1) + 1));

	printf("%c ", *(str3[0] + 0));
	printf("%c ", *(str3[0] + 1));
	printf("%c ", *(str3[1] + 0));
	printf("%c\n", *(str3[1] + 1));

	printf("%c ", str3[0][0]);
	printf("%c ", str3[0][1]);
	printf("%c ", str3[1][0]);
	printf("%c\n\n", str3[1][1]);
	// *(str3 + 0)等效于str3[0]，*(*(str3 + 0) + 0)等效于str3[0][0] 

	char *szStr = "abcde";
	printf("%c\n", szStr[0]); // 输出a 
	printf("%llu\n", szStr); // 输出4210713，该值为"abcde"这个常串中字符a所在的地址
	szStr += 2;
	printf("%c\n", szStr[0]); // 输出c 
	printf("%llu\n\n", szStr); // 输出4210715，该值为"abcde"这个常串中字符c所在的地址

	char dqq[][10] = {{'h', 'e', 'l', 'l', 'o'}, {'q', 'w', 'e'}};
	printf("%s\n", dqq); // 输出hello，因为第一维多的部分被自动初始化为'\0'，所以输出的时候截断了 
	printf("%s\n", dqq[1]); // 将第二维输出，所以是输出qwe
	printf("%c\n\n", dqq[1][0]); // 输出q

	char acHello[][5] = {{'h', 'e', 'l', 'l', 'o'}, {'h', 'e', 'l', 'l'}};
	example(acHello);
	printf("%s\n\n", acHello); // 输出cellohell，由于是传的指针，所以第一个字符被修改为c

	return 0;
}

《C++笔记》 Part7 一维数组与二维数组的初始化问题（vector）
 
转载自： 
 C++——二维vector初始化大小方法 
 C++ vector多维数组初始化及清零
 
一. 一维数组初始化问题
 
数组元素初始化时，若没有显式提供幸元素的值，则元素会被像普通变量一样初始化：
 
 
 
函数体外定义的内置类型数组（即内置类型的全局数组），元素初始化为0；
函数体内定义的内置类型数组，元素无初始化（注意，若只初始化部 分元素，其后的元素此时也会被初始化为0）；
如果不是内置类型，则不管其在哪定义，自动调用其默认构造函数为其初始化，若该类型无默认构造函数则会报错。
 
 
下面针对1和2的不同给出具体例子： 
 
1. 对条件1给出的例子，此时输出的a[0]为0，初始化为了0
 
#include <iostream>
using namespace std;

int a[6];//数组a定义在主函数外

int main(){
    cout << a[0] << endl;
    return 0;
}
 
2. 对条件2给出的例子，此时输出的a[0]为一个未初始化的值
 
#include <iostream>
using namespace std;

int main(){
    int a[6];//数组a定义在主函数内
    cout << a[0] << endl;
    return 0;
}
 
二、二维数组初始化
 
1. 直接用初始化方法
 
定义空二维vector，再赋值 
 vector<vector <int> > ivec(m,vector<int>(n)); //m*n的二维vector，
 
注意两个 “> > “之间要有空格！如下：
 
 vector<vector<int> > newOne(r, vector<int>(c, 0));
 
2. 用resize()来控制大小
 
  vector<vector<int> > res;
        res.resize(r);//r行
        for (int k = 0; k < r; ++k)
        {
            res[k].resize(c);//每行为c列
        }
 
3. 用reserve来预设数组大小
 
 
 
reserve() 设置Vector最小的元素容纳数量 函数为当前vector预留至少共容纳size个元素的空间.(译注:实际空间可能大于size)
resize() 改变Vector元素数量的大小 函数改变当前vector的大小为size,且对新创建的元素赋值val
reverse和resize的区别
 
 
1). vector 的reverse只是增加了vector的capacity，但是size没有改变！ 
 resize同时改变了vector的capacity和size！
 
 
2). reserve是容器预留空间，但并不真正创建元素对象，在创建对象之前，不能引用容器内的元素，因此当加入新的元素时，需要用push_back()/insert()函数。
 
 
3). resize是改变容器的大小，并且创建对象，因此，调用这个函数之后，就可以引用容器内的对象了，因此当加入新的元素时，用operator[]操作符，或者用迭代器来引用元素对象。
 
 
再者，两个函数的形式是有区别的，reserve函数之后一个参数，即需要预留的容器的空间；resize函数可以有两个参数，第一个参数是容器新的大小，第二个参数是要加入容器中的新元素，如果这个参数被省略，那么就调用元素对象的默认构造函数。
 
 
如reserve的用法：
 
vector<int> myVec; 
myVec.reserve( 100 );     // 新元素还没有构造, 
                          // 此时不能用[]访问元素 
for (int i = 0; i < 100; i++ ) 
{ 
     myVec.push_back( i ); //新元素这时才构造 
} 
 
resize的用法：
 
myVec.resize( 102 );      // 用元素的默认构造函数构造了两个新的元素 
myVec[100] = 1;           //直接操作新元素 
myVec[101] = 2;  
 
注：
 
 
 
<1> 为实现resize的语义，resize接口做了两个保证：
 
 
 
  
一是保证区间[0, new_size)范围内数据有效，如果下标index在此区间内，vector[indext]是合法的。
 
  
二是保证区间[0, new_size)范围以外数据无效，如果下标index在区间外，vector[indext]是非法的。
 
 
 
 
<2> reserve的使用注意点：
 
 
 
  
一、reserve只是保证vector的空间大小(capacity)最少达到它的参数所指定的大小n。在区间[0, n)范围内，如果下标是index，vector[index]这种访问有可能是合法的，也有可能是非法的，视具体情况而定。 
 二、reserve使用时要避免查找索引时，查找索引在区间[0, n)内但是非法，出现out of range 类型的错误。
 
 
 
 
<3>resize和reserve接口的共同点:
 
 
 
  
它们都保证了vector的空间大小(capacity)最少达到它的参数所指定的大小。
 
 
 

原文：https://blog.csdn.net/weixin_37832275/article/details/84573267
 
在LeetCode刷算法的时候发现，使用vector<vector<int>> 时如果声明时不初始化，会报空指针引用错误：reference binding to null pointer of type 'value_type'。
 
根据《C++ primer第五版》P40：
 默认初始化：
 
如果是内置类型的变量未被显示初始化，它的值由定义的位置决定。定义于任何函数体之外的变量被初始化为0。一种例外情况是，定义在函数体内部的内置类型变量将不被初始化。一个未被初始化的内置类型变量的值是未定义的，如果试图拷贝或者其他形式访问此类型将引发错误。
 
初始化方法：
 int numRows=10,zone=5;//层数，每层需要的空间
 vector<vector<int>> vec(numRows, vector<int>());//初始层数，赋值
 for (int i = 0; i < numRows; i++) {
     vec[i].resize(zone);
 }
  

 
文章目录
 
1. 定义一维数组
2. 一维数组初始化
   
  
 

 
1. 定义一维数组
 
一般形式： 类型说明符 数组名[常量表达式]
 eg: int a[10];
 
下标从0开始，这10个元素是从a[0]~a[9]
类型说明符：指定数组中元素的类型 ，a中所有元素都是int类型的
数组名命名规则和变量名相同，遵循标识符命名规则（字母数字下划线组成，数字不开头）
常量表达式可以包含常量和符号常量，eg:int a[3+5];
定义数组 int a[10];后，如果直接用for循环遍历会输出不可预知的数。
 
2. 一维数组初始化
 
 
定义数组时，对元素赋初值
 * 对全部元素赋值 eg : int a[10]={0,1,2,3,4,5,6,7,8,9}; 这时[ ]中的10可以不写。
 * 对部分元素赋值 eg: int a[10]={0,1,2,3,4};系统自动给后5个元素赋初值为0。
 * 若想将数组元素全部赋值为0，可以对全部元素赋值，也可int a[10]={0};还可直接写空的大括号,如：int a[10]={};。
 * 在指定数组长度并初始化时，未被初始化的元素，如果是字符型数组，初始化为’\0’,如果是指针型数组，初始化为NULL,即空指针。
 
 
定义数组后，对元素赋初值
 * int a[10]; a[10]={0,1,2,3,4,5,6,7,8,9};编译错误
 * 定义数组后再赋值，可以通过for循环赋值，如下：
 
 
	for(int i=0;i<10;i++){
		a[i]=i;
		printf("%d\t",a[i]);
	}```