精华内容
下载资源
问答
  • 对数组定义及初始化不正确
    千次阅读
    2021-09-21 17:14:14


    # 学习简介 主要学习数组的初始化和数组的常见操作等。

    一、数组的概念

    1.定义

    数组(array)是一种数据格式,能够存储多个同类型的值。

    2.声明数组

    通用格式: TypeName ArrayName[ArraySize];
    (1)TypeName :存储在数组中每个元素的值得类型,比如:int、 float 、double、char等。
    (2)ArrayName :数组名。
    (3)ArraySize :数组元素的个数。该值一定是在编译时就是已知确定的值。所以它必须是整型常数或者是const值、常量表达式,不能是编译时值不确定的变量。
    注意:
    if(ArrayIdx > ArraySize)
    编译可正常编译,不报错;
    运行结果为脏值;
    这种情况的写法是非常危险的。

    错误示例:
    	int name[10];
    	cout<<name[0]<<endl;
    	cout<<name[20]<<endl; //在编译时,不会报错,所以这种数组越界访问是很危险,需要人为校验,或者添加代码校验,否则输出脏值。
    	//以上代码在运行时,会发生提示:使用数组name,但没有对其进行初始化,输出的值都是脏值。
    正确示例:
    	int name[10]={0,1,2}; //这种初始化,默认后面的数值均为0
    	cout<<name[0]<<endl; //0
    	cout<<name[2]<<endl; //2
    	cout<<name[8]<<endl; //0
    

    二、数组初始化规则

    1.数组只有在定义时才能使用初始化。
    2.数组不能直接赋值给另一个数组。
    3.在数组定义时就进行初始化时,数组大小可以不写,编译器会自动计算元素个数。
    4.数组初始化时,当初始化的值少于数组大小时,未指定的元素会被编译器自动设置为0。
    5.当数组需要指定所有值为A时,只需写成int ArrayName[10] = {1};即将数组的元素全指定为1。

    //正确代码
    	int a[4]={1,2,3,5}; // 1 2 3 5
    	int b[] ={1,2,3}; // 1 2 3 没有指定数组大小,但编译器自动计数为3个元素。sizeof(b) = 12个byte(3*4byte),求数组长度应该为sizeof(b)/sizeof(b[0]);
    	int c[3] = {0}; // 0 0 0
    	int d[5]={0,1,2}; // 0 1 2 0 0 
    	int h[3] = {}; // 0 0 0 大括号中什么不写,也是自动初始化为0,一般我们显示写比较好。
    
    //错误示例
    	int e[2] = {1,2,3}; //初始值设定项太多
    	
    	int f[4]; 
    	f[4] = {1,2,3,4}; //采用{}方式初始化数组必须在定义的同时进行初始化,先定义再初始化是不行的,f[4]是表示一个元素,且索引还超出该数组的范围了。
    	f = a; //错误提示: 左操作数必须为左值。因为不能直接将整个数组名直接赋值给另一个数组名。
    	char  g[2] = {199.0, 2}; //-57 2  虽然编译不会报错,但199.0是double类型,和char转换存在精度损失,同时199.0超过了char的范围。
    
    //纠正错误示例
    int f[4];
    //定义后再初始化,可以使用for循环对每个元素初始化,或者用memcopy从另一个数组复制的初始值,或者用memset统一初始化。
    
    

    补充:左操作数必须为左值
    通常我们认为表达式的等号左侧的数为左值,右侧的数为右值。一般,左值是一个变量(即存在内存地址)。

    //以下两行代码在C++中会运行正常,且得到我们程序设计的正常结果,原因是C++会自动优化。
    //但如果在C语言中,会编译报错,提示左操作数必须为左值。
    int a=1,b=2,c;
    c = a>b?a:b=10;  //原因等价于先计算表达式a>b?a:b,返回一个常量(常量不是变量,没地址),常量是无法被赋值成10的。
    
    //在C语言中,正确写法
    int a=1,b=2,c;
    c = a>b?a:(b=10); //非要赋值,则需要加括号,c = 10。
    

    二、数组的常规操作

    1. 数组结构的实现是使用顺序存储结构,是一种线性存储结构,对存储数据通常只有查找和修改操作。
    2. 数组的修改(插入和删除),其算法效率比较差。
    3. 数组可以有多维的,但顺序存储是一维的,所以数组的存储方式有两种:
      (1)以列为主(先列后行)。
      (2)以行为主(先行后列)——C语言一般采用该方法。

    多维数组查找指定元素

    需要确定如下信息:
    (1)多维数组是以列为主还是以行为主?
    (2)多维数组在内存中存放的首地址,一般就是数组名。
    (3)数组的坐标索引。
    (4)数组的数据类型——获取每个元素的字节数。
    比如数组a[n][m],查找aij的位置,数据类型为int,以行序为主。
    a[i][j]= (&a[0][0] + (im+j)*sizeof(int));


    总结

    更多相关内容
  • 定义的数组a有5个元素,但在花括号中仅提供了两个初始值,这意味着仅初始化了前两个元素a [0]和a [1],而后三个元素是没有初始化. 如果未完全初始化,则未初始化的元素会自动设置为0. 应注意,“未完成初始化”与...

    b2df1cff4ebbabdbb549a571c67029ba.png

    可以说,数组是迄今为止存储数据的第一个实际结构. 尽管较早学习的变量也可以存储数据,但是变量可以存储的数据非常有限. 不仅如此,数组和指针(将在后面讨论)是互补的,学习数组可以为学习指针奠定基础.

    那么数组到底是什么?顾名思义,数组是许多数字的组合!那么对这些数字有什么要求,不管什么数字组合在一起,它都是一个数组吗?存储在同一数组中的数字必须满足以下两个条件: 这些数字的类型必须相同. 这些数字必须连续存储在内存中.

    换句话说,数组是连续存储在内存中的相同类型数据的集合.

    一维数组一维数组的定义如下:

    类型说明符数组名称[常量表达式];

    示例:

    int a[5];

    这意味着定义了一个整数数组,数组名称为a,定义的数组称为数组a. 数组名a不仅表示数组,而且还表示数组的第一个地址(该地址暂时不讨论,稍后将讨论指针).

    这时,数组a中有5个元素,每个元素都是一个int变量,并且它们在内存中的地址是连续分配的. 也就是说,int变量占据4个字节的内存空间,然后5个int变量占据20字节的内存空间,并且它们的地址被连续分配.

    这里的元素是变量的含义,而数组中的元素在传统上称为元素.

    定义数组时,需要指定数组中元素的数量. 方括号中的常量表达式用于指定元素的数量. 数组中的元素数也称为数组的长度.

    i-nv40TkpB6i2T5TU8frD81X7YrSQQ.jpg

    由于数组中有多个元素,如何区分这些元素?该方法是通过对每个元素编号. 数组元素的数量也称为下标.

    数组中的下标从0(而不是1)开始. 那么,如何用下标表示每个数组元素呢?通过“数组名[下标]”方法. 例如,“ int a [5];”表示定义了一个包含5个元素的数组a,这5个元素是[0],[1],[2],[3],[4]. 其中,[0],[1],[2],[3]和[4]分别代表这五个元素的变量名.

    为什么下标从0开始而不是1?想象一下,如果从1开始,数组的第五个元素是[5],并且当数组定义为int a [5]时,两者都是[5],这很容易引起混淆. 下标从0开始时不存在此问题!因此,定义一个数组a [n],则该数组中元素的最大索引为n–1;元素a [i]表示数组a中的第i + 1个元素.

    此外,方括号中的常量表达式可以是“数字常量表达式”或“符号常量表达式”. 但是无论表达式是什么,它都必须是常量,并且绝对不是变量. 通常,C语言不允许动态定义数组的长度. 换句话说,在程序运行期间,数组的大小不取决于变量的值. 异常情况是动态内存分配. 在这种情况下,可以动态定义数组的长度,这将在后面描述.

    一维数组初始化可以使用以下方法实现一维数组初始化:

    1)定义数组时,为所有元素分配初始值. 这称为“完全初始化”. 例如:

    int a[5] = {1, 2, 3, 4, 5};

    通过将数组元素的初始值放在一对大括号中,这样的初始化之后,[0] = 1; a [1] = 2; a [2] = 3; a [3] = 4; [4] = 5,它从左到右依次分配给每个元素. 应该注意的是,在初始化期间,元素之间用逗号而不是分号分隔.

    2)您只能为几个元素分配值,这称为“不完全初始化”. 例如:

    int a[5] = {1, 2};

    已定义的数组a有5个元素,但在花括号中仅提供了两个初始值,这意味着仅初始化了前两个元素a [0]和a [1],而后三个元素是没有初始化. 如果未完全初始化,则未初始化的元素会自动设置为0.

    c46abb3238c09a4d1d77c1742fe11114.jpg

    应注意,“未完成初始化”与“未完成初始化”不同. 如果“根本没有初始化”,即仅“ int a [5];”. 未初始化,则每个元素的值都不为0,并且所有元素均为垃圾值.

    您也不能写“ int a [5] = {};”. 如果大括号中没有写任何内容,则这是一个非常严重的语法错误. 用大括号写至少一个数字. 例如,“ int a [5] = {0};”一维数组的初始化方法,这一次是为了使数组“零”,这时数组中的每个元素都是零. 此外,如果定义的数组的长度小于大括号中提供的初始值的数量,则它也是语法错误,例如“ a [2] = {1、2、3、4、5 };“.

    3)如果在定义数组时为数组中的所有元素分配了初始值,则可能未指定数组的长度,因为已经确定了元素的数量. 我们在编程时经常使用这种书写方式,因为它很方便,不会有问题,也不需要自己计算几个元素. 系统将自动分配空间. 例如:

    int a[5] = {1, 2, 3, 4, 5};

    可以写为:

    int a[] = {1, 2, 3, 4, 5};

    在第二种书写方式中,大括号中有5个数字,因此系统将自动将数组a的长度定义为5. 但是,应注意的是,只有在定义数组时进行初始化时才能这样做. 如果在定义数组时未初始化,则省略数组长度是语法错误. 例如:

    int a[];

    然后它将在编译时提示错误,并且编译器将提示您未指定数组的长度.

    这是每个人的简单程序:

    # include

    int main(void)

    {

    int a[5] = {1, 2, 3, 4, 5};

    int i;

    for (i=0; i<5; ++i)

    {

    printf("%d\n", a[i]);

    }

    return 0;

    }

    7-810-jpg_6-1080-0-0-1080.jpg

    输出为:

    1

    2

    3

    4

    5

    a表示数组的名称,[5]表示数组具有5个元素,并由[0],[1],[2],[3]和[4]表示]. 并在大括号中将1、2、3、4、5分配给变量a [0],a [1],a [2],a [3],a [4]. 同样,下标从0开始,即从[0]而不是[1]开始.

    您还可以使用scanf从键盘手动初始化阵列:

    # include

    int main(void)

    {

    int a[5] = {0}; //数组清零初始化

    int i;

    printf("请输入5个数:");

    for (i=0; i<5; ++i)

    {

    scanf("%d", &a[i] );

    }

    for (i=0; i<5; ++i)

    {

    printf("%d\x20", a[i]);

    }

    printf("\n");

    return 0;

    }

    输出为:

    请输入5个数字: 1 2 3 4 5

    4495f628092369fed8a1abf39b25fc51.png

    1 2 3 4 5

    与使用scanf向字符数组输入字符串不同. 您必须使用for循环来输入数字. 不用在输入字符串时使用循环,只需使用scanf.

    一维数组元素的参考数组必须在使用前定义. C语言规定只能一一引用数组元素,而不能一次引用整个数组. 如前所述,数组元素的表示形式为:

    数组名[下标]

    下标可以是整数常量或整数表达式,例如:

    a[0] = a[5] + a[7] - a[2 * 3]

    请注意,定义数组时使用的“数组名称[常量表达式]”与引用数组元素时使用的“数组名称[下标]”有所不同. 定义数组时的常量表达式公式表示数组的长度,引用数组元素时的下标表示元素的编号. 例如:

    # include

    int main(void)

    {

    int a[5] = {1, 2, 3, 4, 5}; //定义长度为5的数组a

    int t;

    t = a[3]; /*引用数组a中下标为3的元素a[3], 此时的3不代表数组的长度*/

    printf("t = %d\n", t);

    return 0;

    }

    输出为:

    t = 4

    “ int a [5];”是定义了5个元素的数组一维数组的初始化方法,这5个元素是[0],[1],[2],[3],[4]. t = a [3]中的a [3]不是数组,而是元素a [3].

    因此,以下过程是错误的:

    # include

    int main(void)

    {

    int a[5];

    a[5] = {1, 2, 3, 4, 5};

    return 0;

    }

    错误的原因是,后面的[5]不是数组. 仅在定义时,“ [常数]”表示数组,方括号中的数字表示数组的长度. 除此之外,在程序中的任何位置都可以看到“ [constant]”不是数组,而只是数组的元素和变量. 这时,“ constant”表示元素的下标.

    此外,当单独为元素分配值时,您不能添加括号,因为元素是变量,即[5]只是变量名. 如何在最前面为变量分配值就是现在如何为数组元素分配值,例如“ a [5] = 1;”. 但是对于上述程序,这仍然是错误的. 因为数组元素的下标从0开始,所以数组a的元素只是[0]〜a [4],而没有[5]元素.

    本文来自电脑杂谈,转载请注明本文网址:

    http://www.pc-fly.com/a/ruanjian/article-182590-1.html

    展开全文
  • 数组用来表示一数据的集合。使用数组,可以方便地定义一个名字(数组名)来表示大批量数据,并能够通过循环批处理大量数据。 一、定义 数组就是一相同类型数据的集合。 一维数组的定义形式为: 元素类型 ...

    数组用来表示一组数据的集合。使用数组,可以方便地定义一个名字(数组名)来表示大批量数据,并能够通过循环批处理大量数据。

    一、定义

    数组就是一组相同类型数据的集合。

    一维数组的定义形式为:

    元素类型  数组名  [常量表达式(数组包含的元素个数)]; 

    int A[10];
    int B[10], C[15]; //多个数组定义
    int E[10], m, n, F[15]; //数组和变量混合在一起定义

    (1)一维数组是由元素类型、数组名和长度(数组包含的元素个数)组成的构造类型。

    int A[10], B[20]; // 元素是整型
    double F1[8], F2[10]; //元素是双精度浮点型
    char S1[80], S2[80]; //元素是字符型
    

    (2)数组名必须符合C++标识符规则。

    (3)常量表达式表示数组中元素的个数,称为数组长度。常量表达式的值必须为正整数且大于等于1

    (4)数组一经定义,数组长度就始终不变。

       如:

    int n;
    cin>>n;
    int a[n];  //错误!
    
    

    二、内存形式

    C++规定数组元素是连续存放的,即在内存中一个元素紧跟着一个元素线性排列

     三、一维数组的初始化

    可以在一维数组定义时对它进行初始化,初始化的语法形式如下:

    元素类型  数组名 [常量表达式]={初值列表};

    int A[5]={1,2,3,4,5} , B[3]={7,8,9};
    //一维数组初始化

    (1)初值列表提供的元素个数不能超过数组长度,但可以小于数组长度。如果初值个数小于数组长度,则只初始化前面的数组元素, 剩余元素初始化为0。例如:

    int A[5]={1,8,9};
    

    (2)在提供了初值列表的前提下,数组定义时可以不用指定数组长度,编译器会根据初值个数自动确定数组的长度。例如:

    int A[]={1,8,9};

    可以用下面的表达式计算出数组A的长度:

     

    (3)若数组未进行初始化,静态数组的元素均初始化为0;在函数体内定义的动态数组,其元素没有初始化,为一个随机值。 

    static int A[10]; //静态数组,默认各元素的值为0
    int A[10]; //动态数组,各元素的值为随机数
    

    四、一维数组的引用 

    数组必须先定义后使用,且只能逐个引用数组元素的值而不能一次引用整个数组全部元素的值。

    数组元素引用是通过下标得到的,一般形式为:

    数组名 [下标表达式]

     (1)注意下标的表示形式

    ►下标表达式可以是常量、变量、表达式,但必须是正整数,不允许为负。

    数组元素下标总是从0开始。

    int A[5]={1,2,3,4,5}, x,i=3;
    x = A[2] ;  //常量
    A[i]++;     //变量
    A[1+2]=10;  //表达式
    

    (2)下标值不能超过数组长度,否则导致数组下标越界的严重错误。例如: 

    int A[5]={1,2,3,4,5};
    A[5]=10; //错误,没有A[5]元素
    

     

     (3)整个数组不允许进行赋值运算、算术运算等操作,只有元素才可以,例如:

    int A[10], B[10], C[10];
    A = B; //错误
    A = B + C; //错误
    A[0] = B[0]; //正确,数组元素赋值
    A[2] = B[2]+C[2]; //正确,数组元素赋值
    

    从数组的内存形式来看,数组元素的下标是有序递增的,这个特点使得可以利用循环来批量处理数组元素。

    如:

    对数组中的所有元素进行输入输出。 

     #include <iostream>
     using namespace std;
     int main() //一维数组的输入输出
     {
     int i, A[100]; 
     for(i=0;i<100;i++) cin>>A[i];
     for(i=100-1;i>=0;i--) cout<<A[i]<<" ";
     return 0;
     } 

    将一个一维数组的元素赋给另一个等长的一维数组。

     #include <iostream>
     int main()
     {
     int A[5]={1,2,3,4,5} , B[5] , i;
     for (i=0; i<5; i++)
     B[i] = A[i]; //元素一一复制
     return 0;
     } 

    展开全文
  • 目录1 实型2 标识符3 变量4 一维数组4.1 注意点4.2 初始化5 二维数组5.1 初始化6 字符数组6.1 初始化6.2 与字符指针的比较7 结构体7.1 声明定义7.2 初始化7.3 结构体指针8 共用体9 枚举 1 实型 实型分为十进制小数...

    1 实型

    实型分为十进制小数类型和指数形式,其中指数形式,规定以字母e和E代表以10为底的指数,但应注意:e或E之前必须有数字,且e或E后面必须为整数。

    • 正确示例:12.34e3、-346.87e-25、0.145E-25、1.2e0、123e03
    • 错误示例:e4、12e2.5

    2 标识符

    除了变量名,后面还会讲到函数名、宏名、结构体名等,它们都是标识符。标识符只能由字母(A~Z, a~z)、数字(0-9)和下划线(_)组成,并且第一个字符必须是字母或下划线,不能是数字。C语言标识符区分大小写。

    • 正确示例:a、x、x3、BOOK_1、sum5
    • 错误示例:3s、-3x、bowy-1、s*T

    C语言虽然不限制标识符的长度,但是它受到不同编译器的限制,同时也受到操作系统的限制。例如在某个编译器中规定标识符前128位有效,当两个标识符前128位相同时,则被认为是同一个标识符。

    3 变量

    可以定义多个变量并为多个变量赋初值,如

    int a, b, c=5; // 正确
    int a=3, b=3, c=3; // 正确
    int a=b=c=3; // 错误
    

    4 一维数组

    4.1 注意点

    • 数组大小可以使用常量或者符号常量,如int a[3+5];,但是不能使用变量,如int a[n];但C99支持这种做法
    • 在被调用函数中定义数组,可以使用变量,如
    void func(int n) {
    	int a[2*n];
    }
    
    • 如果指定数组为静态数组,则不能使用可变长数组,如static int a[2*n];就是错误的。

    4.2 初始化

    • 在定义数组时对全部数组元素赋初值,如
    int a[10] = {0, 1, 2, 3, 4, 5, 6, 7, 8, 9};
    
    • 可以对数组中一部分元素赋初值,则只给前五个元素赋值,后5个赋值0,如
    int a[10] = {0, 1, 2, 3, 4};
    
    • 可以初始化全部为0,如
    int a[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
    int a[10] = {0};
    
    • 初始化可以不指定长度,如
    int a[] = {1, 2, 3, 4, 5};
    

    5 二维数组

    5.1 初始化

    • 分行给二维数组赋初值,如
    int a[3][4] = {{1, 2, 3, 4}, {5, 6, 7, 8}, {9, 10, 11, 12}};
    
    • 可以将数据写在一个括号里赋初值,如
    int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    
    • 可以对部分元素赋初值,这样对各行第一个元素赋初值,其他的为0,如
    int a[3][4] = {{1}, {5}, {9}};
    /*
        1 0 0 0
        5 0 0 0 
        9 0 0 0
    */
    
    • 可以对各行中某一元素赋初值,如
    int a[3][4] = {{1}, {0, 6}, {0, 0, 11}};
    /*
        1 0 0 0
        0 6 0 0 
        0 0 11 0
    */
    
    • 可以只对某行几个元素赋初值,如
    int a[3][4] = {{1}, {5, 6}};
    /*
        1 0 0 0
        5 6 0 0 
        0 0 0 0
    */
    
    • 也可以对其中一行不赋值,如
    int a[3][4] = {{1}, {}, {9}};
    /*
        1 0 0 0
        0 0 0 0 
        9 0 0 0
    */
    
    • 如果对全部元素赋初值,则一维长度可以省略,二者等价,如
    int a[][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    int a[3][4] = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12};
    
    • 可以只对部分元素赋初值并省略一维长度,如
    int a[][4] = {{0, 0, 3}, {}, {0, 10}};
    /*
        0 0 3 0
        0 0 0 0 
        0 10 0 0
    */
    

    6 字符数组

    6.1 初始化

    • 把各个字符依次赋值给数组,数量大于数组长度会报错,数量小于数组长度会将剩下的位置赋值为\0,如
    char c[10] = {'I', ' ', 'a', 'm', ' ', 'h', 'a', 'p', 'p', 'y'};
    
    • 二维字符数组,如
    char c[2][3] = {{'y', 'o', 'u'}, {'a', 'r', 'e'}};
    
    • 用字符串常量来初始化字符数组,三者等价,此时系统会在末尾加上一个\0,所以实际长度会是字符串长度+1,若给定了字符数组的长度,而字符串长度小于字符数组定义长度,其余位置会赋值\0,如
    char c[] = {"I am happy"};
    char c[] = "I am happy";    // 可以省略花括号
    char c[] = {'I', ' ', 'a', 'm', ' ', 'h', 'a', 'p', 'p', 'y', '\0'}; // 与上面等价
    

    6.2 与字符指针的比较

    • 字符数组存放若干元素,字符指针存放字符串的首地址
    • 可以对字符指针赋值,但不能对数组名赋值,如
    char *p;
    p = "I love China"; // 正确
    
    char c[14];
    c = "I love China"; // 错误
    c[14] = "I love China"; // 错误
    
    • 字符数组中各元素的值是可以改变的(可以再次赋值),字符指针指向的字符串常量是不能再次赋值的,如
    char a[] = "china";
    char *b = "china";
    a[2] = 'r'; // 正确
    b[2] = 'r'; // 错误
    

    7 结构体

    7.1 声明定义

    • 先声明,再定义,如
    struct Student {
    	char name[20];
    	int age;
    };
    struct Student student1, student2; // 定义了两个Student结构体
    
    • 在声明类型的同时定义变量,如
    struct Student {
    	char name[20];
    	int age;
    }student1, student2;
    
    • 匿名结构体,直接定义变量,如
    struct {
    	char name[20];
    	int age;
    }student1, student2;
    

    7.2 初始化

    • 定义结构体并初始化
    struct Student {
    	char name[20];
    	int age;
    }student1 = {"xiaoming", 20};
    
    • C99允许对某个成员初始化,则其他变量默认初始化0,如
    struct Student student1={.age=12}; // 只对age进行初始化
    
    • 同类型结构体变量可以相互赋值,如
    student1 = student2;
    
    • 定义结构体数组并初始化,如
    struct Student {
    	char name[20];
    	int age;
    }student[2] = {"xiaoming", 20, "lihao", 15};
    
    • 定义时初始化,如
    struct Student student[2] = {"xiaoming", 20, "lihao", 15};
    

    7.3 结构体指针

    struct Student *p = student1;,使用p->age代替(*p).age(.优先级大于*,括号不能省),以下三种写法等价

    student1.age;
    (*p).age;
    p->age;
    

    8 共用体

    共用体union可以用一段内存存放不同类型的变量,它在每一瞬间只能存放其中一个成员,对共用体变量多次赋值,只保留最后一次赋值的值,共用体变量所占的内存长度等于最长的成员长度,初始化跟结构体有点像。

    • 声明并定义共用体,如
    union Data {
    	int i;
    	char ch;
    	float f;
    }a, b, c;
    
    • 可以声明和定义分开,如
    union Data {
    	int i;
    	char ch;
    	float f;
    };
    union Data a, b, c;
    
    • 初始化方法,如
    union Data {
    	int i;
    	char ch;
    	float f;
    }a = {1, 'a', 1.5}; // 错误,不能同时初始化3个
    union Data a = {16}; // 正确
    union Data a = {.ch='j'}; // 正确 C99新增
    
    • 对共用体赋值要指明赋值对象,如
    a.ch = 'A'; // 正确
    a.f = 1.5;  // 正确
    a.i = 40;   // 正确
    a = 1;      // 错误,没有指明赋值对象
    
    • C99 允许共用体之间相互赋值,允许共用体变量作为函数参数

    9 枚举

    如果变量有几种可能的值,则可以定义枚举,即把可能的值一一列举出来,变量的值只限于举例出来的值范围内,每一个枚举变量范围取值代表一个整数,从0开始递增。

    • 声明枚举类型,如
    enum Weekday {sun, mon, tue, wed, thu, fri, sat};
    
    • 定义枚举类型,如
    enum Weekday workday, weedkend;
    
    • 赋值,如
    workday = mon; // 正确
    workday = sun; // 正确
    Weekday = monday; // 错误,monday不是范围类的取值
    
    • 可以人为的指定枚举元素的取值,如
    enum Weekday {sun=7, mon=1, tue, wed, thu, fri, sat};
    // sun=7, mon=1, tue=2, wed=3, thu=4, fri=5, sat=6
    
    • 枚举元素可以用来做判断比较,通过初始化时的整数进行比较,如
    if (workday == mon){} // 正确
    if (workday > sun){} // 正确
    
    展开全文
  • Java中对数组的声明与初始化

    千次阅读 2021-03-15 21:18:03
    Java语言中,使用数组必须经过数组的声明和分配储存空间两个步骤。... 在声明数组的时候虽然默认初始值NUL表示没有分配储存空间,建议声明时一定要给出默认值。(数组类型属于引用类型,赋值为null表示还指向...
  • //一般对数组初始化可以用以下方法实现: #include using namespace std; int main(){ //一般对数组初始化可以用以下方法实现: //(1)在定义数组时对数组元素赋以初值。如: int a[8] = {0,1,2,3,4,5,6,7}; cout[0]=...
  • 他说,“学过编程,我便考一考你,在使用数组之前,应应该初始化数组?”我暗想,这么简单的问题,也配考我么?只是数组,在使用任何变量之前,都应该对变量进行初始化,这是一个编程的好习惯,可以有效避免许多...
  • 数组的初始化

    千次阅读 2021-04-14 20:41:09
    数组并一定是整型,还有浮点型(double),布尔型(boolean),字符型(char)等等 (2)静态初始化:由我们为数元素赋值,由系统计算长度 int[]arr1=new int[]{1,2,3}; Int[]arr1={1,2,3,4};(简写方式) 注意事项: 这...
  • C语言数组的初始化表示方法

    万次阅读 多人点赞 2019-07-25 10:51:22
    经过上面的定义初始化后,a[0]=0,a[1]=1,… ,a[9]=9。 (2)初始化时可以只对一部分元素赋初值。例如: static int a[10]={0,1,2,3,4}; 定义的数组有10个元素,但只对其中前...
  • 如何初始化数组

    万次阅读 多人点赞 2018-04-16 23:43:12
    分析:如果直接输出未初始化的数组元素值,以观察未初始化的数组,实现方法代码如下所示: #include&lt;stdio.h&gt; #define SIZE 10 int main() { int array[SIZE] ; int i = 0; for(i = 0;i &lt; ...
  • 字符数组的初始化及字符串的使用

    千次阅读 2020-10-15 18:55:45
    文章目录字符数组的定义字符数组初始化字符串存放'\0'的作用 字符数组的定义 同整型数组一样: char c[10]; char ch[3][4]; 字符数组初始化 定义数组时初始化,如: char c[10]={'a','b','c','d'}; 如果输出格式为...
  • C++字符数组 定义初始化 赋值和引用
  • c语言二维数组的定义初始化

    万次阅读 2015-09-03 00:44:57
    //对数组元素进行直接初始化,少于其3*4的个数后面用0补充,多余的舍去 int a[3][4] = {1,2,2,3,4,4,4,5,5,5,4,5}; //分配内存的同时初始化数组 printfArray(a,3); printf("===============================\n...
  • 数组初始化

    2021-07-02 17:59:57
    数组的初始化是指在定义数组时进行数组元素赋值,其初始化的语法格式如下: 数据类型 数组名[数组元素个数] = {值1, 值2, …, 值n}; (1)对数组全部元素赋初值,示例代码如下: int a[4] = {1, 2, 3, 4}; 在定义...
  • C语言 - 数组与结构体初始化方法

    千次阅读 2019-09-19 00:14:10
    C语言 - 数组与结构体初始化方法与区别 说明 本文的测试均在VS2015的开发环境下测试。 数组与结构体初始化方法 ...1.定义变量后,再初始化 int array[5]; array[0] = 0; array[1] = 1; array[2] = 2; arr...
  • 字符串的定义与赋值及初始化

    万次阅读 多人点赞 2013-06-18 14:08:57
    字符串的定义与赋值及初始化 C语言的运算符根本无法操作字符串。在C语言中把字符串当作数组来处理,因此,对字符串的限制方式和对数组的一样,特别是,它们都能用C语言的运算符进行复制和比较操作。 怎么给这个...
  • 二维数组的创建和初始化

    千次阅读 2022-04-27 09:20:35
    一、二维数组的创建 //数组创建 int arr[3][4]; char arr[3][5]; double arr[2][4]; #include<stdio.h> //二维数组的创建 ...二、二维数组的初始化 ...完全初始化: ...完全初始化: 二维数组
  • 结构体变量的初始化和引用

    千次阅读 2021-01-21 18:28:37
    结构体变量的初始化和引用 任务描述 本关任务:从键盘输入两个学生的学号,姓名和成绩(整数),分别存入结构体中,输出成绩较高的学生的学号,姓名和成绩。 相关知识 结构体类型用于描述由多个不同数据类型的数据...
  • C语言数组初始化

    千次阅读 2019-01-13 23:23:20
    C语言数组初始化 wchar_t wname[128]={0}; char cname[256]={0}; 我感兴趣的是: ...当初始化值的个数少于数组元素个数时,前面的按序初始化相应值,后面的初始化为0(全局或静态数组)或为确定值(局部...
  • Java数组初始化、赋值与输出

    千次阅读 2020-05-31 23:01:00
    文章目录Java数组相关知识数组初始化一维数组二维数组数输出一维数组二维数组 Java数组相关知识 数组初始化 一维数组 初始化为0 int[] a; a = new int[5]; int[] b = new int[5]; 初始化为指定值 int[] a = new ...
  • C语言 数组指针初始化

    千次阅读 2020-06-20 10:41:03
    当然不行,不管从初始化器,还是从原理上来讲都不正确,首先a[3][4]表示的是数组中第4行第5个元素,请问,可以对数组中具体的一个元素赋这么长一串值吗?所以能这样赋值。第一种写法是属于初始化初始化会自动...
  • 一、字符数组的定义初始化 字符数组的初始化,最容易理解的方式就是逐个字符赋给数组中各元素。 charstr[10]={'I','','a','m','',‘h’,'a','p','p','y'}; 即把10个字符分别赋给str[0]到str[9]10个元素 如果花...
  • C语言中,数组初始化的方式主要有三种:1、声明时,使用 {0} 初始化;2、使用memset;3、用for循环赋值。那么,这三种方法的原理以及效率如何呢?请看下面的测试代码:#define ARRAY_SIZE_MAX(1*1024*1024)void ...
  • JAVA中数组的正确定义方法是什么?

    千次阅读 2021-03-06 18:37:34
    §5.1一维数组一、一维数组的定义type arrayName[];其中类型(type)可以为Java中任意的数据类型,包括简单类型组合类型,数组名arrayName为一个合法的标识符,[]指明该变量是一个数组类型变量。例如:int intArray[];...
  • C语言中,数组初始化的方式主要有三种:1、声明时,使用 {0} 初始化;2、使用memset;3、用for循环赋值。那么,这三种方法的原理以及效率如何呢? 请看下面的测试代码:[cpp]view plaincopy#defineARRAY_SIZE_MAX(1*...
  • C++字符数组的定义初始化、引用

    万次阅读 2016-09-03 23:10:04
    用来存放字符数据的数组是字符数组,字符...一、字符数组的定义初始化 定义字符数组的方法与前面介绍的类似。例如 char c[10]; c[0]=′I′;c[1]=′ ′;c[2]=′a′;c[3]=′m′;c[4]=′ ′;c[5]=′h′;c[6]=′a′;c
  • C语言的数组初始化

    千次阅读 2018-07-06 15:25:45
    这是很基础的东西,但基础的重要性不言而喻,我敢肯定这个知识点我肯定曾经了解过,但现在,我敢确定,由此可见纪录的重要性,这世界没有什么捷径,找对方向,然后不停重复.所以从今天开始,我会比
  • 一维数组初始化

    千次阅读 2019-04-25 11:03:08
    为了使程序运行简便,在程序定义的时候就把有相同性的值进行赋值也就是对数组的初始化例如: int a[10]={1,2,3,4,5,6,7,8,9}将数组中的各种元素初始值按顺序放到花括号里,数据用逗号隔开,中括号里的值就是数组初始...
  • 先来看看常用的权值初始化方法,这是网络模型搭建好之后的一个非常重要的步骤,正确的权值初始化可以加速模型的收敛, 恰当的权值初始化导致输出层的输出过大或者过小,最终导致梯度爆炸或者消失,使得模型无法...
  • [C]二维数组的初始化规则

    万次阅读 多人点赞 2018-10-04 23:12:20
    二维数组初始化形式如下: int/char arr [100][200]  数据类型 数组名 [整常量表达式][整常量表达式] = {初始化数据}; 在{}中给出各组元素的初值,各初值之间用逗号分开。把{}中的初值依次赋给各数组元素。 ...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 33,349
精华内容 13,339
热门标签
关键字:

对数组定义及初始化不正确