数组的初始化有哪两种格式,字符的二维数组如何初始化？
数组的初始化有哪两种格式,字符的二维数组如何初始化？详细介绍
本文目录一览： 若有定义语句：int m[][3]={1，2，3，4，5，6，7}；，则与该语句等价的是
【答案】：A
二维数组的初始化有两种方式，一种是分行初始化，方式为：数据类型数组名[行下标表达式][列下标表达式]={{第0行初值}，{第1行初值表}，…{最后l行初值表}}；，如果初值表只对部分元素赋初值，没有被赋初值的元素将被自动赋值为0。另一种是按二维数组在内存中的排列顺序给各元素赋初值，这种方式就是不分行将所有数据依次列在一个花括号里，方式为：数据类型数组名[行下标表达式][列下标表达式]={初值表}；，这种方式的赋值就是将初值表的数据依次赋予数组的每个元素，其中赋值是按照数组元素在内存中的位置进行的。题目中的初始化语句是第二种方法，如果用第一种方法应该是int m[][3]={{1，2，3}，{4，5，6{，{7{}；，这里应该保证除了最后一行，每一行都满列有3个元素，A选项正确。
C语言题目 对二维数组的正确说明是：
C是对的，可以编译通过。
D显然格式就不对，排除。
而ABC呢，C语言二维数组初始化时，第一维可以不指定数字，但第二维必须指定数字。语言规则。没什么解释的。可以自己揣摩一下为什么是这个规则。
c是正确的。
二维数组初始化的形式为：
数据类型 数组名[整常量表达式][ 整常量表达式]={ 初始化数据 }；
在{ }中给出各数组元素的初值，各初值之间用逗号分开。把{ }中的初值依次赋给各数组元素。
有如下几种初始化方式：
⑴ 分行进行初始化
int a[2][3]={{1,2,3},{4，5，6}};
在{ }内部再用{ }把各行分开，第一对{ }中的初值1，2，3是0行的3个元素的初值。第二对{ }中的初值4，5，6是1行的3个元素的初值。相当于执行如下语句：
int a[2][3]；
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，5，6};
把{ }中的数据依次赋给a数组各元素（按行赋值）。即a[0][0]=1; a[0][1]=2；a[0][2]=3；a[1][0]=4；a[1][1]=5；a[1][2]=6；
⑶ 为部分数组元素初始化
static int a[2][3]={{1,2},{4}};
第一行只有2个初值，按顺序分别赋给a[0][0]和a[0][1]；第二行的初值4赋给a[1][0]。由于存储类型是static，故其它数组元素的初值为0。注：某些C语言系统（如：Turbo C）中，存储类型不是static的变量或数组的初值也是0。
static int a[2][3]={ 1,2};
只有2个初值，即a[0][0]=1，a[0][1]=2，其余数组元素的初值均为0。
⑷ 可以省略第一维的定义，但不能省略第二维的定义。系统根据初始化的数据个数和第2维的长度可以确定第一维的长度。
int a[ ][3]={ 1,2，3，4，5，6};
a数组的第一维的定义被省略，初始化数据共6个，第二维的长度为3，即每行3个数，所以a数组的第一维是2。
一般，省略第一维的定义时，第一维的大小按如下规则确定：
初值个数能被第二维整除，所得的商就是第一维的大小；若不能整除，则第一维的大小为商再加1。例如，int a[ ][3]={ 1,2，3，4};等价于：int a[2][3]={ 1,2，3，4};
若分行初始化，也可以省略第一维的定义。下列的数组定义中有两对{ }，已经表示a数组有两行。
static int a[ ][3]={{1,2},{4}};
来自http://blog.csdn.net/chenshijun0101/article/details/6640377
C语言定义字符型数组时，两种初始化方式的区别？
char a[]={'a','b','c','d'};
char b[]="abcd";
你查资料说两个的区别时，说上面一个是长度为4，下面一个长度为5，因为下面那个还有一个表示结束的'\0'。这是很正确的。
但是，你用两个不同的C语言编程工具得到的结果都不是这样。这应该是编程工具的区别。
使用strlen求b的长度的时候是8，另外要输出整个b的时候，它不但输出了整个b，还在后面跟上了整个a。这也是正常的。原因是：
b存储的4个字符并不是字符串，当你按照字符串长度函数strlen函数时，系统会在内存中从第一个字符开始查找结束符，一直找到为止，而这是不可预知的。
你得到的8是碰巧了。
还有，你打印b字符串，后面把a字符串也打印出来了，只是内存中碰巧的结果，它也是不可预知的。
比如，你把a去掉，只保留b，看一看就知道了。
因为你前半段说的长度是用sizeof算的，不是用strlen算的。如果是strlen算的，你必须确保字符串有\0结尾，所以你第一种初始化方式得到的数组是禁止用strlen的
strlen和printf中的%s都是以字符串结束符'\0'作为结束标志的
而逼的数组b定义时没有多复制一个字符串结束符,导致数组越界访问,直至遇到'\0'采集结束输出/判断字符串长度
这二种初始化方式的区别在于第一种方法是存储了5个字节的内容，即能看到的个字母，外加一个字符串结束符'\0'。这样才能正确地以%s的形式来输出这个字符串；而第二种方法则是只存储了4个字母，但是却没有字符串结束符，所以它不能以%s的形式正确输出。如果也要以%s的形式输出这个字符串，那就应该在末尾增加一个字节，用来存储一个字符串结束符'\0'。
字符的二维数组如何初始化？
char s[4][20]={"chengdu","beijing","shanghai","chongqing"};
这一句就是初始终化了。
你要输出这个数组就要循环才行，二维的下标最大是4.
可以这个写：
#include
int main()
{
int i;
char s[4][20]={"chengdu","beijing","shanghai","chongqing"};
for(i=0;i<4;i++)
printf("%s\n",s[i]);
}
#include
void main()
{
char s[4][80]={"chengdu,beijing,shanghai,chongqing"};
printf("%s",s);
}
你输出的列长度不够 ,还有你不能用分号来分行,要加的话,你把四行就加一个花括号才可以
二维数组初始化的基本格式：
（1）int
a[3][4]={{2,6,3,9},{5,7,9,8},{1,6,4,2}};//a数组元素完全被初始化
（2）int
a[3][4]={2,6,3,9,5,7,9,8,1,6,4,2};//与（1）类似，全部被初始化
（3）int
a[][4]={{1,2,3,4},{5,6,7,8}};//初始化了全部数组元素，隐含了行数
（4）int
a[3][3]={{6}，{1,8},{1,2,3}};//给出部分数值元素的值
就是这几种啦
可以： char ch[5][25]={10;10;10;10;10;}; strcpy(ch[0],"I an a student!"); ch[0]+strlen(ch[0])=10; //10就是字符换车符，或直接赋值 ch[0]+strlen(ch[0])='\n'; 一样的。
~
二维数组初始化的基本格式：
（1）int a[3][4]={{2,6,3,9},{5,7,9,8},{1,6,4,2}};//a数组元素完全被初始化
（2）int a[3][4]={2,6,3,9,5,7,9,8,1,6,4,2};//与（1）类似，全部被初始化
（3）int a[][4]={{1,2,3,4},{5,6,7,8}};//初始化了全部数组元素，隐含了行数
（4）int a[3][3]={{6}，{1,8},{1,2,3}};//给出部分数值元素的值
二维数组
二维数组又称为矩阵，本质上是以数组作为数组元素的数组。
基本介绍
定义
类型说明符 数组名[常量表达式][常量表达式]
例如：
float a[3][4],b[5][10];
定义a为3*4（3行4列）的数组，b为5*10（5行10列）的数组。注意，不能写成
float a[3,4],b[5,10];
概述
二维数组A[m][n]，这是一个m行，n列的二维数组。设a[p][q]为A的第一个元素，即二维数组的行下标从p到m，列下标从q到n，按“行优先顺序”存储时则元素a[i][j]的地址计算为：
LOC(a[i][j]) = LOC(a[p][q]) + ((i ? p) * n + (j ? q)) * t
按“列优先顺序”存储时，地址计算为：
LOC(a[i][j]) = LOC(a[p][q]) + ((j ? q) * m + (i ? p)) * t
存放该数组至少需要的单元数为(m-p+1) * (n-q+1) * t 个字节
二维数组又称为矩阵，行列数相等的矩阵称变方阵。对称矩阵a[i][j] = a[j][i]，对角矩阵：n阶方阵的所有非零元素都集中在主对角线上.
定义一个二维数组a[3][2],赋初值{{1,2},{4,5},{5,6}},至少用三种不同的方法
这是第一行的元素 这是第二行的元素 这是第三行的元素a[2][2]为0,第二行第二列的元素 这是第四行的元素4412
有如下几种初始化方式：
1. 分行进行初始化
int a[2][3]={{1,2,3},{4，5，6}};
2. 不分行的初始化
int a[2][3]={ 1,2，3，4，5，6};
3. 为部分数组元素初始化
static int a[2][3]={{1,2},{4}};
4. 可以省略第一维的定义，但不能省略第二维的定义。系统根据初始化的数据个数和第2维的长度可以确定第一维的长度。
int a[ ][3]={ 1,2，3，4，5，6};
5. 若分行初始化，也可以省略第一维的定义。下列的数组定义中有两对{ }，已经表示a数组有两行。
static int a[ ][3]={{1,2},{4}};
3.将数组inta[2][4]做初始化定义的方式有哪些？请写出至少三种
数组inta[2][4]的初始化定义方式有以下几种：
直接初始化： int inta[2][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}};
逐个元素赋值： int inta[2][4]; inta[0][0] = 1; inta[0][1] = 2; inta[0][2] = 3; inta[0][3] = 4; inta[1][0] = 5; inta[1][1] = 6; inta[1][2] = 7; inta[1][3] = 8;
使用循环赋值： int inta[2][4]; int count = 1; for (int i = 0; i < 2; i++) { for (int j = 0; j < 4; j++) { inta[i][j] = count; count++; } }
这些是常见的初始化定义方式，您可以根据具体需求选择适合的方式。
C语言数组的初始化表示方法
C语言数组的初始化表示方法有4种，分别是：
1、定义的同时进行初始化，我们同样用数组的初始化引出结构体的初始化，我们知道数组在定义的同时进行初始化的代码如下：
int nums[] = {1, 3, 5}；
由此可推出结构体在定义的同时进行初始化的代码如下：
struct Person p = {"lee", 23, 1.8};
2、先定义再进行初始化，这种初始化方法其实昨天的内容里已经写过了，代码如下：
struct Person p;
p.name = "lee";
p.age = 23;
p.height = 1.8;
我们知道数据定义好后就不能对其进行一次性初始化了，比如如下代码是编译不通过的。
int nums[3];
num = {1, 2, 3}
3、第三种结构体比较例外，它可以这样做，只不过需要对其进行一下强制类型转换，代码如下：
struct Person p;
p = (struct Person){"xq, 8, 8.8}
4、指定将数据赋值给指定的属性，数组中我们见过这种写法，代码如下：
int nums[3] = {[0] = 2, [2] = 1, [1] = 2};
我们可以为不同的索引指定值，并不需要一定要按顺序来，所以数组可以，结构体是否可以呢，当然，代码如下：
struct Person p = {.height = 1.8, .name = "lee", .age = 23};
Java数组初始化，这三种方式有什么区别
三种初始化完全没区别，纯粹看个人习惯
创建数组的三种方式：其实分为2类,一种是静态的创建，如方式一。一种是动态的创建，只不过根据写法的不同分为方式二和方式三：
[java] view plain copy
public static void main(String[] args) {
// 1.方式一 声明 分配空间并赋值
int[] arr1 = {1,2,3};
// 2.方式二 显示初始化
int[] arr2;
arr2 = new int[]{1,2,3};
// 3.方式三 显示初始化()
int[] arr3;
arr3 = new int[3];
}
他们的区别，方式一：在声明的时候直接就已经分配空间，并赋值，方式一是不能写成如下这种形式的。
[java] view plain copy
int[] arr1;
arr1 = {1,2,3};//错误写法 编译不同过
方式二和方式三,声明和内存分配是分开的，如上面的例子，
[java] view plain copy
int[] arr2; 和 int[] arr3;
这一步是在栈空间分配一个引用，存放的是一个引用，null
[java] view plain copy
arr2 = new int[]{1,2,3};
到这一步的时候jvm才开始在内存堆区域分配空间，并赋值，方式二直接赋值 1,2,3 方式三 默认初始化，基本类型是 0 布尔类型是 false 引用类型为null，
注：内存一旦分配不能改变，所有说数组长度固定
字符串数组的初始化方式？
错。
char a[3][4]＝{"aa","bb","cc"};
char a[3]＝"aa";
1、直接逐个初始化字符数组:
字符数组的初始化，最容易理解的方式就是逐个字符赋给数组中各元素。
1
char str[10]={ 'I',' ','a','m',' ',‘h’,'a','p','p','y'};
注意：如果花括号中提供的字符个数大于数组长度，则按语法错误处理；若小于数组长度，则只将这些字符数组中前面那些元素，其余的元素自动定为空字符（即'\0' )。
2、用字符串常量来初始化字符数组：
在c语言中，将字符串作为字符数组来处理。因此可以使用字符串来初始化字符数组。
1
char str[]={"I am happy"};
也可以省略花括号。
1
char str[]="I am happy";
但是，上述这种字符数组的整体赋值只能在字符数组初始化时使用，不能用于字符数组的赋值，字符数组的赋值只能对其元素一一赋值，下面的赋值方法是错误的。
1
2
char str[];
str="I am happy";//错误，字符数组的赋值只能按元素一一赋值