一、C++程式碼

以下是常用的幾種型別互相之間的轉換
string 轉 int
..............................
char* 轉 int 
#include <stdlib.h> 

int atoi(const char *nptr); 
long atol(const char *nptr); 
long long atoll(const char *nptr); 
long long atoq(const char *nptr); 
...................................................................
int 轉 string 
可以使用stringstream類(需要包含<sstream>標頭檔案)
int main()
{
   stringstream ss;
   int i = 100;
   string str;
   ss >> i;
   ss << str; //這時str中就是字串"100".
   retturn 0;
}

.............................
char* 轉 string  
string s(char *);  
你的只能初始化，在不是初始化的地方最好還是用assign().
..................................................................
int 轉 char *
在stdlib.h中有個函式itoa() 
itoa的用法： 
itoa(i,num,10); 
i 需要轉換成字元的數字 
num 轉換後儲存字元的變數 
10 轉換數字的基數（進位制）10就是說按照10進位制轉換數字。
還可以是2，8，16等等你喜歡的進位制型別 
原形：char *itoa(int value, char* string, int radix); 

例項： 
#include "stdlib.h" 
#include "stdio.h" 
main() 
{ 
    int i=1234; 
    char s[5]; 
    itoa(i,s,10); 
    printf("%s",s); 
    getchar(); 
}
..........................................
string 轉 char *  
char *p = string.c_str();  

string aa("aaa"); 
char *c=aa.c_str(); 
string mngName； 
char t[200]; 
memset(t,0,200); 
strcpy(t,mngName.c_str());
.......................................... 


posted on 2008-04-17 15:22 林公子 閱讀(8479) 評論(3)  編輯 收藏 引用 所屬分類: C++/CLI 
 


評論
# re: [轉]string, char*, int型別轉換 2009-01-29 16:51 ChriHan 
string str; 
ss >> i; 
ss << str; //這時str中就是字串"100". 

這個部分好像不對， 
應該是 
ss << i; 這時str中就是字串"100". 
可以通過ss.str()提取ss中的內容  回覆  更多評論 
   


# re: [轉]string, char*, int型別轉換 2009-02-02 13:57 erosnick 
@ChriHan 
謝謝Chrihan的更正，以後得注意點, 避免bug:)  回覆  更多評論 
   


# re: [轉]string, char*, int型別轉換 2009-07-06 13:17 Robert.Hu 
在"string 轉 char * "中

"char *c=aa.c_str();"
錯了吧，c_str()返回的是const char* 而 const char* 不能轉換成char*  回覆  更多評論 
   
 

二、
c++ int轉換成string型別 程式碼

//第一種方法 
C++程式碼：

 #include <iostream>
#include <string>
using namespace std;

int main()
{
    int n = 65535;
    char t[256];
    string s;

    sprintf(t, "%d", n);
    s = t;
    cout << s << endl;

    return 0;
}

//第二種方法

C++程式碼：

#include <iostream>
#include <string>
#include <strstream>
using namespace std;

int main()
{
    int n = 65535;
    strstream ss;
    string s;
    ss << n;
    ss >> s;
    cout << s << endl;

    return 0;
}
 

三、

引用

最近做專案用到c++，才發現c++中的資料型別不是一般的BT。尤其是我和婷還是分開操作的。我寫底層，用的是WIN32控制檯；而婷寫MFC。由於沒有經驗，所以沒有寫中間的轉換程式。當整合時，型別轉換特別麻煩。以下都是我收集的型別轉換的方法和一些經驗，供大家參考。歡迎補充~~ 

1. char* to string 
string s(char *);  
注：在不是初始化的地方最好用assign(). 
！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！！ 
2. string to const char* 
string a="strte"; 
const char* r=a.c_str(); 
注意是const的。還要轉到char*： 
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 
2.2. const char* to char* 
const char* r="123"; 
char   *p1   =   new   char[strlen(r)+1]; 
strcpy(p1,r); 
附：http://hi.baidu.com/cfans/blog/item/06970ef4b671f366dcc4745d.html 
這個頁面是具體講述區別的。 
············································································································· 
3. cstring to string 
vs2005 Unicode下： 
  CStringW   str(L"test");   
  CStringA   stra(str.GetBuffer(0));   
  str.ReleaseBuffer();       
  std::string   strs   (stra.GetBuffer(0));   
  stra.ReleaseBuffer(); 

非Unicode下： 
CString cs("test"); 
std::string str=cs.getBuffer(0); 
cs.ReleaseBuffer(); 

注：GetBuffer()後一定要ReleaseBuffer(),否則就沒有釋放緩衝區所佔的空間. 
++++++++++++++++++++++++++++++++++++++++++++++++++++ 
4. double ,int to string 
#include <sstream> 
using namespace std; 

stringstream ss; 
string result; 
long n=11111; 
stream << n; //從long型資料輸入 
stream >>result; //轉換為 string 


=================================================== 

5.char*  to int, double ,long 

char *s; double x; int i; long l; 

s = " -2309.12E-15"; /* Test of atof */ 
x = atof( s ); 
printf( "atof test: ASCII string: %s\tfloat: %e\n", s, x ); 

s = "7.8912654773d210"; /* Test of atof */ 
x = atof( s ); 
printf( "atof test: ASCII string: %s\tfloat: %e\n", s, x ); 

s = " -9885 pigs"; /* Test of atoi */ 
i = atoi( s ); 
printf( "atoi test: ASCII string: %s\t\tinteger: %d\n", s, i ); 

s = "98854 dollars"; /* Test of atol */ 
l = atol( s ); 
printf( "atol test: ASCII string: %s\t\tlong: %ld\n", s, l ); 
------------------------------------------------------------------------------------------------ 
6. string to int ,long ,double             
              int s; 
string str="123"; 
stringstream ss; 
ss<<str;//從str輸入 
ss>>s;//輸出到int 
ss.clear(); 


—————————————————————————————————————————— 
7. date to string 
#include <time> 
using namespace std; 

char dateStr [9]; 
char timeStr [9]; 
_strdate( dateStr); 
printf( "The current date is %s \n", dateStr); 
_strtime( timeStr ); 
printf( "The current time is %s \n", timeStr); 

--------實踐證明是正確的版本-------------------------------------------------------------- 
#include <iostream> 
#include <ctime> 
#include <cerrno> 

int main() 
{ 
     //Find the current time 
     time_t curtime = time(0); 
      
      //convert it to tm 
      tm now=*localtime(&curtime); 
     
     //BUFSIZ is standard macro that expands to a integer constant expression 
     //that is greater then or equal to 256. It is the size of the stream buffer 
     //used by setbuf() 
     char dest[BUFSIZ]={0}; 
     
     //Format string determines the conversion specification's behaviour 
     const char format[]="%A, %B %d %Y. The time is %X"; 
     
     //strftime - converts date and time to a string 
     if (strftime(dest, sizeof(dest)-1, format, &now)>0) 
       std::cout<<dest<<std::endl; 
     else 
       std::cerr<<"strftime failed. Errno code: "<<errno<<std::endl; 
} 

||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||||| 
8.string to cstring 

+++++++++++++++++++++++++++++++++++++++++++++++++++++ 
非Unicode下： 
int 轉 CString： 
CString.Format("%d",int); 
............................... 
string 轉 CString  
CString.format("%s", string.c_str());  
用c_str()確實比data()要好.  
....................................... 
char* 轉 CString  
CString.format("%s", char*);  
CString strtest;  
char * charpoint;  
charpoint="give string a value";  
strtest=charpoint; //直接付值 
..................................................... 
CString 轉 int 
CString  ss="1212.12";  
int temp=atoi(ss); //atoi _atoi64或atol 
................................................................................................................................... 
9.在Unicode下的CString to double 
CSting sTemp("123.567"); 
double dTemp = _wtof(sTemp.GetString()); 

文章出處：飛諾網(www.firnow.com):http://dev.firnow.com/course/3_program/c++/cppjs/20090412/164832.html
 

4、收藏 

強制轉化四種類型可能很多人都常常忽略就象我一樣，但是有時還是比較有用的。不瞭解的建議看看，一些機制我也不是十分了解，只是將一些用法寫出來讓大家看看。
                                                            2004-11-27 9:00

強制轉化無論從語法還是語意上看，都是c++中最難看的特徵之一。但是基於c風格的轉化的語義的不明確性及其一些潛在問題。強制型別轉化最終還是被c++接受了。
1.static_cast運算子號
static_cast<T>(e),stroustrup讓我們可以把它看成隱含轉換的顯示的逆運算。這個是有一定道理的，基於隱式轉化的物件型別我們可以使用static_cast轉化運算子號。它是靜態的檢測，無法執行時檢測型別，在繼承中尤為突出。
使用範圍 

<1>用於所有系統型別之間轉化，不能用於系統型別指標型別轉化

C++程式碼：

  double t_d = 0;
int t_i= static_cast<int>(t_d); //是合法的轉化

而企圖將double*->int*是不允許的
<2>用於繼承類之間的轉化（含指標），不能用於其他沒有隱式轉化的物件型別之間的轉化
繼承舉例:

C++程式碼：

class x
{
};
class y: public x
{
};
使用:x t_o_x;
y t_o_y = static_cast<y>(t_o_x); //x* y*轉化也可以進行因為x,y繼承關
//系，型別可以自動隱式轉化使用
   隱式轉化舉例:
class x
{
};
class y
{

public:
    y( x i_x ) {}
};
    x t_o_x;
     y t_o_y = static_cast<y>(t_o_x);

//大家看到y建構函式可以對於x型別隱式轉化
//所以可以將x->y，如果企圖將y->x會報錯
2.reinterpret_cast 運算
主要用於對於型別指標型別的強制轉化，some_type* -> special_type*這樣轉化，型別資訊可以是不完全的。它允許將任意指標轉化到其他型別指標，也允許任意整數型別到任意指標型別轉化(BT)。這樣導致的結果是極其不安全的，不能安全的應用於其他目的，除非轉化到原來型別。
<1> 使用所有整形可以轉化為任意型別的指標(指標是4位元組的long的東東，那麼機器就認為同類型就是可以轉化)

C++程式碼

int c;
x* p = reinterpret_cast<x*>(c); 

//x是自定義的任意型別，當然包括系統型別
<2> 可以對於任意型別指標之間轉化

C++程式碼：

y* c;
x* p = reinterpret_cast<x*>(c);//

x,y代表所有自定義或系統型別
大家可以看到reinterpret_cast的轉化是極度的不負責任的，他只管轉化不檢測是否可以轉化。 

<3> const_cast運算子號
這個很簡單從名字大家可以看出來，僅僅為了去掉或著加上const修飾符號。但是對於本身定義時為const的型別，即使你去掉const性，在你操作這片內容時候也要小心，只能r不能w操作，否則還是會出錯。

C++程式碼：

const char* p = "123";
char* c = const_cast<char*>(p);

c[0] = 1;  //表面上通過編譯去掉了const性，但是操作其地址時系統依然不允許這
//麼做。這是一個漏洞吧 

<4> dynamic_cast運算子號
Scott Mayers將其描述為用來執行繼承體系中：安全的向下轉型或者跨系轉型動作。也就是說你可以，用dynamic_cast將 指向base class的指標或引用轉型為 指向子類的物件的指標或引用。

C++程式碼：

class B {};  //polymorphic型別含virtual才能dynamic_cast
class D: public B {}
void f( B* pb )
{
    D* pd1 = dynamic_cast<D*>(pb);//如果pb為d型別正確返回，如果不是返回0
    D* pd2 = static_cast<D*>(pb);

//不管怎麼樣都返回指標有可能指向不合適的對
//象，因為static僅僅靜態檢測，不能得到運
//行時物件的資訊是否真正為D型別
}

反正大家在使用知道怎麼用就ok了，c++強制轉化在模板中還是非常有用的，其他時候本人也喜歡用c的轉化方便


本文來自CSDN部落格，轉載請標明出處：http://blog.csdn.net/goodluckyxl/archive/2005/01/19/259851.aspx

5、static_cast<>揭密
C++程式碼：

static_cast<>揭密


作者：Sam NG 

譯者：小刀人


原文連結：What static_cast<> is actually doing

本文討論static_cast<> 和 reinterpret_cast<>。 

介紹
大多程式設計師在學C++前都學過C，並且習慣於C風格（型別）轉換。當寫C++（程式）時，有時候我們在使用static_cast<>和reinterpret_cast<>時可能會有點模糊。在本文中，我將說明static_cast<>實際上做了什麼，並且指出一些將會導致錯誤的情況。

泛型（Generic Types）



        float f = 12.3;
        float* pf = &f;
      // static cast<>
        // 成功編譯, n = 12
        int n = static_cast<int>(f);
        // 錯誤,指向的型別是無關的（譯註：即指標變數pf是float型別，現在要被轉換為int型別）
        //int* pn = static_cast<int*>(pf);
        //成功編譯
        void* pv = static_cast<void*>(pf);
        //成功編譯, 但是 *pn2是無意義的記憶體（rubbish）
        int* pn2 = static_cast<int*>(pv);
      // reinterpret_cast<>
        //錯誤,編譯器知道你應該呼叫static_cast<>
        //int i = reinterpret_cast<int>(f);
        //成功編譯, 但是 *pn 實際上是無意義的記憶體,和 *pn2一樣
        int* pi = reinterpret_cast<int*>(pf);
簡而言之，static_cast<> 將嘗試轉換，舉例來說，如float-到-integer，而reinterpret_cast<>簡單改變編譯器的意圖重新考慮那個物件作為另一型別。

指標型別（Pointer Types）

指標轉換有點複雜，我們將在本文的剩餘部分使用下面的類：
class CBaseX
      {
      public:
      int x;
      CBaseX() { x = 10; }
      void foo() { printf("CBaseX::foo() x=%d\n", x); }
      };
      class CBaseY
        {
        public:
        int y;
        int* py;
        CBaseY() { y = 20; py = &y; }
        void bar() { printf("CBaseY::bar() y=%d, *py=%d\n", y, *py); 
        }
        };
      class CDerived : public CBaseX, public CBaseY
        {
        public:
        int z;
        };
情況1：兩個無關的類之間的轉換 



      // Convert between CBaseX* and CBaseY*
      // CBaseX* 和 CBaseY*之間的轉換
      CBaseX* pX = new CBaseX();
      // Error, types pointed to are unrelated
      // 錯誤， 型別指向是無關的
      // CBaseY* pY1 = static_cast<CBaseY*>(pX);
      // Compile OK, but pY2 is not CBaseX
      // 成功編譯, 但是 pY2 不是CBaseX
      CBaseY* pY2 = reinterpret_cast<CBaseY*>(pX);
      // System crash!!
      // 系統崩潰!!
      // pY2->bar();
正如我們在泛型例子中所認識到的，如果你嘗試轉換一個物件到另一個無關的類static_cast<>將失敗，而reinterpret_cast<>就總是成功“欺騙”編譯器：那個物件就是那個無關類。

情況2：轉換到相關的類
      1. CDerived* pD = new CDerived();
      2. printf("CDerived* pD = %x\n", (int)pD);
      3. 
      4. // static_cast<> CDerived* -> CBaseY* -> CDerived*
      //成功編譯，隱式static_cast<>轉換
      5. CBaseY* pY1 = pD;
      6. printf("CBaseY* pY1 = %x\n", (int)pY1);
      // 成功編譯, 現在 pD1 = pD
      7. CDerived* pD1 = static_cast<CDerived*>(pY1);
      8. printf("CDerived* pD1 = %x\n", (int)pD1);
      9. 
      10. // reinterpret_cast
      // 成功編譯, 但是 pY2 不是 CBaseY*
      11. CBaseY* pY2 = reinterpret_cast<CBaseY*>(pD);
      12. printf("CBaseY* pY2 = %x\n", (int)pY2);
      13. 
      14. // 無關的 static_cast<>
      15. CBaseY* pY3 = new CBaseY();
      16. printf("CBaseY* pY3 = %x\n", (int)pY3);
      // 成功編譯,儘管 pY3 只是一個 "新 CBaseY()"
      17. CDerived* pD3 = static_cast<CDerived*>(pY3);
      18. printf("CDerived* pD3 = %x\n", (int)pD3);
      ---------------------- 輸出 ---------------------------
      CDerived* pD = 392fb8
      CBaseY* pY1 = 392fbc
      CDerived* pD1 = 392fb8
      CBaseY* pY2 = 392fb8
      CBaseY* pY3 = 390ff0
      CDerived* pD3 = 390fec
      
注意：在將CDerived*用隱式 static_cast<>轉換到CBaseY*（第5行）時，結果是（指向）CDerived*（的指標向後） 偏移了4（個位元組）（譯註：4為int型別在記憶體中所佔位元組數）。為了知道static_cast<> 實際如何，我們不得不要來看一下CDerived的記憶體佈局。

CDerived的記憶體佈局（Memory Layout）
[img]http://www.vckbase.com/document/journal/vckbase48/images/static_cast_layout.gif[/img] 

C++程式碼：

<A href="http://www.vckbase.com/document/journal/vckbase48/images/static_cast_layout.gif">http://www.vckbase.com/document/journal/vckbase48/images/static_cast_layout.gif</A>

C++程式碼：

如圖所示，CDerived的記憶體佈局包括兩個物件，CBaseX 和 CBaseY，編譯器也知道這一點。因此，當你將CDerived* 轉換到 CBaseY*時，它給指標新增4個位元組，同時當你將CBaseY*轉換到CDerived*時，它給指標減去4。然而，甚至它即便不是一個CDerived你也可以這樣做。
當然，這個問題只在如果你做了多繼承時發生。在你將CDerived轉換 到 CBaseX時static_cast<> 和 reinterpret_cast<>是沒有區別的。

情況3：void*之間的向前和向後轉換

因為任何指標可以被轉換到void*，而void*可以被向後轉換到任何指標（對於static_cast<> 和 reinterpret_cast<>轉換都可以這樣做），如果沒有小心處理的話錯誤可能發生。



    CDerived* pD = new CDerived();
        printf("CDerived* pD = %x\n", (int)pD);
          CBaseY* pY = pD; // 成功編譯, pY = pD + 4
        printf("CBaseY* pY = %x\n", (int)pY);
            void* pV1 = pY; //成功編譯, pV1 = pY
        printf("void* pV1 = %x\n", (int)pV1);
               // pD2 = pY, 但是我們預期 pD2 = pY - 4
        CDerived* pD2 = static_cast<CDerived*>(pV1);
        printf("CDerived* pD2 = %x\n", (int)pD2);
        // 系統崩潰
        // pD2->bar();
        ---------------------- 輸出 ---------------------------
        CDerived* pD = 392fb8
        CBaseY* pY = 392fbc
        void* pV1 = 392fbc
        CDerived* pD2 = 392fbc
     
[b]一旦我們已經轉換指標為void*，我們就不能輕易將其轉換回原類。在上面的例子中，從一個void* 返回CDerived*的唯一方法是將其轉換為CBaseY*然後再轉換為CDerived*。 [/b]但是如果我們不能確定它是CBaseY* 還是 CDerived*，這時我們不得不用dynamic_cast<> 或typeid[2]。

註釋：
1. dynamic_cast<>，從另一方面來說，可以防止一個泛型CBaseY* 被轉換到CDerived*。
2. dynamic_cast<>需要類成為多型，即包括“虛”函式，並因此而不能成為void*。
參考： 
1. [MSDN] C++ Language Reference -- Casting 
2. Nishant Sivakumar, Casting Basics - Use C++ casts in your VC++.NET programs 
3. Juan Soulie, C++ Language Tutorial: Type Casting
推薦連結：如何在執行時確定物件型別（RTTI）