• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C++类型转换

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

隐式转换

在赋值给一个兼容类型会出现隐式类型转换.比如下面这个例子.

short a=2000;
int b;
b=a;

在以上例子中.值从short自动提升到int,这是标准转换。标准转换影响基本数据类型,它在类型数字类型之间(short to intint to floatdouble 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关键字之前指定。

explicit关键字

在函数调用时,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

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.

兼容提示: dynamic_cast需要运行时信息追踪动态类型。某些编译器这个功能默认是关闭的。为了保证dynamic_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在俩个相关类型之间执行转换,可以是往上转换,也可以是往下转换。转换时不执行任何运行时检查,因此也就不保证目标类型一定正确。所以,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转换任意指针类型到其他指针类型,即使是不相关的类型也可以转换。它转换的结果仅仅只是复制二进制数据到目标类型,任何类型的转换都可以使用reinterpret_cast。它既不检查内容,也不检查类型。它可以把指针转换成一个数字或者把一个数字转换成指针。当把一个数字转换成指针时的结果由平台来决定。

它只保证把指针转换成数值时,数值的宽度可以完全包含指针的内容。同样,再次转换回指针时也是完全合法的指针。

通过interpret_cast,而不是static_cast来转换。这是一种根据类型来重新解释二进制数据的低级别操作。大多数场景下结果根据平台而定,因此也就是失去了可移植性。

class A { /* ... */ };
class B { /* ... */ };
A * a = new A;
B * b = reinterpret_cast<B*>(a);

代码能编译,但是没有什么意义,因为a被转换成了一个完全不相关类型,当b解引用的时候是不安全的。

const_cast

这个转换类型操作指针的常量属性,可能是添加常量属性,也可能是移除常量属性。比如下面这个为了传递一个常量指针到一个非常量指针。

// 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

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异常.


鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
跨平台网络库(采用C++11)发布时间:2022-07-13
下一篇:
C#写的笔记管理软件发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap