精华内容
下载资源
问答
  • C# 枚举初始化及获取索引值

    千次阅读 2019-02-24 15:41:11
    /// 枚举初始化 && 获取枚举索引值 /// public class SetEnum : MonoBehaviour { public m_Enum m_Enum; void Update() { //1.枚举类型赋值 if (Input.GetKeyDown(KeyCode.Alpha1)) { m_Enum = m_Enum....

     


    using System.Collections;
    using System.Collections.Generic;
    using UnityEngine;
    using System;
    
    /// <summary>
    /// 自定义Enum
    /// </summary>
    public enum m_Enum
    {
        obj0,
        obj1,
        obj2
    }
    
    /// <summary>
    /// 枚举的初始化 && 获取枚举索引值
    /// </summary>
    public class SetEnum : MonoBehaviour {
    
        public m_Enum m_Enum;
    
    	void Update() {
    
            //1.枚举类型赋值
            if (Input.GetKeyDown(KeyCode.Alpha1))
            {
                m_Enum = m_Enum.obj0;
            }
    
            //2.string类型赋值
            if (Input.GetKeyDown(KeyCode.Alpha2))
            {
                m_Enum = (m_Enum)Enum.Parse(typeof(m_Enum), "obj1");
            }
    
            //3.int类型赋值
            if (Input.GetKeyDown(KeyCode.Alpha3))
            {
                m_Enum = (m_Enum)Enum.ToObject(typeof(m_Enum), 2);
            }
    
            //获取枚举索引值
            print("m_Enum index : " + m_Enum.GetHashCode());
        }
    }
    
    
    

     

    展开全文
  • 在看http_errno展开的时候,发现由HTTP_ERRNO_GEN通过HTTP_ERRNO_MAP的生成的枚举"XX_UNKNOWN,"多一个逗号,而编译器并不报错,而是接受它了。这明明是一个语法错误么! int a[] = {1, 2, 3, }; enum b ...

    在看http_errno展开的时候,发现由HTTP_ERRNO_GEN通过HTTP_ERRNO_MAP的生成的枚举"XX_UNKNOWN,"多一个逗号,而编译器并不报错,而是接受它了。这明明是一个语法错误么!

    int a[] = {1, 2, 3, };
    enum b { c = 1, d, };

    google之“c array last comma”,找到了些解释。发现不仅仅是C如此,java,php...都有这样的情况。编译器对此都是允许的。

    1、http://stackoverflow.com/questions/792753/is-the-last-comma-in-c-enum-required

    2、http://stackoverflow.com/questions/3850203/java-array-initialization-list-ending-with-a-comma

    有些东西还真是不可妄断。

    1 C,C++,Java,PHP都能容忍末尾的逗号

    C,C++,Java中对数组赋值时,最后一个元素末尾的逗号可有可无。下面两行代码对这些语言来说是等效的。

    int a[] = {1,2,3};      /* 正确 */
    int a[] = {1,2,3,};     /* 正确 */

    PHP这一点也继承了C的特点,下面的两行代码等效。

    $a = array(1,2,3); /* 正确 */
    $a = array(1,2,3,); /* 正确 */

    2 JavaScript视末尾逗号为语法错误!

    然而到了JavaScript,情况大不相同了,最后一个元素末尾一定不能有逗号,否则就是语法错误。

    var a = new Array(1,2,3); //正确
    var a = new Array(1,2,3,); //报错

    对于对象,同样不能有末尾的逗号。

    var o = { name:'赵', age:12 }; // 正确
    var o = { name:'赵', age:12,}; // 报错

    尽管有些浏览器在检测到这种错误后,最大容忍地去执行,但这不是统一的行为。IE系列浏览器统统不能容忍这种错误。

    3 JSON同样不能容忍末尾的逗号

    {"name":"zhao", "age":12}   // 正确的JSON格式
    {"name":"zhao", "age":12,}  // 错误的JSON格式

    需要注意的是,JSON是一种通用数据格式,与具体编程语言无关。各种语言在解码JSON时,也会采用不同的容忍程度。PHP的json_decode()就不能容忍末尾的逗号。

    json_decode({"name":"zhao", "age":12,}); // 解析会发生错误
    展开全文
  • 以下是从MSDN中copy出来的一段,其实就是形式语法的规定,加不加都是可以的。 注:其实原来我是不加的,后来我有看Linux下的源码,然后也发现了这个问题,后来有Google到gcc下的语法,觉得其实加上更好,现在...

    http://bbs.csdn.net/topics/330052999


    以下是从MSDN中copy出来的一段,其实就是形式语法的规定,加不加都是可以的。
    注:其实原来我是不加的,后来我有看Linux下的源码,然后也发现了这个问题,后来有Google到gcc下的语法,觉得其实加上更好,现在就都加了。

    Initializing Aggregate Types
    An “aggregate” type is a structure, union, or array type. If an aggregate type contains members of aggregate types, the initialization rules apply recursively. 

    Syntax

    initializer :

    { initializer-list } /* For aggregate initialization */
    { initializer-list , }

    initializer-list :

    initializer
    initializer-list , initializer

    The initializer-list is a list of initializers separated by commas. Each initializer in the list is either a constant expression or an initializer list. Therefore, initializer lists can be nested. This form is useful for initializing aggregate members of an aggregate type, as shown in the examples in this section. However, if the initializer for an automatic identifier is a single expression, it need not be a constant expression; it merely needs to have appropriate type for assignment to the identifier.

    For each initializer list, the values of the constant expressions are assigned, in order, to the corresponding members of the aggregate variable. 

    If initializer-list has fewer values than an aggregate type, the remaining members or elements of the aggregate type are initialized to 0 for external and static variables. The initial value of an automatic identifier not explicitly initialized is undefined. If initializer-list has more values than an aggregate type, an error results. These rules apply to each embedded initializer list, as well as to the aggregate as a whole.

    A structure’s initializer is either an expression of the same type, or a list of initializers for its members enclosed in curly braces ({ }). Unnamed bit-field members are not initialized. 

    When a union is initialized, initializer-list must be a single constant expression. The value of the constant expression is assigned to the first member of the union. 

    If an array has unknown size, the number of initializers determines the size of the array, and its type becomes complete. There is no way to specify repetition of an initializer in C, or to initialize an element in the middle of an array without providing all preceding values as well. If you need this operation in your program, write the routine in assembly language. 

    Note that the number of initializers can set the size of the array:

    int x[ ] = { 0, 1, 2 }

    If you specify the size and give the wrong number of initializers, however, the compiler generates an error.

    Microsoft Specific —>

    The maximum size for an array is defined by size_t. Defined in the header file STDDEF.H, size_t is an unsigned int with the range 0x00000000 to 0x7CFFFFFF.

    END Microsoft Specific

    Examples

    This example shows initializers for an array. 

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

    This statement declares P as a four-by-three array and initializes the elements of its first row to 1, the elements of its second row to 2, and so on through the fourth row. Note that the initializer list for the third and fourth rows contains commas after the last constant expression. The last initializer list ({4, 4, 4,},) is also followed by a comma. These extra commas are permitted but are not required; only commas that separate constant expressions from one another, and those that separate one initializer list from another, are required. 

    If an aggregate member has no embedded initializer list, values are simply assigned, in order, to each member of the subaggregate. Therefore, the initialization in the previous example is equivalent to the following:

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

    Braces can also appear around individual initializers in the list and would help to clarify the example above. 

    When you initialize an aggregate variable, you must be careful to use braces and initializer lists properly. The following example illustrates the compiler’s interpretation of braces in more detail:

    typedef struct 
    {
        int n1, n2, n3;
    } triplet;

    triplet nlist[2][3] = 
    {
        { {  1, 2, 3 }, {  4, 5, 6 }, {  7, 8, 9 } },  /* Row 1 */
        { { 10,11,12 }, { 13,14,15 }, { 16,17,18 } }   /* Row 2 */
    };

    In this example, nlist is declared as a 2-by-3 array of structures, each structure having three members. Row 1 of the initialization assigns values to the first row of nlist, as follows: 

    The first left brace on row 1 signals the compiler that initialization of the first aggregate member of nlist (that is, nlist[0]) is beginning.


    The second left brace indicates that initialization of the first aggregate member of nlist[0] (that is, the structure at nlist[0][0]) is beginning.


    The first right brace ends initialization of the structure nlist[0][0]; the next left brace starts initialization of nlist[0][1].


    The process continues until the end of the line, where the closing right brace ends initialization of nlist[0]. 
    Row 2 assigns values to the second row of nlist in a similar way. Note that the outer sets of braces enclosing the initializers on rows 1 and 2 are required. The following construction, which omits the outer braces, would cause an error:

    triplet nlist[2][3] =  /* THIS CAUSES AN ERROR */
    {
         {  1, 2, 3 },{  4, 5, 6 },{  7, 8, 9 },   /* Line 1 */
         { 10,11,12 },{ 13,14,15 },{ 16,17,18 }    /* Line 2 */
    };

    In this construction, the first left brace on line 1 starts the initialization of nlist[0], which is an array of three structures. The values 1, 2, and 3 are assigned to the three members of the first structure. When the next right brace is encountered (after the value 3), initialization of nlist[0] is complete, and the two remaining structures in the three-structure array are automatically initialized to 0. Similarly, { 4,5,6 } initializes the first structure in the second row of nlist. The remaining two structures of nlist[1] are set to 0. When the compiler encounters the next initializer list ( { 7,8,9 } ), it tries to initialize nlist[2]. Since nlist has only two rows, this attempt causes an error. 

    In this next example, the three int members of x are initialized to 1, 2, and 3, respectively. 

    struct list 
    {
        int i, j, k;
        float m[2][3];
    } x = {
            1,
            2,
            3,
           {4.0, 4.0, 4.0}
          };

    In the list structure above, the three elements in the first row of m are initialized to 4.0; the elements of the remaining row of m are initialized to 0.0 by default.

    union
    {
        char x[2][3];
        int i, j, k;
    } y = { {
                {'1'},
                {'4'} 
            }
          };

    The union variable y, in this example, is initialized. The first element of the union is an array, so the initializer is an aggregate initializer. The initializer list {'1'} assigns values to the first row of the array. Since only one value appears in the list, the element in the first column is initialized to the character 1, and the remaining two elements in the row are initialized to the value 0 by default. Similarly, the first element of the second row of x is initialized to the character 4, and the remaining two elements in the row are initialized to the value 0. 

    展开全文
  • 枚举初始化

    千次阅读 2018-07-22 15:16:13
    知识点:枚举类 所有的枚举值都是类静态常量,在初始化时会对所有的枚举值对象进行第一次初始化。 package zml; enum AccountType { SAVING, FIXED, CURRENT; private AccountType() { System.out.println(&...

    知识点:枚举类 所有的枚举值都是类静态常量,在初始化时会对所有的枚举值对象进行第一次初始化。

    package zml;
    enum AccountType
    {
        SAVING, FIXED, CURRENT;
        private AccountType()
        {
            System.out.println("It is a account type");
        }
    }
    
     
    public class TestEnum {
         public static void main(String[]args)
            {
                System.out.println(AccountType.FIXED);
                System.out.println("=================");
                System.out.println(AccountType.FIXED);
            }
    }
    
    

    结果:

    展开全文
  • 枚举设置 初始化字典

    千次阅读 2019-06-14 10:42:44
    一、枚举 /** * @ClassName:EnumModel * @Description: 系统枚举类,包括枚举大类,具体单个枚举类 * @Description: 运行 http://localhost:8089/anonymous/initDB * @Author: liuhm * @Date: 2019/5/5 09:...
  • C# 枚举初始化

    2017-02-09 10:08:00
    3.2 枚举类型(Enum types)的默认值  对于枚举类型(Enum types),.NET会自动将字面值0(literal 0)隐式地转换为对应的枚举类型。  3.2.1 有一个0值成员  如果枚举类型中的某个成员被赋予0值(不要求是第一...
  • 枚举类型的初始化

    万次阅读 2015-11-03 12:41:05
    1.如果是在函数外面定义一个枚举类型的...其实这块:全局变量和静态类型变量没有初始化的话也会自动初始化为0或空字符。 enum x{ x1 = 3, x2, x3, } ; x X; int main() {  cout  getchar();  return
  • 对于具有固定底层类型的枚举,因为c++ 17可以使用该类型的整数值直接初始化列表。 1. 对于普通枚举类型 制定底层类型的普通枚举可以通过{integer_value}直接初始化: // unscoped enum with underlying type: ...
  • C++ 枚举类型初始化方式及值

    千次阅读 2019-03-07 14:06:10
    枚举类型 枚举类型(enumeration)是C++中的一种派生数据类型,它是由用户定义的若干枚举常量的集合。 如果一个变量只有几种可能的值,可以定义为枚举(enumeration)类型。所谓"枚举"是指将变量的值一一列举...
  • 枚举初始化说起

    千次阅读 2010-02-24 17:40:00
    原文:http://www.cnblogs.com/allenlooplee/archive/2005/04/29/147356.html 我知道你的痛,是我给的承诺。你说给过我纵容,沉默是... 缘起本文写作缘于netwy的《枚举类型的变量的默认值一定是 0 !》。 1. 问题//C
  • 结构体数组 枚举 综合运用
  • typedef enum { A1, A2, A3, A4 = 10, A_END }A; 如果A1赋值为5,则下列依次递增1,即A2等于6,A3等于7; 由于A4赋值为10,所以A_END等于11 如果A1不赋值,A1默认为0,下列依次递增1 ...
  • 枚举初始化说起 [C#] Written by Allen Lee 我知道你的痛,是我给的承诺。你说给过我纵容,沉默是因为包容。如果要走,请你记得我;如果难过,请你忘了我。——周杰伦,《借口》 0. 缘起本文写作缘于netwy的...
  • public enum AAA { S111,SBBB,SCCC; private AAA() { System.out.println("123"); } } public class TestMain { public static void main(String [] args) { ...three 123
  • Golang 常量初始化规则与枚举

    千次阅读 2018-10-17 16:10:29
    在定义常量组时,如果不提供初始值,则表示将使用上行的表达式。 package main import "... // b、c、d没有初始化,使用上一行(即a)的值 fmt.Println(b) // 输出1 fmt.Println(c) // 输出1 fmt.Pri...
  • 被定义为全局的数组,在声明的时候,就自动赋为0了; 但是字符数组仍为空。 对于局部变量类型的数组,也只要在初始化定义时写一个0进去就行了,其余元素也会相应地赋0;如:int a[50]={0};
  • public enum ResultEnum {   SUCCESS ("200","成功"),   FAILURE ("500","发生异常");...关联数据用于对枚举实例进行初始化 转载于:https://www.cnblogs.com/feng9exe/p/11316333.html
  • 今天写枚举类的时候发现了一个有趣的现象,在这里分享一下: 首先我们定义一个简单的枚举类: /** * @author jinghuaixin * @date 2020/04/30 */ public enum Week { Monday, Tuesday; // 静态代码块 static ...
  • 块: 类型范围: 枚举类型: 变量初始化
  • JAVA:初始化及使用enum枚举类型

    万次阅读 2018-04-02 21:20:41
    在使用enum之前,需要先创建一个整型常量集,但枚举值并不会取值限定在这个常量集的范围内,因此,具有一定的风险,且较难使用。枚举类型的创建,public enum Spiciness{ NOT,MILD,MEDIUM,HOT,FLAMING }创建枚举类型...
  • I . 枚举类常用用法 ... 枚举初始化 III. 枚举类匿名类 IV . 枚举类实现接口 V . 获取枚举常量名称和位置索引 VI . 获取枚举常量的成员变量 VII . 调用枚举常量的方法 VIII . Kotlin 枚举完整代码示例
  • linux启动过程中pci总线初始化主要包括2部分,pci控制器的注册和pci设备的枚举,pci总线和其他总线一个很重要的区别就是pci总线的枚举,在启动过程中遍历pci总线树上所有可能的dev func,记录下所有存在的设备的...
  • USB设备驱动之设备初始化(设备枚举)

    千次阅读 2014-06-24 10:06:23
    USB设备从接入HUB到正常工作之前,都属于设备枚举阶段。所谓设备枚举,就是让host控制器认识USB设备,并为其准备资源,建立好主机与设备间的数据传递机制。 该阶段的工作,是USB通信协议规定的,所以属于ISO标准...
  • 结构体 在 Swift 标准库中,绝大多数的公开类型都是结构体,而枚举和类只占很小一部分 比如Bool、Int、Double、String、Array、...编译器会根据情况,可能会为结构体生成多个初始化器,宗旨是:保证所有成...
  • 文章目录背景说明枚举初始化使用枚举常量实例 背景 学习 记录分享 坚持开源! 说明 枚举类最基本的用法是实现一个类型安全的枚举。 枚举常量用逗号分隔,每个枚举常量都是一个对象。 enum class Color { RED,...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 211,256
精华内容 84,502
关键字:

枚举初始化