（黑马C++）L09 C++类型转换 异常 输入输出流

一、C++类型转换

类型转换（cast）是将一种数据类型转换成另一种数据类型，一般情况下要尽量少的去使用类型转换，除非解决非常特殊的问题。

（1）静态转换（static_cast）

static_cast使用方式：static_cast<目标类型>(原始对象)；

• 用于类层次结构中基类（父类）和派生类（子类）之间指针或引用的转换。
• 没有父子关系的自定义类型不能进行转换。

#include <iostream>
using namespace std;

class Base{};
class Child : public Base{};

void test() {
    Base* base = NULL;
    Child* child = NULL;

    //把base转成child，向下类型转换，不安全
    Child* child2 = static_cast<Child*> (base);

    //把child转成base，向上类型转换，安全
    Base* base2 = static_cast<Base*> (child);
}


int main() {
    test();
    system("pause");
    return 0;
}

• 用于基本数据类型之间的转换，如把int转换成char，或者把char转换成int。

#include <iostream>
using namespace std;

void test() {
    char a = 'a';
    double d = static_cast<double>(a);
    cout << "d = " << d <<endl;
}


int main() {
    test();
    system("pause");
    return 0;
}

（2）动态转换（dynamic_cast）

• 动态转关非常严格，失去精度或者不安全都不可以转换。
• 没有发生多态的情况下，可以用于子类转基类，但是不能用于基类转子类。
• dynamic_cast如果发生了多态，可以让基类转为派生类，向下转换。

#include <iostream>
using namespace std;

class Base{
public:
    virtual void func() {};
};

class Child : public Base{
    virtual void func() {};
};

void test() {
    Base* base = NULL;
    Child* child = NULL;

    Base* base2 = new Child;
    Child* child = dynamic_cast<Child*> (base2);
}


int main() {
    test();
    system("pause");
    return 0;
}

（3）常量转换（const_cast）

用于修改类型的const属性。

• 常量指针被转化为非常量指针，并且仍然指向原来的对象。
• 常量引用被转换成非常量引用，并且仍然指向原来的对象。
• 注意：不能直接对非指针和非引用的变量使用const_cast操作符直接移除它的const。

#include <iostream>
using namespace std;

void test() {
    //去除const
    const int * p = NULL;
    int * newp = const_cast<int*> (p);

    //加上const
    int * p2 = NULL;
    const int * newp2 = const_cast<const int*> (p2);
}


int main() {
    test();
    system("pause");
    return 0;
}

（4）重新解释转换（reinterpret_cast）

• 最不安全的转换机制，最有可能出现问题，不推荐使用。
• 主要用于将一种数据类型转换为另一种类型，可以将一个指针转换成一个整数，也可以将一个整数转换成一个指针。

二、C++异常

（1）异常的基本使用

• 异常处理就是处理程序中的错误，即程序运行过程中发生的一些异常事件（如：除0溢出，数组下标越界，读取的文件不存在。空指针，内存不足等）。
• 在C语言中对错误的处理有两种方法：一是使用整型的返回值标识错误，二是使用errno宏，用不同的数字变量返回错误，该方法的局限是会出现不一致的问题，可能无法判断是返回值还是异常。

int myDevide(int a, int b) {
    if(b == 0) return -1;
    return a/b;
}

• C++的异常机制：使用抛出异常和处理异常，抛出的异常必须进行处理，否则程序会出错。
• 如果异常种类较多，都要进行处理，也可以使用以下方式：

catch(...) { //捕获异常
        cout << "其他类型异常捕获" << endl;
    }

#include <iostream>
using namespace std;

int myDevide(int a, int b) {
    if(b == 0) {
        throw -1; //抛出int类型的异常
    }
    return a/b;
}

void test() {
    int a = 10;
    int b = 0;
    try{
        myDevide(a, b);
    }
    catch(int) { //捕获异常
        cout << "int类型异常捕获" << endl;
    }
}

int main() {
    test();
    system("pause");
    return 0;
}

• 异常处理可以在调用跳级，假设在有多个函数的调用栈中出现了某个错误，使用整型返回码要求在每一级函数中都进行处理，而使用异常处理的栈展开机制，只需要在一处进行处理就行，不需要每级函数都处理。
• 以下代码会打印 double类型异常捕获，但是不想处理时可以继续向上抛出
• 如果异常没有处理，会调用terminate函数，使程序中断

#include <iostream>
using namespace std;

int myDevide(int a, int b) {
    if(b == 0) {
        throw 3.14;
    }
    return a/b;
}

void test() {
    int a = 10;
    int b = 0;
    try{
        myDevide(a, b);
    }

    catch(int) { //捕获异常
        cout << "int类型异常捕获" << endl;
    }

    catch(double) { //捕获异常
        //如果不想处理这个异常需要向上抛出
        //throw; 此时会返回main函数中double类型异常捕获
        cout << "double类型异常捕获" << endl;
    }
}

int main() {
    try{
        test();
    }
    catch(double) {
        cout << "main函数中double类型异常捕获" << endl;
    }
    system("pause");
    return 0;
}

（2）对自定义异常进行捕获

可以抛出自定义对象，捕获自定义异常。

#include <iostream>
using namespace std;

//自定义异常
class myException {
public:
    void printError() {
        cout << "自定义异常" << endl;
    }
};

int myDevide(int a, int b) {
    if(b == 0) {
        throw myException(); //匿名对象
    }
    return a/b;
}

void test() {
    int a = 10;
    int b = 0;
    try{
        myDevide(a, b);
    }

    catch(myException e) { //捕获异常
       e.printError();
    }
}

int main() {
    test();
    system("pause");
    return 0;
}

（3）栈解璇

异常被抛出后，从进入try块起，到异常被抛出前，这期间在栈上构造的所有对象，都会被自动析构，析构的顺序与构造的顺序相反，这一过程称为栈的解璇。

（4）异常的接口声明

• 为了加强程序的可读性，可以在函数声明中列出可能抛出异常的所有类型，例如：void func() throw(A, B, C) } {}；这个函数func只能抛出类型A, B, C及其子类型的异常。
• 如果函数声明中没有包含异常接口声明，则此函数可以抛出任何类型的异常。
• 一个不抛出任何类型异常的函数可声明为void func() throw() {}。
• 如果一个函数抛出了它的异常接口声明不允许抛出的异常，unexcepted函数会被调用，该函数默认调用terminate函数中断程序。

（5）异常变量生命周期

#include <iostream>
using namespace std;

class myException {
    myException() {
        cout << "默认构造函数调用" <<endl;
    }

    myException(const myException& e) {
        cout << "拷贝构造函数调用" <<endl;
    }

    ~myException() {
        cout << "析构函数调用" <<endl;
    }
};

void doWork() {
    throw myException();
}

void test() {
    try{
        doWork();
    }
    catch(myException e) {
        cout << "捕获异常" << endl;
    }
}

int main() {
    test();
    system("pause");
    return 0;
}

以上函数会输出以下结果，因为myException()调用默认构造，myException e调用拷贝构造，此时拷贝构造会多花费一份开销，所以一般写成myException &e，此时不会再调用拷贝构造。

默认构造函数调用
拷贝构造函数调用
捕获异常
析构函数调用
析构函数调用

 当异常写成以下形式时，会先析构，执行结果为默认构造函数调用，析构函数调用，捕获异常。

#include <iostream>
using namespace std;

class myException {
    myException() {
        cout << "默认构造函数调用" <<endl;
    }

    myException(const myException& e) {
        cout << "拷贝构造函数调用" <<endl;
    }

    ~myException() {
        cout << "析构函数调用" <<endl;
    }
};

void doWork() {
    throw &myException();
}

void test() {
    try{
        doWork();
    }
    catch(myException* e) {
        cout << "捕获异常" << endl;
    }
}

int main() {
    test();
    system("pause");
    return 0;
}

（6）异常的多态使用

利用多态可以实现printError同一个接口调用，抛出不同的错误对象。

#include <iostream>
using namespace std;

//异常基类
class BaseException{
public:
    virtual void printError() {
        
    }
};

class NullPointerException : public BaseException {
public:
    virtual void printError() {
        cout << "空指针异常" << endl;
    }
};

void doWork() {
    throw NullPointerException();
}

void test() {
    try{
        doWork();
    }
    catch(BaseException& e) { //父类的引用调用子类的对象
        e.printError();
    }
}

int main() {
    test();
    system("pause");
    return 0;
}

（7）C++标准异常库

标准库中提供了很多的异常类，它们是通过类继承组织起来的，异常类继承层级结构图如下：

•  在上述继承中，每个类都提供了构造函数，拷贝构造函数，析构函数和赋值运算符的重载；
• logic_error类以及其子类、runtime_error类以及其子类，他们的构造函数接收一个string类型的参数，用于异常信息的描述；
• 所有的异常都有一个what方法，返回 const char* 类型的值，描述异常信息。

 exception的直接派生类：

 logic_error的派生类：

 runtime_error 的派生类：

 以out_of_range异常为例，看一下它具体的使用方法，使用时需要包含头文件<stdexcept>

#include <iostream>
#include <string>
using namespace std;
//系统提供的异常
#include <stdexcept>

class Person {
public:
    Person(string name, int age) {
        this->m_Name = name;
        if(age < 0 || age > 200) {
            //抛出越界异常
            throw out_of_range("年龄越界！");
        }
        else {
            this->m_Age = age;
        }
    }

    string m_Name;
    int m_Age;
};

void test01() {
    try{
        Person p("张三"， 300);
    }
    catch(out_of_range& e) {
        cout << e.what() << endl;
    }
}

int main() {
    test01();
    system("pause");
    return 0;
}

三、C++输入与输出流

程序的输入指的是从输入文件将数据传送给程序，程序的输出指的是从程序将数据传送给输出文件。

C++的输入输出包含三种：

标准I/O：从键盘输入数据，输出到显示器屏幕

文件I/O：以外存磁盘文件为对象进行输入和输出

串I/O：对内存中指定的空间进行输入和输出，通常指定字符数组作为存储空间进行信息存储

（1）标准输入流

• 缓冲区：输入和输出的所有数据，都不是直接放在程序中，而是先放在缓冲区中，然后再从缓冲区中取出数据。
• cin.get()：一次读取一个字符，输入abc 输出a

void test01()
{
    char ch;
    ch = cin.get(); //输入as
    cout << "ch = " << ch << endl; //输出a

    ch = cin.get();
    cout << "ch = " << ch << endl; //输出s

    ch = cin.get();
    cout << "ch = " << ch << endl; //输出换行

    ch = cin.get();
    cout << "ch = " << ch << endl; //等待下一次输入
}

• cin.get(一个参数)：读一个字符，与上面效果一样
• cin.get(两个参数)：可以读字符串

void test() {
    char buf[1024];
    //cin >> buf;  //采用>>运算符输入字符窜，遇到空格就会停止
    //cout << buf << endl;
    
    cin.get(buf, 1024); //不会拿走换行，换行还在缓冲区
    cout << buf<< endl;
}

• cin.getline()：读取一行字符串

void test() {
    char buf[1024];
    cin.getline(buf, 1024); //会把换行符也读取并扔掉换行符
    cout << buf<< endl;
}

• cin.ignore()：默认忽略缓冲区的一个字符，带参数N，代表忽略N个字符

void test() {
    cin.ignore(); //输入as
    char c = cin.get();
    cout << c << endl; //输出s
}

• cin.peek()：从缓冲区查看一个字符，但不会从缓冲区取走

void test()
{
    char c = cin.peek();  //输入as
    cout <<"c = "<< c <<endl; //输出a

    ch = cin.get();
    cout << "c = " << c << endl; //输出a
}  

• cin.pushback()：将缓冲区取出的字符放回原位置

void test()
{
    char c = cin.get();  //输入helloworld  h被拿走
    cin.putback(c); //h被放回

    char buf[1024];
    cin.getline(buf, 1024); //读取字符串
    cout << "buf = " << buf << endl;
}

• 标准输入流案例
• （1）判断用户输入的是字符串还是数字

void test() {
    cout << "请输入一串数字或者字符串" << endl;
    //判断第一个字母(peek)
    char c = cin.peek();
    if(c >= '0' && c <= '9') {
        int num;
        cin >> num; //在缓冲区读取
        cout << "您输入的是数字，数字为：" << num <<endl;
    }
    else {
        char buf[1024];
        cin >> buf;
        cout << "您输入的是字符串，字符串为：" << buf <<endl;
    }
}

• （2）让用户输入1-10的数字，如果输入有误，重新输入

void test() {
    int num;
    while(true) {
        cout << "请输入数字:" << endl;
        cin >> num; //如果输入的是char形，标志位会被修改
        if(num > 0 && num <= 10) {
            cout << "输入的数字为:" << num << endl;
            break;
        }
        else {
            cout << "对不起，请重新输入!" << endl;
            cin.clear(); //重置标志位
            cin.sync();  //清空缓冲区
            //cout <<"标志位：" << cin.fail() << endl; //标志位0正常 1不正常
        } 
    }
    
}

（2）标准输出流

• cout.flush()：刷新缓冲区，Linux下有效
• cout.put()：向缓冲区写字符

void test() {
    cout.push('a').put('b'); //输入ab
}

• cout.write()：从buffer中写num个字节到当前的输出流中

void test() {
    char buf[1024] = "helloworld";
    cout.write(buf, strlen(buf));
}

•  格式化输出：使用控制符方法；使用流对象的有关成员函数
• 使用成员函数

void test()
{
    int num = 99;
    cout.width(20);  //设置宽度，前面加18个空格
    cout.fill('*');  //设置填充，将空格填充为*
    cout.setf(ios::left); //左设置对齐  set format
    cout.unsetf(ios::dec); //卸载十进制
    cout.setf(ios::hex);  //安装十六进制
    cout.setf(ios::showbase);//显示进制基数，如果是十六进制，前面加上0x
    cout.unsetf(ios::hex);  //卸载十六进制
    cout.setf(ios::oct);  //安装八进制
    cout << num << endl;
}

• 使用控制符(包含头文件iomanip)

void test03()
{
    int num = 99;
    cout << setw(20)                   //设置宽度
         << setfill('~')               //设置填充
         << setiosflags(ios::showbase) //显示进制基数
         << setiosflags(ios::left)     //左对齐
         << hex                        //安装16进制
         << num << endl;
}

（3）文件的读写操作

文件读写定义了三个类，分别是ofstream、ifstream、fstream。

• 打开文件

用一个流对象打开一个文件的成员函数是open (filename, mode)；其中 filename 是一个字符串，表示要打开的文件的名称，mode 是一个可选参数，由以下标志组合而成:

• 写文件操作示例如下：

#include <iostream>
using namespace std;
//文件读写头文件
#include <fstream>

//写文件
void test01() {
    //以输出方式打开文件
    ofstream ofs("./test.txt", ios::out | ios::trunc);
    
    //后期指定打开方式
    ofstream ofs;
    ofs.open("./test.txt", ios::out | ios::trunc);

    //判断是否打开成功
    if(!ofs.is_open()) {
        cout << "打开失败！" << endl;
    }
    
    //输入内容
    ofs << "姓名：abc" <<endl;
    ofs << "年龄：20" <<endl;
    ofs << "性别：男" <<endl;

    //写入完毕后关闭文件
    ofs.close();
}

• 读文件操作示例如下：

void test02() {
    ifstream ifs;
    ifs.open("./test.txt", ios::in);

    //判断是否打开成功
    if(!ifs.is_open()) {
        cout << "打开失败" << endl;
    }
    
    //第一种方式 -- 用数组存储
    char buf[1024];
    while(ifs >> buf) { //按行读取
        cout << buf <<endl;
    }

    //第二种方式
    char buf2[1024];
    while(!ifs.eof()) { //eof读到文件的尾部
        ifs.getline(buf2, sizeof(buf2));
        cout << buf2 << endl;
    }

    //第三种方式 -- 按单个字符读取（不推荐）
    char c;
    while((c = ifs.get()) != EOF) { //EOF 文件尾
        cout << c;
    }
}