初始值个数小于数组元素的个数,如果初始化字符序列中的字符个数少于字符数组的元素数，则多出来的元素值均为'
初始值个数小于数组元素的个数,如果初始化字符序列中的字符个数少于字符数组的元素数，则多出来的元素值均为'详细介绍
本文目录一览： 如果初始化字符序列中的字符个数少于字符数组的元素数，则多出来的元素值均为'
这话的意思是：
若char a[10]="1234";的话，那么a[0]=1、a[1]=2、a[2]=3、a[3]=4，而其他的a[5]~a[9]均等于'\0'。
它是说这两种初始化方法的结果不同：
char s1[20]="abcd";
char s2[20]={'a','b','c','d'};
一种，余下的元素是 '\0', 另一种 是 随机的，不是 '\0'
-----------
实际上，要看编译器处理。MS VC++ 6.0 都处理成 '\0':
#include
#include
main(){
char s1[20]="abcd";
char s2[20]={'a','b','c','d'};
int i;
for (i=0;i<10;i++){
printf("%d ",s1[i]);
}
for (i=0;i<10;i++){
printf("%d ",s2[i]);
}
return 0;
}
急！急！ 懂c语言的朋友请帮个忙
分类: 电脑/网络 >> 程序设计 >> 其他编程语言
问题描述:
有几个题不会 请大哥大姐帮忙看看！
一、填空题
1.语言是一套具有________、________规则的系统。
2.计算机可以识别的命令称作________， 它的有序 *** 称作________。
3.翻译程序的作用是把源程序翻译成等价的___________。
4.被调用函数中的_________ 语句用来把表达式的值传回给调用函数。
5.要想使函数中的局部变量在函数调用之间保持其值，该变量必须用存储类别说明符_________说明。
6.指针是把另一个变量的_________作为其值的变量。
7.c语言中，申请内存使用malloc，释放内存使用_________。
8.若a是int型变量，且a的初值为4，则计算表达式a+=a-=a*a后a的值为_______。
9.C语言中，数组名是一个不可改变的________，不能对它进行赋值运算。
10.在C语言中，&运算符作为单目运算符时表示的是_________运算。
11.如果一个函数直接或间接地调用自身，这样的调用称为_______调用。
12.如果初始化值列表中的初始化值的个数少于数组的元素个数，C编译器会自动把剩余的元素初始化为_________。
13.int*p[n]定义了一个指针数组， int(*p) [n]定义了一个_________。
14.能够赋给指针的唯一的整数是_________ 。
15._________是C程序的起始点，可以独立运行。
16.C提供了一个测定某一种类型数据所占存储空间长度的运算符________。
17.“＼5”是指ASCII码值为_______的字符。
18.十进制常数25对应的八进制的C表示为________。
二、判断题
1.所有的预处理命令都是以符号"#"开头的,必须放在程序的开头部分。( )
2.所有的C语言程序都必须有一个名为main的主函数。
3.Int,a15,char都是合法的标识符。
4.c语言中'b'和"b"是等同的。
5.C语言本身没有输入输出语句。
6.系统分配给结构体变量的内存是成员中占内存量最大者所需的容量。
7.C语言共用体类型变量在程序运行期间所有成员一直驻留在内存中。
8.系统的标准输入文件是指硬盘。
9.C语言中，被调用的函数的定义出现在主调用函数之前时，函数原型可以省略。
10.系统的标准输出文件是指显示器。
解析:
把我知道的给一部分吧,有一部分没有把握,不敢乱说
一、填空题
3.翻译程序的作用是把源程序翻译成等价的_____二进制代码。
4.被调用函数中的____return 语句用来把表达式的值传回给调用函数。
5.要想使函数中的局部变量在函数调用之间保持其值，该变量必须用存储类别说明符__extern_说明。
6.指针是把另一个变量的__地址_作为其值的变量。
7.c语言中，申请内存使用malloc，释放内存使用_free_。
8.若a是int型变量，且a的初值为4，则计算表达式a+=a-=a*a后a的值为__-24_。
9.C语言中，数组名是一个不可改变的_地址值_，不能对它进行赋值运算。
10.在C语言中，&运算符作为单目运算符时表示的是__取地址_运算。
11.如果一个函数直接或间接地调用自身，这样的调用称为_递归__调用。
12.如果初始化值列表中的初始化值的个数少于数组的元素个数，C编译器会自动把剩余的元素初始化为__0__。
13.int*p[n]定义了一个指针数组， int(*p) [n]定义了一个__指向n个元素数组的指针_。
14.能够赋给指针的唯一的整数是_________ 。
15.__main()_是C程序的起始点，可以独立运行。
16.C提供了一个测定某一种类型数据所占存储空间长度的运算符_sizeof_。
17.“＼5”是指ASCII码值为_______的字符。
此处题目是错误的不能用双引号
18.十进制常数25对应的八进制的C表示为__031__。
二、判断题
1.所有的预处理命令都是以符号"#"开头的,必须放在程序的开头部分。(√ )
2.所有的C语言程序都必须有一个名为main的主函数。 √
3.Int,a15,char都是合法的标识符。 ×
4.c语言中'b'和"b"是等同的。 ×
5.C语言本身没有输入输出语句。 √
6.系统分配给结构体变量的内存是成员中占内存量最大者所需的容量。 ×
7.C语言共用体类型变量在程序运行期间所有成员一直驻留在内存中。 ×
8.系统的标准输入文件是指硬盘。 ×
9.C语言中，被调用的函数的定义出现在主调用函数之前时，函数原型可以省略。 √
10.系统的标准输出文件是指显示器。√
c++ 数组怎么一次批量赋值
通过数组指针给对象赋值：
#include
#include
using namespace std;
void main()
{
vector
ivec1(10,42); //内置方法，初始化的内容为10个42
vector
ivec2(10);
vector
::size_type ix=0;
for(ix;ix<10;++ix)
{
ivec2[ix]=42; //下标操作
}
vector
ivec3(10);
for(vector
::iterator iter=ivec3.begin();iter!=ivec3.end();++iter)
{
*iter=42; //迭代器
}
/////下面两种方法最佳，他们使用标准库定义的操作，无须再定义vector对象时指定容器的大小。比较灵活且不容易出错.
vector
ivec4;
vector
::iterator iter=ivec4.end();
for(int i=0;i!=10;++i)
{
ivec4.insert(iter,42); //在指定位置iter前插入值为的元素,返回指向这个元素的迭代器,
iter=ivec4.end();
}
vector
ivec5;
vector
::size_type cnt=1;
for(cnt;cnt<=10;++cnt)
{
ivec5.push_back(42); //push_back()添加值为的元素到当前vector末尾
}
}
通过数组指针给对象赋值：
#include
#include
using namespace std;
void main()
{
vector
ivec1(10,42); //内置方法，初始化的内容为10个42
vector
ivec2(10);
vector
::size_type ix=0;
for(ix;ix<10;++ix)
{
ivec2[ix]=42; //下标操作
}
vector
ivec3(10);
for(vector
::iterator iter=ivec3.begin();iter!=ivec3.end();++iter)
{
*iter=42; //迭代器
}
/////下面两种方法最佳，他们使用标准库定义的操作，无须再定义vector对象时指定容器的大小。比较灵活且不容易出错.
vector
ivec4;
vector
::iterator iter=ivec4.end();
for(int i=0;i!=10;++i)
{
ivec4.insert(iter,42); //在指定位置iter前插入值为的元素,返回指向这个元素的迭代器,
iter=ivec4.end();
}
vector
ivec5;
vector
::size_type cnt=1;
for(cnt;cnt<=10;++cnt)
{
ivec5.push_back(42); //push_back()添加值为的元素到当前vector末尾
}
}
可以用memset
#include
void * memset ( void * ptr, int value, size_t num );
如：
int a[M][N];
memset(a[0],0,N*sizeof(int)); //第一行赋值0
memset(a[1],1,N*sizeof(int)); //第二行赋值1
定义的时候可以批量赋值，如：
int a[20]={ 0 };
如此，整个数组都为0了，但是以后就不能这样赋值了，只能在刚看时初始化的时候这样！
连续的话，赋值为0很容易，有API的
memset(a, 0, 100*sizeof(int));
全1，那肯定只能用循环的
classA{
char*pname;
intproperty[5];
public:
voidipt(char*t,intpt[]){pname=t;
for(inti=0;i<5;i++)
property[i]=pt[i];
}
}
方法如下：
structAc{
char*pname;
intproperty[5];
}inita[2]={{"a",1,2,3,4,5},{"b",2,3,4,5,6}};
这样就可以调用ipt了：
Aa;
for(inti=0;i<2;i++)
a.ipt(inita[i].pname,inita[i].property[]);
扩展资料
C++中数组初始化
1、定义数组后必须要初始化，如果不初始化，局部变量在栈上，各数组元素的值将是随机数，系统不会自动初始化为0；
2、数组初始化时，把数组元素的第一个数组元素初始化为0，剩余的元素系统会自动初始化为0。如：
inta[5]={0}
3、初始化值的个数可少于数组元素个数，当初始化值的个数少于数组元素个数时，前面的按序初始化相应值，后面的初始化为0；
inta[5]={0,0}
4、在初始化时，如果指定的元素个数超过这个数组已经定义的大小，就会产生错误。如：
inta[3]={1,2,3,4,5}
5、若数组定义时没有指定大小，但初始化采用列表初始化了，那么数组的大小由初始化时列表元素个数决定。如：
inta[]={1,2,3,4,5}
二维数组可以用一个空的花括号吗
不能为空。采用花括号初始化的方式中，花括号里面不能为空。采用花括号为空，里面初始值的个数不能多于每行元素的个数，若初始值的个数小于每行元素个数，则会自动补。
判断题47、一维数组初始化的数据个数允许少于数组的长度,但不能多于数组的长度。
以上题目是正确的，少于数组长度的时候，之后未用数值初始化的元素，编译器会全部自动初始化为0;但超长的时候属于越界操作，是必须避免的。
c语言结构体中的一个char数组怎么赋值？
常用两种措施：
在声明结构体变量时初始化，如——
//#include "stdafx.h"//If the vc++6.0, with this line.#include "stdio.h"struct stu{ int x; char name[10];};int main(void){ struct stu s={8,"123"};//这样初始化 printf("%d %s\n",s.x,s.name); return 0;}向数组里直接拷贝字符串，如——
//#include "stdafx.h"//If the vc++6.0, with this line.#include "stdio.h"#include "string.h"struct stu{ int x; char name[10];};int main(void){ struct stu s; strcpy(s.name,"abcd");//向name拷贝字符串 s.x=128; printf("%d %s\n",s.x,s.name); return 0;}
st.name="123"; 非法，常量字符串不能直接赋值给字符数组，因为st.name 地址是确定的，不能再改了。 char name[10]="123";可以的，定义时，进行初始化字符数组。
st.name="123"; 非法，常量字符串不能直接赋值给字符数组，因为st.name 地址是确定的，不能再改了。 char name[10]="123";可以的，定义时，进行初始化字符数组。
好吧,比如:
struct emu={
int i;
char ch[50];}
那么对char ch赋值可以
for(j=0;j<=49;j++) emu.ch[j]=j;
或者一个字符一个字符的赋值,比如emu.ch[0]='a';
对字符串的赋值不能直接等于,要用函数strcpy,
好吧,比如:
struct
emu={
int
i;
char
ch[50];}
那么对char
ch赋值可以
for(j=0;j<=49;j++)
emu.ch[j]=j;
或者一个字符一个字符的赋值,比如emu.ch[0]='a';
对字符串的赋值不能直接等于,要用函数strcpy,
（1）用字符常量逐个初始化数组。例如：
char a[8]={'i'，'l'，'o'，'v'，'e'，'y'，'o'，'u'}；
把8个字符依次分别赋给c[0]~c[7]这8个元素。
如果在定义字符数组时不进行初始化，则数组中各元素的值是不可预料的。如果花括号中提供的初值个数（即字符个数）大于数组长度，则出现语法错误。
如果初值个数小于数组长度，则只将这些字符赋给数组中前面那些元素，其余的元素自动定为空字符（即'\0'）。
如果提供的初值个数与预定的数组长度相同，在定义时可以省略数组长度，系统会自动根据初值个数确定数组长度。
例如：char c[]={‘c’，‘’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'}；
这时c数组的长度自动定为9。也可以定义和初始化一个二维字符数组，例如：
char diamond[5][5]={{''，''，'#'}，{''，'#'，''，'#'}，{'#'，''，''，''，'#'}，
{''，'#'，''，'#'}，{''，''，'#'}};用它代表一个菱形的平面图形。
（2）字符串常量初始化数组。例如：
char c[]={‘c’，‘’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'}；
可写为：char c[]={"C program"}；
或去掉{}写为：char c[]="C program";
注意：此时数组c的长度不是9，而是10。因为字符串常量的最后由系统加上一个'\0'。上面的初始化与下面的初始化等价。
char c[]={‘c’，‘’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'，'\0'}；
扩展资料：其定义的一般形式是：char数组名[数据长度]
例如：
char c[10];
c[0]='I';c[1]='';c[2]='l';c[3]='o';c[4]='v';c[5]='e';c[6]='';c[7]='y';c[8]='o';c[9]='u';
以上定义了c为字符数组，包含10个元素。
由于字符型数据是以整数形式(ASCII代码)存放的，因此也可以用整型数组来存放字符数据，例如：
int c[10];
但这时每个数组元素占2个字节的内存单元，浪费存储空间。
字符数组也可以是二维或多维数组，例如：
char c[5][10];
即为二维字符数组。
初始化
字符数组的初始化与数值型数组初始化没有本质区别。但它除了可以逐个给数组元素赋予字符外，也可以直接用字符串对其初始化。
输入输出
字符数组的输入
（1）用getchar()或scanf()的'%c'格式符对数组进行字符赋值。例如，对于数组a[10]:用getchar()赋值：
for(i=0;i<10;i++)
a=getchar();
用scanf()赋值：
for(i=0;i<10;i++)
scanf("%c",&a);
（2）用scanf()的'%s'格式对数组赋值。还是对于数组a[10]:
scanf("%s",a);
或
scanf("%s“,&a[0]);
输入”C program“并回车时，a数组会自动包含一个以”\0“结尾的字符串”C program“。
字符数组的输出
（1）用putchar()或printf()的‘%c’格式符对数组进行字符赋值。例如，对于数组a[10]：用putchar()赋值：
for(i=0;i<10;i++)
a=putchar();
用printf()赋值：
for(i=0;i<10;i++)
printf("%c",a);
输出结果为：
c program
（2）用printf()的'%s'格式对数组赋值。还是对于数组a[10];
printf("%s",a);
输出结果为：
c program
参考资料：
百度百科——字符数组
数组初始化
int a[1000][1000]={0,0};
定义时就赋值,其余的默认就成0了.
C语言对一维数组的初始化赋值有以下几点规定：
1) 可以只给部分元素赋初值。
当{ }中值的个数少于元素个数时，只 给前面部分元素赋值。
例如：
int a[10]={0,1,2,3,4};
表示只给a[0]～a[4]5个元素赋值，而后5个元素自动赋0值。///应该是你想要的答案
2) 只能给元素逐个赋值，不能给数组整体赋值。
例如给十个元素全部赋1值，只能写为：
int a[10]={1,1,1,1,1,1,1,1,1,1};
而不能写为：
int a[10]=1;
3) 如给全部元素赋值，则在数组说明中，可以不给出数组元素的个数。
例如：
int a[5]={1,2,3,4,5};
可写为：
int a[]={1,2,3,4,5};
对于二维数组初始化赋值还有以下说明：
1) 可以只对部分元素赋初值，未赋初值的元素自动取0值。///应该是你想要的答案
例如：
int a[3][3]={{1},{2},{3}};
是对每一行的第一列元素赋值，未赋值的元素取0值。 赋值后各元素的值为：
1 0 0
2 0 0
3 0 0
int a [3][3]={{0,1},{0,0,2},{3}};
赋值后的元素值为:
0 1 0
0 0 2
3 0 0
2) 如对全部元素赋初值，则第一维的长度可以不给出。
例如：
int a[3][3]={1,2,3,4,5,6,7,8,9};
可以写为：
int a[][3]={1,2,3,4,5,6,7,8,9};
3) 数组是一种构造类型的数据。二维数组可以看作是由一维数组的嵌套而构成的。设一维数组的每个元素都又是一个数组，就组成了二维数组。当然，前提是各元素类型必须相同。根据这样的分析，一个二维数组也可以分解为多个一维数组。C语言允许这种分解。
如二维数组a[3][4]，可分解为三个一维数组，其数组名分别为：
a[0]
a[1]
a[2]
对这三个一维数组不需另作说明即可使用。这三个一维数组都有4个元素，例如：一维数组a[0]的元素为a[0][0],a[0][1],a[0][2],a[0][3]。
必须强调的是，a[0],a[1],a[2]不能当作下标变量使用，它们是数组名，不是一个单纯的下标变量。
以上是我找的资料，希望对你有帮助
置0
int a[1000][1000];
memset(a, 0, sizeof(int)*1000*1000);
这样是不对的，要不你就用系统的内存初始化函数：
int
a[10];
memset(a,0,10
*
sizeof(int));
要不你就：
int
a[10]
=
{0};
这样也全是0啦。
或者
int
a[10]
=
{0,1,2,3};
其他没写的就是0啦。
你的编译器的问题，asni
c99
标准里int
a[10]={0};是完全正确的，并指定a[0]的值为0，但你并没有给后面的变量赋值，编译器会自动把没有赋值的变量初始化为数组最后一个成员的值，即int
a[10]={0};数组a的值都被初始化为了0，应该是你编译器过老的缘故，问题2也是
使用memset函数
例如：
#include
using namespace std;
int a[1000][1000];
int main()
{
memset(a,0,sizeof(a));
for(int i=0;i<1000;i++)
for(int j=0;j<1000;j++)
{
cout<
<a[i][j]<<endl;
}
system("pause");
}
这样就行了，但只能赋值为0和-1；
</a[i][j]<<endl;
数组初始化时，如果初值个数多于数组长度，会出错？
一、如果定义数组的同时，赋予初值，那么可以省略数组的个数申明，编译系统自动计算你的初始化元素个数来确定数组大小。
二、我上面用词是“可以”，那么也可以指明数组的大小，当然指定的大小一定要比初始化元素个数多才行。
三、如果没有初始化，比如仅仅是“char a[8];”，那么一定要指明大小，否则系统不知道分配多少空间。
以上说明是针对C语言而言的，如果是对于JAVA、PHP、PERL等语言，其数组大小是动态可以调的，也就是说都可以不指定，或者指定一个很小的，以后使用中会自动扩充。
#include
int main()
{
int a[1] = {5,8};
return 0;
}
--------------------Configuration: dos - Win32 Debug--------------------
Compiling...
dos.cpp
C:\Program Files\Microsoft Visual Studio\MyProjects\dos\dos.cpp(4) : error C2078: too many
initializers
执行 cl.exe 时出错.
dos.obj - 1 error(s), 0 warning(s)
#include
int main()
{
int a[1] = {5};
return 0;
}
--------------------Configuration: dos - Win32 Debug--------------------
Compiling...
dos.cpp
dos.obj - 0 error(s), 0 warning(s)
c语言，字符数组中最后一个字必须为‘
不是字符数组中最后一个字符必须为'\0',如果字符数组中存放的是一个字符串,则最后一个字符应当'\0','\0'是结束符号,这样当输出这个字符串时,只须输入数组名就可以,输出函数会自动输出数组中的字符,直到遇到'\0'为止,否则你就要利用循环自己将字符一个一个的输出,而且还要判断该字符是不是所需要的字符,明白了么?
'\0'是为了关闭字符串，如果不关闭，那么就要爆掉！
所以开数组时要开大！
c语言中字符数组并没有规定最后一个字符为'\0'，甚至可以不包含'\0'，添加'\0'作为结束标志是针对于c语言对字符串的处理而言的，因此，字符数组中最后一个字必须为‘\0’是错误的。
C语言中没有字符串类型，字符串是存放在字符型数组中的。在C语言中，是将字符串作为字符数组来处理的。为了测定字符串的实际长度，C语言规定了一个“字符串结束标志”，以字符'\0'作为结束标志 。
例如：char a[8]={'i'，'l'，'o'，'v'，'e'，'y'，'o'，'u'}；把8个字符依次分别赋给c[0]~c[7]这8个元素。这样的字符数组长度为8，并没有在最后添加'\0'符号，但其初始化是完全正确的。
扩展资料：
C语言对'\0'结束的相关处理：
1、字符数组的初始化，如果初值个数小于数组长度，则只将这些字符赋给数组中前面那些元素，其余的元素自动定为空字符（即'\0'）。例如：char a[9]={'1'，'2'，'3'，'4'，'5'，'6'，'7'，'8'}；中，初始化数值只提供了8个，但字符长度为9，因此，会自动在补充空字符（即'\0'）。
2、字符串常量初始化数组。
例如：char c[ ]={‘c’，‘ ’，‘p’，‘r’，‘o'，'g'，'r'，'a'，'m'}；可写为：char c[ ]={"C program"} 或去掉{}写为：char c[ ]="C program";注意：此时数组c的长度不是9，而是10。因为字符串常量的最后由系统加上一个'\0'。上面的初始化与下面的初始化等价。
参考资料来源：百度百科-字符数组