标签：== C++类型转换 inter 宽度 包含 short 基本数据 eva 操作
在赋值给一个兼容类型会出现隐式类型转换.比如下面这个例子.
short a=2000; int b; b=a;
在以上例子中.值从short自动提升到int，这是标准转换。标准转换影响基本数据类型，它在类型数字类型之间(short to int, int to float, double to int...)，
布尔类型和一些指针之间执行。
从小的数字类型转换成int，或者float to double叫做类型提升。这样的转换保证生成相同的值。但是其他一些转换不保证一定生成同样的值。
1.如果负数转换成unsigned 类型。-1转换成最大无符号值。
2.其他类型转bool或者由bool转换成其他类型。false转成0(数值类型)nullptr(指针类型)。true转换成1。
3.由浮点数转换成整数类型.值被截断(小数部分直接被移除).如果剩余的部分超出整数能表示的范围，结果未知。
4.如果转换发生在相同的数值类型.整数-整数,浮点数-浮点数.转换是合法的.但是具体的值是多少由实现着指定(可能不具有移植性)。
某些转换可能会丢失精度，编译器会通知出现精度丢失，但是显式的转换不会出现通知。
对于非基本类型，数组和函数隐式转换成指针类型。指针之间转换根据以下规则
1.null指针允许转换成任意类型。
2.任何类型指针都能转换成void类型指针。
3.指针向上转换，派生类指针能够转换成任意基类指针，前提是没有const，volatile修饰。
在类的世界里，类的转换由以下三个成员函数控制。
1.只有一个参数的构造函数：允许从一个特定类型隐式转换来初始化对象。
2.赋值操作：允许在赋值的时候出现隐式转换。
3.类型转换操作：允许隐式转换一个特定类型。
// implicit conversion of classes: #include <iostream> using namespace std; class A {}; class B { public: // conversion from A (constructor): B (const A& x) {} // conversion from A (assignment): B& operator= (const A& x) {return *this;} // conversion to A (type-cast operator) operator A() {return A();} }; int main () { A foo; B bar = foo; // calls constructor bar = foo; // calls assignment foo = bar; // calls type-cast operator return 0; }
类型转换操作使用特殊的语法：它使用operator关键字后面跟上目标类型然后是一对圆括号。注意返回的是特定对象的类型，并且也没有在operator关键字之前指定。
在函数调用时，C++允许隐式转换参数，这可能会引起错误。比如下面这个函数(来自上面的例子)
void fn (B arg) {}
这个函数的参数类型是B，但是它可以用A来调用。
fn(foo)
我们可以在构造函数上使用explicit关键字消除这个影响。
// explicit: #include <iostream> using namespace std; class A {}; class B { public: explicit B (const A& x) {} B& operator= (const A& x) {return *this;} operator A() {return A();} }; void fn (B x) {} int main () { A foo; B bar (foo); bar = foo; foo = bar; // fn (foo); // not allowed for explicit ctor. fn (bar); return 0; }
另外，在使用explicit标记构造函数后，不能使用类似赋值的方法隐式调用构造函数。比如下面这个不允许。
B bar = foo;
类型转换函数也可以加上explicit关键字，效果和在构造函数上加一致。
foo = bar; //转换函数加上explicit后，这个调用是错误的.
C++是一个强类型语言.有许多类型转换不能隐式进行。特别是表示对值有不同解释的转换，这些类型转换都需要显示指定。
主要有俩种风格，函数型风格和C语言风格，如下。
double x = 10.3; int y; y = int (x); // functional notation y = (int) x; // c-like cast notation
函数风格转换满足大部分基本类型转换。但在类和指针转换到类的时候会混淆不清。这样容易引起运行时错误，比如下面这个代码，编译时没有任何错误。
// class type-casting #include <iostream> using namespace std; class Dummy { double i,j; }; class Addition { int x,y; public: Addition (int a, int b) { x=a; y=b; } int result() { return x+y;} }; int main () { Dummy d; Addition * padd; padd = (Addition*) &d; cout << padd->result(); return 0; }
程序声明一个指针指向Addition，但是它被赋值了一个不相关的对象。
padd = (Addition*) &d;
自由的显式类型转换允许一个指针类型转换成任何一个指针类型。上面的调用会导致一个运行时错误或者是一个不期望的结果。
为了控制这种不受控制的转换，我们新增了四种特定的类型转换。dynamic_cast，static_cast，reinterpret_cast，const_cast。
语法如下。
dynamic_cast <new_type> (expression) reinterpret_cast <new_type> (expression) static_cast <new_type> (expression) const_cast <new_type> (expression)
等价于传统的类型转换
(new_type) expression
new_type (expression)
但是以上的每一种类型转换都有自己独特的特点。
dynamic_cast仅能在指针或者引用上使用，当然也包含void*。它用来保证转换的目标类型是一个完全合法的类型。这个转换包括指针向上转换(基类指针转换成父类指针)，有时候这个也叫做隐式转换。同样，dynamic_cast也被用来实现向下转换，但也只是在多态类的时候。如下
// dynamic_cast #include <iostream> #include <exception> using namespace std; class Base { virtual void dummy() {} }; class Derived: public Base { int a; }; int main () { try { Base * pba = new Derived; Base * pbb = new Base; Derived * pd; pd = dynamic_cast<Derived*>(pba); if (pd==0) cout << "Null pointer on first type-cast.\n"; pd = dynamic_cast<Derived*>(pbb); if (pd==0) cout << "Null pointer on second type-cast.\n"; } catch (exception& e) {cout << "Exception: " << e.what();} return 0; }
Null pointer on second type-cast.
以上代码尝试执行俩次类型转换，都是从基类转换成子类，但是只有第一次是成功的。注意他们的初始化。
Base * pba = new Derived; Base * pbb = new Base;
虽然他们都是Base* 类型的指针，但是pba实际上指向的是Derived类型的指针，pbb的实际类型是Base*。因此当使用dynamic_cast转换的时候，pba成功了，因为pbb指向的是Base，不是一个完整的Delived对象，所以转换时失败。
当转换失败的时候，dynamic_cast返回一个null指针表示转换失败。如果dynamic_cast转换一个引用失败，将会抛出bad_cast类型的异常。
dynamic_cast同样也允许在指针上执行隐式转换，null指针在俩个类型之间转换(即使是没有任何关联的类型)，转换任何指针类型变成void* 类型指针。
static_cast在俩个相关类型之间执行转换,可以是往上转换，也可以是往下转换。转换时不执行任何运行时检查，因此也就不保证目标类型一定正确。所以，static_cast需要程序员保证转换是安全的。与dynamic_cast相比，static_cast转换更快。
class Base {}; class Derived: public Base {}; Base * a = new Base; Derived * b = static_cast<Derived*>(a);
这是一个合法的代码，但是b指向的对象不是一个完整的对象，所以运行时解引用会抛出一个错误。
static_cast同样也能用于隐式转换(不仅仅是指向对象的指针)。
1.把void*转换成任何类型的指针。这样的转换保证x->void*->x，即保证把void*转换成以前的类型。
2.转换数值，浮点数，枚举类型到枚举类型。
另外，static_cast也能在以下场景中使用。
1.显式调用只有一个参数的构造函数或者赋值操作。
2.转换成右值引用。
3.把enum转换成int或者float。
4.把任何类型转换成void，evaluating and discarding the value。
reinterpret_cast转换任意指针类型到其他指针类型，即使是不相关的类型也可以转换。它转换的结果仅仅只是复制二进制数据到目标类型，任何类型的转换都可以使用reinterpret_cast。它既不检查内容，也不检查类型。它可以把指针转换成一个数字或者把一个数字转换成指针。当把一个数字转换成指针时的结果由平台来决定。
它只保证把指针转换成数值时，数值的宽度可以完全包含指针的内容。同样，再次转换回指针时也是完全合法的指针。
通过interpret_cast，而不是static_cast来转换。这是一种根据类型来重新解释二进制数据的低级别操作。大多数场景下结果根据平台而定，因此也就是失去了可移植性。
class A { /* ... */ }; class B { /* ... */ }; A * a = new A; B * b = reinterpret_cast<B*>(a);
代码能编译，但是没有什么意义，因为a被转换成了一个完全不相关类型，当b解引用的时候是不安全的。
这个转换类型操作指针的常量属性，可能是添加常量属性，也可能是移除常量属性。比如下面这个为了传递一个常量指针到一个非常量指针。
// const_cast #include <iostream> using namespace std; void print (char * str) { cout << str << ‘\n‘; } int main () { const char * c = "sample text"; print ( const_cast<char *> (c) ); return 0; }
sample text
以上样例保证安全，因为函数没有写指针指向的内容。但是请注意。在移除指针的常量属性后进行写入操作，这个结果是未知的。
typeid (expression)
typeid检查表达式的类型，返回<typeinfo>头文件中定义的常量对象的引用。所有typeid的返回值可以通过==或者!=来比较，或者可以通过name()方法来返回类型名字。
// typeid #include <iostream> #include <typeinfo> using namespace std; int main () { int * a,b; a=0; b=0; if (typeid(a) != typeid(b)) { cout << "a and b are of different types:\n"; cout << "a is: " << typeid(a).name() << ‘\n‘; cout << "b is: " << typeid(b).name() << ‘\n‘; } return 0; }
a and b are of different types: a is: int * b is: int
typeid在类上使用时，它使用运行时类型信息来跟踪动态对象(RTTI)。如果在多态类上使用时，它返回子类的类型。
// typeid, polymorphic class #include <iostream> #include <typeinfo> #include <exception> using namespace std; class Base { virtual void f(){} }; class Derived : public Base {}; int main () { try { Base* a = new Base; Base* b = new Derived; cout << "a is: " << typeid(a).name() << ‘\n‘; cout << "b is: " << typeid(b).name() << ‘\n‘; cout << "*a is: " << typeid(*a).name() << ‘\n‘; cout << "*b is: " << typeid(*b).name() << ‘\n‘; } catch (exception& e) { cout << "Exception: " << e.what() << ‘\n‘; } return 0; }
a is: class Base * b is: class Base * *a is: class Base *b is: class Derived
注意，typeid返回类型的name()方法的结果，根据使用的编译器和库的不同而不同，它有可能不是一个简单的字符串。
注意typeid是怎么考虑指针类型（a和b指针的是Base* 类型）,当typeid在对象上使用时（*a和*b）,typeid返回的是动态类型（*a是Base类型,*b是Derived类型）。
如果传入的指针等于null，会抛出bad_typeid异常.
标签：== C++类型转换 inter 宽度 包含 short 基本数据 eva 操作
原文地址：https://www.cnblogs.com/shuiyonglewodezzzzz/p/11118205.html
