C++新式转型之static_cast

绝地灬酷狼 2022-06-12 01:18 154阅读 0赞

用来强迫隐式转换(implict conversions)，例如将non-const对象转为const对象，将int转为double。他也可以用来执行上述多种转换的反向转换，例如将void\*转换为typed指针，将pointer-to-base转为pointer-to-derived(downcast)。但他无法将const转为non-const(const\_cast)

依然参考cppreference，不牵涉到类型检查，比dynamic\_cast要好理解了。

> ***1) If there is an implicit conversion sequence from expression to new\_type, or if overload resolution for a direct initialization of an object or reference of type new\_type from expression would find at least one viable function, then static\_cast(expression) returns the imaginary variable Temp initialized as if by new\_type Temp(expression);, which may involve implicit conversions, a call to the constructor of new\_type or a call to a user-defined conversion operator.***

强制隐式转换，转换时会调用构造器、或者调用用户定义的转换操作符，这种方式，跟C风格的类型转换颇为相似。

int main()
    {
        int a = 65;//大写字母A的ASCII码
        char c = static_cast<char>(a);
        cout << c << endl;//输出A
        return 0;
    }

--------------------

***2) If new\_type is a pointer or reference to some class D and the type of expression is a pointer or reference to its non-virtual base B, static\_cast performs a downcast. This downcast is ill-formed if B is ambiguous, inaccessible, or virtual base (or a base of a virtual base) of D. Such static\_cast makes no runtime checks to ensure that the object’s runtime type is actually D, and may only be used safely if this precondition is guaranteed by other means, such as when implementing static polymorphism. Safe downcast may be done with dynamic\_cast.***

static\_cast也可以执行downcast操作，即，将基类指针转化为派生类指针，但这样的操作往往是危险的，因为它不做运行时检查。static\_cast返回结果看似没有问题，因为基类对象往往是派生类对象的subobject，派生类有可能包含基类不包含的域：

class B {};  
    
    class D : public B {};  
    
    void f(B* pb, D* pd) {  
    //downcast
       D* pd2 = static_cast<D*>(pb);   // Not safe, D can have fields  
                                       // and methods that are not in B.  
    
      //upcast: safe
       B* pb2 = static_cast<B*>(pd);   // Safe conversion, D always  
                                       // contains all of B.  
    }

--------------------

> ***3) If new\_type is an rvalue reference type, static\_cast converts the value of glvalue, class prvalue, or array prvalue (until C++17)any lvalue (since C++17) expression to xvalue referring to the same object as the expression, or to its base sub-object (depending on new\_type). If the target type is an inaccessible or ambiguous base of the type of the expression, the program is ill-formed. If the expression is a bit field lvalue, it is first converted to prvalue of the underlying type. This type of static\_cast is used to implement move semantics in std::move.***

`static_cast<T&&>(t)`将t表达式转换成一个右值引用：

int a = 10;
    int &&ra = static_cast<int&&>(a);

用`static_cast`来实现`std::move`中函数，直接看`std::move`源码

template<typename _Tp>  
      inline typename std::remove_reference<_Tp>::type&&  
      move(_Tp&& __t)  
      { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

关于`std::move`具体解析，参见：[C++ std::move和std::forward源码分析][C_ std_move_std_forward]

--------------------

> ***4) If new\_type is the type void (possibly cv-qualified), static\_cast discards the value of expression after evaluating it.***

将表达式转化为`void`类型，如若此做，表达式的值将被丢弃。该表达式也可以是`cv-qualified`

void func(const int& a)
    {
        return static_cast<void>(a);
    }

--------------------

> ***5) If a standard conversion sequence from new\_type to the type of expression exists, that does not include lvalue-to-rvalue, array-to-pointer, function-to-pointer, null pointer, null member pointer, function pointer, (since C++17) or boolean conversion, then static\_cast can perform the inverse of that implicit conversion.***

static\_cast可以执行反向的隐式转换，除了某些情况以外。比如static\_cast可以将左值引转成右值却不能反过来。

int main()
    {
        int &b = static_cast<int&>(10);//error inverse of lvalue-to-rvalue
        int n = 10;
        int &&a = static_cast<int &&>(n);// ok lvalue-to-rvalue
    }

--------------------

> ***6) If conversion of expression to new\_type involves lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion, it can be performed explicitly by static\_cast.***

跟5)类似，可以用`static_cast`将左值转成右值，将数组转指针，函数转指针。这些可以显示地用`static_cast`来表示

void func(int a)
    {
        cout << a << endl;
    }
    typedef void(*pFunc)(int);
    int main()
    {
        pFunc p = static_cast<pFunc>(func);
        p(10);
    }

--------------------

> ***7) Scoped enumeration type can be converted to an integer or floating-point type. When the target type is cv bool, the result is false if the original value is zero and true for all other values. For the remaining integral types, the result is the value of the enum if it can be represented by the target type and unspecified otherwise. (since C++11)***  
> ***8) Integer, floating-point, or enumeration type can be converted to any complete enumeration type. The result is unspecified (until C++17)undefined behavior (since C++17) if the value of expression, converted to the enumeration’s underlying type, is out of range (if the underlying type is fixed, the range is the range of the type. If the underlying type is not fixed, the range is all values possible for the smallest bit field large enough to hold all enumerators of the target enumeration)***

7)和8)枚举相关，可以将枚举类型转成整型，或者将枚举类型1转成枚举类型2

--------------------

> ***9) A pointer to member of some class D can be upcast to a pointer to member of its unambiguous, accessible base class B. This static\_cast makes no checks to ensure the member actually exists in the runtime type of the pointed-to object.***

指向类成员的指针可以向上转型成基类的成员指针，这里的pointer-to-member的用法如下：

#include <iostream>
    using namespace std;
    
    class Car
    {
        public:
        int speed;
    };
    
    int main()
    {
        int Car::*pSpeed = &Car::speed;
    
        Car c1;
        c1.speed = 1;       // direct access
        cout << "speed is " << c1.speed << endl;
        c1.*pSpeed = 2;     // access via pointer to member
        cout << "speed is " << c1.speed << endl;
        return 0;
    }

本条中的示例：

struct B {
        int m = 0;
        void hello() const {
            std::cout << "Hello world, this is B!\n";
        }
    };
    struct D : B {
        void hello() const {
            std::cout << "Hello world, this is D!\n";
        }
    };
    
    
    int main()
    {
    
        // static downcast
        D d;
        B& br = d; // upcast via implicit conversion
        // pointer to member upcast
        int D::*pm = &D::m;
        std::cout << br.*static_cast<int B::*>(pm) << '\n';
        system("pause");
        return 0;
    }

--------------------

***10) A prvalue of type pointer to void (possibly cv-qualified) can be converted to pointer to any type. If the value of the original pointer satisfies the alignment requirement of the target type, then the resulting pointer value is unchanged, otherwise it is unspecified. Conversion of any pointer to pointer to void and back to pointer to the original (or more cv-qualified) type preserves its original value.***

将指针转成void\*再转回去，将保持原值。

int main()
    {
        int a = 65;
        void * pa = &a;
        //void * to any type
        char *pc = static_cast<char *>(pa);
        cout << *pc << endl;
        system("pause");
        return 0;
    }

## 附cppreference上的代码 ##

#include <vector>
    #include <iostream>
    
    struct B {
        int m = 0;
        void hello() const {
            std::cout << "Hello world, this is B!\n";
        }
    };
    struct D : B {
        void hello() const {
            std::cout << "Hello world, this is D!\n";
        }
    };
    
    enum class E { ONE = 1, TWO, THREE };
    enum EU { ONE = 1, TWO, THREE };
    
    int main()
    {
        // 1: initializing conversion
        int n = static_cast<int>(3.14); 
        std::cout << "n = " << n << '\n';
        std::vector<int> v = static_cast<std::vector<int>>(10);
        std::cout << "v.size() = " << v.size() << '\n';
    
        // 2: static downcast
        D d;
        B& br = d; // upcast via implicit conversion
        br.hello();
        D& another_d = static_cast<D&>(br); // downcast
        another_d.hello();
    
        // 3: lvalue to xvalue
        std::vector<int> v2 = static_cast<std::vector<int>&&>(v);
        std::cout << "after move, v.size() = " << v.size() << '\n';
    
        // 4: discarded-value expression
        static_cast<void>(v2.size());
    
        // 5. inverse of implicit conversion
        void* nv = &n;
        int* ni = static_cast<int*>(nv);
        std::cout << "*ni = " << *ni << '\n';
    
        // 6. array-to-pointer followed by upcast
        D a[10];
        B* dp = static_cast<B*>(a);
    
        // 7. scoped enum to int or float
        E e = E::ONE;
        int one = static_cast<int>(e);
        std::cout << one << '\n';
    
        // 8. int to enum, enum to another enum
        E e2 = static_cast<E>(one);
        EU eu = static_cast<EU>(e2);
    
        // 9. pointer to member upcast
        int D::*pm = &D::m;
        std::cout << br.*static_cast<int B::*>(pm) << '\n';
    
        // 10. void* to any type
        void* voidp = &e;
        std::vector<int>* p = static_cast<std::vector<int>*>(voidp);
    }

## 参考 ##

[http://en.cppreference.com/w/cpp/language/static\_cast][http_en.cppreference.com_w_cpp_language_static_cast]  
[https://msdn.microsoft.com/zh-cn/library/c36yw7x9.aspx][https_msdn.microsoft.com_zh-cn_library_c36yw7x9.aspx]  
[引用折叠][Link 1]

[C_ std_move_std_forward]: http://blog.csdn.net/zhangxiao93/article/details/74980130
[http_en.cppreference.com_w_cpp_language_static_cast]: http://en.cppreference.com/w/cpp/language/static_cast
[https_msdn.microsoft.com_zh-cn_library_c36yw7x9.aspx]: https://msdn.microsoft.com/zh-cn/library/c36yw7x9.aspx
[Link 1]: http://blog.csdn.net/sixdaycoder/article/details/46489891