static_cast - CSDN
static_cast 订阅
static_cast是一个c++运算符,功能是把一个表达式转换为某种类型,但没有运行时类型检查来保证转换的安全性。 展开全文
static_cast是一个c++运算符,功能是把一个表达式转换为某种类型,但没有运行时类型检查来保证转换的安全性。
信息
类    型
C++ static_cast
分    类
强制类型转换
中文名
暂无
外文名
static_cast
static_cast用法
static_cast ( expression )
收起全文
  • static_cast用法

    万次阅读 2012-07-03 15:54:38
    用法:static_cast ( expression )  该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:  ①用于类层次结构中基类(父类)和派生类(子类)之间指针...

      用法:static_cast < type-id > ( expression )
      该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:
      ①用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。
      进行上行转换(把派生类的指针或引用转换成基类表示)是安全的;
      进行下行转换(把基类指针或引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
      ②用于基本数据类型之间的转换,如把int转换成char,把int转换成enum。这种转换的安全性也要开发人员来保证。
      ③把空指针转换成目标类型的空指针。
      ④把任何类型的表达式转换成void类型。
      注意:static_cast不能转换掉expression的const、volatile、或者__unaligned属性。
      C++中static_cast和reinterpret_cast的区别
      C++primer第五章里写了编译器隐式执行任何类型转换都可由static_cast显示完成;reinterpret_cast通常为操作数的位模式提供较低层的重新解释
      1、C++中的static_cast执行非多态的转换,用于代替C中通常的转换操作。因此,被做为隐式类型转换使用。比如:
      int i;
      float f = 166.7f;
      i = static_cast<int>(f);
      此时结果,i的值为166。
      2、C++中的reinterpret_cast主要是将数据从一种类型的转换为另一种类型。所谓“通常为操作数的位模式提供较低层的重新解释”也就是说将数据以二进制存在形式的重新解释。比如:
      int i;
      char *p = "This is a example.";
      i = reinterpret_cast<int>(p);

      此时结果,i与p的值是完全相同的。reinterpret_cast的作用是说将指针p的值以二进制(位模式)的方式被解释为整型,并赋给i,//i 也是指针,整型指针;一个明显的现象是在转换前后没有数位损失。


    展开全文
  • C风格的强制转换较简单,如将float a转换为int b,则可以这样:b = (int)a,或者b=int(a)。 C++类型转换分为隐式类型转换和显示类型转换。 隐式类型转换又称为标准转换,包括以下几种情况: ...

    C风格的强制转换较简单,如将float a转换为int b,则可以这样:b = (int)a,或者b=int(a)。

    C++类型转换分为隐式类型转换和显示类型转换。

    隐式类型转换又称为标准转换,包括以下几种情况:

    (1)、算术转换:在混合类型的算术表达式中,最宽的数据类型成为目标转换类型;

    (2)、一种类型表达式赋值给另一种类型的对象:目标类型是被赋值对象的类型;

    (3)、将一个表达式作为实参传递给函数调用,此时形参和实参类型不一致:目标转换类型为形参的类型;

    (4)、从一个函数返回一个表达式,表达式类型与返回类型不一致:目标转换类型为函数的返回类型。

    显示类型转换被称为强制类型转换(cast)。

    C++提供了四种强制类型转换形式:static_cast、const_cast、dynamic_cast、reinterpret_cast.每一种适用于特定的场合。

    static_cast语法:static_cast<type-id>(expression)

    static_cast:仅根据表达式中存在的类型,将expression转换为type-id类型。此运算符可用于将指向基类的指针转换为指向派生类的指针等操作。此类转换并非始终安全。

    通常使用 static_cast 转换数值数据类型,例如将枚举型转换为整型或将整型转换为浮点型,而且你能确定参与转换的数据类型。 static_cast转换安全性不如dynamic_cast转换,因static_cast不执行运行时类型检查,而dynamic_cas执行该检查。对不明确的指针的 dynamic_cast将失败,而static_cast的返回结果看似没有问题,这是危险的。尽管 dynamic_cast转换更加安全,但是dynamic_cast只适用于指针或引用,而且运行时类型检查也是一项开销。dynamic_cast 和static_cast运算符可以在整个类层次结构中移动指针。然而,static_cast完全依赖于转换语句提供的信息,因此可能不安全。

    static_cast可以反向执行隐式转换,可用于任何隐式允许的转换类型,而在这种情况下结果是不确定的。这需要程序员来验证static_cast转换的结果是否安全。

    static_cast可用于将int转换为char。但是,得到的char可能没有足够的位来保存整个int值。同样,这需要程序员来验证static_cast转换的结果是否安全。

    static_cast运算符还可用于执行任何隐式转换,包括标准转换和用户定义的转换。

    static_cast 运算符可以将整数值显式转换为枚举类型。如果整型值不在枚举值的范围内,生成的枚举值是不确定的。

    static_cast运算符将null指针值转换为目标类型的null指针值。

    任何表达式都可以通过static_cast运算符显式转换为void类型。目标void类型可以选择性地包含const、volatile或__unaligned特性。

    static_cast运算符无法转换掉const、volatile或 __unaligned特性。

    只有在确信代码将正常运行的时候,在性能关键代码中使用 static_cast。如果必须在发布模式下使用static_cast,请在调试版本中用 safe_cast(C++ 组件扩展)替换它以确保成功。

    任何具有明确定义的类型转换,只要不包含底层const,都可以使用static_cast。

    const_cast语法:const_cast<type-id>(expression)

    const_cast:从类中移除const、volatile和__unaligned特性。

    指向任何对象类型的指针或指向数据成员的指针可显式转换为完全相同的类型(const、volatile 和 __unaligned 限定符除外)。对于指针和引用,结果将引用原始对象。对于指向数据成员的指针,结果将引用与指向数据成员的原始(未强制转换)的指针相同的成员。根据引用对象的类型,通过生成的指针、引用或指向数据成员的指针的写入操作可能产生未定义的行为。

    不能使用const_cast运算符直接重写常量变量的常量状态。

    const_cast运算符将null指针值转换为目标类型的null指针值。

    dynamic_cast语法:dynamic_cast<type-id>(expression)

    dynamic_cast:type-id必须是一个指针或引用到以前已定义的类类型的引用或“指向 void的指针”。如果type-id是指针,则expression的类型必须是指针,如果type-id是引用,则为左值。

    在托管代码中的 dynamic_cast的行为中有两个重大更改:(1)、为指针的dynamic_cast对指向装箱的枚举的基础类型的指针将在运行时失败,则返回0而不是已转换的指针。(2)、dynamic_cast 将不再引发一个异常,当type-id是指向值类型的内部指针,则转换在运行时失败。该转换将返回0指示运行值而不是引发。

    如果type-id是指向expression的明确的可访问的直接或间接基类的指针,则结果是指向type-id类型的唯一子对象的指针。

    如果type-id为void*,则做运行时进行检查确定expression的实际类型。结果是指向byexpression的完整的对象的指针。

    如果type-id不是 void*,则做运行时进行检查以确定是否由expression指向的对象可以转换为由type-id指向的类型。如果expression类型是type-id类型的基类,则做运行时检查来看是否expression确实指向type-id类型的完整对象。如果为true,则结果是指向type-id类型的完整对象的指针。

    dynamic_cast运算符还可以使用执行“相互转换”。使用同一个类层次结构可能进行指针转换。

    当使用dynamic_cast时,如果expression无法安全地转换成类型type-id,则运行时检查会引起变换失败。

    指针类型的非限定转换的值是null指针。引用类型的非限定转换会引发bad_cast异常。

    dynamic_cast支持运行时类型识别。

    reinterpret_cast语法:reinterpret_cast<type-id>(expression)

    reinterpret_cast:允许将任何指针转换为任何其他指针类型。也允许将任何整数类型转换为任何指针类型以及反向转换。

    滥用reinterpret_cast运算符可能很容易带来风险。除非所需转换本身是低级别的,否则应使用其他强制转换运算符之一。

    reinterpret_cast运算符可用于char*到int*或One_class*到Unrelated_class*之类的转换,这本身并不安全。

    reinterpret_cast的结果不能安全地用于除强制转换回其原始类型以外的任何用途。在最好的情况下,其他用途也是不可移植的。

    reinterpret_cast运算符不能丢掉const、volatile或__unaligned特性。

    reinterpret_cast运算符将null指针值转换为目标类型的null指针值。

    reinterpret_cast的一个实际用途是在哈希函数中,即,通过让两个不同的值几乎不以相同的索引结尾的方式将值映射到索引。

    reinterpret_cast通常为运算对象的位模式提供较低层次上的重新解释。reinterpret_cast本质上依赖机器。要想安全地使用reinterpret_cast必须对涉及的类型和编译器实现转换的过程都非常了解。

    static_cast is the first cast you should attempt to use. It does things like implicit conversions between types (such as int to float, or pointer to void*), and it can also call explicit conversion functions (or implicit ones). In many cases,explicitly stating static_cast isn't necessary, but it's important to note that the T(something) syntax is equivalent to (T)something and should be avoided(more on that later). A T(something, something_else) is safe, however, and guaranteed to call the constructor.

    static_cast can also cast through inheritance hierarchies. It is unnecessary when casting upwards (towards a base class), but when casting downwards it can be used as long as it doesn't cast through virtual inheritance. It does not do checking,however, and it is undefined behavior to static_cast down a hierarchy to a type that isn't actually the type of the object.

    const_cast can be used to remove or add const to a variable; no other C++ cast is capable of removing it (not even reinterpret_cast). It is important to note that modifying a formerly const value is only undefined if the original variable is const; if you use it to take the const off a reference to something that wasn't declared with const, it is safe. This can be useful when overloading member functions based on const, for instance. It can also be used to add const to an object,such as to call a member function overload.

    const_cast also works similarly on volatile, though that's less common.

    dynamic_cast is almost exclusively used for handling polymorphism. You can cast a pointer or reference to any polymorphic type to any other class type (a polymorphic type has at least one virtual function, declared or inherited). You can use it for more than just casting downwards -- you can cast sideways or even up another chain. The dynamic_cast will seek out the desired object and return it if possible. If it can't, it will return nullptr in the case of a pointer, or throw std::bad_cast in the case of a reference.

    dynamic_cast has some limitations, though. It doesn't work if there are multiple objects of the same type in the inheritance hierarchy (the so-called 'dreaded diamond') and you aren't using virtual inheritance. It also can only go through public inheritance - it will always fail to travel through protected or private inheritance. This is rarely an issue, however, as such forms of inheritance are rare.

    reinterpret_cast is the most dangerous cast, and should be used very sparingly. It turns one type directly into another - such as casting the value from one pointer to another, or storing a pointer in an int, or all sorts of other nasty things.Largely, the only guarantee you get with reinterpret_cast is that normally if you cast the result back to the original type, you will get the exact same value (but not if the intermediate type is smaller than the original type).There are a number of conversions that reinterpret_cast cannot do, too. It's used primarily for particularly weird conversions and bit manipulations, like turning a raw data stream into actual data, or storing data in the low bits of an aligned pointer.

    C casts are casts using (type)object or type(object). A C-style cast is defined as the first of the following which succeeds:(1)、const_cast; (2)、static_cast(though ignoring access restrictions); (3)、static_cast (see above), then const_cast; (4)、reinterpret_cast; (5)、reinterpret_cast, then const_cast。

    It can therefore be used as a replacement for other casts in some instances, but can be extremely dangerous because of the ability to devolve into a reinterpret_cast,and the latter should be preferred when explicit casting is needed, unless you are sure static_cast will succeed or reinterpret_cast will fail. Even then,consider the longer, more explicit option.

    C-style casts also ignore access control when performing a static_cast, which means that they have the ability to perform an operation that no other cast can. This is mostly a kludge, though, and in my mind is just another reason to avoid C-style casts.

    测试代码如下:

    static_cast.hpp:

    #ifndef FBC_MESSY_TEST_STATIC_CAST_HPP_
    #define FBC_MESSY_TEST_STATIC_CAST_HPP_
    
    #include <iostream>
    
    // reference: https://msdn.microsoft.com/zh-cn/library/c36yw7x9.aspx
    class B1 {
    public:
    	virtual void Test(){}
    };
    
    class D1 : public B1 {};
    
    class CCTest {
    public:
    	void setNumber(int);
    	void printNumber() const;
    private:
    	int number;
    };
    
    class B2 { };
    class C2 : public B2 { };
    class D2 : public C2 { };
    
    class A3 { virtual void f(); };
    class B3 { virtual void f(); };
    
    class B4 { virtual void f(); };
    class D4 : public B4 { virtual void f(); };
    
    // Returns a hash code based on an address
    unsigned short Hash(void *p);
    
    void test_static_cast1();
    void test_static_cast2(B1* pb, D1* pd);
    void test_static_cast3(B1* pb);
    void test_static_cast4();
    void test_static_cast5();
    void test_static_cast6();
    void test_static_cast7();
    void test_static_cast8();
    void test_static_cast9();
    void test_static_cast10();
    
    #endif // FBC_MESSY_TEST_STATIC_CAST_HPP_

    static_cast.cpp:

    #include "static_cast.hpp"
    #include <iostream>
    
    void CCTest::setNumber(int num) { number = num; }
    
    void CCTest::printNumber() const {
    	std::cout << "\nBefore: " << number;
    	//this 指针的数据类型为 const CCTest *。
    	//const_cast 运算符会将 this 指针的数据类型更改为 CCTest *,以允许修改成员 number。
    	//强制转换仅对其所在的语句中的其余部分持续
    	const_cast< CCTest * >(this)->number--;
    	std::cout << "\nAfter: " << number;
    }
    
    void A3::f()
    {
    
    }
    
    void B3::f()
    {
    
    }
    
    void B4::f()
    {
    
    }
    
    void D4::f()
    {
    
    }
    
    unsigned short Hash(void *p) {
    	//reinterpret_cast 允许将指针视为整数类型。结果随后将按位移位并与自身进行“异或”运算以生成唯一的索引(具有唯一性的概率非常高)。
    	//该索引随后被标准 C 样式强制转换截断为函数的返回类型。
    	unsigned int val = reinterpret_cast<unsigned int>(p);
    	return (unsigned short)(val ^ (val >> 16));
    }
    
    // C风格强制类型转换
    void test_static_cast1()
    {
    	float a = 1.1, b = 1.9;
    
    	int ret1 = (int)a;
    	int ret2 = int(b);
    
    	std::cout << ret1 << "    " << ret2 << "    " << std::endl;
    }
    
    void test_static_cast2(B1* pb, D1* pd)
    {
    	//与 dynamic_cast 不同,pb 的 static_cast 转换不执行运行时检查。
    	//由 pb 指向的对象可能不是 D 类型的对象,在这种情况下使用 *pd2 会是灾难性的。
    	//例如,调用 D 类(而非 B 类)的成员函数可能会导致访问冲突。
    	D1* pd2 = static_cast<D1*>(pb);   // Not safe, D can have fields and methods that are not in B.
    	B1* pb2 = static_cast<B1*>(pd);   // Safe conversion, D always contains all of B.
    }
    
    void test_static_cast3(B1* pb)
    {
    	//如果 pb 确实指向 D 类型的对象,则 pd1 和 pd2 将获取相同的值。如果 pb == 0,它们也将获取相同的值。
    	//如果 pb 指向 B 类型的对象,而非指向完整的 D 类,则 dynamic_cast 足以判断返回零。
    	//但是,static_cast 依赖于程序员的断言,即 pb 指向 D 类型的对象,因而只是返回指向那个假定的 D 对象的指针。
    	D1* pd1 = dynamic_cast<D1*>(pb);
    	D1* pd2 = static_cast<D1*>(pb);
    }
    
    void test_static_cast4()
    {
    	char ch;
    	int i = 65;
    	float f = 2.5;
    	double dbl;
    
    	ch = static_cast<char>(i);   // int to char
    	dbl = static_cast<double>(f);   // float to double
    	i = static_cast<int>(ch);
    }
    
    void test_static_cast5()
    {
    	CCTest X;
    	X.setNumber(8);
    	X.printNumber();
    }
    
    void test_static_cast6(D2* pd)
    {
    	//此转换类型称为“向上转换”,因为它将在类层次结构上的指针,从派生的类移到该类派生的类。向上转换是一种隐式转换。
    	C2* pc = dynamic_cast<C2*>(pd);   // ok: C is a direct base class pc points to C subobject of pd 
    	B2* pb = dynamic_cast<B2*>(pd);   // ok: B is an indirect base class pb points to B subobject of pd
    }
    
    void test_static_cast7()
    {
    	A3* pa = new A3;
    	B3* pb = new B3;
    	void* pv = dynamic_cast<void*>(pa);// pv now points to an object of type A
    	pv = dynamic_cast<void*>(pb);// pv now points to an object of type B
    }
    
    void test_static_cast8()
    {
    	B4* pb = new D4;   // unclear but ok
    	B4* pb2 = new B4;
    
    	//此转换类型称为“向下转换”,因为它将在类层次结构下的指针,从给定的类移到该类派生的类。
    	D4* pd = dynamic_cast<D4*>(pb);   // ok: pb actually points to a D
    	D4* pd2 = dynamic_cast<D4*>(pb2);   // pb2 points to a B not a D
    }
    
    void test_static_cast9()
    {
    	A3* pa = new A3;
    	B3* pb = dynamic_cast<B3*>(pa);   // fails at runtime, not safe;B not derived from A
    }
    
    void test_static_cast10()
    {
    	int a[20];
    	for (int i = 0; i < 20; i++) {
    		std::cout << Hash(a + i) << std::endl;
    	}
    }
    

    主要参考文献:

    1. https://msdn.microsoft.com/zh-cn/library/c36yw7x9.aspx

    2. http://en.cppreference.com/w/cpp/language/static_cast 

    3. http://stackoverflow.com/questions/332030/when-should-static-cast-dynamic-cast-const-cast-and-reinterpret-cast-be-used 

    GitHubgithub.com/fengbingchun/Messy_Test

    展开全文
  • static_cast和dynamic_cast详解

    万次阅读 多人点赞 2018-04-06 22:59:50
    类继承关系图注:从图中可以看出,派生类不仅有自己的方法和属性,同时它还包括从父类继承来的方法和属性。当我们从派生类向基类转换时,不管用传统的c语言还是c++转换方式都可以百分百转换成功。...

    类继承关系图

    这里写图片描述

    注:从图中可以看出,派生类不仅有自己的方法和属性,同时它还包括从父类继承来的方法和属性。当我们从派生类向基类转换时,不管用传统的c语言还是c++转换方式都可以百分百转换成功。但是可怕是向下转换类型,也就是我们从基类向派生类转换,当我们采用传统的C语言和c++转换时,就会出现意想不到的情况,因为转换后派生类自己的方法和属性丢失了,一旦我们去调用派生类的方法和属性那就糟糕了,这就是对类继承关系和内存分配理解不清晰导致的。好在c++增加了static_cast和dynamic_cast运用于继承关系类间的强制转化

    一、static_cast和dynamic_cast使用方式

    static_cast< new_type >(expression)
    dynamic_cast< new_type >(expression)
    备注new_type为目标数据类型,expression为原始数据类型变量或者表达式。

    二、static_cast详解:

    static_cast相当于传统的C语言里的强制转换,该运算符把expression转换为new_type类型,用来强迫隐式转换如non-const对象转为const对象,编译时检查,用于非多态的转换,可以转换指针及其他,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法:

    用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换
    进行上行转换(把派生类的指针或引用转换成基类表示)是安全的;
    进行下行转换(把基类指针或引用转换成派生类表示)时,由于没有动态类型检查,所以是不安全的。
    用于基本数据类型之间的转换,如把int转换成char,把int转换成enum
    把空指针转换成目标类型的空指针
    把任何类型的表达式转换成void类型
    注意:static_cast不能转换掉expression的const、volatile、或者__unaligned属性

    基本类型数据转换举例如下:

    char a = 'a';
    int b = static_cast<char>(a);//正确,将char型数据转换成int型数据
    
    double *c = new double;
    void *d = static_cast<void*>(c);//正确,将double指针转换成void指针
    
    int e = 10;
    const int f = static_cast<const int>(e);//正确,将int型数据转换成const int型数据
    
    const int g = 20;
    int *h = static_cast<int*>(&g);//编译错误,static_cast不能转换掉g的const属性

    类上行和下行转换:

    class Base
    {};
    
    class Derived : public Base
    {}
    
    Base* pB = new Base();
    if(Derived* pD = static_cast<Derived*>(pB))
    {}//下行转换是不安全的(坚决抵制这种方法)
    
    Derived* pD = new Derived();
    if(Base* pB = static_cast<Base*>(pD))
    {}//上行转换是安全的

    三、dynamic_cast详解:

    转换方式:
    dynamic_cast< type* >(e)
     type必须是一个类类型且必须是一个有效的指针
    dynamic_cast< type& >(e)
    type必须是一个类类型且必须是一个左值
    dynamic_cast< type&& >(e)
    type必须是一个类类型且必须是一个右值

    e的类型必须符合以下三个条件中的任何一个:
    1、e的类型是目标类型type的公有派生类
    2、e的类型是目标type的共有基类
    3、e的类型就是目标type的类型。

    如果一条dynamic_cast语句的转换目标是指针类型并且失败了,则结果为0。如果转换目标是引用类型并且失败了,则dynamic_cast运算符将抛出一个std::bad_cast异常(该异常定义在typeinfo标准库头文件中)。e也可以是一个空指针,结果是所需类型的空指针。

    dynamic_cast主要用于类层次间的上行转换下行转换,还可以用于类之间的交叉转换(cross cast)。

    在类层次间进行上行转换时,dynamic_cast和static_cast的效果是一样的;在进行下行转换时,dynamic_cast具有类型检查的功能,比static_cast更安全。dynamic_cast是唯一无法由旧式语法执行的动作,也是唯一可能耗费重大运行成本的转型动作。

    (1)指针类型
    举例,Base为包含至少一个虚函数的基类,Derived是Base的共有派生类,如果有一个指向Base的指针bp,我们可以在运行时将它转换成指向Derived的指针,代码如下:

    if(Derived *dp = dynamic_cast<Derived *>(bp)){
      //使用dp指向的Derived对象  
    }
    else{
      //使用bp指向的Base对象  
    }

    值得注意的是,在上述代码中,if语句中定义了dp,这样做的好处是可以在一个操作中同时完成类型转换和条件检查两项任务。

    (2)引用类型

    因为不存在所谓空引用,所以引用类型的dynamic_cast转换与指针类型不同,在引用转换失败时,会抛出std::bad_cast异常,该异常定义在头文件typeinfo中。

    void f(const Base &b){
     try{
       const Derived &d = dynamic_cast<const Base &>(b);  
       //使用b引用的Derived对象
     }
     catch(std::bad_cast){
       //处理类型转换失败的情况
     }
    }

    四、转换注意事项:

    尽量少使用转型操作,尤其是dynamic_cast,耗时较高,会导致性能的下降,尽量使用其他方法替代。

    展开全文
  • static_cast

    2018-10-13 10:10:19
    #include &lt;iostream&gt; #include &lt;string&gt; using namespace std; class ANIMAL { public: ANIMAL() :_type("ANIMAL"){}; virtual void OutPutname(){ cout &... string _t...
    #include <iostream>
    #include <string>
    using namespace std;
    
    class ANIMAL
    {
    public:
    	ANIMAL() :_type("ANIMAL"){};
    	virtual void OutPutname(){ cout << "ANIMAL"; };
    private:
    	string _type;
    };
    
    class DOG :public ANIMAL
    {
    public:
    	DOG() :_name("大黄"), _type("DOG"){};
    	void OutPutname(){ cout << _name; };
    	void OutPuttype(){ cout << _type; };
    private:
    	string _name;
    	string _type;
    };
    
    int main()
    {
    	//基类指针转为派生类指针,且该基类指针指向基类对象。
    	ANIMAL * ani1 = new ANIMAL;
    	DOG * dog1 = static_cast<DOG*>(ani1);
    	dog1->OutPutname();
    	//dog1->OutPuttype();//错误,在ANIMAL类型指针不能调用方法OutPutType();在运行时出现错误。
    
    	//基类指针转为派生类指针,且该基类指针指向派生类对象
    	ANIMAL * ani3 = new DOG;
    	DOG* dog3 = static_cast<DOG*>(ani3);
    	dog3->OutPutname(); //正确, 结果输出为大黄
    
    	//子类指针转为派生类指针
    	DOG *dog2 = new DOG;
    	ANIMAL *ani2 = static_cast<DOG*>(dog2);
    	ani2->OutPutname(); //正确,结果输出为大黄
    
    	//
    	system("pause");
    
    }

    展开全文
  • static_cast用法浅析

    万次阅读 2015-04-10 14:55:28
    用法:static_cast ( expression ) 一般来说,编译器隐式执行的任何类型转换都可以由static_cast显式完成。static_cast可以用来将枚举类型转换成整型,或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向...
  • static_cast 用法

    千次阅读 2018-04-11 16:32:29
    https://blog.csdn.net/moruihong用法:static_cast &lt; type-id &gt; ( expression ) 该运算符把expression转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法: ①用于...
  • static_cast的用法

    2019-08-23 21:47:18
    static_cast在C++中用于将表达式的值转换为指定的类型,但没有运行时类型检查来保证转换的安全性。 主要有以下用法: (1)用于类层次结构中基类(父类)和派生类(子类)之间指针或引用的转换。 (2)用于基本数据...
  • 首先回顾一下C++类型转换: C++类型转换分为:隐式类型转换和显式类型转换 第1部分.... 包括以下几种情况: ... 1) 算术转换(Arithmetic conversion) : 在混合类型的算术表达式中, 最宽的数据类型成为目标转换类型。...
  • 1.static_cast 用于将参数转换为指定类型。需要注意的是,进行类型转换时,编译器不会进行类型检查保证安全性。当对类对象进行下行类型转换时,也不会进行动态类型检查,因此是不安全的。static_cast中提供了空指针...
  • Qt 中static_cast 和 reinterpret_cast的区别

    千次阅读 2019-02-19 16:26:48
    Qt 中static_cast 和 reinterpret_cast的区别 1. C++中的static_cast执行非多态的转换,用于代替C中通常的转换操作。因此,常做为隐式类型转换使用。比如: int i;  float f = 166.7f;  i = static_cast...
  • c++除了能使用c语言的强制类型转换外,还新增了四种强制类型转换:static_cast、dynamic_cast、const_cast、reinterpret_cast,主要运用于继承关系类间的强制转化,语法为: 强制类型转换运算符 <要转换到的类型&...
  • C++中static_cast和dynamic_cast强制类型转换

    万次阅读 多人点赞 2017-03-16 09:02:09
    最近在编程过程中了解到C++类型的层次转换(这就涉及到了多态和继承的相关概率),通常C语言中可以对内置类型进行强制转换,但是这样做不是很安全,在C++标准中,提供了关于类型层次转换中的两个关键字static_cast和...
  • 1.static_cast在编译时期强制转换,dynamic_cast在运行时期转换(较安全)    2.static_cast是c语言的强制转换代替品;dynamic_cast会运行时检查该转换是否类型安全,只在多态类型时合法,即该类至少具有一个虚拟方法...
  •  char *q = static_cast&lt;char*&gt;(cp); //错误:static_cast不能转换掉const性质static_cast&lt;string&gt;(cp); //正确:字符串字面值转换成string类型const_cast&lt;string&gt;(cp);...
  • const_cast,dynamic_cast,reinterpret_cast,static_cast四种转换的区别一,const_cast一,dynamic_cast一,reinterpret_cast一,static_cast C++是一种强类型语言,对类型的检查非常严格,我们可以使用C语言中的...
  • static_cast和dynamic_cast的区别

    千次阅读 2018-09-10 10:42:30
    3.1 static_cast 用法:static_cast &lt; type-id &gt; ( exdivssion )  该运算符把exdivssion转换为type-id类型,但没有运行时类型检查来保证转换的安全性。它主要有如下几种用法: ①用于类层次结构中...
  • C++:static_cast

    2015-08-04 15:46:18
    static_cast一般用来将枚举类型转换成整型,或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向子类的指针。做这些转换前,你必须确定要转换的数据确实是目标类型的数据,因为static_cast不做运行时的类型...
  • static_cast一般用来将枚举类型转换成整型,或者整型转换成浮点型。也可以用来将指向父类的指针转换成指向子类的指针。做这些转换前,你必须确定要转换的数据确实是目标类型的数据,因为static_cast不做运行时的类型...
  • static_cast&amp;lt;&amp;gt;() 静态类型转换,编译的时 c++编译器会做类型检查; 基本类型能转换 但是不能转换指针类型 若不同类型之间,进行强制类型转换,用 reinterpret_cast&amp;lt;&amp;...
  • C++的static_cast等转换

    2019-01-15 10:54:15
    static_cast: 在功能上基本上与C风格的类型转换一样强大,含义也一样。它也有功能上限制。例如,你不能用static_cast象用C风格的类型转换一样把struct转换成int类型或者把double类型转换成指针类型,另外,static_...
1 2 3 4 5 ... 20
收藏数 114,077
精华内容 45,630
热门标签
关键字:

static_cast