精华内容
下载资源
问答
  • C++类型转换类型转换概念静态转换(static_cast)(编译时类型检查)语法作用动态转换(dynamic_cast)(运行时类型检查)作用语法动态转换的运行时类型检查常量转换(const_cast)作用注意语法重新解释转换(reinterpret_...

    类型转换概念

    类型转换(cast)是将一种数据类型转换成另一种数据类型。
    例如,如果将一个整型值赋给一个浮点类型的变量,编译器会暗地里将其转换成浮点类型(隐式类型转换)。

    转换是非常有用的,但是它也会带来一些问题,比如在转换指针时,我们很可能将其转换成一个比它更大的类型,但这可能会破坏其他的数据。(指针步长与偏移量等因素导致)

    c++提供了一个显示的转换的语法,来替代旧的C风格的类型转换。(静态、动态、常量、重新解释)

    新类型的强制转换可以提供更好的控制强制转换过程,允许控制各种不同种类的强制转换。C++风格的强制转换其他的好处是,它们能更清晰的表明它们要干什么。程序员只要扫一眼这样的代码,就能立即知道一个强制转换的目的。

    C++层次转换规则

    C++中层次类型转换中无非两种:上行转换和下行转换

    C++规定自定义类型数据如果发生了继承关系,编译器允许进行类型转换(向上转型、向下转型),否则不能进行类型转换

    静态转换(static_cast)(编译时类型检查)

    语法

    静态转换需要用C++内置函数模板static_cast( expression )

    static_cast < T > ( expression ),该运算符把expression转换为T类型,但没有运行时类型检查来保证转换的安全性

    作用

    1. 用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。
      在这里插入图片描述
      C++规定自定义类型数据如果发生了继承关系,编译器允许进行类型转换(向上转型、向下转型),否则不能进行类型转换转换将会失败

      进行上行转换(把派生类的指针或引用转换成基类表示)是安全的
      基类指针步长相对于派生类指针步长来说较小,并不会超出派生类范围访问其他数据
      进行下行转换(把基类指针或引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
      基类指针步长相对于派生类指针步长来说较小,使用派生类指针访问基类对象,可能会超出范围
    2. 用于基本数据类型之间的转换,如把int转换成char,把char转换成int(这种转换的安全性也要开发人员来保证)
      在这里插入图片描述

    动态转换(dynamic_cast)(运行时类型检查)

    作用

    dynamic_cast主要用于类层次结构中父类和子类之间指针和引用的转换(上行转换和下行转换)
    在这里插入图片描述

    在类层次间进行上行转换时(安全的转换),dynamic_cast和static_cast的效果是一样的

    在进行下行转换时(不安全,子类指针可能会超出基类对象),dynamic_cast具有类型检查的功能,比static_cast更安全

    dynamic_cast不能作用于基本数据类型
    在这里插入图片描述

    语法

    动态转换需要用C++内置函数模板dynamic_cast( expression )

    dynamic_cast< T > ( expression ),该运算符把expression转换为T类型,具有运行时类型检查,因此可以保证下行转换的安全性
    安全性,即转换成功就返回转换后的正确类型指针,如果转换失败,则返回NULL,之所以说static_cast在下行转换时不安全,是因为即使转换失败,它也不返回NULL。

    动态转换的运行时类型检查

    dynamic_cast运行时会进行类型检查,且检测非常严格,失去精度或不安全的转换均无法进行

    上行转换中,基类指针指向派生类对象,派生类中有基类中所有成员(属性和方法),还有自定义的成员,所有派生类的大小至少大于基类,因此基类指针步长小于派生类指针步长,所以使用基类指针访问派生类成员时并不会超出派生类对象范围,因此时安全的

    下行转换中,派生类指针指向基类对象,派生类中有基类中所有成员(属性和方法),还有自定义的成员,所有派生类的大小至少大于基类,因此派生类指针步长大于基类指针步长,所以使用派生类指针指向基类对象时可能会发生超出基类对象范围访问其他地址问题,因此时不安全的

    下行转换是不安全的,在运行时可能会有问题,因为子类中包含父类中没有的数据和函数成员,如果去访问子类中有但父类中没有的成员,就会出现访问越界的错误,导致程序崩溃,动态转型(dynamic_cast)由于具有运行时类型检查功能,转换时将会检测被转换对象的类型,下行转换将会失败,返回NULL

       发生多态情况例外,多态是使用基类指针指向子类对象(上行转型),从而调用子类方法,这种情况下可以使用动态转换再将指向子类对象的父类指针转换成子类指针
    在这里插入图片描述

    常量转换(const_cast)

    作用

    常量转换用来修改类型的const属性,即将非常量(指针/引用)转换为常量(指针/引用),将常量(指针/引用)转换为非常量(指针/引用)
    在这里插入图片描述
    不能直接对非指针和非引用的变量使用const_cast操作符去直接添加/移除它的const,只能操作指针或引用数据
    在这里插入图片描述

    注意

    常量指针被转化成非常量指针,并且仍然指向原来的对象(常量符号表中对象);
    常量引用被转换成非常量引用,并且仍然指向原来的对象(常量符号表中对象);

    语法

    常量转换需要用C++内置函数模板const_cast( expression )

    const_cast< T > ( expression ),该运算符把expression转换为T类型

    重新解释转换(reinterpret_cast)

    重新解释转换是最不安全的一种转换机制,最有可能出问题。

    重新解释转换用于将一种数据类型从一种类型转换为另一种类型

    它甚至可以:

    将一个指针转换成一个整数,也可以将一个整数转换成一个指针.
    在这里插入图片描述

    将没有继承关系的类相互层次转换
    在这里插入图片描述

    语法

    重新解释转换需要用C++内置函数模板reinterpret_cast( expression )

    reinterpret_cast< T > ( expression ),该运算符把expression转换为T类型

    展开全文
  • 前言使用标准C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast和const_cast。const_cast,字面上理解就是去const属性。static_cast,命名上理解是静态类型转换。如int转换成char。dynamic_cast,命名...

    前言

    使用标准C++的类型转换符:static_cast、dynamic_cast、reinterpret_cast和const_cast。

    const_cast,字面上理解就是去const属性。

    static_cast,命名上理解是静态类型转换。如int转换成char。

    dynamic_cast,命名上理解是动态类型转换。如子类和父类之间的多态类型转换。

    reinterpreter_cast,仅仅重新解释类型,但没有进行二进制的转换。

    一、static_cast

    用法:static_cast (expression)

    该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:

    (1)用于类层次结构中基类和派生类之间指针或引用的转换

    进行上行转换(把派生类的指针或引用转换成基类表示)是安全的

    进行下行转换(把基类的指针或引用转换为派生类表示),由于没有动态类型检查,所以是不安全的

    (2)用于基本数据类型之间的转换,如把int转换成char。这种转换的安全也要开发人员来保证

    (3)把空指针转换成目标类型的空指针

    (4)把任何类型的表达式转换为void类型

    注意:static_cast不能转换掉expression的const、volitale或者__unaligned属性。

    二、dynamic_cast

    用法:dynamic_cast (expression)

    该运算符把expression转换成type_id类型的对象。type_id必须是类的指针、引用或者void*;

    如果type_id是类指针类型,那么expression也必须是一个指针,如果type_id是一个引用,那么expression也必须是一个引用。

    dynamic_cast主要用于类层次间的上行转换和下行转换,还可以用于类之间的交叉转换。

    在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;

    在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。

    class B

    {

    public:

    int m_iNum;

    virtualvoid foo();

    };

    class D:public B

    {

    public:

    char *m_szName[100];

    };

    void func(B *pb)

    {

    D *pd1 = static_cast(pb);

    D *pd2 = dynamic_cast(pb);

    }

    在上面的代码段中,如果pb指向一个D类型的对象,pd1和pd2是一样的,并且对这两个指针执行D类型的任何操作都是安全的;

    但是,如果pb指向的是一个B类型的对象,那么pd1将是一个指向该对象的指针,对它进行D类型的操作将是不安全的(如访问m_szName),而pd2将是一个空指针。

    另外要注意:B要有虚函数,否则会编译出错;static_cast则没有这个限制。这是由于运行时类型检查需要运行时类型信息,而这个信息存储在类的虚函数表(关于虚函数表的概念,详细可见)中,只有定义了虚函数的类才有虚函数表,没有定义虚函数的类是没有虚函数表的。

    另外,dynamic_cast还支持交叉转换,如下所示。

    class A

    {

    public:

    int m_iNum;

    virtualvoid f(){}

    };

    class B:public A

    {

    };

    class D:public A

    {

    };

    void foo()

    {

    B *pb = new B;

    pb->m_iNum = 100;

    D *pd1 = static_cast(pb); //compile error

    D *pd2 = dynamic_cast(pb); //pd2 is NULL

    deletepb;

    }

    在函数foo中,使用static_cast进行转换是不被允许的,将在编译时出错,而使用dynamic_cast转换则是允许的,结果是空指针。

    三、reinterpret_cast

    用法:reinterpret_cast (expression)

    type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。

    它可以把一个指针转换成一个整数,也可以把一个整数转换成一个指针(先把一个指针转换成一个整数,在把该整数转换成原类型的指针,还可以得到原先的指针值)。

    该运算符的用法比较多。

    (static_cast .与. reinterpret_cast比较,见下面 )

    该运算符平台移植性比价差。

    四、const_cast

    用法:const_cast (expression)

    该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外, type_id和expression的类型是一样的。

    常量指针被转化成非常量指针,并且仍然指向原来的对象;

    常量引用被转换成非常量引用,并且仍然指向原来的对象;常量对象被转换成非常量对象。

    volatile和const类型,举例如下所示。

    class B

    {

    public:

    int m_iNum;

    }

    void foo()

    {

    const B b1;

    b1.m_iNum = 100; //comile error

    B b2 = const_cast(b1);

    b2. m_iNum = 200; //fine

    }

    上面的代码编译时会报错,因为b1是一个常量对象,不能对它进行改变;

    使用const_cast把它转换成一个非常量对象,就可以对它的数据成员任意改变。注意:b1和b2是两个不同的对象。

    五、比较

    (1)dynamic_cast vs static_cast

    class B

    {

    ...

    };

    class D : public B

    {

    ...

    };

    void f(B* pb)

    {

    D* pd1 = dynamic_cast(pb);

    D* pd2 = static_cast(pb);

    }

    If pb really points to an object of type D, then pd1 and pd2 will get the same value. They will also get the same value if pb == 0.

    If pb points to an object of type B and not to the complete D class, then dynamic_cast will know enough to return zero. However, static_cast relies on the programmer's assertion that pb points to an object of type D and simply returns a pointer to that supposed D object.

    即dynamic_cast可用于继承体系中的向下转型,即将基类指针转换为派生类指针,比static_cast更严格更安全。dynamic_cast在执行效率上比static_cast要差一些,但static_cast在更宽上范围内可以完成映射,这种不加限制的映射伴随着不安全性。static_cast覆盖的变换类型除类层次的静态导航以外,还包括无映射变换、窄化变换(这种变换会导致对象切片,丢失信息)、用VOID*的强制变换、隐式类型变换等…

    (2)static_cast vs reinterpret_cast

    reinterpret_cast是为了映射到一个完全不同类型的意思,这个关键词在我们需要把类型映射回原有类型时用到它。我们映射到的类型仅仅是为了故弄玄虚和其他目的,这是所有映射中最危险的。(这句话是C++编程思想中的原话)

    static_cast 和 reinterpret_cast 操作符修改了操作数类型。它们不是互逆的; static_cast 在编译时使用类型信息执行转换,在转换执行必要的检测(诸如指针越界计算, 类型检查). 其操作数相对是安全的。另一方面;reinterpret_cast 仅仅是重新解释了给出的对象的比特模型而没有进行二进制转换, 例子如下:

    int n=9; double d=static_cast < double > (n);

    上面的例子中, 我们将一个变量从 int 转换到 double。 这些类型的二进制表达式是不同的。 要将整数 9 转换到 双精度整数 9,static_cast 需要正确地为双精度整数 d 补足比特位。其结果为 9.0。

    而reinterpret_cast 的行为却不同:

    int n=9;

    double d=reinterpret_cast (n);

    这次, 结果有所不同. 在进行计算以后, d 包含无用值. 这是因为 reinterpret_cast 仅仅是复制 n 的比特位到 d, 没有进行必要的分析.

    因此, 你需要谨慎使用 reinterpret_cast.

    引自:http://www.cppblog.com/lapcca/archive/2010/11/30/135081.aspx

    补充:

    (1)static_cast:在功能上基本上与C风格的类型转换一样强大,含义也一样。它有功能上的限制。例如,你不能用static_cast像用C风格转换一样把struct转换成int类型或者把double类型转换成指针类型。另外,static_cast不能从表达式中去除const属性,因为另一个新的类型转换符const_cast有这样的功能。

    可以静态决议出类型的转换可能性,即使是在继承体系中,即使包括了多重继承和虚继承,只要可以进行静态决议就可以转换成功

    (2)const_cast:用于类型转换掉表达式的const或volatile属性。通过使用const_cast,你向人们和编译器强调你通过类型转换想做的只是改变一些东西的constness或者volatieness属性。这个含义被编译器所约束。如果你试图使用const_cast来完成修改constness或者volatileness属性之外的事情,你的类型转换将被拒绝。

    (3)dynamic_cast:它被用于安全地沿着类的继承关系向下进行类型转换。这就是说,你能用dynamic_cast把指向基类的指针或引用转换成指向其派生类或其兄弟类的指针或引用,而且你能知道转换是否成功。失败的转换将返回空指针(当对指针进行类型转换时)或者抛出异常(当对引用进行类型转换时)。

    (4)reinterpret_cast:使用这个操作符的类型转换,其转换结果几乎都是执行期定义。因此,使用reinterpret_cast的代码很难移植。reinterpret_casts的最普通的用途就是在函数指针类型之间进行转换。

    举例如下:

    #include

    usingnamespace std;

    class A

    {

    public:

    virtualvoid foo()

    {

    }

    };

    class B

    {

    public:

    virtualvoid foo()

    {

    }

    };

    class C : public A , public B

    {

    public:

    virtualvoid foo() { }

    };

    void bar1(A *pa)

    {

    B *pc = dynamic_cast(pa);

    }

    void bar2(A *pa)

    {

    B *pc = static_cast(pa); //error

    }

    void bar3()

    {

    C c;

    A *pa = &c;

    B *pb = static_cast(static_cast(pa));

    }

    int main()

    {

    return 0;

    }

    A、bar1无法通过编译

    B、bar2无法通过编译

    C、bar3无法通过编译

    D、bar1可以正常运行,但是采用了错误的cast方法

    解答:

    选B。

    dynamic_cast是在运行时遍历继承树,所以,在编译时不会报错。但是因为A和B没啥关系,所以运行时报错(所以A和D都是错误的)。

    static_cast:编译器隐式执行的任何类型转换都可由它显示完成。其中对于:(1)基本类型。如可以将int转换为double(编译器会执行隐式转换),但是不能将int*用它转换到double*(没有此隐式转换)。(2)对于用户自定义类型,如果两个类无关,则会出错(所以B正确),如果存在继承关系,则可以在基类和派生类之间进行任何转型,在编译期间不会出错。所以bar3可以通过编译(C选项是错误的)。

    总结

    以上就是这篇文章的全部内容了,希望本文的内容对大家的学习或者工作能带来一定的帮助,如果有疑问大家可以留言交流。

    展开全文
  • C#第二节(类型转换、变量、常量

    千次阅读 2018-04-28 15:10:17
    一、C#类型转换 含义:把数据从一种类型转换为另一种类型(也叫类型铸造);在C#中有两种转换方式: 隐式类型转换;eg:从小的整数转为大的整数类型,从派生类转换为基类; 显示类型转换;即强制类型转换,其需要...

    一、C#类型转换
    含义:把数据从一种类型转换为另一种类型(也叫类型铸造);在C#中有两种转换方式:

    • 隐式类型转换;eg:从小的整数转为大的整数类型,从派生类转换为基类;
    • 显示类型转换;即强制类型转换,其需要强制转换运算符,并且会造成数据丢失;
      下面的demo 展示了显示类型转换:
                double d = 1265.66;
                int i;
                i = (int)d;
                Console.WriteLine("强制类型转换的结果为:{0}", i);
                Console.ReadKey();

    运行结果为:
    这里写图片描述

    二、C#强制类型转换方法
    C#提供了下列内置的类型转换方法
    这里写图片描述
    这里写图片描述
    下面的demo将不同的值类型转换为string类型

    class Program
        {
            //JdJos.Rectangle rectangle = new JdJos.Rectangle();
            static void Main(string[] args)
            {
                int i = 88;
                float f = 56.25f;
                double d = 894.59489;
                bool b = true;
                Console.WriteLine("将整型转换为string类型:{0}", i.ToString());
                Console.WriteLine("将float转换为string类型:{0}", f.ToString());
                Console.WriteLine("将double转换为string类型:{0}", d.ToString());
                Console.WriteLine("将bool转换为string类型:{0}", b.ToString());
    
                Console.ReadKey();
    
    
            }
        }

    运行结果为:
    这里写图片描述

    笔记:
    类型之间的转换————-Convert和Parse

                String str = 666.ToString();
                //如果要将str转为整型
    
                //方法一:
                int istr = Convert.ToInt16(str);
    
                //方法二:
                int istr2 = int.Parse(str);
                Console.WriteLine("使用Convert将String类型转为int类型结果为:{0},使用Parse将同样数据转为int类型的结果为:{1}", istr, istr2);
    
                Console.ReadKey();

    运行结果为:
    这里写图片描述

     int.TryParse(string s, out int i);

    该方式也是将数组内容的字符串转换为int类型,但是该方式比int.Parse(string s)好一些,它不会出现异常,最后一个参数result是输出值,如果转换成功则输出相应的值,转换失败则输出0.

                String s1 = "abcd";
                String s2 = "1234";
                int a, b;
                bool bol = int.TryParse(s1, out a);
                Console.WriteLine("====================将string类型的abcd转为int类型======================");
                if(bol ==true)
                {
                    Console.WriteLine("转换成功,abcd转为int类型结果为:{0}", a);
                }else
                {
                    Console.WriteLine("转换失败,abcd转为int类型转换失败:{0},转换结果为{1}",bol, a);
                }
                Console.WriteLine("====================将string类型的1234转为int类型====================");
                bool bol2 = int.TryParse( s2,out b);
                if (bol2 == true)
                {
                    Console.WriteLine("转换成功,s2的{0}转为int类型结果为:{1}", s2, b);
                }
                else
                {
                    Console.WriteLine("转换失败,1234转为int类型转换失败:{0},转换结果为{1}", bol2, a);
                }
    
                Console.ReadKey();

    这里写图片描述

    C#中对double类型的数据取整,可以使用convert.toint32()方法,也可使用int强制类型转换为整数,使用int时并不存在四舍五入的情况,而是直接将后面的小数位数丢掉,eg:

    static void Main(string[] args)
            {
                double a = 1.256;
                double b = 826.66649;
                int a1 = Convert.ToInt32(a);
                int a2=(int)a;
                int b1 = Convert.ToInt32(b);
                int b2 = (int)b;
                Console.WriteLine("{0}使用了convert方式强制类型转换,结果为:{1}", a, a1);
                Console.WriteLine("{0}使用了int强制类型转换,结果为:{1}", a, a2);
                Console.WriteLine("{0}使用了convert方式进行强制类型转换,结果为{1}",b, b1);
                Console.WriteLine("{0}使用了int方式强制类型转换,结果为{1}", b, b2);
                Console.ReadKey();
    
        }
    

    运行结果为:
    这里写图片描述

    Convert.ToInt32()与int.Parse()区别
    举例来说:假如从url中取一个参数page的值,这个值是int类型的,所以既可以用Convert.ToInt32(Request.QueryString[“page”]),也可以用 int.Parse(Request.QueryString[“page”]),但是如果page这个参数在url中不存在,那么前者将返回0,0可能是一个有效的值,所以你不知道url中原来根本没有这个参数而继续进行下一步的处理,这就可能产生意想不到的效果,而用后一种办法的话,没有page这个参数会抛出异常,我们可以捕获异常然后再做出相应的处理,比如提示用户缺少参数,而不是把参数值当做0来处理。
    (1)、这两个方法的最大不同是:他们对null值得处理方法:Convert.ToInt32(null)会返回0而不会产生任何异常,但是int.Parse(null)则会产生异常。
    (2)、对数据四舍五入时候的区别
    a、Convert.ToInt32(double value)如果value为两个整数中间的数字,则返回二者中的偶数;即3.5转换为4,4.5转换为4,而5.5转换位6.不过4.6可以转换为5,4.4转换为4.
    b.int.Parse(“4.5”)直接报错:“输入的字符串格式不正确”。
    c.int(4.6)=4 int转换其他数值类型为int时都没有四舍五入,强制转换。
    (3)、对被转换类型的区别:int.Parse是转换String为int,Convert.ToInt32是转换继承自Object的对象为int的(可以有很多其他类型的数据)。你得到一个Object对象,你想把它转换为int,用int.Parse就不可以,要用Convert.ToInt32.

    String 转int与抛异常
    string字符串类型和int是可以转换的。但是下面demo的转换方式是错误的:

                string a = "123";
                int x = (int)a;

    这里写图片描述

    这里我们需要应用到int.Parse(),核心代码为:

                string a = "123";
                int x = int.Parse(a);

    如果仅仅是这样,是没有问题的,但是,我们下面来做一个实例。用户输入一个数字,然后计算机在输入的数字上加上1并显示。用户输入的东西,即Console.ReadLine(),一定是以字符串形式表现的

                Console.WriteLine("请输入一个数字:");
                int a = int.Parse(Console.ReadLine());//将用户输入的string类型转为int类型
                Console.WriteLine("您输入的数字为:{0},   返回结果为:{1}", a, ++a);
                Console.ReadKey();
    

    运行结果:
    这里写图片描述
    但是用户如果输入的不是数字而是其他字符,如字符串,汉字,会发生什么呢?
    输入任意一个字符串或者汉字,程序就报错无法再进行下去,因为int类型只能存储整数,不能存字符。
    这里写图片描述
    所以保险起见使用try,catch.顾名思义,try{}就是尝试进行下面的代码,catch{}部分,则是检查异常。这样,在出现异常时,catch就能捕获到异常,从而能程序并不会停止。

     try
                {
                    Console.WriteLine("请输入一个数字:");
                    int a = int.Parse(Console.ReadLine());//将用户输入的string类型转为int类型
                    Console.WriteLine("您输入的数字为:{0},   返回结果为:{1}", a, ++a);
                }
                catch
                {
                    Console.WriteLine("对不起,输入不合法,无法转换。");
                }
    
    
                Console.ReadKey();

    运行结果:
    这里写图片描述

    C#变量

    变量是一个供程序操作的存储区的名字。在C#中,每个变量都有特定的类型,类型决定了变量的内存大小和分布,范围内的值可以存储在内存中,可以对变量进行一系列操作。。C#中提供的基本的值类型大致可分为以下几类:
    这里写图片描述
    C#允许定义其他值的变量,比如:enum,也允许定义引用类型变量,比如class。
    C#中变量的定义

    <有效的C#数据类型{char,intfloat,double或其他用户自定义的数据类型}> <由一个或多个逗号分隔的标识符名称组成>

    eg:一些有效变量名定义:

                int i, j, k;
                char c, ch;
                float f, f1;
                double d;
                int i1 = 100;//定义时候直接初始化
    
    

    C#变量的初始化—-赋值
    eg:

               int i = 66, k = 5;
                byte z = 66;
                double pi = 3.1415926;
                char x = 'x';//注意这里是单引号

    接受来自用户的值
    System命名空间中的Console类提供了一个函数ReadLine(),用于接收来自用户的输入,并把它存储到变量中,eg:

    int num;
    num = Convert.ToInt32(Console.ReadLine());

    函数Convert.ToInt32()把用户输入的数据转换为int.

    C#中的Lvalues和Rvalues
    C#中两种表达式:
    1、lvalue:lvalue表达式可以出现在赋值语句的左边或右边;
    2、rvalue:rvalue表达式可以出现在赋值语句的右边,不能出现在左边。
    变量是lvalue的,所以可以出现在赋值语句的左边。数值是rvalue的,因此不能被赋值,不能出现在赋值语句的左边;eg:

    int g = 20;
    33 = 60;//invalid assignment sentence

    C#常量

    常量是固定值,执行期间不会改变,可以是任何基本数据类型,eg:整数常量、浮点数常量、字符常量或字符串常量,枚举常量。它们的值在定义后不能被修改。
    整数常量
    可以为十进制、八进制、或者十六进制的常量,前缀指定技术:0x或0X表示十六进制,0表示八进制,没有前缀表示十进制。
    常量可以有后缀,U和L组合,分别代表unsigned和long,后缀大小写任何,多个后缀以任意顺序进行组合。

    212         /* 合法 */
    215u        /* 合法 */
    0xFeeL      /* 合法 */
    078         /* 非法:8 不是一个八进制数字 */
    032UU       /* 非法:不能重复后缀 */

    以下是各种类型的整数常量实例:

                85//十进制
                0213 //八进制
                0xbd4  //十六进制
                30     //int
                66u     //无符号int
                99l     //long
                99ul    //无符号long

    浮点常量
    eg:

                3.1415926       //合法
                314159E -5L     //合法
                510E            //非法,不完全指数
                210f            //非法,没有小数或指数
                .e55            //非法,缺少整数或小数

    使用小数形式表示时,必须包含小数点、指数或同时包含两者,使用指数形式表示时,必须包含整数部分、小数部分或同时包含两者。有符号的指数是用e或E表示的。

    字符常量

    字符常量是括在单引号里,eg:’x’,且可存储在一个简单的字符类型变量中。一个字符常量可以是一个普通字符(eg’X’)、一个转义序列(eg’\t’)或者一个通用字符(eg’\u02c0’).
    有一些特定字符,当它们签名带有反斜杠时有特殊意义,可表示换行符(\n)或制表符tab(\t)
    这里写图片描述

    字符串常量
    字符串常量是括在双引号“”里,或者是在@”“里。字符串常量包含字符与字符常量相似。可以是普通字符、转义字符、和通用字符
    定义常量
    常量使用const关键字来定义。语法如下:

    const <类型> <常量名>=value;

    下面demo演示如何使用常量:

    static void Main(string[] args)
            {
                const double pi = 3.141592653;
                double r;
                Console.WriteLine("Enter Radius of Integer:");
                r = Convert.ToInt32(Console.ReadLine());
                double areaCircle = pi * r * r;
                Console.WriteLine("Radius:{0},Area:{1}", r, areaCircle);
                Console.ReadKey();
    
    }

    运行结果:
    这里写图片描述

    笔记:
    1、Convert.ToDouble与Double.Parse的区别。实际上,Convert.ToDouble内部调用了Double.Parse:
    (1)、对于参数为null时候:
    Convert.ToDouble参数为null是,返回0.0;
    Double.Parse参数为null时,抛出异常;
    (2)、对于参数为“”时:
    Convert.ToDouble参数为”“时,抛出异常;
    Double.Parse参数为“”时,抛出异常。
    (3)、其他区别:
    Convert.ToDouble可以转换的类型较多;
    Double.Parse只能转换数字类型的字符串。
    Double.TryParse与Double.Parse又较为类似,但它不会产生异常,转换成功返回true,转换失败返回false.最后一个参数为输出值,如果转换失败,输出值为0.0;
    情况一:将0.2这类字符串通过三种方式转换:
    这里写图片描述
    情况二:将null类型字符串进行三种方式转换:
    这里写图片描述
    情况三:将“”类型字符串进行三种方式转换:
    这里写图片描述
    测试demo为:

    static void Main(string[] args)
            {
                try
                {
                    //string a = "0.2";//没有走try里面的数据
                    //String a = null;
                    string a = "";
                    Console.WriteLine("将字符串为空通过下面三种方式进行转换为double类型:",a);
                    try
                    {
                        double d1 = Double.Parse(a);
                        Console.WriteLine("{0}通过Double.Parse转换成功结果为:{1}。", a,d1);
                    }
                    catch(Exception e)
                    {
                        Console.WriteLine("{0}通过Double.Parse转换出错信息:{1}。", a, e.Message);
                    }
    
                    Console.WriteLine();
                    Console.WriteLine("使用Double.Parse转换进行转换:");
                    try
                    {
                        double d2 = Convert.ToDouble(a);
                        Console.WriteLine("{0}通过Double.Parse转换成功结果为:{1}", a, d2);
                    }
                    catch(Exception e)
                    {
                        Console.WriteLine("{0}通过Convert.ToDouble方式转换错误:{1}", a, e.Message);
                    }
                    Console.WriteLine();
                    Console.WriteLine("使用Double.TryParse进行转换:");
                    try
                    {
                        double d3;
                        Double.TryParse(a, out d3);
                        Console.WriteLine("{0}通过Double.TryParse转换成功结果为:{1}", a, d3);
                    }
                    catch(Exception e)
                    {
                        Console.WriteLine("{0}通过Double.TryParse方式转换错误:{1}", a,e.Message);
                    }
    
                }finally
                {
                    Console.WriteLine();
                    Console.WriteLine("finally方法一定走");
                    Console.ReadKey();
                }
     }           
    展开全文
  • js常量 数据类型 数据类型转换

    千次阅读 2016-12-17 12:13:30
    常量:值不能被改变的量,使用关键字const声明一个常量,习惯上常量名使用纯大写形式 数据类型 js中数据类型分为两种,一是原始类型(number、string、boolean、null),二是引用类型(object对象、date日期等) ...
    <!-- 
    
    常量:值不能被改变的量,使用关键字const声明一个常量,习惯上常量名使用纯大写形式
    数据类型
    js中数据类型分为两种,一是原始类型(number、string、boolean、null),二是引用类型(object对象、date日期等)
    1、基本数据类型
    number类型:数字类型,可以表示整数,也可以表示小数
    string类型:字符串类型,表示一系列的文本字符数据;js对字符和字符串的区分没有那么严格,首尾用单引号或双引号括起来。
    boolean类型:布尔类型,仅有两个值,true/false,也代表1和0
    数据类型转换
    隐式转换(自动转换):
    js属于松散类型的程序语言,变量类型在声明时不需要指定,具体类型在赋值时确定,不同类型数据在计算过程中会自动进行转换。
    在js中,可以使用typeof()函数来查询当前变量的值
    常用转换函数
    -toString(),转换字符串,所有的数据类型均可转换为字符串
    -parseInt()函数,解析出string或number中的整数部分,如果没有可以转换的部分,则返回NaN(Not a Number)
    -parseFloat(),解析出string浮点部分,如果没有课转换的部分,则返回NaN;
    -Number(),把一个string解析为number
     -->


     <html>
     <head>
      <title></title>
      <meta charset="utf-8">
     </head>
     <body>
      <!--计算圆的面积-->
      <script type="text/javascript">
      //圆的面积:pi*r*r
      var a="a1";
      console.log(parseInt(a));
      const PI = 3.14;
      var r = 10;
      var s = PI*r*r;
      console.log('面积是:'+s);
      PI=1.5;
      s=PI*r*r;//改变常量的值
      console.log("面积是:"+s);
      //结论:强行修改常量的值不会报错,但是也没有效果
      </script>
      <script type="text/javascript">
      var age = 20;//number
      var height = 1.80;//number
      var name="李四";
      var sex="男";
      var isShuai=true;
      console.log(age);
      console.log(height);
      console.log(name);
      console.log(isShuai);//布尔类型,输出true或false
      </script>
      <!-- 类型转换 -->
      <script type="text/javascript">
      var a=1;
      var b='abc';
      var c = true;
      var d = false;
      //数字+字符串=字符串
      console.log(a+b);
      console.log(typeof(a+b));
      //数字+布尔=数字,布尔变量会转换为数字,true为1,false为0
      console.log(a+d);
      console.log(typeof(a+c));
      //字符串+布尔=字符串,布尔值会转换为字符串true或false
      console.log(b+c);
      console.log(typeof(b+c));
      //布尔+布尔=数字,布尔值转换为0或1
      console.log(c+d);
      console.log(typeof(c+d));
      console.log(a+(c+b));
      //对一个变量使用toString()函数时,其结果是字符串类型,但是原有变量类型不改变
      var num = 123;
      var num1 = num.toString();
      console.log(typeof(num1));
      //parseInt(要转换的变量)函数
      var s=12.2;
      console.log(parseInt(s));
      //parseFloat(要转换的string),注意,转换结果只会取到第一个小数点,如果小数点后没有值,则取出整数
      var s1 = '10.1.1';
      console.log(parseFloat(s1));
      //Number()函数只能解析纯数字的字符串,如果包含非数字的内容,则返回NaN
      var s2 = '123w';
      console.log(Number(s2));
      </script>
      <!-- 获取页面输入的内容 -->
      <script type="text/javascript">
      //prompt输入提示框
      var money = prompt('请输入金额');
      console.log(typeof(money));
      //结论:js中只要是从页面上获取到的内容,都是字符串类型
      </script>
     </body>
     </html>
    展开全文
  • 3.类型转换问题 4.运算符的总结 1.配置环境变量: (1)Path:让工具可以在任何位置都可以用/让操作系统找到相应的指令 (2)classPath:生成的class文件都统一的存储在配置的目录下 (3)JAVA_HOME:让路径的写法变...
  • 类型转换 强制转换 parseInt( ) 把字符串开头部分的数字转为整数 parseFloat( ) 把字符串开头部分的数字转为小数 如果开头不是数字,则返回NaN (Not a Number) console.log( parseInt('3.14abc') ) // 3 数值类型 ...
  • => 对两个 NULL 做比较时会返回 1,这两种情况都不需要做类型转换 – 两个参数都是字符串,会按照字符串来比较,不做类型转换 – 两个参数都是整数,按照整数来比较,不做类型转换 – 十六进制的值和非数字做比较时...
  • 返回上一级 cd … 返回根目录 cd \ 显示文件夹下文件 dir 清空屏幕 cls 退出 exit cmd操作方法 切换盘符 ‘D\’ 进入文件夹 ‘cd 文件夹名称’ 进入多级文件夹 ‘’ ...
  • C#——变量与常量
  • 使用eval()函数计算字符串中的有效Python表达式,并返回结果 _____________________________________ 好,切入正题 int(str,num)  书本上表示为int(x[,base])大概[]表示为可有可无吧 其中,str为数字类型的...
  • 常量表达式库(简称CXL) 基本公用事业 include / cxl / utility.hpp包含在整个库中使用的基本模板类型和函数,例如cxl::index_t (用于代替size_t并用作索引),它应该是能够容纳相对较大值的带符号整数类型值,则...
  • 这段代码乍一看,仿佛并没有什么不同,也是普通返回类型,也是按常量引用传值。可是这个调用的返回传值的表现就大大不同了,传统 C++ 确实还是会按值返回,发生拷贝,但是 C++11 中就会自动转化为移动语义,使用移动...
  • C++: 隐式类型转换和显式类型转换

    千次阅读 2019-11-06 12:49:44
    1) 算术转换(Arithmetic conversion) : 在混合类型的算术表达式中, 最宽的数据类型成为目标转换类型。 intival=3; doubledval=3.14159; ival+dval;//ival被提升为double类型 2)一种类型表达式赋值给另一种类型的...
  • 它们是在编译时被创建,即使被定义为函数局部的也如此,并且只能是数字,字符(符文),字符串或者布尔类型。由于编译时的限制,定义它们的表达式必须为能被编译器求值的常量表达式。例如,1是一个常量表达式,而...
  • 文章目录重温Golang语法-常量、字符串、类型转换2 常量、字符串、类型转换2.1 常量2.2 字符串2.3 类型转换 重温Golang语法-常量、字符串、类型转换 2 常量、字符串、类型转换 2.1 常量 定义赋值之后不能更改值! ...
  • 常量 概念 在程序运行期间,固定不变的量 使用了final关键字修饰 常量的分类 字符串常量:凡是用双引号引起来的部分,叫做字符串常量。例如:“abc”、“hello”、“123” 整数常量:直接写上的数字,没有...
  • Golang常量无法取地址

    2021-11-29 15:29:26
    Golang常量无法取地址 今天在尝试取常量的地址时出现了报错,会有这样一些场景,嵌套型的struct有些字段是string或者int package main type Obj struct { Prop1 *string Prop2 *int } func main() { obj := Obj...
  • 类型转换类型转换函数

    千次阅读 2018-02-03 21:31:05
    所以类型转换,就是为了告诉编译器这部分内存,应该用什么方式去解释它,如何组织这段内存。 1、C风格类型转换 c语言比较熟悉,指针类型转换很常见。通过圆括号和标识符组成(type) expression。允许任何类型...
  • C++ 强制类型转换

    千次阅读 2020-01-07 21:00:07
    强制类型转换 C++语言中提供了static_cast、const_cast、reinterpret_cast和dynamic_cast。这四个关键字都是用于强制类型转换的。 二.static_cast 1.基本数据之间的转换,如int转化为double int a = 1; ...
  • Golang的变量常量及基本类型

    万次阅读 2016-02-01 19:04:53
    1,变量变量的声明: ...关键字var,而类型信息放在变量名之后,示例如下:1.1变量的声明var v1 int var v2 string var v3 [10]int // 数组 var v4 []int // 数组切片 var v5 struct { f int } var v6 *int // 指针 v
  • 【C++】四种强制类型转换

    万次阅读 多人点赞 2019-02-28 21:05:08
    C++ 四种强制类型转换   C语言中的强制类型转换(Type Cast)有显式和隐式两种,显式一般就是直接用小括号强制转换,TYPE b = (TYPE)a; 隐式就是直接 float b = 0.5; int a = b; 这样隐式截断(by the way 这样...
  • C++迭代器和显示类型转换

    千次阅读 2018-11-12 16:19:28
    前三个类型转换是在编译的时候进行类型转换,最后一个则是在运行的时候进行类型转换,并可返回转换成功与否的标志。 2.1 reinterpret_cast **reinterpret_cast类型转换函数将一个类型的指针转换为另一个类型的...
  • C语言的数据类型c语言中,有关数据类型的分类,网上有很多种版本,未找到比较统一的标准,下图为我比较认可的划分:常量的默认类型在C语言中,数值常量分为两种:整数和小数。整数常量默认为有符号的int类型,而小数...
  • 常量定义:形式一 // define("PI",常量值); define("PI",3.14); define("school","讲理");形式二 // 定义形式二 const cc1 = 1234; const cc2 = "abcd"; 使用:形式一 // 直接使用常量名 echo "PI的值:".PI;...
  • byte 数据类型是8位、有符号的,以二进制补码表示的整数;(Byte) short 数据类型是 16 位、有符号的以二进制补码表示的整数;(Short) int 数据类型是32位、有符号的以二进制补码表示的整数;(Integer) long ...
  • 常量 概念:常量就是程序运行过程中其值不发生变化的量; 常量的分类 字面值常量 自定义常量 自己创建的空间 存储一个值 让它固定,使其不能发生变化 例如 final int i = 1; 字面值常量的分类 整数...
  • C语言运算中的数据类型自动转换原则

    万次阅读 多人点赞 2018-09-29 16:35:08
    1、隐式转换 C在以下... 1、算术运算式中,低类型能够转换为高类型。  2、赋值表达式中,右边表达式的值自动隐式转换为左边变量的类型,并赋值给他。  3、函数调用中参数传递时,系统隐式地将实参转换为形参的...
  • 1.常量指针与指针常量的区分 A、常量指针(const int* p) 常量指针本质上是一个指针,是一个指向“常量”的指针,即不能通过指针改变指向对象的值(不能解除引用),但可以更改指向。用法如下 int a=3,b=4; const ...
  • 文章目录1、数据类型1.1、数值类型1.1.1、整型(整数类型)1.1.2、浮点型(小数类型)1.1.3、复数1.2、bool类型(布尔类型)1.3、字符串类型1.3.1、定义字符串1.3.2、字符串拼接...8 和 Unicode 的区别2、类型转换2...
  • 函数的隐晦返回类型是 int static num; // 变量的隐晦类型是 int   这种 feature 在 C89 中还可以使用,但在 C99 和 C++ 中都被去除了。( gcc 3.4 版本对于这种声明会给出编译错误,而 VC++6.0 会认为这是合法的...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 251,355
精华内容 100,542
关键字:

无法转换常量返回类型