【C++】类型转换

【C++】类型转换

1、C语言中的类型转换

两种：隐式类型转换、显式类型转换

• 隐式类型转换：编译器在编译阶段自动进行转换，如果两者之间不能进行类型转换，编译会失败。
• 显式类型转换：（指定类型）变量的方式进行类型转换。

double a = 1.4;
int b = a;//隐式转换
int* p = &b;
int c = (int)p;//显式转换

2、C++中 string 与 int 相互转换

（1）使用atoi()函数

函数原型：int atoi(const char *nptr);

需要先用c_str()方法将string类型转为const char*。

c_str()函数返回一个指向正规C字符串的临时指针常量，不能对其进行操作，一定要用strcpy()函数等操作方法操作c_str()返回的指针。

string c("110");
int d = atoi(c.c_str());
cout << d << endl;

（2）stringstream

C++本身就提供了字符串与整型数之间的互换，那就是利用stringstream。

stringstream stream;//声明一个stringstream变量
int n;
string str;
stream << "123";//向stream插入字符串“123”
stream >> n; //从stream中提取字符串“123”，并且完成string到int的转换赋值给n
cout << "n的值：" << n << endl;

stream.clear();//清除steam的内容

stream << 123;
stream >> str;//int转为string
cout << "str的值：" << str << endl;

转换时，遇到数字或正负号才开始进行转换，直至遇到一个非数字或者字符串结束时(‘\n’)时结束转换。

3、C++的四种类型转换

因此C++为了加强类型转换的可视性，引入了四种命名的强制类型转换操作符，分别是static_cast、reinterpret_cast、const_cast和dynamic_cast。

（1）static_cast

static_cast用于相近类型之间的转换，编译器隐式执行的任何类型转换都可用static_cast，但它不能用于两个不相关类型之间转换。

double a = 1.4;
int b = static_cast<int>(a);//static_cast:double -> int

（2）reinterpret_cast

reinterpret_cast用于两个不相关类型之间的转换。

int* p = &b;
int c = reinterpret_cast<int>(p);

（3）const_cast

const_cast用于删除变量的const属性，转换后就可以对const变量的值进行修改。

const int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
cout << *p << endl;//3
cout << a << endl;//2

cout << (int)p << endl;
cout << (int)&a << endl;

const volatile int a = 3;
int& b = const_cast<int&>(a);
b = 2;//可以修改a内存里的值
cout << a << endl;//2
cout << b << endl;

cout << &a << endl;
cout << &b << endl;

实际上a所在的地址和指针p所指的地址是一致的那为什么a和*p的输出不一样呢？

• 由于编译器认为const修饰的变量是不会被修改的，因此会将const修饰的变量存放到寄存器当中，当需要读取const变量时就会直接从寄存器中进行读取，而我们修改的实际上是内存中的a的值，因此最终打印出a的值是未修改之前的值。

• 如果不想让编译器将const变量优化到寄存器当中，可以用**volatile关键字**对const变量进行修饰，这时当要读取这个const变量时编译器就会从内存中进行读取，即保持了该变量在内存中的可见性。

如：

const volatile int a = 2;
int* p = const_cast<int*>(&a);
*p = 3;
cout << *p << endl;//3
cout << a << endl;//3

cout << (int)p << endl;
cout << (int)&a << endl;

（4）dynamic_cast

dynamic_cast用于将父类的指针（或引用）转换成子类的指针（或引用）。

向上转型： 子类的指针（或引用）→ 父类的指针（或引用）。
向下转型： 父类的指针（或引用）→ 子类的指针（或引用）。

向上转型就是所说的切割/切片，向上转型是语法自然支持的，不需要进行转换。

向下转型的两个问题：

1. 如果父类的指针（或引用）指向的是一个父类对象，那么将其转换为子类的指针（或引用）是不安全的，因为转换后可能会访问到子类的资源，而这个资源是父类对象所没有的。
2. 如果父类的指针（或引用）指向的是一个子类对象，那么将其转换为子类的指针（或引用）则是安全的。

使用C风格的强制类型转换进行向下转型是不安全的，因为此时无论父类的指针（或引用）指向的是父类对象还是子类对象都会进行转换。而使用dynamic_cast进行向下转型则是安全的，如果父类的指针（或引用）指向的是子类对象那么dynamic_cast会转换成功，但如果父类的指针（或引用）指向的是父类对象那么dynamic_cast会转换失败并返回一个空指针。

class A {
public:
	virtual void f(){}
};

class B :public A {

};

void fun(A* pa) {
	B* pb1 = (B*)pa;//不安全
	B* pb2 = dynamic_cast<B*>(pa);//安全

	cout << "pa:" << pa << endl;
	cout << "pb:" << pb1 << endl;
	cout << "pb:" << pb2 << endl;
}

int main() {
	B b;
	A* pa = &b;
	fun(pa);
	return 0;
}

注意： dynamic_cast只能用于含有虚函数的类，因为运行时类型检查需要运行时的类型信息，而这个信息是存储在虚函数表中的，只有定义了虚函数的类才有虚函数表。

4、explicit

explicit用来修饰构造函数，从而禁止单参数构造函数的隐式转换。

class A {
public:
	int m_A;
    
	A(int a):m_A(a) {

	}	
};

int main() {
	A a = 1;//隐式转换
}

当遇到A a = 1这句代码时，会直接按照A a(1)的方式进行处理，这也叫做隐式类型转换。但对于单参数的自定义类型来说，A a = 1这种代码的可读性不是很好，因此可以用explicit修饰单参数的构造函数，从而禁止单参数构造函数的隐式转换，如：

class A {

public:
	int m_A;

	explicit A(int a) :m_A(a) {

	}
};

int main() {
	A a1 = 1;//错误，explicit修饰了单参数的构造函数，不允许
	A a2(1);//允许，可读性更强
}

5、小结

1、c++中string转int的两种方法：

atoi(const char *nptr)函数，stringstream，要注意的是atoi(const char *nptr)函数中接收的是常量指针，可使用c_str()使string转为const char*类型，这里要注意的是c_str()返回的是一个临时常量指针，不能对其进行操作。

2、c++中的四种类型转换：

• static_cast
• reinterpret_cast
• const_cast
• dynamic_cast