显示类型转换

1.Number()：函数把对象的值转换为数字，如果对象的值无法转换为数字，那么 Number() 函数返回 NaN。

        var a = 'true';
        console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
        var a = '1a';
        console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
        var a = undefined;
        console.log(typeof(Number(a)) + '-' + Number(a)); // number-NaN
        var a = null;
        console.log(typeof(Number(a)) + '-' + Number(a)); // number-0
        var a = '123';
        console.log(typeof(Number(a)) + '-' + Number(a)); //number-123
        var a = true;
        console.log(typeof(Number(a)) + '-' + Number(a)); //number-1

2.parseInt():函数可解析一个字符串，并返回一个整数

        var a = '3.14';
        console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-3
        var a = true;
        console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-NaN
        var a = null;//undefined,NaN
        console.log(typeof(parseInt(a)) + '-' + parseInt(a));//number-NaN
        var a='10';
        console.log(parseInt(a,16));//16
        var a='b';
        console.log(parseInt('abc123'));//NAN
        var a='b';
        console.log(parseInt('123abc'));//123 

3.parseFloat():函数可解析一个字符串，并返回一个浮点数

	    var a = 'b';
        console.log(parseFloat('3.1415')); //3.1415
        var num = parseFloat('3.1415')
        console.log(num.toFixed(2));//3.14  四舍五入

4.String():函数把需要转换的值转换为字符串，并返回。

        console.log(typeof(String(123))); //string
        console.log(typeof(123 + '')); //string

5.toString(）

        var str = '3.14';
        console.log(str.toString()); //3.14
        var str = undefined; //null也没有toString()
        console.log(str.toString()); //报错
        var str = '100';
        console.log(parseInt(str, 2));//二进制100变十进制  4
        console.log(parseInt(str, 2).toString(16));//4

6.Boolean()

        console.log(Boolean(1));//true
        console.log(Boolean(null));//false  NAN 空字符串 0 undefined null

隐式类型转换

+运算符内部会隐式调用String()

     var a = 'a' + 1; //String(1) 'a'+'1'=a1
     console.log(a) //a1

运算符内部(-,*,/,%)会隐式调用Number()

     var a = '3' * 2; //* / - % str-->Number转换为数字
     console.log(a); //6
     var a = '1' > 2; //转换成Number >=<
     console.log(a); //false
     //转换成ASCII var a='a'>'b';
     var a=1=='1';
     console.log(a);//true
     var a=1==='1';//不进行隐式转换
     var a=NaN==NaN;//false

内部会隐式调用Bollean()

     var a1=2>1>3;
     var a2=2>1==1;
     console.log(a1);//false
     console.log(a2);//true
     var a=undefined>0;//undefined和null既不大于0也不小于0 也不等于0
     var a=null==0;//false
     var a=undefined==null;//true
     var a=undefined===null;//false
     console.log(a)//false

运算符内部(++/–,正负)会隐式调用Number()

     var a = '123';
     a++;
     console.log(a); //124
     var num='123';
     console.log(typeof(+num));//number
     var num='abc';
     console.log(typeof(-num)+':'+-num);//number:NaN

isNaN() 需要经过Number()处理

     console.log(isNaN(NaN));//true
     console.log(isNaN(undefined))//true
     console.log(isNaN(null));//false
     console.log(isNaN('ab'));//true
     console.log(isNaN('null'));//true
     console.log(isNaN(1));//false

经典面试题

1.if(typeof(a) &&(-true) +(+undefined)+ ' '){
   //"undefined" && "NaN "  (-1+NaN+' ')
   console.log('通过了')
  }else{
   console.log('没通过')
  }
   console.log(a);
   //通过了
   //a is not defined

未被定义的变量直接console.log会报引用错误，但是放在typeof里面不会出错。

2.console.log(!!' '+!!''-!!false || '未通过');
//1

或运算符遇到一个条件为真就直接输出运算结果，遇到条件为假的情况就继续判断。
分析：前面的’ ‘中是一个空格,空格是true，在两次!之后还是true，遇到+运算符转换为数字1，后面的’'是一个空字符串，它是false，两次!!后还是false，转换为数字0，由此可知，或运算符前面的计算结果是1，所以结果为1。

3.window.a || (window.a = '1');
  console.log(window.a);
 //'1'

分析：括号的面的优先级是最高的，先看括号里面的内容。

4.var =???
  if(a == 1 && a == 2 && a == 3){
  console.log("1");
  }

分析：与运算符条件条件全部为真才会输出运算结果。上述题中，a需要满足三个条件，此时应该想到复杂数据类型转换。
复杂数据类型转number顺序如下:
1.先使用valueOf()方法获取其原始值，如果原始值不是number类型，则使用 toString()方法转成string
2.再将string转成number运算
对象的valueOf（）方法是可以重写的。

var a = {
i : 0,//声明一个属性i
valueOf:function ( ) {
return ++a.i;//每调用一次，让对象a的i属性自增一次并且返回
}
}
if (a == 1 && a == 2 && a == 3){//每一次运算时都会调用一次a的valueOf()方法

在定义变量时，有许多要注意的问题，一不小心就会出现损失精度或者不兼容类型等问题。

例如：

    1.定义长整型数据时，必须加后缀l或L

              long l =123456789012345L

    2.定义单精度类型时（7-8位有效数字），必须加后缀 f 或 F

              float f = 12.5F

          3. boolean类型不可以转换为其它的数据类型。

这其中，我们常常会遇到数据类型的转换问题，最为常见的要属隐式转换和强制转换了，我们来分析一下。

隐式转换

特征：

从小到大，可以隐式转换，数据类型将自动提升。

byte，short，char -->int  -->long -->float -->double

注意：long是8个字节，float是4个字节。

long是整数，float是浮点型，整数和浮点数的存储规则不一样，记住一点long的范围是小于float的。

例 :

byte a=10;

int b=a;

当编译intb=a 时，  a隐式转换为int类型。

强制转换

特征:

     从大到小（如果你明确知道数据是可以用该数据类型来表示的，可以用强制转换）

格式：

    （转换后的数据类型）变量或者值。

注：一般情况下，根本不推荐使用强制类型转换。

           例1 :

int a=10;

byte b=(byte)a;

当编译 byte b=(byte)a时， a被强制转换为byte类型。

例2:

[java] view plain copy

1. class QiangZhiDemo  
2. {  
3.     public static void main(String[] args)  
4.     {  
5.         byte b=(byte)130;  
6.         System.out.println(b);  //打印结果-126  
7.     }     
8. }  

解析：

数据130默认的是int类型的十进制数据,

第一步:十进制130转换成二进制数据。

  10000010

第二步：130在内存中的表示形式如下

原码：0000000000000000 00000000 10000010

第三步：求int130的补码

因为130是正数，所以，反码和补码都和原码一致。

补码：0000000000000000 00000000 10000010

第四步：对补码进行截取，只剩下最后8位。

(byte)130 的补码为：10000010

第五步：把该补码转化为原码。

由于符号位（第一位）是1，故该数为负数，

反码：10000001     (补码-1)

原码：11111110     (符号位不变，数据位取反)

转化为十进制为 -126，所以最终打印-126。

     例3 :

shorts = 1;

s= s +1;                

和

shorts = 1;

s+=1;                        

有问题吗?为什么呢?

     解析：

第一程序会报错：错误：不兼容的类型：从int转换到short可能会有损失

原因：s=s+1;s+1会隐式转换为int类型，当把一个int类型赋值给short类型是，可能会损失。

第二个程序可以编译运行。

原因：s+=1，虽然可以看做s=s+1,但是还是有区别的，s+=1中有一个强制转换，即s=(short)(s+1),会把s+1的值强制转换为short类型，故不会报错。

小结：

数据类型转换的问题如果发生在一些小程序上，我们或许能够一眼看出，可是当编写一个庞大的系统时，拥有庞大数据量时，这些小小的问题可能导致系统出错甚至崩溃，所以前期代码编写的严谨性就得靠我们自己把握了。

1. 迭代器
   其实迭代器很简单，没有我们想象中的那么复杂。以前要读写数据结构中的数据，一般是通过移动指针来进行的，但是在编写指针的过程中难免会出现野指针等情况出现，而且指针用起来也相对复杂。这时候，神奇的迭代器出现了。
   迭代器是指针的一个泛化，在容器和算法之间充当桥梁的作用。区别于指针，迭代器本身重载的“++”和“–”操作符，能够直接指向前驱和后继节点。
2. 显式类型转换
   将一种类型转换成另一种类型，在程序中很常见，转换后的类型变量，它的内部存储方式一般也随之改变。C++提供了四种显式的类型转换操作函数reinterpret_cast、const_cast、static_cast和dynamic_cast。前三个类型的转换是在编译的时候进行类型转换，最后一个则是在运行的时候进行类型转换，并可返回转换成功与否的标志。
   2.1 reinterpret_cast
   **reinterpret_cast类型转换函数将一个类型的指针转换为另一个类型的指针。**这种转换不用修改指针变量值数据存放格式(不改变指针变量的值)，也不能把const指针转换成void*指针，只需在编译时重新解释指针的类型就行。

double d = 9.3;
    double *pd = &d;
    int *pi = reinterpret_cast<int* >(pd);  //相当于隐式转换int *pi = (int*)pd;
    class A{};
    class B{};
    A *pa = new A;
    B *pb = reinterpret_cast<B* >(pa);        //相当于隐式转换B* pb = (B* )pa;
    long j = reinterpret_cast<long>(pi);      //相当于long j = (long)pi;

2.2const_cast
const_cast用于去除指针变量的常量属性，将它转换为一个对应指针类型的普通变量，反过来也成立。

    const int* pci =0;
    int *pj = const_cast<int *>(pci);    //相当于int* pj = (int*)pci;
    const A* pca = new A;
    A* pa = const_cast<A*>(pca);    //相当于A* pa = (A*)pca;

const_cast只是针对于指针操作，无法将非指针的常变量转换为普通变量。

    int* pi = 0;
    const int* pcj = const_cast<const int* >(pi);//将普通指针转换为常量指针
    int i=0;
    const int cj = const_cast<const int>(i);//非指针转换为const指针，不能通过编译！
    const int ck = (const int)i;//隐式转换，可通过编译

2.3 static_cast
static_cast一般用于基本类型之间和具有继承关系之间的类型转换，这种转换一般会更改变量的内部表示方式。一般不用于指针类型转换。

    int i = 0;
    double d = static_cast<double>(i);//将i的int型转换为double型然后赋值给d;
    int j = static_cast<int>(j); //将double型转换为int 型然后赋值给j;
    class Base{};
    class Derived:Base{};
    Derived d;
    Base b = static_cast<Base>(d);//将子类对象d转换为父类然后赋值给b;

2.4 dynamic_cast
与上面三个不同，dynamic_cast是在运行的时候进行转换分析的，上面三个是在编译时进行。
dynamic_cast只能在继承类对象的指针之间或引用之间进行类型转换。进行转换时，会根据当前运行对象的运行时类型信息，判断类型对象之间是否转换合法。dynamic_cast的指针转换失败，可通过是否为null指针检测；引用转换失败则抛出一个bad_cast异常。

#include <QCoreApplication>
#include <iostream>
#include<stdio.h>
#include<typeinfo.h>
using namespace std;
int main(int argc, char *argv[])
{
    QCoreApplication a(argc, argv);
    class Base{};
    class Derived:public Base{};
    //子类指针pd转化为父类指针pb
    Derived* pd = new Derived;
    Base* pb = dynamic_cast<Base* >(pd);
    if(!pb)
    {
        cout << "类型转换失败" << endl;
    }
    else
    {
        cout << "类型转换成功" << endl;
    }
    //子类引用转化为父类引用
    Derived d;
    Base& b = dynamic_cast<Base& >(d);
    //没有继承关系，但被转化的类有虚函数
    class A{
        virtual ~A(){}
    };
    class B{};
    A* pa = new A;
    B* pc = dynamic_cast<B* >(pa);//有虚函数的对象指针，可以转化
    if(!pc)
    {
        cout << "类型转换成功" << endl;
    }
    else
    {
        cout << "类型转换失败" << endl;
    }
    return a.exec();
}

运行结果：

dynamic_cast不只是应用于类型转换，**通常利用它做运行时对象类型检查的特性，在程序中检测当前内存对象的类型信息，**以决定下一步操作，使程序更灵活机动。