C/C++类型转换

1. 将浮点型数据赋值给整型变量时，舍弃其小数部分。
2. 将整型数据赋值给浮点型变量时，数值不变，但是以指数形式存储。
3. 将double型数据赋值给float型变量时，注意数值范围溢出。
4. 字符型数据可以赋值给整型变量，此时存入的是字符的ASCII码。
5. 将一个int，short或long型数据赋值给一个char型变量，只将低8位原封不动的送到char型变量中。 
6. 将有符号型数据赋值给长度相同的无符号型变量，连同原来的符号位一起传送。

int a = 10;
int b = 3;
double result = (double)a / (double)b;

int a = 10;
int b = 3;
double result = static_cast<double>(a) / static_cast<double>(b);

•     该运算符用来修改类型的const或volatile属性。除了const 或volatile修饰之外， type_id和expression的类型是一样的。
•     常量指针被转化成非常量指针，并且仍然指向原来的对象；
•     常量引用被转换成非常量引用，并且仍然指向原来的对象；常量对象被转换成非常量对象。

const int a = 10;
const int * p = &a;
*p = 20;                  //compile error
int b = const_cast<int>(a);  //compile error

#include<iostream>
using namespace std;
 
int main()
{
    const int a = 10;
    const int * p = &a;
    int *q;
    q = const_cast<int *>(p);
    *q = 20;    //fine
    cout <<a <<" "<<*p<<" "<<*q<<endl;
    cout <<&a<<" "<<p <<" "<<q <<endl;
    return 0;
}

10 20 20
002CFAF4 002CFAF4 002CFAF4

#include<iostream>
using namespace std;
 
const int * Search(const int * a, int n, int val);
 
int main()
{
    int a[10] = {0,1,2,3,4,5,6,7,8,9};
    int val = 5;
    int *p;
    p = const_cast<int *>(Search(a, 10, val));
    if(p == NULL)
        cout<<"Not found the val in array a"<<endl;
    else
        cout<<"hvae found the val in array a and the val = "<<*p<<endl;
    return 0;
}
 
const int * Search(const int * a, int n, int val)
{
    int i;
    for(i=0; i<n; i++)
    {
        if(a[i] == val)
            return &a[i];
    }
    return  NULL;
}

#include<iostream>
using namespace std;
 
const int & Search(const int * a, int n, int val);
 
int main()
{
int a[10] = {0,1,2,3,4,5,6,7,8,9};
int val = 5;
int &p = const_cast<int &>(Search(a, 10, val));
if(p == NULL)
cout<<"Not found the val in array a"<<endl;
else
cout<<"hvae found the val in array a and the val = "<<p<<endl;
return 0;
}
 
const int & Search(const int * a, int n, int val)
{
int i;
for(i=0; i<n; i++)
{
if(a[i] == val)
return a[i];
}
return NULL;
}

•     type-id必须是一个指针、引用、算术类型、函数指针或者成员指针。
•     它可以把一个指针转换成一个整数，也可以把一个整数转换成一个指针（先把一个指针转换成一个整数，在把该整数转换成原类型的指针，还可以得到原先的指针值）。

int *a = new int;
double *d = reinterpret_cast<double *>(a);

1. 其他三种都是编译时完成的，dynamic_cast是运行时处理的，运行时要进行类型检查。
2. 不能用于内置的 基本数据类型 的强制转换。
3. dynamic_cast转换如果成功的话返回的是指向类的 指针或引用，转换失败的话则会返回 NULL 。
4. 使用dynamic_cast进行转换的，基类中一定要有虚函数，否则编译不通过。     
5. 在类的转换时，在类层次间进行上行转换时，dynamic_cast和static_cast的效果是一样的。在进行下行转换时，dynamic_cast具有类型检查的功能，比static_cast更安全。

#include<iostream>
using namespace std;
 
class base
{
public :
    void m(){cout<<"m"<<endl;}
};
 
class derived : public base
{
public:
    void f(){cout<<"f"<<endl;}
};
 
int main()
{
    derived * p;
    p = new base;
    p = static_cast<derived *>(new base);
    p->m();
    p->f();
    return 0;
}

#include<iostream>
using namespace std;
 
class base
{
public :
    void m(){cout<<"m"<<endl;}
};
 
class derived : public base
{
public:
    void f(){cout<<"f"<<endl;}
};
 
int main()
{
    derived * p;
    p = new base;
    p = dynamic_cast<derived *>(new base);
    p->m();
    p->f();
    return 0;
}

virtual void m(){cout<<"m"<<endl;}

#include<iostream>
#include<cstring>
 
using namespace std;
 
class A
{
   public:
   virtual void f()
   {
         cout<<"hello"<<endl;
   };
};
  
class B:public A
{
    public:
    void f()
    {
          cout<<"hello2"<<endl;
    };
};
 
class C
{
  void pp()
  {
        return;
  }
};
 
int fun()
{
  return 1;
}
 
int main()
{
    A* a1=new B;                 //a1是A类型的指针指向一个B类型的对象
    A* a2=new A;                 //a2是A类型的指针指向一个A类型的对象
    B* b;
    C* c;
    b=dynamic_cast<B*>(a1);        //结果为not null，向下转换成功，a1之前指向的就是B类型的对象，所以可以转换成B类型的指针。
    if(b==NULL)  
    {
        cout<<"null"<<endl;
    }
    else
    {
        cout<<"not null"<<endl;
    }
 
    b=dynamic_cast<B*>(a2);        //结果为null，向下转换失败(向下转换的成功与否 还与将要转换的类型有关，即 要转换的指针指向的对象的实际类型 与 转换以后的对象类型 一定要相同，否则转换失败。)     if(b==NULL)
    {
        cout<<"null"<<endl;
    }
 
    else
    {
        cout<<"not null"<<endl;
    }
 
    c=dynamic_cast<C*>(a);          //结果为null，向下转换失败
    if(c==NULL)
    {
        cout<<"null"<<endl;
    }
 
    else
    {
        cout<<"not null"<<endl;
    }
 
    delete(a);
    return 0;
}

   unsigned int a=20;
    signed int b=-130;

 unsigned int a=20;
 signed int b=-130;
 std::cout<<a+b<<std::endl;

signed int b=-130;
std::cout<<b+30<<std::endl;