C++轉(zhuǎn)型操作符

Fredanf 2012-09-27

展開全文

C++有四種轉(zhuǎn)型操作符,以下小結(jié)一下:

1,static_cast<>()

用得最多的，如果轉(zhuǎn)換的是類型，則調(diào)用轉(zhuǎn)型函數(shù)：比如int轉(zhuǎn)float，float轉(zhuǎn)int等基本數(shù)據(jù)類型的轉(zhuǎn)型，如果是一個類，就調(diào)用類型轉(zhuǎn)換函數(shù)，比如：

#include <iostream>
using namespace std;
class A
{
public:
    explicit A(int _a = 0) : a(_a) {}
    operator int() const
    {
        return a;
    }
private:
    int a;
};
int main()
{
    A a(100);
    int b = static_cast<int>(a);
    cout<<b<<endl;
    system("PAUSE");
    return 0;
};

可以轉(zhuǎn)換一個基類指針到子類指針的轉(zhuǎn)型，但是不做動態(tài)類型檢查，可以不存在虛函數(shù)，因此轉(zhuǎn)型可能是不安全的，但是是快速的。

2,dynamic_cast<>()

專門用于C++類的指針轉(zhuǎn)型，且是用于多態(tài)繼承體系中的類。public繼承體現(xiàn)了‘is-a’的類關(guān)系，一個基類指針，可以指向子類對象，它的子類類型是動態(tài)類型，dynamic_cast<>()就是將基類指針轉(zhuǎn)型成它動態(tài)類型的子類指針，如果類型不對，結(jié)果就是空。

#include <iostream>
using namespace std;
class B
{
public:
    virtual void foo() {
        cout<<"B.foo"<<endl;
    }
};
class D1 : public B
{
public:
    void foo() {
        cout<<"D1.foo"<<endl;
    }
    void foo2() {
        cout<<"D1.foo2"<<endl;
    }
};
class D2 : public B
{
public:
    void foo() {
        cout<<"D2.foo"<<endl;
    }
    void foo3() {
        cout<<"D2.foo3"<<endl;
    }
};
int main()
{
    B *pb = new D2;
    pb->foo();
    D1 *pd1 = dynamic_cast<D1*>(pb);
    if(pd1)
    {
        pd1->foo2();
    }
    D2 *pd2 = dynamic_cast<D2*>(pb);
    if(pd2)
    {
        pd2->foo3();
    }
    delete pb;
    system("PAUSE");
    return 0;
};

(1)必須有虛接口，那么，如果用基類指針使用虛接口，則可以動態(tài)綁定，不需要轉(zhuǎn)型，就能體現(xiàn)多態(tài)；(2)如果是子類指針，可以直接給基類指針，可以直接使用。所以使用dynamic_cast的情形比較簡單，就是用基類指針使用非虛接口的情形。非虛接口體現(xiàn)了子類的特有操作，也就是要確定它的動態(tài)類型，如上例，給了pb指針，但不知道是D1還是D2，轉(zhuǎn)型后，看結(jié)果是否非空，如果空則表示不是這個類型，然后分情況處理。它相當(dāng)于使用typeid+static_cast，是安全的轉(zhuǎn)型。

3,const_cast<>()

用以去掉‘?dāng)?shù)據(jù)’的常量屬性，常量屬性多體現(xiàn)在指針和引用，因為如果沒有指針和引用，就不存在不小心修改了不能修改的東西。如

const int a =314;
a=2;//這個傻瓜編譯器都知道你在忽悠它
int *p = &a;
*p=3;//這兩句，是不是可以成功忽悠你，轉(zhuǎn)了彎修改了不能修改的東西
C++會報錯，因為&a是const int *，不能將一個const指針或引用賦給指針或初始化引用。換成這樣就行了：
int *p=const_cast<int*>(&a);

編譯器放給了你這樣的權(quán)力，如果你這樣寫，表明你能為它的后果負責(zé)，如果出了錯，如果你做的是導(dǎo)彈火控系統(tǒng)，你將會知道結(jié)果有多嚴重。

MSDN里有一個例子，一個const成員函數(shù)里修改this指針的常量性，這很高明，真的很高明，因為完全沒有理由使用mutable關(guān)鍵字啦~~const成員函數(shù)的第一個參數(shù)類型是const ClassName*，簡單的不同。

4,reinterpret_cast

這個我用得非常少，因為太長了，每次打都不記得。字面意思是重新解釋，就是可以將任何指針轉(zhuǎn)型成其它指針或者整型類型，它是底層的轉(zhuǎn)型，也是不安全的。MSDN里有一個hash函數(shù)的例子比較‘高層’的運用了它。哦，對了，它不能去掉const屬性。

給一個我的例子,功能是顯示數(shù)據(jù)的每一個字節(jié):

#include <cstdlib>
#include <iostream>
using namespace std;
template<typename Functor>
class for_byte
{
public:
    template<typename T>
    void operator()(T & data)
    {
        unsigned char * p = reinterpret_cast<unsigned char*>(&data);
        for(int i=sizeof(T);i>0;--i)
        {
            fun(*p++);
        }
    }
private:
    Functor fun;
};
struct display_bit
{
    void operator()(unsigned char byte)
    {
        printf("%02X",byte);
    }
};
int main(int argc, char *argv[])
{
    for_byte<display_bit> display;
    double x = 3.14;
    int y = -1;
    display(x);
    printf("\n");
    display(y);
    printf("\n");
    display(display);
    printf("\n");
    system("PAUSE");
    return EXIT_SUCCESS;
}