C++常見類型主要為

// 一個字節(jié)等于 8 bit
[signed] int //字節(jié)數(shù)為 4
unsigned [int] //字節(jié)數(shù)為 4
short [int] //字節(jié)數(shù) 2
unsigned short [int] //字節(jié)數(shù) 2
long [int] //字節(jié)數(shù) 4
unsigned long [int] //字節(jié)數(shù) 4
[signed] char //字節(jié)數(shù) 1
unsigned char //字節(jié)數(shù) 1
float //字節(jié)數(shù) 4
double //字節(jié)數(shù) 8
long long [int] //字節(jié)數(shù) 8
unsigned long long [int] //字節(jié)數(shù) 8
size_t //字節(jié)數(shù) 4-8

如下 C++ 11代碼

#include<bits/stdc++.h>
using namespace std;
int main(){
 // 高位轉(zhuǎn)化為低位 
 unsigned long x1 = pow(2,32)-1; // 無符號 
 cout<<"實際存取數(shù)字："<<x1<<endl; 
 cout<<"利用長整型來存取實際數(shù)字："<<long(x1)<<endl; // 溢出 
 cout<<"利用整型來存取實際數(shù)字："<<int(x1)<<endl; // 溢出 
 cout<<"利用字符型來存取實際數(shù)字："<<char(x1)<<endl; // 溢出 輸出為空格 字符 
 
 cout<<"------------------------------------------"<<endl; 
 // 低位轉(zhuǎn)化為高位 
 char x2 = pow(2,7)-1; // 有符號 
 cout<<"實際存取字符："<<x2<<endl; // 輸出為空格 ASCII碼 
 cout<<"利用無符號字符型來存取實際字符："<<(unsigned char)(x2)<<endl; // 輸出為空格 ASCII碼 
 cout<<"利用短整型來存取實際數(shù)字："<<short(x2)<<endl; 
 cout<<"利用整型來存取實際數(shù)字："<<int(x2)<<endl;
 cout<<"利用無符號長整型來存取實際數(shù)字："<<(unsigned int)(x2)<<endl;
 cout<<"利用無符號長整型來存取實際數(shù)字："<<(unsigned long)(x2)<<endl;
 cout<<"利用單精度浮點型來存取實際數(shù)字："<<float(x2)<<endl;
 cout<<"利用雙精度浮點型來存取實際數(shù)字："<<double(x2)<<endl;
 // 更高范圍的整數(shù)類型轉(zhuǎn)化 
 cout<<"利用長長整型來存取實際數(shù)字："<<(long long)(pow(2,62)-1)<<endl; 
 cout<<"利用無符號長長整型來存取實際數(shù)字："<<(unsigned long long)(pow(2,63)-1)<<endl;
 // 特殊類型強(qiáng)制轉(zhuǎn)化 
 cout<<"利用size_t類型來存取x1："<<size_t(x1)<<endl;
 cout<<"利用size_t類型來存取x2："<<size_t(x2)<<endl;
 cout<<"利用size_t類型來存取 x1+1 : "<<size_t(x1+1)<<endl; // 溢出 
 cout<<"利用size_t類型來存取 -1 : "<<size_t(-1)<<endl; // 溢出 
 return 0;
}

結(jié)果如下：

C++ 4種強(qiáng)制類型轉(zhuǎn)換：

在C++語言中新增了四個關(guān)鍵字static_cast、const_cast、reinterpret_cast和dynamic_cast。這四個關(guān)鍵字都是用于強(qiáng)制類型轉(zhuǎn)換的。

新類型的強(qiáng)制轉(zhuǎn)換可以提供更好的控制強(qiáng)制轉(zhuǎn)換過程，允許控制各種不同種類的強(qiáng)制轉(zhuǎn)換。

C++中風(fēng)格是static_cast<type>(content)。C++風(fēng)格的強(qiáng)制轉(zhuǎn)換其他的好處是，它們能更清晰的表明它們要干什么。程序員只要掃一眼這樣的代碼，就能立即知道一個強(qiáng)制轉(zhuǎn)換的目的。

1) static_cast

在C++語言中static_cast用于數(shù)據(jù)類型的強(qiáng)制轉(zhuǎn)換，強(qiáng)制將一種數(shù)據(jù)類型轉(zhuǎn)換為另一種數(shù)據(jù)類型。例如將整型數(shù)據(jù)轉(zhuǎn)換為浮點型數(shù)據(jù)。
[例1]C語言所采用的類型轉(zhuǎn)換方式：

int a = 10;
int b = 3;
double result = (double)a / (double)b;

例1中將整型變量a和b轉(zhuǎn)換為雙精度浮點型，然后相除。在C++語言中，我們可以采用static_cast關(guān)鍵字來進(jìn)行強(qiáng)制類型轉(zhuǎn)換，如下所示。
[例2]static_cast關(guān)鍵字的使用：

int a = 10;
int b = 3;
double result = static_cast<double>(a) / static_cast<double>(b);

在本例中同樣是將整型變量a轉(zhuǎn)換為雙精度浮點型。采用static_cast進(jìn)行強(qiáng)制數(shù)據(jù)類型轉(zhuǎn)換時，將想要轉(zhuǎn)換成的數(shù)據(jù)類型放到尖括號中，將待轉(zhuǎn)換的變量或表達(dá)式放在元括號中，其格式可以概括為如下形式：   

用法：static_cast <類型說明符> （變量或表達(dá)式）

它主要有如下幾種用法：
    （1）用于類層次結(jié)構(gòu)中基類和派生類之間指針或引用的轉(zhuǎn)換
      進(jìn)行上行轉(zhuǎn)換（把派生類的指針或引用轉(zhuǎn)換成基類表示）是安全的
      進(jìn)行下行轉(zhuǎn)換（把基類的指針或引用轉(zhuǎn)換為派生類表示），由于沒有動態(tài)類型檢查，所以是不安全的
    （2）用于基本數(shù)據(jù)類型之間的轉(zhuǎn)換，如把int轉(zhuǎn)換成char。這種轉(zhuǎn)換的安全也要開發(fā)人員來保證
    （3）把空指針轉(zhuǎn)換成目標(biāo)類型的空指針
    （4）把任何類型的表達(dá)式轉(zhuǎn)換為void類型
    注意：static_cast不能轉(zhuǎn)換掉expression的const、volitale或者_(dá)_unaligned屬性。

static_cast:可以實現(xiàn)C++中內(nèi)置基本數(shù)據(jù)類型之間的相互轉(zhuǎn)換。

如果涉及到類的話，static_cast只能在有相互聯(lián)系的類型中進(jìn)行相互轉(zhuǎn)換,不一定包含虛函數(shù)。

2) const_cast

在C語言中，const限定符通常被用來限定變量，用于表示該變量的值不能被修改。

而const_cast則正是用于強(qiáng)制去掉這種不能被修改的常數(shù)特性，但需要特別注意的是const_cast不是用于去除變量的常量性，而是去除指向常數(shù)對象的指針或引用的常量性，其去除常量性的對象必須為指針或引用。

用法：const_cast<type_id> (expression)
    該運(yùn)算符用來修改類型的const或volatile屬性。除了const 或volatile修飾之外， type_id和expression的類型是一樣的。
    常量指針被轉(zhuǎn)化成非常量指針，并且仍然指向原來的對象；
    常量引用被轉(zhuǎn)換成非常量引用，并且仍然指向原來的對象；常量對象被轉(zhuǎn)換成非常量對象。

[例3]一個錯誤的例子：

const int a = 10;
const int * p = &a; *p = 20; //compile error int b = const_cast<int>(a); //compile error

在本例中出現(xiàn)了兩個編譯錯誤，第一個編譯錯誤是*p因為具有常量性，其值是不能被修改的；另一處錯誤是const_cast強(qiáng)制轉(zhuǎn)換對象必須為指針或引用，而例3中為一個變量，這是不允許的！

[例4]const_cast關(guān)鍵字的使用

#include<iostream>
using namespace std;
 
int main()
{
 const int a = 10;
 const int * p = &a;
 int *q;
 q = const_cast<int *>(p);
 *q = 20; //fine
 cout <<a<<" "<<*p<<" "<<*q<<endl;
  cout <<&a<<" "<<p<<" "<<q<<endl;
 return 0;
}

在本例中，我們將變量a聲明為常量變量，同時聲明了一個const指針指向該變量（此時如果聲明一個普通指針指向該常量變量的話是不允許的，Visual Studio 2010編譯器會報錯）。

之后我們定義了一個普通的指針*q。將p指針通過const_cast去掉其常量性，并賦給q指針。之后我再修改q指針?biāo)傅刂返闹禃r，這是不會有問題的。

最后將結(jié)果打印出來，運(yùn)行結(jié)果如下：
10 20 20
002CFAF4 002CFAF4 002CFAF4

查看運(yùn)行結(jié)果，問題來了，指針p和指針q都是指向a變量的，指向地址相同，而且經(jīng)過調(diào)試發(fā)現(xiàn)002CFAF4地址內(nèi)的值確實由10被修改成了20，這是怎么一回事呢？為什么a的值打印出來還是10呢？

其實這是一件好事，我們要慶幸a變量最終的值沒有變成20！變量a一開始就被聲明為一個常量變量，不管后面的程序怎么處理，它就是一個常量，就是不會變化的。試想一下如果這個變量a最終變成了20會有什么后果呢？對于這些簡短的程序而言，如果最后a變成了20，我們會一眼看出是q指針修改了，但是一旦一個項目工程非常龐大的時候，在程序某個地方出現(xiàn)了一個q這樣的指針，它可以修改常量a，這是一件很可怕的事情的，可以說是一個程序的漏洞，畢竟將變量a聲明為常量就是不希望修改它，如果后面能修改，這就太恐怖了。

在例4中我們稱“*q=20”語句為未定義行為語句，所謂的未定義行為是指在標(biāo)準(zhǔn)的C++規(guī)范中并沒有明確規(guī)定這種語句的具體行為，該語句的具體行為由編譯器來自行決定如何處理。對于這種未定義行為的語句我們應(yīng)該盡量予以避免！

從例4中我們可以看出我們是不想修改變量a的值的，既然如此，定義一個const_cast關(guān)鍵字強(qiáng)制去掉指針的常量性到底有什么用呢？我們接著來看下面的例子。

例5：

#include<iostream>
using namespace std;
 
const int * Search(const int * a, int n, int val);
 
int main()
{
 int a[10] = {0,1,2,3,4,5,6,7,8,9};
 int val = 5;
 int *p;
 p = const_cast<int *>(Search(a, 10, val));
 if(p == NULL)
  cout<<"Not found the val in array a"<<endl;
 else
  cout<<"hvae found the val in array a and the val = "<<*p<<endl;
 return 0;
}
 
const int * Search(const int * a, int n, int val)
{
 int i;
 for(i=0; i<n; i++)
 {
  if(a[i] == val)
   return &a[i];
 }
 return NULL;
}

在例5中我們定義了一個函數(shù)，用于在a數(shù)組中尋找val值，如果找到了就返回該值的地址，如果沒有找到則返回NULL。函數(shù)Search返回值是const指針，當(dāng)我們在a數(shù)組中找到了val值的時候，我們會返回val的地址，最關(guān)鍵的是a數(shù)組在main函數(shù)中并不是const，因此即使我們?nèi)サ舴祷刂档某Ａ啃杂锌赡軙斐蒩數(shù)組被修改，但是這也依然是安全的。

對于引用，我們同樣能使用const_cast來強(qiáng)制去掉常量性，如例6所示。

例6：

#include<iostream>
using namespace std;
 
const int & Search(const int * a, int n, int val);
 
int main()
{
int a[10] = {0,1,2,3,4,5,6,7,8,9};
int val = 5;
int &p = const_cast<int &>(Search(a, 10, val));
if(p == NULL)
cout<<"Not found the val in array a"<<endl;
else
cout<<"hvae found the val in array a and the val = "<<p<<endl;
return 0;
}
 
const int & Search(const int * a, int n, int val)
{
int i;
for(i=0; i<n; i++)
{
if(a[i] == val)
return a[i];
}
return NULL;
}

 了解了const_cast的使用場景后，可以知道使用const_cast通常是一種無奈之舉，同時也建議大家在今后的C++程序設(shè)計過程中一定不要利用const_cast去掉指針或引用的常量性并且去修改原始變量的數(shù)值，這是一種非常不好的行為。

3) reinterpret_cast

在C++語言中，reinterpret_cast主要有三種強(qiáng)制轉(zhuǎn)換用途：改變指針或引用的類型、將指針或引用轉(zhuǎn)換為一個足夠長度的整形、將整型轉(zhuǎn)換為指針或引用類型。

用法：reinterpret_cast<type_id> (expression)
    type-id必須是一個指針、引用、算術(shù)類型、函數(shù)指針或者成員指針。
    它可以把一個指針轉(zhuǎn)換成一個整數(shù)，也可以把一個整數(shù)轉(zhuǎn)換成一個指針（先把一個指針轉(zhuǎn)換成一個整數(shù)，在把該整數(shù)轉(zhuǎn)換成原類型的指針，還可以得到原先的指針值）。
    在使用reinterpret_cast強(qiáng)制轉(zhuǎn)換過程僅僅只是比特位的拷貝，因此在使用過程中需要特別謹(jǐn)慎！

例7：

int *a = new int;
double *d = reinterpret_cast<double *>(a);

在例7中，將整型指針通過reinterpret_cast強(qiáng)制轉(zhuǎn)換成了雙精度浮點型指針。
reinterpret_cast可以將指針或引用轉(zhuǎn)換為一個足夠長度的整形，此中的足夠長度具體長度需要多少則取決于操作系統(tǒng)，如果是32位的操作系統(tǒng)，就需要4個字節(jié)及以上的整型，如果是64位的操作系統(tǒng)則需要8個字節(jié)及以上的整型。 

4) dynamic_cast

用法：dynamic_cast<type_id> (expression)

（1）其他三種都是編譯時完成的，dynamic_cast是運(yùn)行時處理的，運(yùn)行時要進(jìn)行類型檢查。

（2）不能用于內(nèi)置的基本數(shù)據(jù)類型的強(qiáng)制轉(zhuǎn)換。

（3）dynamic_cast轉(zhuǎn)換如果成功的話返回的是指向類的指針或引用，轉(zhuǎn)換失敗的話則會返回NULL。

（4）使用dynamic_cast進(jìn)行轉(zhuǎn)換的，基類中一定要有虛函數(shù)，否則編譯不通過。

        B中需要檢測有虛函數(shù)的原因：類中存在虛函數(shù)，就說明它有想要讓基類指針或引用指向派生類對象的情況，此時轉(zhuǎn)換才有意義。

       這是由于運(yùn)行時類型檢查需要運(yùn)行時類型信息，而這個信息存儲在類的虛函數(shù)表（關(guān)于虛函數(shù)表的概念，詳細(xì)可見<Inside c++ object model>）中，
        只有定義了虛函數(shù)的類才有虛函數(shù)表。

 （5）在類的轉(zhuǎn)換時，在類層次間進(jìn)行上行轉(zhuǎn)換時，dynamic_cast和static_cast的效果是一樣的。在進(jìn)行下行轉(zhuǎn)換時，dynamic_cast具有類型檢查的功能，比static_cast更安全。

        向上轉(zhuǎn)換，即為子類指針指向父類指針（一般不會出問題）；向下轉(zhuǎn)換，即將父類指針轉(zhuǎn)化子類指針。

       向下轉(zhuǎn)換的成功與否還與將要轉(zhuǎn)換的類型有關(guān)，即要轉(zhuǎn)換的指針指向的對象的實際類型與轉(zhuǎn)換以后的對象類型一定要相同，否則轉(zhuǎn)換失敗。

        在C++中，編譯期的類型轉(zhuǎn)換有可能會在運(yùn)行時出現(xiàn)錯誤，特別是涉及到類對象的指針或引用操作時，更容易產(chǎn)生錯誤。Dynamic_cast操作符則可以在運(yùn)行期對可能產(chǎn)生問題的類型轉(zhuǎn)換進(jìn)行測試。

例1：

#include<iostream>
using namespace std;
 
class base
{
public :
 void m(){cout<<"m"<<endl;}
};
 
class derived : public base
{
public:
 void f(){cout<<"f"<<endl;}
};
 
int main()
{
 derived * p;
 p = new base;
 p = static_cast<derived *>(new base);
 p->m();
 p->f();
 return 0;
}

本例中定義了兩個類：base類和derived類，這兩個類構(gòu)成繼承關(guān)系。在base類中定義了m函數(shù)，derived類中定義了f函數(shù)。在前面介紹多態(tài)時，我們一直是用基類指針指向派生類或基類對象，而本例則不同了。

本例主函數(shù)中定義的是一個派生類指針，當(dāng)我們將其指向一個基類對象時，這是錯誤的，會導(dǎo)致編譯錯誤。

但是通過強(qiáng)制類型轉(zhuǎn)換我們可以將派生類指針指向一個基類對象，p = static_cast<derived *>(new base);語句實現(xiàn)的就是這樣一個功能，這樣的一種強(qiáng)制類型轉(zhuǎn)換時合乎C++語法規(guī)定的，但是是非常不明智的，它會帶來一定的危險。

在程序中p是一個派生類對象，我們將其強(qiáng)制指向一個基類對象，首先通過p指針調(diào)用m函數(shù)，因為基類中包含有m函數(shù)，這一句沒有問題，之后通過p指針調(diào)用f函數(shù)。一般來講，因為p指針是一個派生類類型的指針，而派生類中擁有f函數(shù)，因此p->f();這一語句不會有問題，但是本例中p指針指向的確實基類的對象，而基類中并沒有聲明f函數(shù)，雖然p->f();這一語句雖然仍沒有語法錯誤，但是它卻產(chǎn)生了一個運(yùn)行時的錯誤。換言之，p指針是派生類指針，這表明程序設(shè)計人員可以通過p指針調(diào)用派生類的成員函數(shù)f，但是在實際的程序設(shè)計過程中卻誤將p指針指向了一個基類對象，這就導(dǎo)致了一個運(yùn)行期錯誤。

產(chǎn)生這種運(yùn)行期的錯誤原因在于static_cast強(qiáng)制類型轉(zhuǎn)換時并不具有保證類型安全的功能，而C++提供的dynamic_cast卻能解決這一問題，dynamic_cast可以在程序運(yùn)行時檢測類型轉(zhuǎn)換是否類型安全。

當(dāng)然dynamic_cast使用起來也是有條件的，它要求所轉(zhuǎn)換的操作數(shù)必須包含多態(tài)類類型（即至少包含一個虛函數(shù)的類）。

例2：

#include<iostream>
using namespace std;
 
class base
{
public :
 void m(){cout<<"m"<<endl;}
};
 
class derived : public base
{
public:
 void f(){cout<<"f"<<endl;}
};
 
int main()
{
 derived * p;
 p = new base;
 p = dynamic_cast<derived *>(new base);
 p->m();
 p->f();
 return 0;
}

在本例中利用dynamic_cast進(jìn)行強(qiáng)制類型轉(zhuǎn)換，但是因為base類中并不存在虛函數(shù)，因此p = dynamic_cast<derived *>(new base);這一句會編譯錯誤。

為了解決本例中的語法錯誤，我們可以將base類中的函數(shù)m聲明為虛函數(shù)，virtual void m(){cout<<"m"<<endl;}。

dynamic_cast還要求<>內(nèi)部所描述的目標(biāo)類型必須為指針或引用。

例3：

#include<iostream>
#include<cstring>
 
using namespace std;
 
class A
{
 public:
 virtual void f()
 {
  cout<<"hello"<<endl;
  };
};
 
 
 
class B:public A
{
 public:
 void f()
 {
  cout<<"hello2"<<endl;
  };
 
};
 
 
 
class C
{
 void pp()
 {
  return;
 }
};
 
 
 
int fun()
{
 return 1;
}
 
int main()
{
 A* a1=new B;//a1是A類型的指針指向一個B類型的對象
 A* a2=new A;//a2是A類型的指針指向一個A類型的對象
 B* b;
 C* c;
 b=dynamic_cast<B*>(a1);//結(jié)果為not null，向下轉(zhuǎn)換成功，a1之前指向的就是B類型的對象，所以可以轉(zhuǎn)換成B類型的指針。
 if(b==NULL)
 {
  cout<<"null"<<endl;
 }
 
 else
 {
  cout<<"not null"<<endl;
 }
 
 b=dynamic_cast<B*>(a2);//結(jié)果為null，向下轉(zhuǎn)換失敗
 if(b==NULL)
 {
  cout<<"null"<<endl;
 }
 
 else
 {
  cout<<"not null"<<endl;
 }
 
 c=dynamic_cast<C*>(a);//結(jié)果為null，向下轉(zhuǎn)換失敗
 if(c==NULL)
 {
  cout<<"null"<<endl;
 }
 
 else
 {
  cout<<"not null"<<endl;
 }
 
 delete(a);
 return 0;
}

 到此這篇關(guān)于C++ 數(shù)據(jù)類型強(qiáng)制轉(zhuǎn)化的實現(xiàn)的文章就介紹到這了,更多相關(guān)C++ 數(shù)據(jù)類型強(qiáng)制轉(zhuǎn)化內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！

最新評論