类型转换

void* 和 string 相互转换

在C++中，可以使用void*类型来表示任意类型的指针。而std::string是C++标准库中的字符串类型。要在void*和std::string之间进行转换，需要使用类型转换操作符或者函数。

下面是void*到std::string的转换示例：

#include <iostream>
#include <string>

std::string voidPtrToString(void* ptr) {
    return reinterpret_cast<char*>(ptr);
}

int main() {
    void* ptr = reinterpret_cast<void*>("Hello, World!");
    std::string str = voidPtrToString(ptr);
    std::cout << str << std::endl;
    return 0;
}

在上面的示例中，我们先将一个字符串字面值转换为void*类型的指针，然后通过voidPtrToString函数将void*转换为std::string类型。最后，我们将该字符串打印到标准输出。

下面是std::string到void*的转换示例：

#include <iostream>
#include <string>

void* stringToVoidPtr(const std::string& str) {
    return const_cast<char*>(str.c_str());
}

int main() {
    std::string str = "Hello, World!";
    void* ptr = stringToVoidPtr(str);
    std::cout << reinterpret_cast<char*>(ptr) << std::endl;
    return 0;
}

在上面的示例中，我们首先将一个std::string类型的字符串定义为str，然后通过stringToVoidPtr函数将std::string转换为void*类型。最后，我们将该字符串打印到标准输出。

需要注意的是，void*和std::string之间的转换可能会引发类型不匹配或者内存访问错误等问题，因此在进行转换时需要谨慎处理。

atoi()函数

表示：ascii to integer 是把字符串转换成整型数的一个函数，头文件<stdlib.h>或

int atoi(const char* str);

atoi（）函数会扫描参数字符串，跳过前面的空白字符（例如空格，tab缩进等），直到遇到数字或者正负符号才开始做转换，遇到非数字或字符串结束时（‘\0’）才结束转换，并将结果返回。如果参数不能转换成int或者参数为空字符串，则将返回0

1、转换类型为char*

#include <stdlib.h>
#include <stdio.h>
 
int main(void)
{
    int n;
    char *str = "12345.67";
    n = atoi(str);
    printf("n=%d\n",n);
    return 0;
}

输出：
n = 12345

#include <cstdlib>
#include <iostream>
using namespace std;
int main()
{
    char* temp = " 2013";
    char temp1[] = "2014";
    string temp2 = "2015";
    int num1,num2,num3;
    num1 = atoi(temp);
    num2 = atoi(temp1);
    //num3 = atoi(temp2);//显示string类型不能直接进行转换。
    num3 = atoi(temp2.c_str());
    cout<<num1<<" "<<num2<<" "<<num3<<endl;
    return 0;
}

输出：
2013 2014 2015

c_str() 函数

atoi不能直接使用string变量，c_str 是c++ 中 string类 (class) 的 函数，它能把string类的对象里的字符串转换成C中char型变量的字符串

#include <bits/stdc++.h>
using namespace std;
int main()
{
        string str1 = "237";
        int a = atoi(str1.c_str());
        cout<<a<<endl;
        return 0;

stoi() 函数

头文件都是#include

atoi()的参数是 const char* ,因此对于一个字符串str我们必须调用 c_str()的方法把这个string转换成 const char类型的,而stoi()的参数是const string,不需要转化为 const char*；

stoi()会做范围检查，默认范围是在int的范围内的，如果超出范围的话则会runtime error！

而atoi()不会做范围检查，如果超出范围的话，超出上界，则输出上界，超出下界，则输出下界；

假设有以下字符串：

char str[10] = "123.45";

要将其转换为小数类型，可以使用stoi函数，如下所示：

int num = stoi(str, 10);
cout << "num = " << num << endl;

输出结果为：

num = 123.45

在上面的例子中，将字符串"123.45"转换为小数类型，可以使用stoi函数，其中radix参数被设置为10，表示以十进制数字的小数点为结尾的小数类型。

static_cast、dynamic_cast、const_cast和reinterpret_cast（四种类型转换运算符）

隐式类型转换

所谓隐式类型转换，是指不需要用户干预，编译器默认进行的类型转换行为（很多时候用户可能都不知道到底进行了哪些转换）。

隐式类型转换一般分为两种：内置数据类型、自定义数据类型。

1. 内置数据类型

   C++ 的隐式类型转换，都满足一个基本原则：由低精度向高精度的转换。若不满足该原则，编译器会提示编译警告。

   • （1）混合类型的算术运算表达式中

     int int_value = 8;
     double dou_value = 10.7;
     double dou_Sum = int_value + dou_value; // int_value会被自动转换为double类型，用转换的结果再与dou_value相加.
     

     （2）不同类型的赋值操作时

     int value = true; // bool类型被转换为int类型
     

     （3）函数参数传值时

     void func(double dArg); // 声明函数
     func(1); // 调用函数。整型数值1被默认转换为double类型数值1.0
     

     （4）函数返回值时

     double add(int num1, int num2)
     {
        return (num1 + num2); // 运算结果会被隐式转换为double类型返回
     }
     

     （5）若不满足该原则，编译器会提示编译警告。如下：：由高精度变为低精度。

     double num1 = 100.66;
     int num2 = num1; // : warning C4244: “初始化”:从“double”转换到“int”，可能丢失数据
     

     （6）如果我们不想看到警告，可以选择强制类型转换。如下：

     double num1 = 100.66;
     int num2 = (int)num1;
     

2. 自定义数据类型

   隐式类型转换的风险一般存在于自定义类型转换间。尤其需要注意自定义类的构造函数。例如：

    class MyString
   {
   public:
       MyString(int n) {}; // 本意：预先分配n个字节给字符串
       MyString(const char* p) {}; // 用C风格的字符串p作为初始化值 
       // ......
   };
   
   void main()
   {
       MyString s1 = "China"; //OK 隐式转换，等价于MyString s1 = MyString（”China”） 
       MyString s2(10); // OK 分配10个字节的空字符串
       MyString s3 = MyString(10); // OK 分配10个字节的空字符串
   
       MyString s4 = 10; // OK，编译通过。也是分配10个字节的空字符串
       MyString s5 = 'A'; // 编译通过。分配int('A')个字节的空字符串
       // s4 和s5 分别把一个int型和char型，隐式转换成了分配若干字节的空字符串，容易令人误解。
   }
   
   

   如上例，要想禁止此种隐式类型转换，可以使用C++关键字explicit。

强制类型转换

C++为了规范C中的类型转换，加强类型转换的可视性，引入了四种强制类型转换操作符：static_cast， reinterpret_cast，const_cast和dynamic_cast，他们本质上都是模板类。

隐式类型转换是安全的，显式类型转换是有风险的，C语言之所以增加强制类型转换的语法，就是为了强调风险，让程序员意识到自己在做什么。

这种强调风险的方式还是比较粗放，粒度比较大，它并没有表明存在什么风险，风险程度如何。再者，C风格的强制类型转换统一使用( )，而( )在代码中随处可见，所以也不利于使用文本检索工具（例如 Windows 下的 Ctrl+F、Linux 下的 grep 命令、Mac 下的 Command+F）定位关键代码。

为了使潜在风险更加细化，使问题追溯更加方便，使书写格式更加规范，C++ 对类型转换进行了分类，并新增了四个关键字来予以支持，它们分别是：

关键字	说明
static_cast	用于良性转换，一般不会导致意外发生，风险很低。
const_cast	用于 const 与非 const、volatile 与非 volatile 之间的转换。
reinterpret_cast	高度危险的转换，这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，但是可以实现最灵活的 C++ 类型转换。
dynamic_cast	借助 RTTI，用于类型安全的向下转型（Downcasting）。

这四个关键字的语法格式都是一样的，具体为：

xxx_cast<newType>(data)

newType 是要转换成的新类型，data 是被转换的数据。例如，老式的C风格的 double 转 int 的写法为：

double scores = 95.5;
int n = (int)scores;

C++ 新风格的写法为：

double scores = 95.5;
int n = static_cast<int>(scores);

1. static_cast 关键字

   static_cast 只能用于良性转换，这样的转换风险较低，一般不会发生什么意外，例如：

   • 原有的自动类型转换，例如 short 转 int、int 转 double、const 转非 const、向上转型等；
   • void 指针和具体类型指针之间的转换，例如void *转int *、char *转void *等；
   • 有转换构造函数或者类型转换函数的类与其它类型之间的转换，例如 double 转 Complex（调用转换构造函数）、Complex 转 double（调用类型转换函数）。

   需要注意的是，static_cast 不能用于无关类型之间的转换，因为这些转换都是有风险的，例如：

   • 两个具体类型指针之间的转换，例如int *转double *、Student *转int *等。不同类型的数据存储格式不一样，长度也不一样，用 A 类型的指针指向 B 类型的数据后，会按照 A 类型的方式来处理数据：如果是读取操作，可能会得到一堆没有意义的值；如果是写入操作，可能会使 B 类型的数据遭到破坏，当再次以 B 类型的方式读取数据时会得到一堆没有意义的值。
   • int 和指针之间的转换。将一个具体的地址赋值给指针变量是非常危险的，因为该地址上的内存可能没有分配，也可能没有读写权限，恰好是可用内存反而是小概率事件。

   static_cast 也不能用来去掉表达式的 const 修饰和 volatile 修饰。换句话说，不能将 const/volatile 类型转换为非 const/volatile 类型。

   static_cast 是“静态转换”的意思，也就是在编译期间转换，转换失败的话会抛出一个编译错误。

   下面的代码演示了 static_cast 的正确用法和错误用法：

   #include <iostream>
   #include <cstdlib>
   using namespace std;
   
   class Complex{
   public:
       Complex(double real = 0.0, double imag = 0.0): m_real(real), m_imag(imag){ }
   public:
       operator double() const { return m_real; }  //类型转换函数
   private:
       double m_real;
       double m_imag;
   };
   
   int main(){
       //下面是正确的用法
       int m = 100;
       Complex c(12.5, 23.8);
       long n = static_cast<long>(m);  //宽转换，没有信息丢失
       char ch = static_cast<char>(m);  //窄转换，可能会丢失信息
       int *p1 = static_cast<int*>( malloc(10 * sizeof(int)) );  //将void指针转换为具体类型指针
       void *p2 = static_cast<void*>(p1);  //将具体类型指针，转换为void指针
       double real= static_cast<double>(c);  //调用类型转换函数
      
       //下面的用法是错误的
       float *p3 = static_cast<float*>(p1);  //不能在两个具体类型的指针之间进行转换
       p3 = static_cast<float*>(0X2DF9);  //不能将整数转换为指针类型
   
       return 0;
   }
   

2. const_cast 关键字

   const_cast 比较好理解，它用来去掉表达式的 const 修饰或 volatile 修饰。换句话说，const_cast 就是用来将 const/volatile 类型转换为非 const/volatile 类型。

   下面我们以 const 为例来说明 const_cast 的用法：

   #include <iostream>
   using namespace std;
   int main(){
       const int n = 100;
       int *p = const_cast<int*>(&n);
       *p = 234;
       cout<<"n = "<<n<<endl;
       cout<<"*p = "<<*p<<endl;
       cout << "&n = " << &n << endl;
       cout << "p = " << p << endl;
       return 0;
   }
   运行结果：
   n = 100
   *p = 234
       
       
   

   

   **&n用来获取 n 的地址，它的类型为const int *，必须使用 const_cast 转换为int *类型后才能赋值给 p。**由于 p 指向了 n，并且 n 占用的是栈内存，有写入权限，所以可以通过 p 修改 n 的值。

   *有读者可能会问，为什么通过 n 和 p 输出的值不一样呢？这是因为 C++ 对常量的处理更像是编译时期的#define，是一个值替换的过程，代码中所有使用 n 的地方在编译期间就被替换成了 100。换句话说，第 7 行代码被修改成了下面的形式：

   cout<<"n = "<<100<<endl;

   这样以来，即使程序在运行期间修改 n 的值，也不会影响 cout 语句了。

   使用 const_cast 进行强制类型转换可以突破 C/C++ 的常数限制，修改常数的值，因此有一定的危险性；但是程序员如果这样做的话，基本上会意识到这个问题，因此也还有一定的安全性。

3. reinterpret_cast 关键字

   reinterpret 是“重新解释”的意思，顾名思义，reinterpret_cast 这种转换仅仅是对二进制位的重新解释，不会借助已有的转换规则对数据进行调整，非常简单粗暴，所以风险很高。

   reinterpret_cast 可以认为是 static_cast 的一种补充，一些 static_cast 不能完成的转换，就可以用 reinterpret_cast 来完成，例如两个具体类型指针之间的转换、int 和指针之间的转换（有些编译器只允许 int 转指针，不允许反过来）。

   下面的代码代码演示了 reinterpret_cast 的使用：

   #include <iostream>
   using namespace std;
   class A{
   public:
       A(int a = 0, int b = 0): m_a(a), m_b(b){}
   private:
       int m_a;
       int m_b;
   };
   int main(){
       //将 char* 转换为 float*
       char str[]="http://c.biancheng.net";
       float *p1 = reinterpret_cast<float*>(str);
       cout<<*p1<<endl;
       //将 int 转换为 int*
       int *p = reinterpret_cast<int*>(100);
       //将 A* 转换为 int*
       p = reinterpret_cast<int*>(new A(25, 96));
       cout<<*p<<endl;
      
       return 0;
   }
   运行结果：
   3.0262e+29
   25
   

   可以想象，用一个 float 指针来操作一个 char 数组是一件多么荒诞和危险的事情，这样的转换方式不到万不得已的时候不要使用。将A*转换为int*，使用指针直接访问 private 成员刺穿了一个类的封装性，更好的办法是让类提供 get/set 函数，间接地访问成员变量。

4. dynamic_cast 关键字

   dynamic_cast 用于在类的继承层次之间进行类型转换，它既允许向上转型（Upcasting），也允许向下转型（Downcasting）。向上转型是无条件的，不会进行任何检测，所以都能成功；向下转型的前提必须是安全的，要借助 RTTI 进行检测，所有只有一部分能成功。

   dynamic_cast 与 static_cast 是相对的，dynamic_cast 是“动态转换”的意思，static_cast 是“静态转换”的意思。dynamic_cast 会在程序运行期间借助 RTTI 进行类型转换，这就要求基类必须包含虚函数；static_cast 在编译期间完成类型转换，能够更加及时地发现错误。

   dynamic_cast 的语法格式为：

   dynamic_cast <newType> (expression)

   newType 和 expression 必须同时是指针类型或者引用类型。换句话说，dynamic_cast 只能转换指针类型和引用类型，其它类型（int、double、数组、类、结构体等）都不行。

   对于指针，如果转换失败将返回 NULL；对于引用，如果转换失败将抛出std::bad_cast异常。

   • （1）向上转型（Upcasting）

     向上转型时，只要待转换的两个类型之间存在继承关系，并且基类包含了虚函数（这些信息在编译期间就能确定），就一定能转换成功。因为向上转型始终是安全的，所以 dynamic_cast 不会进行任何运行期间的检查，这个时候的 dynamic_cast 和 static_cast 就没有什么区别了。

     「向上转型时不执行运行期检测」虽然提高了效率，但也留下了安全隐患，请看下面的代码：

     #include <iostream>
     #include <iomanip>
     using namespace std;
     class Base{
     public:
         Base(int a = 0): m_a(a){ }
         int get_a() const{ return m_a; }
         virtual void func() const { }
     protected:
         int m_a;
     };
     class Derived: public Base{
     public:
         Derived(int a = 0, int b = 0): Base(a), m_b(b){ }
         int get_b() const { return m_b; }
     private:
         int m_b;
     };
     int main(){
         //情况①
         Derived *pd1 = new Derived(35, 78);
         Base *pb1 = dynamic_cast<Derived*>(pd1);
         cout<<"pd1 = "<<pd1<<", pb1 = "<<pb1<<endl;
         cout<<pb1->get_a()<<endl;
         pb1->func();
         //情况②
         int n = 100;
         Derived *pd2 = reinterpret_cast<Derived*>(&n);
         Base *pb2 = dynamic_cast<Base*>(pd2);
         cout<<"pd2 = "<<pd2<<", pb2 = "<<pb2<<endl;
         cout<<pb2->get_a()<<endl;  //输出一个垃圾值
         pb2->func();  //内存错误
         return 0;
     }
     

     情况①是正确的，没有任何问题。对于情况②，pd 指向的是整型变量 n，并没有指向一个 Derived 类的对象，在使用 dynamic_cast 进行类型转换时也没有检查这一点，而是将 pd 的值直接赋给了 pb（这里并不需要调整偏移量），最终导致 pb 也指向了 n。因为 pb 指向的不是一个对象，所以get_a()得不到 m_a 的值（实际上得到的是一个垃圾值），pb2->func()也得不到 func() 函数的正确地址。

   • （2）向下转型（Downcasting）

     向下转型是有风险的，dynamic_cast 会借助 RTTI 信息进行检测，确定安全的才能转换成功，否则就转换失败。那么，哪些向下转型是安全地呢，哪些又是不安全的呢？下面我们通过一个例子来演示：

     #include <iostream>
     using namespace std;
     class A{
     public:
         virtual void func() const { cout<<"Class A"<<endl; }
     private:
         int m_a;
     };
     class B: public A{
     public:
         virtual void func() const { cout<<"Class B"<<endl; }
     private:
         int m_b;
     };
     class C: public B{
     public:
         virtual void func() const { cout<<"Class C"<<endl; }
     private:
         int m_c;
     };
     class D: public C{
     public:
         virtual void func() const { cout<<"Class D"<<endl; }
     private:
         int m_d;
     };
     int main(){
         A *pa = new A();
         B *pb;
         C *pc;
        
         //情况①
         pb = dynamic_cast<B*>(pa);  //向下转型失败
         if(pb == NULL){
             cout<<"Downcasting failed: A* to B*"<<endl;
         }else{
             cout<<"Downcasting successfully: A* to B*"<<endl;
             pb -> func();
         }
         pc = dynamic_cast<C*>(pa);  //向下转型失败
         if(pc == NULL){
             cout<<"Downcasting failed: A* to C*"<<endl;
         }else{
             cout<<"Downcasting successfully: A* to C*"<<endl;
             pc -> func();
         }
        
         cout<<"-------------------------"<<endl;
        
         //情况②
         pa = new D();  //向上转型都是允许的
         pb = dynamic_cast<B*>(pa);  //向下转型成功
         if(pb == NULL){
             cout<<"Downcasting failed: A* to B*"<<endl;
         }else{
             cout<<"Downcasting successfully: A* to B*"<<endl;
             pb -> func();
         }
         pc = dynamic_cast<C*>(pa);  //向下转型成功
         if(pc == NULL){
             cout<<"Downcasting failed: A* to C*"<<endl;
         }else{
             cout<<"Downcasting successfully: A* to C*"<<endl;
             pc -> func();
         }
        
         return 0;
     }
     
     运行结果：
     Downcasting failed: A* to B*
     Downcasting failed: A* to C*
     -------------------------
     Downcasting successfully: A* to B*
     Class D
     Downcasting successfully: A* to C*
     Class D
     

     这段代码中类的继承顺序为：A --> B --> C --> D。pa 是A*类型的指针，当 pa 指向 A 类型的对象时，向下转型失败，pa 不能转换为B*或C*类型。当 pa 指向 D 类型的对象时，向下转型成功，pa 可以转换为B*或C*类型。*同样都是向下转型，为什么 pa 指向的对象不同，转换的结果就大相径庭呢？

     虚函数存在时对象的真实内存模型，每个类都会在内存中保存一份类型信息，编译器会将存在继承关系的类的类型信息使用指针“连接”起来，从而形成一个继承链（Inheritance Chain），也就是如下图所示的样子：

     

     当使用 dynamic_cast 对指针进行类型转换时，程序会先找到该指针指向的对象，再根据对象找到当前类（指针指向的对象所属的类）的类型信息，并从此节点开始沿着继承链向上遍历，如果找到了要转化的目标类型，那么说明这种转换是安全的，就能够转换成功，如果没有找到要转换的目标类型，那么说明这种转换存在较大的风险，就不能转换。

     对于本例中的情况①，pa 指向 A 类对象，根据该对象找到的就是 A 的类型信息，当程序从这个节点开始向上遍历时，发现 A 的上方没有要转换的 B 类型或 C 类型（实际上 A 的上方没有任何类型了），所以就转换败了。

     对于情况②，pa 指向 D 类对象，根据该对象找到的就是 D 的类型信息，程序从这个节点向上遍历的过程中，发现了 C 类型和 B 类型，所以就转换成功了。

     总起来说，dynamic_cast 会在程序运行过程中遍历继承链，如果途中遇到了要转换的目标类型，那么就能够转换成功，如果直到继承链的顶点（最顶层的基类）还没有遇到要转换的目标类型，那么就转换失败。对于同一个指针（例如 pa），它指向的对象不同，会导致遍历继承链的起点不一样，途中能够匹配到的类型也不一样，所以相同的类型转换产生了不同的结果。

     从表面上看起来 dynamic_cast 确实能够向下转型，本例也很好地证明了这一点：B 和 C 都是 A 的派生类，我们成功地将 pa 从 A 类型指针转换成了 B 和 C 类型指针。但是从本质上讲，dynamic_cast 还是只允许向上转型，因为它只会向上遍历继承链。造成这种假象的根本原因在于，派生类对象可以用任何一个基类的指针指向它，这样做始终是安全的。本例中的情况②，pa 指向的对象是 D 类型的，pa、pb、pc 都是 D 的基类的指针，所以它们都可以指向 D 类型的对象，dynamic_cast 只是让不同的基类指针指向同一个派生类对象罢了。

unsigned short 转 CString

unsigned short p = ntohs((pOwner->serverAddress[0]).sin_port);
CString str;  
str.Format(_T("%hu"), p); // 使用%hu格式说明符来格式化unsigned short
AfxMessageBox(str);

		unsigned short p = _wtoi(lastSegment.GetBuffer(0));
		//unsigned short p = static_cast<unsigned short>(_tcstoi(lastSegment));
		CString str;  
		str.Format(_T("%hu"), p); // 使用%hu格式说明符来格式化unsigned short
		AfxMessageBox(str);

unsigned char 转 CString

unsigned char aaa = msgTime.second;
char asciiChar = static_cast<char>(aaa);
CString asciiString;
asciiString.Format(_T("The ASCII character of %d is %c."), aaa, asciiChar);
AfxMessageBox(asciiString);

int 转 CString

int num = pFrame->m_SiteInfo_v.size();
CString str;
str.Format(_T("num = %d"), num);
AfxMessageBox(str);

CString 转为 unsigned short

_wtoi();

		CString lastSegment = strIP.Mid(dotPos + 1); 
		AfxMessageBox(lastSegment);
		unsigned short p = _wtoi(lastSegment.GetBuffer(0));
		//unsigned short p = static_cast<unsigned short>(_tcstoi(lastSegment));
		CString str;  
		str.Format(_T("%hu"), p); // 使用%hu格式说明符来格式化unsigned short
		AfxMessageBox(str);

CString 转为 int

_ttoi();

			CString strPort = str.Mid(str.Find(_T(":"))+1);
			//AfxMessageBox(strPort);
			destUDPPort = _ttoi(strPort);