const在指针中的运用、string类、C++四种类型转换运算符

const限定符在指针中的运用

const和 * 的第1类关系， * 左右都没有const
pa的内存和a的内存都没有const就是都没有冻结，都可以改变，所以 * pa和pa都可以被改变

int main()
{
	int a=10;
	int b=20;
	int * pa=&a;
	cout<<"a="<<a<<endl;//输出a本来的10
	*pa=100;//间接访问a改变为100
	cout<<"a="<<a<<endl;//输出现在的a为100
	pa=&b;//因为pa是变量，所以可以改变指向，现在pa指向b
	return 0;
}

const和 * 的第2类关系, * 左没有const，* 右有const
pa的内存受const修饰，说明pa的内存被冻结了，所以pa不能被改变，就是不能pa=&b的地址；但是 * pa没有受到const修饰，所以 * pa可以被赋值，可以间接改变pa指向的a的内存里的值

#include <iostream>
using namespace std;
int main()
{
	int a = 10;
	int b = 20;
	int* const pa = &a;
	cout << "a=" << a << endl;//输出a本来的10
	*pa = 100;//间接访问a改变为100
	cout << "a=" << a << endl;//输出现在的a为100
	pa = &b;//这种情况下，这一行是编译通不过的，因为pa定义的时候由const修饰
	return 0;
}

const和 * 的第3类关系， * 左有const， * 右没有const
pa的内存没有const修饰，所以pa可以被改变，pa=&b可以编译通过；但是 * 左边有const修饰，说明pa指向的单元受const修饰，这时候不能用pa间接改变pa指向的单元的内存，就是 * pa=100是编译通不过的

int main()
{
	int a=10;
	int b=20;
	int  const * pa=&a;//等价于 const  int * pa=&a;
	cout<<"a="<<a<<endl;//输出a本来的10
	*pa=100;//这种情况下，这一行是编译通不过的
	pa=&b;//pa没有受const修饰，可以被改变，就是可以指向其他的变量
	return 0;
}

const和 * 的第4类关系， * 左右都有const
* 左边有const修饰，说明pa指向的单元受const修饰，这时候不能用pa间接改变pa指向的单元的内存，就是 * pa=100是编译通不过的；pa的内存受const修饰，说明pa的内存被冻结了，所以pa不能被改变，就是不能pa=&b的地址

int main()
{
	int a=10;
	int b=20;
	int  const * const pa=&a;//等价于 const  int * pa=&a;
	cout<<"a="<<a<<endl;//输出a本来的10
	*pa=100;//这种情况下，这一行是编译通不过的
	pa=&b;//这种情况下，这一行是编译通不过的
	return 0;
}

解除const对指针的限定

#include <iostream>
using namespace std;

int main()
{
    int num = 100;
    const int* p1 = &num;
    //int* p2 = p1;
    //*p2 = 200;    此处修改无效，因为此时的p1被const限定无法修改
    int* p2 = const_cast<int*>(p1); //将常量指针p1转换成普通指针
    *p2 = 200;
    cout << num <<endl; //输出结果：200

    return 0;
}

string类

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

int main()
{

    string a = "Hello";
    string b = " world";

    cout << a + b <<endl;   //输出第三个字符:l

    cout << a[2] <<endl;    //输出指定位置的字符

    //测量字符串长度
    cout << a.size() <<endl;    //输出5
    cout << a.length() <<endl; //输出5 

    //字符串的交换
    cout << a <<endl;  //输出结果：Hello
    cout << b <<endl;  //输出结果： world
    a.swap(b);  //字符串交换函数
    cout << a <<endl;  //输出结果： world
    cout << b <<endl;  //输出结果：Hello

    return 0;
}

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);

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 类型。

const_cast 关键字

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

注意：const_cast中的类型必须是指针、引用或指向对象类型成员的指针

#include<iostream>
using namespace std;
int main()
{
    //此语句错误，因为:const_cast中的类型必须是指针、引用或指向对象类型成员的指针
    //const int a=3;
    //int b=const_cast<int>(a);
    //b=5;
    //cout<<b<<endl;

    const int a = 10;
    int* b = const_cast<int*>(&a);  //此时b未被const限定
    cout << a << endl;
    cout << *b << endl;
    *b = 100;
    cout << *b << endl;
    return 0;
}

reinterpret_cast 关键字

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

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

dynamic_cast 关键字

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

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