数组初始化时,数组如何快速初始化为某个值
数组初始化时,数组如何快速初始化为某个值详细介绍
本文目录一览： 数组怎么初始化？
下面3种方法：
1.int arr[10]={0};
如果只对数组的一部分进行初始化，则编译器将把其他元素设置为0。因此，当只将第一个元素初始化为0时，编译器会自动将其他元素设为0 (就像前一句说的那样)。
2.int arr[31]={};
3.用memset函数在程序开始时初始化数组。比如：
int arr[1024];
memset(arr, 0, 1024); //清零
扩展资料：
memset()函数原型是extern void *memset(void *buffer, int c, int count) buffer：为指针或是数组,c：是赋给buffer的值,count：是buffer的长度。
函数解释：将s中当前位置后面的n个字节 （typedef unsigned int size_t ）用 ch 替换并返回 s 。
memset：作用是在一段内存块中填充某个给定的值，它是对较大的结构体或数组进行清零操作的一种最快方法 ，它通常为新申请的内存做初始化工作。
参考资料：memset-百度百科
数组初始化时,下面说法错误的是______。
B
只可以省略行，不能省略列
如a[][2]={1,2,3};那这就是一个3行2列的二位数组
a[0][0]=1,a[0][1]=0
a[1][0]=2,a[1][1]=0
a[2][0]=3,a[2][1]=0;
不可以省略列,即使是三维的也就是最高维的可以不定义长度,剩下的两维也必须有长度
D错的原因是：只能省略第一维，第二维必须有值
int a[][] = {1. 2. 3};
int b[][][] = {1, 2, 3};
编译错误：
declaration of ‘a’ as multidimensional array must have bounds for all dimensions except the first
declaration of ‘b’ as multidimensional array must have bounds for all dimensions except the first
所以不管几维，除了 第一维都不能少
D错误
a 正确 因为编译器能自动计算长度
b 也对 这里是不指定维数(行)，不是不指定长度（列），那么维数也能计算出来
c 正确，字符串的长度也能自动计算
d错误，因为abc都正确
int a[]={1,2,3};
int a2[][3]={1,2,3,4,5,6};维数可省，长度不可
char a3[]="adfaadf";
char a4[]={"adfaadf"};
D错误：
char a5[][100]={"adfaadf","dd"};原因不明，调试一下，果然是错的
数组动态初始化时,数组元素会被赋予一个默认值,简述各数据类型的初始值？
对于java而言：
一、
各种数值类型的默认值都是0或0.0。
具体包括byte、short、int、long的默认值都是0，而float和double类型的默认值都是0.0。
二、
char类型的默认值是''(即空字符)。
三、
boolean类型的默认值是false。
四、
所有引用类型的默认值都是null。
现在很多编译器对于不给初值依赖所谓的默认值的都直接算报错了吧，这是哪儿的题目，还问默认值
数组初始化的时候允许加空格么？
在数组初始化的时候还允许在数组的最后加一个逗号（，），比如：
int month_lengths[] = {’31’,’29’,’31’,’30’,’31’,’30’,’31’,’31’,’30’,’31’,’30’,’31’,};
因为在分行的情况下，编译程序是通过逗号作为标志的，所以这是合法的。
以上结构可以写为如下的形式：
int month_lengths[] = {’31’,’29’,’31’,’30’,’31’,’30’,’31’,’31’,’30’,’31’,’30’,’31’,};
还有一点必须注意了，字符和字符串的表达式不一样的。单引号用于字符表达式，而双引号则用于字符串表达式的。这是好多人，包括C的老手，最爱犯的错误。写一个换行语句是会
写成 ：
printf(’\n’); ,而在字符判断操作的时候却写成了：
int c;
[...]
if((c = getchar()) != "\n"){
do something here
}
[...]
这种低级的错误是很容易避免的，但是一不小心就出错了，而且还不少呢，在教科书、参考书、以及一些文献以及网络文字里经常出现，只要你细心一点就可以发现。这看似问题不大，但是
如果在嵌入式系统，尤其是实时系统有可能造成系统崩溃的，所以写程序时不要报以任何的侥幸心理，必须审慎每一个细节。程序设计不是一门技术,而是一门艺术。
下面看看指针吧。
指针是（pointer）是存放内存地址的变量。 从这个定义中我们可以实力一个这样的概念： 与指针操作相关的最直接的要素是地址，内存地址。这里的地址指内存中另一个变量的位置。
如果一个变量含有一个变量的地址，则称一个变量指向第二个变量。
准备存放指针的变量必须在使用前声明好。 指针的声明由一个基类（base type）、一个星号（*）和变量名组成。 一般的形式为：
type * name;
其中，type是指针的基类类型，可以是任何有效的数据类型，name是指针变量的名称。当然了 type *name 和 type * name是等效的，一般的编译器都会在编译程序的时候忽略中间的空格。
指针的基类定义了指针可以指向的变量的类型。 技术上，任何指针类型都可以指向内存的任何位置。然而，指针的操作是基于指针的类型的，也就是说指针变量和其指向的地址的变量的类型必须兼容。即如下的操作时错误的：
int *p;
char ch = ’A’;
p = &ch;
因为类型不匹配，所以这是错误的。其实，这句话不完全对。这只是一个标准罢了，具体还需要看你的编译器的实现了。上面这种方式的操作在好多编译器上是可以通过的，比如，Win-TC、LCC等（在Win-TC下直接通过，而在LCC下也只有一个警告罢了）。 不过采用这种方式设计的程序的可移植性一定是很糟糕的。还有如果在操作中如果你想把指针地址存给一个数组元素时，如果类型不匹配，那么你只有强制转换指针地址的数据类型了，直接赋值是不可能的。所以我们提倡还是采用标准的规定来进行操作。还有下面这一种操作也是错误的，虽然类型是匹配的：
int *p;
int i;
p = &i;
因为i仅被用户声明了，但是没有分配内存，所以这是错误的。一个变量只有在被初始化的时候，才有可能分配到内存的（大多数情况是初始化之后，就分配到内存，但是如果在内存不足的情况就不可能满足这个要求了）。 在指针声明中还存在一个误区，那就是错误的认为在如是的表达式 int *p,m,n; 中声明了3个指针变量，其实只有第一个（p）是指针变量，而其他两个（m,n）只是int型变量罢了。只有这样才能同时声明几个指针变量的： int *p, *m, *n, ...;
指针也可以像一般变量一样进行初始化的，但是你不能给一个一个指针直接的赋值哦。 比如：
int *p;
p = 10; 只是错误的。不过你可以把指针赋值为空，即
int *p = 0; 或者
int *p;
p = NULL;
因为在许多的C语言的头文件，如,定义了宏NULL，它是一个空指针常量，所以我们的表达式是合法的，效果和上面的一个相同。
我们可以把一个数组变量赋予一个指针，因为它们都是一种地址的映射罢了。这才是我们的主题。比如：
char str[100], *pointer;
pointer = str;
这里，pointer指向数组str的首元素，与str[0]或者访问变量str的实质是一样的，操作的都是数组的第1个元素，0位置上的元素。如果要访问str数组的第10个元素，那么操作如下：
str[9]或*(pointer + 9) 这是等效的。在指针中也有++，--这样的操作，尤其在指针和数组互操作时，用到的机率最大，因为操作很灵活。比如：
#include
int main(){
char hello[] = "Hello, world !";
char *p;
p = hello;
do{
printf("%c", *p);
p++;
} while(*p);
printf("\n");
return ;
}
这是一个典型的例子，即用了指针的“自增”操作，还是数组合指针互操作的好例子。你的操作还可以是：
p = &hello[3];
*p = hello[3];
*&hello[3] = *p;
printf("%d\n",*&hello[3]);
hello[3] = *p;
printf("%d\n",&hello[3]);
hello[3] = *p;
printf("%d\n",hello[3]);
等等，其中 *&hello[3] 和 &hello[3]的值是一样的，都是读取hello数组中3号元素（第四个元素）的地址的。而语句 p = &hello[3];是把3号元素的地址赋给指针变量，而hello[3] = *p;
是把指针p的值赋给hello[3]的。这也是互操作的一种方式。
注意了： *++P , ++*p 和 *p++ 以及 *--p , --*p 和 *p-- 表示的结果是不同的。因为++、--的优先级高于*的优先级，所以前边的表达式相当于 *(++p) , *(++p) 和 *(p++) 以及 *(--p) , *(--p) 和 *(p--)。建议牢牢的记住操作符的优先级，因为在这些细节上稍不注意就会产生问题，我们意想不到的。
数组和指针都可以当作参数来处理，但是才用指针的概率要高一些，因为指针较数组更加灵活。例如，你可以如下传递一个数组或指针变量：
#include
int main(){
char hello[] = "Hello, world !\n";
char *p;
p = hello;
printf(hello);
printf(p);
printf("%s", p);
printf("%s", hello);
do{
printf("%c", *p);
p++;
} while(*p);
printf("\n");
return ;
}
在LCC中是完全通过的，其输出结果是：
Hello, world !
Hello, world !
Hello, world !
Hello, world !
Hello, world !
但是在有些编译器上，语句：
printf(hello);
printf(p);
可能只会输出字符串的第1个元素，因为有些编译器采取的是对字符串进行“截取”的方式来处理，所以其结果有可能是：
HHHello, world !
Hello, world !
Hello, world !
什么叫对数组的初始化？怎么初始化
就是定义的时候给数组元素赋上值。
比如int a[3] = {1,2,3};
对数组的初始化就是数组内元素全部进行清零。清零的办法有很多种，有软件的有硬件的，软件的方法也分很多种。你可以找相关的资料看看。
String a[] = new String[0];
java的数组初始化
数组的初始化就是对其赋初值，也就是向这个数组中装入有意义的数据。初始化的方法有很多：
1、如果事先已知数组的值，可以在声明数组时直接初始化。例：int s[5]={1,2,3,4,5};
2、我们用得最多的是输入数据给数组，这就需要用到循环for(i=0;i
<n;i++)来对从0到n-1个数组元素进行赋值，i在这里是充当数组的下标s[i].
建议你仔细看看书吧。
</n;i++)来对从0到n-1个数组元素进行赋值，i在这里是充当数组的下标s[i].
数组如何快速初始化为某个值
一般对数组初始化可以用以下方法实现:
（1）在定义数组时对数组元素赋以初值。如:
1
static int a［10］=｛0，1，2，3，4，5，6，7，8，9｝;
经过上面的定义和初始化后，a［0］=0，a［1］=1，…，a［9］=9。
（2）初始化时可以只对一部分元素赋初值。例如:
1
static int a［10］=｛0，1，2，3，4｝;
定义的数组有10个元素，但只对其中前5个元素赋了初值，后5个元素初值为0。
（3）如果想使一个数组的元素值全部为0，可以用下面的方法:
1
static int a［10］=｛0，0，0，0，0，0，0，0，0，0｝;
不能用:
1
static int a［10］=｛0*10｝;
如果对static型数组不赋初值，系统会对定义的所有数组元素自动赋以0值。
（4）在对全部数组元素赋初值时，可以不指定数组长度。
C语言数组的初始化表示方法
在C语言中,数组的初始化有以下几种方式:
1、定义的时候同时初始化:
int array[10] = {1,2,3,4,5};
2、定义的时候不指定数组大小,由初始化的数组元素来确定大小:
int array[] = {1,2,3,4,5};
3、先定义变量,然后初始化.注意点:定义变量时必须制定数组的大小.此时只能对数组变量成员元素逐一赋值,不能批量赋值.
// int array[]; //错误用法
int array[12];
// array = {1, 2, 3}; //错误用法.
array[0] = 1;
array[1] = 2;
array[2] = 3;
4、只有一种情况,在作为方法的形式参数时,可以不指定数组的大小.这时传入方法的是数组的首地址,所以在方法内部是无法得到数组长度的,数组长度必须作为参数传入函数.
void test()
{
int array[] = {1,2,3,4,5};
int length = sizeof(array)/sizeof(int);
int result = sumOfArray(array, length);
printf("%d",result);
}
int sumOfArray(int array[], int length)
{
int result = 0;
for (int i=0; i
<length; i++)
{
result += array[i];
}
return result;
}
扩展资料
C语言数组构建：
1、遵循原则
申请的时候从外层往里层，逐层申请；
释放的时候从里层往外层，逐层释放。
2、构建所需指针
对于构建一维动态数组，需要一维指针；
对于二维，则需要一维，二维指针；
三维需要一，二，三维指针；
依此类推。
参考资料
百度百科-C语言
一般对数组初始化可以用以下方法实现:
（1）在定义数组时对数组元素赋以初值。如:
static int a［10］=｛0，1，2，3，4，5，6，7，8，9｝;经过上面的定义和初始化后，a［0］=0，a［1］=1，…，a［9］=9。
（2）初始化时可以只对一部分元素赋初值。例如:
static int a［10］=｛0，1，2，3，4｝;定义的数组有10个元素，但只对其中前5个元素赋了初值，后5个元素初值为0。
（3）如果想使一个数组的元素值全部为0，可以用下面的方法:
static int a［10］=｛0，0，0，0，0，0，0，0，0，0｝;不能用:
static int a［10］=｛0*10｝;如果对static型数组不赋初值，系统会对定义的所有数组元素自动赋以0值。
（4）在对全部数组元素赋初值时，可以不指定数组长度。
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};
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};
数组的初始化：
int a[]={1,2,3}; 这种方式初始化，大括号里写了几个元素那么数组里就有几个元素，相当于int a[3]={1,2,3}
int a[3]={0}; 这样是将a中的所有元素初始化为0；
int a[4]={1,2}; 这样是将a[0]初始化为1，a[1]初始化为2，其他的初始化为0
不是inta[] 而是例如int a[10]这种。括号内一定要有个常量数字。
我们可以这样定义
#define N 5
int a[N]
这表明了数组名为a；数组有5个元素；分别是a[0]到a[4];
对于数组来说；数组是变量的集合，因此数组也具有与变量相同的数据类型和储存类型。数组的类型就是它所有的变量的类型。在定义数组时，应在数组名前对数组的类型加以确定。如上面的int a[10];则表明了数组内元素均为整形。
所有当表示浮点型可以定义为例如float a[10]。 举例如下：
扩展资料数组名是由用户命名的C语言标识符，要遵循标识符命名规则。数组名表示数组存储区域的首地址。数组的首地址也就是第一个元素的地址。数组名是一个地址常量，不能对它赋值。
数组名后是由方括号括起来的常量表达式，不能使用其他括号
字符数组初始化时只能在定义时初始化 是什么意思
怎么说呢，在最初定义的时候，系统会分配给你一个空间，并把你初始化的值放进去，但是如果你直接将数组指向某个字符串这是不可以的，因为数组名是一个常量，它指向定义时申请的空间。
在定义时可以整体一起初始化，定义之后需要对每一个元素 单独 赋值
1、变量的初始化有两种：
一种是先定义变量，再给变量赋初始值，有的书上说这已经不叫初始化叫赋值。
int a;
a=0
另一种是定义变量的同时给变量赋初始值，有的书上只把这种定义称为变量的初始化。
int a=0;
2、数组的初始化只有第二种情况可以一次赋多个元素的，以后只能单个元素赋值。
3、字符数组初始化时只能在定义时初始化的意思是：
char c[50]={"Hello world."};//是对的。
char c[50];
c[50]={"Hello world."};//是错误的。
char c[50];//后只能单个元素赋值。
c[1]='H';
c[2]='e';
c[3]='l';
...
c[10]='d';
c[11]='.';
c[12]='\0';
数据初始化时数组元素对应的下标是什么？
数组的初始化:
int a[]={1,2,3}; 这种方式初始化，大括号里写了几个元素那么数组里就有几个元素，相当于int a[3]={1,2,3}
int a[3]={0}; 这样是将a中的所有元素初始化为0;
int a[4]={1,2}; 这样是将a[0]初始化为1，a[1]初始化为2，其他的初始化为0
如何对数组进行初始化？
一维数组：
1.定义时直接初始化，如：int a[3]={1,2,3};
2.先定义，并给定大小，然后根据需要通过输入的数据来初始化；如：int a[3];
for(int i=0;i<3;i++)
{
cin>>a[i];
}
void *memset(void *s, int c, size_t n);
以char型为例：
char str[10];
memset(str, 0x00, sizeof(char) * 10);
含义：初始化char型数组str，数值是0，数组的大小是10个char型大小的空间。
假设数组类型是整型，就可以这样初始化：
int a[3]={1,3,5};
这样就可以了，不同类型的要赋值对应类型的数据，不然会报错！
不管是否是字符数组，都可以这样:int a[]={1,2,3,4,5,6};char *s="asdfghj";
直接赋值
你要用哪种语言初始化数组，另外初始化什么数组，简单的值数组、对象数组············
说清楚好吗！