精华内容
参与话题
问答
  • Java数据类型转换

    千次阅读 2016-08-30 20:33:38
    Java数据类型转换 在说明数据类型转换(下简称类型转换)之前,得先说明什么是数据,数据可不仅仅是一个值,而是包括描述数据的种类(数据类型)、值以及基于其类型基础上可进行的操作的集合。从类型A转换到类型B,...

    Java数据类型转换

    在说明数据类型转换(下简称类型转换)之前,得先说明什么是数据,数据可不仅仅是一个值,而是包括描述数据的种类(数据类型)、值以及基于其类型基础上可进行的操作的集合。从类型A转换到类型B,这需要类型B拥有类型A的相关性质,他们之间的转换需要遵从一定规则,并不是可以任意转换的,最基本的转换思想:只有同类可转换,低级转高级可自动转换,高级转低级需要强制转换。
      所谓的自动转换(也称为隐式转化),就是编译器会自动帮助将低级类型转换成高级类型,而不需要程序员添加相关代码;而强制转换(也称为显示转换)则必须由开发人员添加相关代码进行强制转换,强制转换一般用于基本数据类型和不明类型对象(Java程序中常会有对象丢失类型信息,最常见的就是集合中对象是无类型信息的)强制转化为已知类型(不过需要知道这个对象确实是这个类型或其子类类型,否则会抛异常)。

    class A{}
    class B extends A{}
    A a = new B();//低级转高级,自动转换
    B b = (B)new A();//高级转低级,需强制转换,但是,虽然编译不报错,运行却是会报
    //错,因为高级转低级,引用数据类型中,运行时是要检查对象的真身的,真身不是引用对
    //象的类型或子类型是会抛异常的,因为B的功能可能A不具有,
    //也可以这样想:每个B肯定是一个A,但不是每一个A都是B,所以为了以防万一,运行时要做检查
    //低级高级,在引用对象数据类型中,就是继承链(包括接口的实现)上位于顶端的(父类)
    //是高级的,位于底层的(子类)是低级的;而在基本数据类型则自有规定
    

    转换的场景包括从变量的定义到复制、数值变量的计算到方法的参数传递、基类与派生类间的造型等。而由于数据类型的不同,转换的方式也不尽相同,前一节讲过,Java数据类型分为两种:基本数据类型和引用数据类型(详见:Java 变量数据类型),下面就这两种分别讲述数据类型的转换。

    1.基本数据类型之间的转换

    0.分类:

    Java变量数据类型一节讲过,Java基本数据类型实际上分为两类:数值类型和布尔类型。布尔类型只有boolean,所以boolean不能与其他7种基本类型互相转换,无论是自动转换还是强制转换。
      前面已经说过,只有拥有相同性质的“同类”类型才可以相互转换,显然布尔类型与数值类型不是同一类,因为布尔类型是不能计算的,而像字符类型char,虽是字符类型,但其实现是无符号整型(字符的ASCII码),加减乘除获得的结果还是整型,仍可转换成字符型(不过这个时候需要强制转换)。

    1.“低级高级”以及转换

    Java中规定,数值类型的从低级到高级:byte—>(short/char)—>int—>long—>float—>double。short/char同等级。其实这里的低级高级,也可以粗略看成范围的大小,范围小的低级,范围大的高级。
    低等级到高等级可自动转换,即

    byte b = 1;//默认1其实是int,但是直接赋值这种(右边是直接量,编译期就可以判
    //断,若是变量则是需要运行期判断,所以为以防万一,需要强制转换),编译器只会检查
    //是否越界,比如
    byte b1 = 222;//这个时候编译器会报错:很显然右边值超出byte范围
    long l = 100000000000l;//同样的,这里右边数值大于int范围,后面需要添加l/L
    //这个时候不加l/L,前面用强制转换也不行,因为右边的值是被认为int,而这个值超出了
    //int范围,小于int范围,就是一般的低级到高级自动转换
    float f = b;
    float f1 = 1.23f;//浮点型,默认double,不同于整型,这是高级到低级的转换,数值后面加f/F或进行强制转换
    char c = b;//报错,虽然char比byte高级,但是char是无符号型,不能自动转换
    

    另外,对于基本类型对应的包装类,也是能自动转换的,即:

    Integer i = 12;//这里int自动转换成Integer
    //但也只能对对应的基本类型进行自动转换
    byte b = 12;
    Integer i1 = b;//编译错误,这里就不能套用低级高级,因为是两个系统
    Byte b1 = 12;
    Integer i2 = b1;//同样不行,包装类也是引用类型,之间的转换遵守引用类型转换规则
    

    高等级到低等级,需要强制转换

    int i = 99;
    char c =(int)i;
    //很显然,这种转换是需要牺牲精度的,比如这个时候i =99999;大于char的取值范
    //围,这个时候,c只能取i的低两个字节为值,牺牲了精度
    

    当进行数学运算时,数据类型会自动发生提升到运算符左右之较大者,以此类推。当将最后的运算结果赋值给指定的数值类型时,可能需要进行强制类型转换。

    2.引用类型数据之间的转换

    这里不讨论,通过某种方法进行类型转换的情况,比如,类A有个方法:

    public B toB(){
    	//通过某些操作达到类型A转换成类型B
    	return B;
    }
    //典型的有每一个类都有的toString();方法,尤其特殊的,对于String,任意类
    //型对象 :a +"";即可转换成String
    

    1.分类

    引用数据类型的分类,是通过继承链来分类的,何谓继承链?即:A继承B,B继承C,C继承D……这样就形成了一条链:A->B->C->D……其中,父类相对子类来说是高级的,反之则是低级的,不在一条链上就不是“同类”。另外,要说明一点的,不只是继承,实现接口也同样能形成继承链,其中父接口是其实现类的高级。

    2.引用类型数据转换

    低级到高级自动转换,这一点同基本数据类型是一样的,但是,引用类型不同于基本数据类型,引用类型中是有两个东西的:引用与对象(这两个是不同的),而基本数据类型中的变量标识和值基本上可以看成一个:

    class A{
    	public void walk(){}
    }
    class B extends A{
    	public void run(){}
    }
    A a = new B();//可自动转换,但是这个时候a不能调用run方法(没有对外接口)
    

    a是引用,new B()是对象,这个时候,虽然转换了,但是,new B()还是B类型。Java中每次新建一个对象(不管是通过构造器还是反射、序列化等),这个对象的类型就已经确定了,在Java中我们可以通过继承、向上转型的关系使用父类类型来引用它,这个时候我们是使用功能较弱的类型(高级)引用功能较强的对象(低级),这是可行的。但是将功能较弱的类型强制转功能较强的对象时,就不一定可以行了。
      就像上面的例子,new B()对象还是B类型(从这一方面来看,引用类型转换并没有“转换”),只不过,这个时候引用它的是A类型,在Java变量数据类型一节有提到,Java任何对象都是通过引用来使用的,这个时候new B()这个对象只能通过a来访问,而a被限定为A类型,只有A类型功能,其功能被消弱了。如果这个时候想将对象还原,可以这样:

    B b = (B)a;//这个时候只是新增了一个B类型引用b指向new B()对象,引用a仍然是A类
    //型,没受影响。但b却是可以使用B类型所有功能
    

    高级转换成低级,需要强制转换

    //最开始
    B b = (B)new A();//编译正确,运行抛异常
    Class C extends B{}
    A a1 = new C();
    B b1 = (B)a1;//编译正确,运行正确
    

    父类强制转换成子类并不是总是成功,当引用类型的真实身份是父类本身的类型时,强制类型转换就会产生错误。编译器在编译时只会检查类型之间是否存在继承关系(是否是“同类”)以及上下级关系(是否需要强转),有则通过;而在运行时就会检查它的真实类型,是则通过,否则抛出ClassCastException异常。
      所以在继承中,子类可以自动转型为父类,但是父类强制转换为子类时只有当引用类型真正的身份为子类或子类的子类时才会强制转换成功,否则失败。
      想要更好的理解引用数据类型的转换,可以参考:Java的静态/动态类型。

    展开全文
  • 一、JS需要类型转换的原因 JS是一种弱类型语言,变量没有类型限制,可以随意赋值。如: var a=5; console.log(typeof a);//number a='我是字符串'; console.log(typeof a);//string如上所示,当把数字5赋值给a...

    一、JS需要类型转换的原因

    JS是一种弱类型语言,变量没有类型限制,可以随意赋值。如:

    var a=5;
    console.log(typeof a);//number
    a='我是字符串';
    console.log(typeof a);//string
    如上所示,当把数字5赋值给a变量时,a变量的类型是number,当把字符串“我是字符串”赋值给变量a时,a变量的类型是string。

    虽然变量没有类型限制,但运算符要求进行运算的变量的类型和运算符期望的类型一致,所以,当不同类型的变量进行加减运算时,就会进行类型转换(如,1+'a'、'3'-'1')。类型转换主要分为两种:强制(显性)类型转换和自动(隐性)类型转换。每种转换又可分为原始类型转换和对象类型转换,原始类型主要包括数字、字符串、布尔值、null、undefined等。



    二、强制(显性)类型转换

    强制类型转换主要是指通过String、Number和Boolean等构造方法手动转换成对应的字符串、数字和布尔值。

    2.1、将其他类型转为字符串

    字符串是JS的基本数据类型之一,使用String对象的构造方法可以将任意类型的数据转换为字符串,其中,这里的任意类型主要分为两大类:原始(基本)类型和对象类型。基本类型的转换相对简单,转换方法如下:

    基本数据类型 String类型
    数字 对应的数字字符串
    true 字符串true
    false 字符串false
    null 字符串null
    undefined 字符串undefined
    如下,均输出对应的字符串值:

    console.log(String(123));//"123"
    console.log(String(true));//"true"
    console.log(String(false));//"false"
    console.log(String(null));//"null"
    console.log(String(undefined));//"undefined"

    对象类型的转换稍微复杂些,对象参与基本类型数据运算时,首先是要将对象转换为基本类型。转换方法如下:

    1、调用toString()方法,如果返回基本类型的值,则用String()构造方法转换该值。

    2、如果toString()方法返回的不是基本类型,则再调用valueOf()方法,如果返回基本类型的值,则用String()构造方法转换该值。

    3、如果valueOf()方法返回的也不是基本类型,就抛出错误,如谷歌抛出:Uncaught TypeError: Cannot convert object to primitive value


    如下,为了方便查看,重写了String的toString()和valueOf()方法:

    例1、当String对象的toString()方法返回基本类型时

    //重写Date对象的toString()
    Date.prototype.toString=function(){
    	console.log('执行了toString(),这里返回数字1');
    	return 1;
    };
    //重写Date对象的valueOf()方法
    Date.prototype.valueOf=function(){
    	console.log('执行了valueOf()方法,这里返回数字2');
    	return 2;
    };
    var date=new Date();
    var str=String(date);
    
    输出结果:

    执行了toString(),这里返回数字1
    

    列2、当toString()方法返回非基本类型时,再次调用valueOf()方法
    //重写Date对象的toString()
    Date.prototype.toString=function(){
    	console.log('执行了toString(),这里返回数字1');
    	return {};
    };
    //重写Date对象的valueOf()方法
    Date.prototype.valueOf=function(){
    	console.log('执行了valueOf()方法,这里返回数字2');
    	return 2;
    };
    var date=new Date();
    var str=String(date);//先调用toString()方法,由于返回的不是基本数据类型,再次调用valueOf()方法
    
    输出结果:

    执行了toString(),这里返回数字1
    执行了valueOf()方法,这里返回数字2
    

    例3、toString()和valueOf()都返回的不是基本数据类型,则抛出异常
    //重写Date对象的toString()
    Date.prototype.toString=function(){
    	console.log('执行了toString(),这里返回数字1');
    	return {};
    };
    //重写Date对象的valueOf()方法
    Date.prototype.valueOf=function(){
    	console.log('执行了valueOf()方法,这里返回数字2');
    	return {};
    };
    var date=new Date();
    var str=String(date);//先调用toString()方法,由于返回的不是基本数据类型,再次调用valueOf()方法,但还是返回非基本数据类型,所以抛出异常
    
    输出结果:

    执行了toString(),这里返回数字1
    执行了valueOf()方法,这里返回数字2
    Uncaught TypeError: Cannot convert object to primitive value


    也可以采用如下方式验证:

    var obj={
    	valueOf:function(){
    		console.log('执行了valueOf()方法,这里返回数字2');
    		return 2;
    	},
    	toString:function(){
    		console.log('执行了toString(),这里返回对象');
    		return 1;
    	}
    };
    String(obj);

    2.2、将其他类型转换成数字

    使用Number构造函数转化任意类型的值时,也分为两种:一种是将基本类型的值转换成数字,一种是将对象型的值转换为数字。基本类型的数据转换数字的规则如下:

    基本数据类型 数字类型
    数字字符串 对应的数字
    true 1
    false 0
    null 0
    undefined NaN
    空字符串 0
    不可完全被解析为数值的字符串 NaN

    如下:

    console.log(Number(123));//123
    console.log(Number('123'));//123
    console.log(Number('123a'));//NaN
    console.log(Number(''));//0
    console.log(Number(true));//1
    console.log(Number(false));//0
    console.log(Number(undefined));//NaN
    console.log(Number(null));//0
    console.log(Number(' \t\n 3.23322\t '));//Number可以自动去掉两头空白符,输出3.23322
    注:Number构造函数将字符串转换为数字时,字符串必须完全被为数字,即只要有一个字符无法转为数值,则整个字符串都会被转为NaN。如果想不精确转换,可以使用parseInt()函数,parseInt()函数将最大限度的将字符串转换为数字。如:

    console.log(parseInt('123abc456'));//123
    console.log(Number('123abc456'));//NaN

    对象类型转换为数字,和上面对象转换为字符串类似,只是转为数字时是先调用valueOf()方法,再调用tostring()方法:

    1、首先调用对象自身的valueOf()方法,如果返回基本类型的值,则用Number构造函数进行转换。

    2、如果valueOf()返回的不是基本类型的值,则再调用toString()方法,如果返回基本类型的值,值用Number构造函数进行转换。

    3、如果toString()返回的不是基本类型的值,则抛出异常。

    验证方法与上面转为字符串的类似,如:

     var obj={
    	valueOf:function(){
    		console.log('执行了valueOf()方法,这里返回数字2');
    		return 2;
    	},
    	toString:function(){
    		console.log('执行了toString(),这里返回对象');
    		return 1;
    	}
    };
    Number(obj); 
    输出结果:

    执行了valueOf()方法,这里返回数字2

    2.3、将其他类型转换为布尔值

    使用Boolean构造函数转换其他类型的数值时,除了下面几种情况返回false外,其他的值都返回true。

    1、null

    2、0、-0或者+0

    3、NaN

    4、''  空字符串

    5、undefined

    如:

    console.log(Boolean(null));//false
    console.log(Boolean(0));//false
    console.log(Boolean(-0));//false
    console.log(Boolean(+0));//false
    console.log(Boolean(''));//false
    console.log(Boolean(NaN));//false
    console.log(Boolean(undefined));//false
    console.log(Boolean({}));//true
    console.log(Boolean([]));//true
    console.log(Boolean("蝈蝈"));//true
    console.log(Boolean(new Boolean(false)));//true

    三、自动(隐性)类型转换

    自动类型转换就是不需要人为强制的进行转换,js会自动将类型转换为需要的类型,所以该转换操作用户是感觉不到的,因此又称为隐性类型转换。自动类型转换实际上和强制类型转换一样,也是通过String()、Number()、Boolean()等构造函数进行转换,只是该操作是JS自己自动完成的而已。自动类型转换的规则和强制类型转换的规则一致,所以这里不再进行描述。下面列举几个例子:

    3.1、转换为数字

    在所有加减乘除等需要数字类型的地方,JS会自动使用Number构造函数对变量进行转换。

    console.log('1'-'2');//-1
    console.log(1+'2');//12 加号+比较特殊,其他类型和字符串相加都会转换成字符串
    console.log('1'-true);//0
    console.log('1'*{});//NaN
    console.log('1'-'a');//NaN

    3.2、转换为字符串

    字符串自动转换主要表现为字符串的拼接,字符串和其他类型用加号(+)拼接时,其他类型都自动转换为字符串。

    console.log('1'+'2');//12
    console.log('1'+'a');//1a
    console.log('1'+1);//11
    console.log('a'+null);//anull
    console.log('1'+undefined);//1undefined
    console.log('a'+{});//a[object Object]
    console.log('a'+true);//atrue

    3.3、转换为布尔值

    当在任意需要布尔类型的地方(如,if条件出、三元运算符条件等),系统都会自动调用Boolean()构造函数将值转换为Boolean类型。null、0、-0、+0、'' 空字符串、undefined、NaN这些都会转换为false,其他的值都会转换为true。












    展开全文
  • double类型转换成int类型

    万次阅读 2018-08-13 16:49:37
    public class test09 { public static void main(String[] args) { double a = 5000.44; double b = 100.12; double v = a / b; int i = new Double(v).intValue(); ...

    1、案例演示 

    public class test09 {
        public static void main(String[] args) {
            double a = 5000.44;
            double b = 100.12;
    
            double v = a / b;
            int i = new Double(v).intValue();
            System.out.println(i);
            System.out.println(v);
        }
    }

    运行结果:

    49
    49.944466640031955

    2、源码查看

        /**
         * Returns the value of this {@code Double} as an {@code int}
         * after a narrowing primitive conversion.
         * @jls 5.1.3 Narrowing Primitive Conversions
         *
         * @return  the {@code double} value represented by this object
         *          converted to type {@code int}
         */
        public int intValue() {
            return (int)value;
        }

    通过以上的官方源码可以发现,这个方法需要创建Double对象,才能调用这个方法。

    3、授之以渔 

    这个是官方源码的构造方法,我们可以看到还可以尝试转换为其他类型,比如转换为short类型。 

     

    展开全文
  • C++基本数据类型类型转换

    千次阅读 2014-05-09 00:15:34
    c++基本数据类型 什么样的数据算是byte类型,int类型,float类型,double类型,long类型? byte类型,就是字符类型.这类数据是字符组成的 INT 类型,为整型数字,不同语言定义的范围不同 FLOAT,为数字浮点型,其小数点后面...

    http://blog.csdn.net/pipisorry/article/details/25346379

    c++基本数据类型

    什么样的数据算是byte类型,int类型,float类型,double类型,long类型?

    byte类型,就是字符类型.这类数据是字符组成的
    FLOAT,为数字浮点型,其小数点后面可以跟N个数字
    DOUBLE,为双精度数字类型,其小数点后只能有两个数字

    int类型

    上面提到了在32位机器和64机器中int类型都占用4个字节。后来,查了The C Programming language这本书,里面有一句话是这样的:Each compiler is free to choose appropriate sizes for its own hardware, subject only to the restriction that shorts and ints are at least 16bits, longs are at least 32bits, and short is no longer than int, which is no longer than long.意思大致是编译器可以根据自身硬件来选择合适的大小,但是需要满足约束:short和int型至少为16位,long型至少为32位,并且short型长度不能超过int型,而int型不能超过long型。这即是说各个类型的变量长度是由编译器来决定的,而当前主流的编译器中一般是32位机器和64位机器中int型都是4个字节(例如,GCC)。

    下面列举在GCC编译器下32位机器和64位机器各个类型变量所占字节数:

    C类型

                32               64
        char             1                1
        short int             2                2
        int             4                4
        long int             4                8
        long long int             8                8
        char*             4                8
        float             4                4
        double             8                8
    关于带符号与无符号类型:整型 int、stort  和  long 都默认为带符号型。要获得无符号型则必须制定该类型为unsigned,比如unsigned long。unsigned int类型可以简写为unsigned,也就是说,unsigned后不加其他类型说明符就意味着是unsigned int。
    Note:
    c语言中int类型为4bytes(64位机上,32位机应该也是),也就是说总是4bytes而不会变,不过不同语言定义的范围不同,如python中是8bytes(64位机)实际对象占用28bytes。
    #include <stdio.h>
    #include <limits.h>
    int main()
    {
        printf("The value of INT_MAX is %i\n", INT_MAX);
        printf("The value of INT_MIN is %i\n", INT_MIN);
        printf("An int takes %ld bytes\n", sizeof(int));
        return 0;
    }
    The value of INT_MAX is 2147483647
    The value of INT_MIN is -2147483648
    An int takes 4 bytes

    一字节表示八位,即:1byte = 8 bit;
    int: 4byte =  32 bit 有符号signed范围:2^31-1 ~ -2^31即:2147483647 ~ -2147483648        无符号unsigned范围:2^32-1 ~ 0即:4294967295 ~ 0
    long: 4 byte = 32 bit 同int型
    double: 8 byte = 64 bit 范围:1.79769e+308 ~ 2.22507e-308
    long double: 12 byte = 96 bit 范围: 1.18973e+4932 ~ 3.3621e-4932
    float: 4 byte = 32 bit 范围: 3.40282e+038 ~ 1.17549e-038
    int、unsigned、long、unsigned long 、double的数量级最大都只能表示为10亿,即它们表示十进制的位数不超过10个,即可以保存所有9位整数。而short只是能表示5位。


    c++类型转换

    1. c++中string到int的转换

    1) 在C标准库里面,使用atoi:

    #include <cstdlib> 
    #include <string>

    std::string text = "152"; 
    int number = std::atoi( text.c_str() ); 
    if (errno == ERANGE) //可能是std::errno 

     //number可能由于过大或过小而不能完全存储 

    else if (errno == ????) 
    //可能是EINVAL 

     //不能转换成一个数字 
    }

    2) 在C++标准库里面,使用stringstream:(stringstream 可以用于各种数据类型之间的转换)

    #include <sstream> 
    #include <string>

    std::string text = "152"; 
    int number; 
    std::stringstream ss;


    ss << text;//可以是其他数据类型
    ss >> number; //string -> int
    if (! ss.good()) 

    //错误发生 
    }

    ss << number;// int->string
    string str = ss.str(); 
    if (! ss.good()) 

     //错误发生 
    }

    3) 在Boost库里面,使用lexical_cast:

    #include <boost/lexical_cast.hpp> 
    #include <string>

    try 

     std::string text = "152"; 
     int number = boost::lexical_cast< int >( text ); 

    catch( const boost::bad_lexical_cast & ) 

     //转换失败 
    }                      

    [如何将字符串转换int64_t]

    int转换成string

    c++中将输入的数字以字符(串)形式输出

    1. #include <iostream>  
    2. #include <sstream>  
    3. #include <string>  
    4. using namespace std;  
    5.   
    6. void main(){  
    7.     int i = 65;   
    8.     cout<<char(i)<<endl;                    //输出‘A' <=>printf("%c\n", i);  
    9.   
    10.     stringstream ss;  
    11.     ss<<i;  
    12.     string s;  
    13.     ss>>s;  
    14.     cout<<s<<endl;                      //输出”65“  
    15.       
    16.     char *c = new char;  
    17.     itoa(65, c, 10);  
    18.     cout<<c<<endl;                      //输出”65“  
    19.     //cout<<strcmp(c, "65")<<endl;    
    20. }  
    [http://bbs.csdn.net/topics/390401758?page=1#post-394058528]


    2.string 转 CString

    CString.format(”%s”, string.c_str());
    用c_str()确实比data()要好;

    3.char 转 CString

    CString.format(”%s”, char*);

    4.char 转 string

    string s(char *);
    只能初始化,在不是初始化的地方最好还是用assign().

    5.string 转 char *

    char *p = string.c_str();

    6.CString 转 string

    string s(CString.GetBuffer());
    GetBuffer()后一定要ReleaseBuffer(),否则就没有释放缓冲区所占的空间.

    7.字符串的内容转换为字符数组和C—string

    (1)  data(),返回没有”\0“的字符串数组
    (2)  c_str(),返回有”\0“的字符串数组
    (3)  copy()

    8.CString与int、char*、char[100]之间的转换

    (1) CString互转int

    将字符转换为整数,可以使用atoi、_atoi64或atol。而将数字转换为CString变量,可以使用CString的Format函数。如
    CString s;
    int i = 64;
    s.Format(”%d”, i)
    Format函数的功能很强,值得你研究一下。

    void CStrDlg::OnButton1()
    {
       CString
       ss=”1212.12″;
       int temp=atoi(ss);
       CString aa;
       aa.Format(”%d”,temp);
       AfxMessageBox(”var is ” + aa);
    }

    (2) CString互转char*

    ///char * TO cstring
    CString strtest;
    char * charpoint;
    charpoint=”give string a value”; //?
    strtest=charpoint;

    ///cstring TO char *
    charpoint=strtest.GetBuffer(strtest.GetLength());

    (3) char *转成CString

    标准C里没有string,char *==char []==string, 可以用CString.Format(”%s”,char *)这个方法来将char *转成CString。
        要把CString转成char *,用操作符(LPCSTR)CString就可以了。
        CString转换 char[100]
       char a[100];
       CString str(”aaaaaa”);
       strncpy(a,(LPCTSTR)str,sizeof(a));


    static_cast类型转换

    static_cast < type-id > ( expression )

    该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:
    ①用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。
    进行上行转换(把派生类的指针或引用转换成基类表示)是安全的;
    进行下行转换(把基类指针或引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
    ②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。
    ③把空指针转换成目标类型的空指针。
    ④把任何类型的表达式转换成void类型。

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

    C++primer第五章里写了编译器隐式执行任何类型转换都可由static_cast显示完成;reinterpret_cast通常为操作数的位模式提供较低层的重新解释
    1、C++中的static_cast执行非多态的转换,用于代替C中通常的转换操作。因此,被做为显式类型转换使用。比如:
    1
    2
    3
    inti;
    floatf = 166.71;
    i = static_cast<int>(f);
    此时结果,i的值为166。
    2、C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。比如:
    1
    2
    3
    inti;
    char*p = "This is an example.";
    i = reinterpret_cast<int>(p);
    此时结果,i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制(位模式)的方式被解释为整型,并赋给i,//i 也是指针,整型指针;一个明显的现象是在转换前后没有数位损失。

    虽然const_cast是用来去除变量的const限定,但是static_cast却不是用来去除变量的static引用。其实这是很容易理解的,static决定的是一个变量的作用域和生命周期,比如:在一个文件中将变量定义为static,则说明这个变量只能在本Package中使用;在方法中定义一个static变量,该变量在程序开始存在直到程序结束;类中定义一个static成员,该成员随类的第一个对象出现时出现,并且可以被该类的所有对象所使用。对static限定的改变必然会造成范围性的影响,而const限定的只是变量或对象自身。但无论是哪一个限定,它们都是在变量一出生(完成编译的时候)就决定了变量的特性,所以实际上都是不容许改变的。这点在const_cast那部分就已经有体现出来。

    static_cast和reinterpret_cast一样,在面对const的时候都无能为力:两者都不能去除const限定。两者也存在的很多的不同,比如static_cast不仅可以用在指针和引用上,还可以用在基础数据和对象上;reinterpret_cast可以用在"没有关系"的类型之间,而用static_cast来处理的转换就需要两者具有"一定的关系"了。reinterpret_cast可以在任意指针之间进行互相转换,即使这些指针所指的内容是毫无关系的,也就是说一下语句,编译器是不会报错的,但是对于程序来说也是毫无意义可言的,只会造成程序崩溃

    unsignedshort Hash( void *p ) {

    unsignedlong val = reinterpret_cast<unsignedlong>( p );

    return ( unsigned short )( val ^ (val >> 16));

    }


    int main() {

    typedefunsignedshort (*FuncPointer)( void *) ;

    FuncPointer fp = Hash; //right,this is what we want

    int a[10];constint* ch = a; //right, array is just like pointer

    char chArray[4] = {'a','b','c','d'};

    fp = reinterpret_cast<FuncPointer> (ch); //no error, but does not make sense

    ch = reinterpret_cast<int*> (chArray); //no error

    cout <<hex<< *ch; //output: 64636261 //it really reinterpret the pointer

    }

    而以上转换,都是static_cast所不能完成的任务,也就是说把上边程序里所有的reinterpret_cast换成static_cast的话,就会立即得到编译错误,因为目标指针和原始指针之间不存在"关系"

    从上边的程序,也就一下子看出来了reinterpret_cast和static_cast之间最本质的区别。

    但是从基类到子类的转换,用static_cast并不是安全的,具体的问题会在dynamic_cast一篇阐述。

    在指针和引用方便,似乎也只有继承关系是可以被static_cast接受的,其他情况的指针和引用转换都会被static_cast直接扔出编译错误,而这层关系上的转换又几乎都可以被dynamic_cast所代替。这样看起来static_cast运算符的作用就太小了。

    实际上static_cast真正用处并不在指针和引用上,而在基础类型和对象的转换上 。 而基于基础类型和对象的转换都是其他三个转换运算符所办不到的

    from: http://blog.csdn.net/pipisorry/article/details/25346379

    ref: 

    展开全文
  • JS数据类型转换

    万次阅读 2019-06-23 14:48:41
    首先我们要知道,在 JS 中类型转换只有三种情况,分别是: 转换为布尔值 转换为数字 转换为字符串 我们先来看一个类型转换表格,然后再进入正题 转Boolean 在条件判断时,除了 undefined, null, false, NaN, ...
  • Swift数据类型及数据类型转换

    千次阅读 2014-06-12 15:55:39
    这些整数类型遵循 C 语言的命名规 约,如 8 位无符号整数的类型为 UInt8,32 位 有符号整数的类型为 Int32。与 Swift 中的所有 类型一样,这些整数类型的名称以大写字母开 头。 Swift 还提供了一个整数类型Int:...
  • 数据类型转换

    万次阅读 2017-06-18 10:44:23
    数据类型转换
  • numpy 数据类型转换

    万次阅读 2019-08-12 15:25:29
    首先需要导入numpy模块 import numpy as np ...我们发现这个数组的type是float64,那我们试着改变一个数组的类型,会有什么样的变化呢?请看下面的截图 我们发现数组长度翻倍了!由原来的(4,)变成了(8...
  • java基本数据类型转换

    万次阅读 2020-07-03 10:39:12
    java基本数据类型的转换自动类型转换强制类型转换 自动类型转换 举例:多种不同的数据类型的一起运算 解释:有多种类型的数据混合运算时,系统首先自动将所有数据转换成容量最大的那个数据类型,然后再进行计算。 ...
  • 在Java中从小到大,可以隐式转换数据类型将自动提升。下面以int为例 这么写是ok的 int a = 2312; long b = a; 那么在Kotlin中 //隐式转换,编译器会报错 val anInt: Int = 5 val ccLong: Long = anInt //...
  • 1、基础类型转换(string转number类型,number转string类型) class TypeChange { constructor() { this.print(); } age: number = 20; ageStr: string = "20"; ageNull: string; public print...
  • Vivado HLS数据类型及数据类型转换

    千次阅读 2020-05-25 19:40:42
    引言 Vivado HLS数据类型与C语言的基本数据类型稍微有些不同,由于FPGA所需要的数据类型可能是任意bit的,而C语言则是以8bit为单位的,所以如果继续沿用C语言的...2、数据类型转换 Vivado HLS还定义了不同数据类...
  • C++之基本数据类型转换和转换函数

    千次阅读 2015-02-04 16:35:23
    C++语言中类型转换有两种:隐式转换和强制转换。在类型转换的过程中还有保值转换和非保值转换之分。保值转换是安全的,数据精度不会受到损失,如数据类型有低向高转换;非保值转换是不安全的,数据精度会受到损失,...
  • mysql数据类型转换

    千次阅读 2018-09-28 09:23:36
    mysql数据类型转换 数字类型转换字符串类型 1、将Int 转为varchar经常用 concat函数,concat(xxx,类型) 比如: concat(8,’0′) 得到字符串 ’80′ 比如将123转换为char类型 SELECT CAST(123 AS CHAR); ...
  • js数据类型类型转换

    千次阅读 2019-08-02 16:58:38
    js判断数据类型 <script type="text/javascript"> function my(){ var al; console.log(typeof (al));//undefined var ae=1; conso...
  • ConversionService是Spring类型转换体系的核心接口,可以利用conversionServiceFactoryBean在Spring工厂容器中定义一个conversionService。Spring将自动识别出ConversionService,并在bean属性配置及SpringMVC处理...
  • python numpy 数据类型转换

    万次阅读 多人点赞 2018-02-07 09:44:40
    python numpy 数据类型转换 numpy数据类型转换需要调用方法astype(),不能直接修改dtype。调用astype返回数据类型修改后的数据,但是源数据的类型不会变,需要进一步对源数据的赋值操作才能改变。例如 >>> a=np....
  • PostgreSQL - 怎么转换数据类型

    千次阅读 2018-12-18 23:55:29
    这个sql,得到的结果是int4类型,如果我们希望将结果转换成其他的数据类型,有两种方法: 方法一:使用::数据类型 select 233::text; 上边的sql通过::text将结果转换成了text类型。 方法二:使用数据类型'' ...
  • Python数据类型转换

    万次阅读 2018-05-31 22:26:18
    函数描述int(x [,base])将x转换为一个整数long(x [,base] )将x转换为一个长整数float(x)将x转换到一个浮点数complex(real [,imag])创建一个复数str(x)将对象 x 转换为字符串repr(x)将对象 x 转换为表达式字符串eval...
  • tensorflow数据类型转换

    千次阅读 2019-07-27 09:37:13
    tensorflow支持14种不同的类型,主要包括: 实数:tf.float32 tf.float64 整数:tf.int8 tf.int16 tf.int32 tf.int64 tf.unit8 布尔:tf.bool 复数:tf.complex64 tf....将张量强制转换为bfloat16类型。(depreca...
  • 在java JNI到C++中调用时候各种常见类型数据如何转换,通过程序演示Java通过JNI调用C++的API读取电脑名称和系统用户名。
  • string sql = "select top 5 * from Dcms_Intro where Intro_CateId=931 order by cint(Intro_ExFlag5) desc " ;// 这样才能正确排序 cint(Intro_ExFlag5) //文本类型转换为数字类型
  • Hive 数据类型类型转换

    万次阅读 2018-08-25 21:59:43
    1.基本数据类型 Hive数据类型 Java数据类型 长度 例子 TINYINT byte 1byte有符号整数 20 SMALINT short ...
  • tensor数据类型转换

    千次阅读 2019-09-16 17:10:33
    tensor数据类型转换 torch.long() 将tensor转换为long类型 torch.half() 将tensor转换为半精度浮点类型 torch.int() 将该tensor转换为int类型 torch.double() 将该tensor转换为double类型 torch.float() 将该...
  • HIVE 数据类型转换

    万次阅读 2017-01-11 14:40:09
    今天的话题是Hive数据类型之间的转换。同Java语言一样,Hive也包括 隐式转换(implicit conversions)和显式转换(explicitly conversions)。  Hive在需要的时候将会对numeric类型的数据进行隐式转换。比如我们对...
  • SparkSql 数据类型转换

    千次阅读 2019-10-14 08:44:38
    SparkSql 数据类型转换1、SparkSql数据类型1.1数字类型1.2复杂类型2、Spark Sql数据类型和Scala数据类型对比3、Spark Sql数据类型转换案例3.1获取Column类3.2测试数据准备3.3spark入口代码3.4测试默认数据类型3.5把...
  • python中数据类型转换的使用

    千次阅读 2018-08-04 17:44:59
    常用的数据类型转换 函数 说明 int(x [,base ]) 将x转换为一个整数 long(x [,base ]) 将x转换为一个长整数(注意python3中没有long了,2里有) float(x ) 将x转换到一个浮点数 complex(real [,...
  • es6 javascript的map数据类型转换

    万次阅读 2016-12-14 10:49:59
    (1) Map 转为数组 前面已经提过, Map 转为数组最方便的方法, 就是使用扩展运算符(...)。 let myMap = new Map().set(true, 7).set({ foo: 3 }, ['abc']); [...myMap] // [ [ true, 7 ], [ { foo: 3 }, [ '...

空空如也

1 2 3 4 5 ... 20
收藏数 180,778
精华内容 72,311
关键字:

类型转换