C++ 语言学习 day11 复习（3）

1.第一个是昨天的作业： 用类实现一个双向循环链表， 完成对应的功能，（增删查改 ）

代码：

list.h

#ifndef LIST_H
#define LIST_H
#include <iostream>
#include <string.h>
using namespace std;

#define Type int //宏定义
typedef unsigned int u32;//无符号整型
/***** 节点的结构体 ****/
struct Node
{
    Node():data(new Type),prev(NULL),next(NULL)
    {
        memset(data,0,sizeof(Type));    /*清零数据*/
    }/*构造函数:申请空间*/
    ~Node(){delete data;}/*析构函数:释放空间*/

    Type *data; /*数据域*/
    Node *prev; /*前驱*/
    Node *next; /*后继*/
};

/****** 链表的结构体 ******/
class List
{
public:
    List() /*链表构造函数*/
    {
        /*1.申请空间*/
        m_head = new Node;
        /*2.更改指向*/
        m_head->next = m_head;
        m_head->prev = m_head;
        /*3.初始化元素个数*/
        m_size = 0;
    }
//    List(const List &list) /*链表拷贝构造*/
//        :List()/*1.调用无参构造*/
//    {
//        /*2.拷贝list表的数据到this表中*/
//        /*调用链表尾部增加 push_back()*/
//    }
    ~List()
    {
        clear();    /*清空非表头节点*/
        delete m_head;/*释放表头*/
    }
public: /* 公有接口 */
    bool push_back(const Type &value)/*链表尾部增加*/
    {
        return insert(m_head,value);
//        /*1.新增节点*/
//        Node *node = new Node;
//        /*2.拷贝数据到新节点空间*/
//        *node->data = value;
//        /*3.找到要插入位置的前后节点*/
//        Node *prev = m_head->prev;
//        Node *next = m_head;
//        /*4.更改指向*/
//        node->prev = prev;
//        node->next = next;

//        prev->next = node;
//        next->prev = node;
//        /*5.元素个数+1*/
//        m_size++;
//        return true;
    }
    bool push_front(const Type &value)/*链表头部增加*/
    {
        return insert(m_head->next,value);
    }
    bool insert(Node *insert_node,const Type &value)/*链表任意节点位置插入*/
    {
        /*1.新增节点*/
        Node *node = new Node;
        /*2.拷贝数据到新节点空间*/
        *node->data = value;
        /*3.找到要插入位置的前后节点*/
        Node *prev = insert_node->prev;
        Node *next = insert_node;
        /*4.更改指向*/
        node->prev = prev;
        node->next = next;

        prev->next = node;
        next->prev = node;
        /*5.元素个数+1*/
        m_size++;

        return true;
    }
    bool insert(u32 index,Type &value)/*链表任意插入*/
    {
        if(index > m_size) index = m_size;
        /**** 找到要插入位置的节点 ****/
        Node *node = m_head->next;

        for(u32 i = 0; i < index;i++)
        {
            node = node->next;
        }
        /**** 插入数据 ****/
        return insert(node,value);
    }
    bool pop_back()/*链表尾部删除*/
    {
        if(m_size == 0) return false;
        return erase(m_head->prev);
    }
    bool pop_front()/*链表头部删除*/
    {
        if(m_size == 0) return false;
        return erase(m_head->next);
    }
    bool erase(int index)/*链表任意删除节点*/
    {
        if(m_size == 0 || index >= m_size) return false;

        /*** 1.找到要删除的节点 ****/
        Node *node = m_head->next;
        for(int i = 0; i < index;i++)
        {
            node = node->next;
        }

        /*** 2.删除节点 ****/
        return erase(node);
    }
    bool erase(Node *node)
    {
        /*** 1.找到前驱和后继 ***/
        Node *prev = node->prev;
        Node *next = node->next;

        /*** 2.释放节点 *****/
        delete node;

        /*** 3.修改指向 ****/
        prev->next = next;
        next->prev = prev;

        /*** 4.元素个数-1 **/
        m_size--;
        return true;
    }
    void clear()/*清空链表*/
    {
        while(m_size != 0)
        {
            pop_back();/*尾部删除*/
        }
    }
    bool remove(const Type &value)/*删除第一个匹配的值 : 会调用 == 运算符重载*/
    {
        /*** 1.找到匹配节点 ****/
        Node *node = m_head->next;

        while(node != m_head)
        {
            if(*node->data == value)
            {
                /**** 删除该节点 ****/
                return erase(node);
            }
            node = node->next;  /*往后遍历*/
        }

        return false;
    }
    template <class _Predicate>/*虚拟类型*/
    bool remove_if(_Predicate Predicate) /*删除第一个匹配的值 : 一元谓词: bool func(Type value) */
    {
        /*** 1.找到匹配节点 ****/
        Node *node = m_head->next;

        while(node != m_head)
        {
            if( Predicate(*node->data) == true)
            {
                /**** 删除该节点 ****/
                return erase(node);
            }
            node = node->next;  /*往后遍历*/
        }

        return false;
    }
    void remove_all(const Type &value)/*删除所有匹配的值: 会调用 == 运算符重载*/
    {
        /**** 1.找到匹配节点 ****/
        while(remove(value) == true);

    }
    template <class _Predicate>/*虚拟类型*/
    void remove_all_if(_Predicate Predicate)/*删除所有匹配的值: 一元谓词: bool func(Type value)*/
    {
        /**** 1.找到匹配节点 ****/
        while(remove_if(Predicate) == true);

    }
    Type &front()/*返回链表第一个元素*/
    {
        return *m_head->next->data;
    }
    Type &back()/*返回链表最后一个元素*/
    {
        return *m_head->prev->data;
    }
    Type &operator [](u32 index) const/*提供随机访问*/
    {
        if(index >= m_size)
        {
            cout << "链表没有元素个数,爆出异常" << endl;
            throw "异常:链表没有元素个数"; /*报异常*/
        }

        Node *node = m_head->next;  /*第一个元素*/
        for(u32 i = 0; i < index;i++)
        {
            node = node->next; /*往后遍历*/
        }

        return *node->data;
    }
    u32 size() const    /*获取元素的个数*/
    {
        return m_size;
    }
    Type &find(Type value)
    {
        /*** 1.找到匹配节点 ****/
        Node *node = m_head->next;

        while(node != m_head)
        {
            if(*node->data == value)
            {
                /**** 返回该节点数据 ****/
                break;
            }
            node = node->next;  /*往后遍历*/
        }

        return *node->data;
    }
    template <class _Predicate>/*虚拟类型*/
    Type &find_if(_Predicate Predicate)
    {
        /*** 1.找到匹配节点 ****/
        Node *node = m_head->next;

        while(node != m_head)
        {
            if(Predicate(*node->data))
            {
                /**** 返回该节点数据 ****/
                break;
            }
            node = node->next;  /*往后遍历*/
        }

        return *node->data;
    }
    static void sort(int *addr,int len) /*冒泡排序:调用 > 运算符重载 */
    {
//        int addr[];
//        int len = 0;
        bool flag = false;/*记录是否排好序,排好序:false,未排好序:true*/

        int temp = 0;/*临时变量,用于交换*/
        for(int i = 0; i < len - 1;i++)
        {
            flag = false;/*清空数据,用于下次记录*/
            for(int j = 0; j < len - i - 1;j++)
            {
                if(addr[j] > addr[j+1])
                {
                    flag = true;/*表名没有排好序*/
                    /*交换*/
                    temp = addr[j];
                    addr[j] = addr[j+1];
                    addr[j+1] = temp;
                }
            }
            if(flag == false) break;    /*检测是否排好序,排好需就直接退出*/
        }
    }

    void sort()
    {
        bool flag = false;/*记录是否排好序,排好序:false,未排好序:true*/
        Type *temp = NULL;/*临时指针,用于交换*/

        Node *node_i = NULL;
        Node *node_j = NULL;

        /****** 排序 *******/
        for(node_i = m_head->next ; node_i != m_head->prev ; node_i = node_i->next)
        {
            flag = false;/*清空数据,用于下次记录*/
            for(node_j = m_head->next;node_j != m_head->prev ; node_j = node_j->next)
            {
                if(*node_j->data > *node_j->next->data)
                {
                    flag = true;/*表名没有排好序*/
                    /*交换*/
                    temp = node_j->data;
                    node_j->data = node_j->next->data;
                    node_j->next->data = temp;
                }
            }
            if(flag == false) break;    /*检测是否排好序,排好需就直接退出*/
        }
    }

/***** 接口使用 *****/
protected:
    Node *m_head;   /* 节点:表头 */
    u32 m_size;     /* 元素个数 */
};

#endif // LIST_H

main.cpp

#include <iostream>
#include "list.h"
using namespace std;
void Print(const List &list);

int main()
{
    List list;

    for(int i = 0 ; i < 10;i++)
    {
        list.push_front(i);
    }

    cout << "排序前:";
    for(u32 i = 0; i < list.size();i++)
    {
        cout << list[i] << ",";
    }
    cout << endl;

    list.sort();

    cout << "排序后:";
    for(u32 i = 0; i < list.size();i++)
    {
        cout << list[i] << ",";
    }
    cout << endl;

    return 0;
}


int test2()
{
    int addr[10] = {123,1234,236,437,64,51,6,6756,845,85};
    int len = 10;

    cout << "未排序addr : ";
    for(int i = 0; i < len;i++)
    {
        cout << addr[i] << ",";
    }
    cout << endl;

    List::sort(addr,len);

    cout << "已排序addr : ";
    for(int i = 0; i < len;i++)
    {
        cout << addr[i] << ",";
    }
    cout << endl;
}















int test1()
{
    List list;

    for(int i = 0; i < 10; i++)
    {
        //list.push_back(i); /*尾部插入:0,1,2,3,4,5,6,7,8,9*/
        //list.insert(0,i);/*头部插入*/
        list.insert(list.size(),i);/*尾部插入*/
    }
    cout << "第一个元素:" << list.front() << endl;
    cout << "最后的元素:" << list.back() << endl;

    /**** 删除头尾 ****/
    list.pop_back();
    list.pop_front();
    cout << "输出list结构的数据:" << endl;
    Print(list);

    /**** 删除下标位 3的位置 *****/
    list.erase(3);
    cout << "输出list结构的数据:" << endl;
    /**** 清空 ****/
    //list.clear();

    //list.remove(6);
    list.push_back(5);
    list.push_front(5);

    //list.remove_all(5);
    Print(list);

    cout << "调用带 自定义策略的函数" << endl;
    bool int_cmp(Type value);   /*函数类声明函数*/
    list.remove_all_if(int_cmp);
    Print(list);

    cout << "查询 3" << endl;
    int value = list.find(10);
    cout << "value = " << value << endl;

    cout << "查询大于 5" << endl;
    value = list.find_if([/*依赖*/](Type value/*参数列表*/)->bool/*返回值类型*/{
                /*匿名函数的函数体*/
                if(value > 5) return true;
                return false;
            });
    cout << "value = " << value << endl;

    cout << "程序正常结束" << endl;
    return 0;
}

bool int_cmp(Type value)
{
    if(value > 5) return true;
    return false;
}

void Print(const List &list)
{
    for(u32 i = 0; i < list.size();i++)
    {
        cout << list[i] << ",";
    }
    cout << endl;
}

2.继承，

/********* 多继承会造成的问题 *************************
 * 1.父类成员同名问题?
 *      答:使用类域调用解决
 * 2.菱形继承(砖石继承)?:
 *      人类
 *  学生    工人
 *     实习生
 *   答:使用虚继承方式,形成续表索引(32位机:虚指针占4字节)
 * *************************************************/

父类成员同名问题?
 *      答:使用类域调用解决

代码：

#include <iostream>
using namespace std;

class Student   /*学生*/
{
public:
    string m_name;  /*姓名*/
    int m_age;      /*年龄*/
    float m_score = 0;  /*分数*/
public:
    void study(){cout << "学习" << endl;}
    void exam(){ cout << "考试" << endl;}
};

class Worker    /*工人*/
{
public:
    string m_name;  /*姓名*/
    int m_age;      /*年龄*/
    int m_salary = 0; /*薪水*/
public:
    void wage(int hour)
    {
        int salary = 20 * hour;
        m_salary += salary;
        cout << "工作:" << hour << "小时,赚取:" << salary << "薪水" << endl;
    }
};

/* 实习生,继承于 学生 和 工人 */
class Trainee : public Student , public Worker
{
public:
    void sleep(){ cout << "我是实习生" << endl;}
};

/********* 多继承会造成的问题 *************************
 * 1.父类成员同名问题?
 *      答:使用类域调用解决
 * 2.菱形继承(砖石继承)?:
 *      人类
 *  学生    工人
 *     实习生
 *   答:使用虚继承方式,形成续表索引(32位机:虚指针占4字节)
 * *************************************************/


int main()
{
    Trainee trainee;

    cout << "m_score = " << trainee.m_score << endl;
    cout << "m_salary = " << trainee.m_salary << endl;

    /******** 使用成员同名变量 ********/
    trainee.Student::m_name = "王老师";
    trainee.Worker::m_name = "王无敌";

    cout << "name = " << trainee.Student::m_name << endl;
    cout << "name = " << trainee.Worker::m_name << endl;

    return 0;
}

虚继承方式,形成续表索引

#include <iostream>
using namespace std;

class People
{
public:
    string m_name;  /*姓名*/
    int m_age;      /*年龄*/
};

class Student : virtual public People  /*学生*/
{
public:
    float m_score = 0;  /*分数*/
public:
    void study(){cout << "学习" << endl;}
    void exam(){ cout << "考试" << endl;}
};

class Worker : virtual public People    /*工人*/
{
public:
    int m_salary = 0; /*薪水*/
public:
    void wage(int hour)
    {
        int salary = 20 * hour;
        m_salary += salary;
        cout << "工作:" << hour << "小时,赚取:" << salary << "薪水" << endl;
    }
};

/* 实习生,继承于 学生 和 工人 */
class Trainee : public Student , public Worker
{
public:
    void sleep(){ cout << "我是实习生" << endl;}
};
/********* 多继承会造成的问题 *************************
 * 1.父类成员同名问题?
 *      答:使用类域调用解决
 * 2.菱形继承(砖石继承)?:
 *      人类
 *  学生    工人    -> 这里使用虚继承 virtual public People
 *     实习生
 *   答:使用 virtual 虚继承方式,形成续表索引(32位机:虚指针占4字节)
 * 3.虚继承的好处
 * *************************************************/
int main()
{
#if 0
    /**** 探讨大小 ***/
    cout << "sizeof(string) = " << sizeof(string) << endl;  //24字节
    cout << "sizeof(People) = " << sizeof(People) << endl;  //28字节

    cout << "sizeof(Student)= " << sizeof(Student) << endl; //32字节
    cout << "sizeof(Worker) = " << sizeof(Worker)  << endl; //32字节

    cout << "sizeof(Trainee)= " << sizeof(Trainee) << endl; //64字节
#else
    /*—— 通过以上可以看出,我共同继承于人类部分多余了,只用一份空间就行,所以照成空间浪费——*/
    /*答:使用 virtual 虚继承方式解决多该案例多占用 28 字节,但是 virtual是虚指针所以需要占用 4字节空间*/
    /**** 探讨大小 ***/
    cout << "sizeof(string) = " << sizeof(string) << endl;  //24字节
    cout << "sizeof(People) = " << sizeof(People) << endl;  //28字节

    cout << "sizeof(Student)= " << sizeof(Student) << endl; //32+4字节
    cout << "sizeof(Worker) = " << sizeof(Worker)  << endl; //32+4字节

    cout << "sizeof(Trainee)= " << sizeof(Trainee) << endl; //64+8-28字节
    /*———————————— 通过以上案例,得出已经只占用一片空间 ————————————*/
#endif
    Trainee trainee;
    trainee.m_name = "老师";
    cout << "姓名:" << trainee.People::m_name << endl;
    cout << "姓名:" << trainee.Student::m_name << endl;
    cout << "姓名:" << trainee.Worker::m_name << endl;
    cout << "姓名:" << trainee.Trainee::m_name << endl;
    return 0;
}

3.多态 （）

多态的定义：

多态是C++面向对象三大特性之一 多态分为两类： ◼静态多态: 函数重载 和 运算符重载属于静态多态，复用函数名 ◼动态多态: 派生类和虚函数实现运行时多态（重写)

静态多态和动态多态区别： ◼静态多态的函数地址早绑定 - 编译阶段确定函数地址 ◼动态多态的函数地址晚绑定 - 运行阶段确定函数地址

总结： 多态满足条件： ◼有继承关系 ◼子类重写父类中的虚函数(”虚“会被继承) 多态使用条件： ◼父类指针或引用指向子类对象 重写：函数返回值类型 函数名 参数列表 完全一致称为重写

多态的优点

多态的优点： ◼代码组织结构清晰 ◼可读性强 ◼利于前期和后期的扩展以及维护 总结：C++开发提倡利用多态设计程序架构，因为多态优点很多

代码：（加强版）

#include <iostream>

using namespace std;
class People
{
public:
    /**** 虚函数 -> Qt里面 函数名变成斜体字 ****/
    virtual void study()
    {
        cout << "自我摸索学习" << endl;
    }
public:
    string m_name;
    int m_age;
};

class Student : public People
{
public:
    void study()    /* -> 重写 */
    {
        cout << "跟着大牛老师学习" << endl;
    }
};

class Teacher : public People
{
public:
    void study()    /* -> 重写 */
    {
        cout << "看国际论坛博文学习" << endl;
    }
};

class Librarian : public People
{
public:
    void study()    /* -> 重写 */
    {
        cout << "看图书学习" << endl;
    }
};

class Programmer : public Student
{
public:
    void study()    /* -> 重写 */
    {
        cout << "百度CP复制学习" << endl;
    }
};

#include <list> /*链表   // STL容器*/   

void Print_study(People &value1)
{
    value1.study();/*打印学习方法*/
}
int main()
{
    Student student;
    Teacher teacher;
    Programmer programmer;

    Print_study(student);
    Print_study(teacher);
    Print_study(programmer);

#if 0
    list<People *> list_v;

    /******* 插入 *******/
    list_v.push_back(new People);
    list_v.push_back(new Student);
    list_v.push_back(new Programmer);
    list_v.push_back(new Librarian);
    list_v.push_back(new Teacher);

    /******* 遍历 *******/
    list<People *>::iterator it;
    for(it = list_v.begin();it != list_v.end();it++)
    {   /** it 遍历出来的指针 **/
        (*it)->study();
    }
#endif

    return 0;
}

代码（普通版）

#include <iostream>

using namespace std;

/***** 饮品制作的基类 *****/
class Beverage
{
public:
    virtual void boil() = 0;            /*煮水*/
    virtual void brewing() = 0;         /*冲泡*/
    virtual void with_cup() = 0;        /*倒入杯中*/
    virtual void ingredients() = 0;     /*加入辅料*/

public:
    void make()/*制作*/
    {
        boil();
        brewing();
        with_cup();
        ingredients();
    }
};

/***** 制作咖啡 ****/
class Coffee : public Beverage
{
public:
    void boil()
    {
        cout << "煮矿泉水" << endl;
    }

    void brewing()
    {
        cout << "冲泡咖啡" << endl;
    }

    void with_cup()
    {
        cout << "倒入咖啡杯中" << endl;
    }

    void ingredients()
    {
        cout << "加入红糖和牛奶" << endl;
    }
};

class Tea : public Beverage
{
public:
    void boil()
    {
        cout << "煮山泉水" << endl;
    }

    void brewing()
    {
        cout << "冲泡茶叶" << endl;
    }

    void with_cup()
    {
        cout << "倒入茶杯中" << endl;
    }

    void ingredients()
    {
        cout << "加入枸杞,人生片" << endl;
    }
};

void make(Beverage &beverage)
{
    beverage.make();
}
int main()
{
    Coffee coffee;
    Tea tea;

    make(coffee);
    make(tea);

    return 0;
}

4.多态的时候，开辟空间需要加上 （虚析构！！）

虚析构和纯虚析构

多态使用时，如果子类中有属性开辟到堆区，那么父类指针在释放时无法调用到子类的析构代码 解决方式：将父类中的析构函数改为虚析构或者纯虚析构

虚析构和纯虚析构共性： ◼可以解决父类指针释放子类对象 ◼都需要有具体的函数实现 虚析构和纯虚析构区别： ◼如果是纯虚析构，该类属于抽象类，无法实例化对象

虚析构语法：virtual ~类名(){} 纯虚析构语法：virtual ~类名() = 0;

总结： ◼ 虚析构或纯虚析构就是用来解决通过父类指针释放子类对象 ◼ 如果子类中没有堆区数据，可以不写为虚析构或纯虚析构 ◼ 拥有纯虚析构函数的类也属于抽象类

代码：

#include <iostream>
using namespace std;

class A
{
public:
    A(){cout << __func__ << endl;}
    virtual ~A(){cout << __func__ << endl;}  //这里可以尝试把 virtual 去掉 调试试试
};

class B :public A
{
public:
    B(){cout << __func__ << endl;}
    ~B(){cout << __func__ << endl;}
};

/**** 一般在调用多态时会造成内存泄漏,可以使用虚析构或纯虚析构解决实现 ****/
int main()
{
    A *a = new B;   /* A()      */
    delete a;       /* ~A()     */

    return 0;
}

5.文件操作

C++中对文件操作需要包含头文件 < fstream >

文件类型分为两种：

1. 文本文件 - 文件以文本的ASCII码形式存储在计算机中
2. 二进制文件 - 文件以文本的二进制形式存储在计算机中，用户一般不能直接读懂它们

操作文件的三大类:

1. ofstream：写操作
2. ifstream： 读操作
3. fstream ： 读写操作

10.1文本文件

10.1.1写文件

写文件步骤如下：

1. 包含头文件

   #include

2. 创建流对象

   ofstream ofs;

3. 打开文件

   ofs.open(“文件路径”,打开方式);

4. 写数据

   ofs << “写入的数据”;

5. 关闭文件

   ofs.close();

代码：

#include <iostream>
#include <fstream>  /* 文件流类 */
using namespace std;

class Student
{
public:
    Student(string name = "",int age = 0):m_name(name),m_age(age){}
    string m_name;
    int m_age;
};


/********** 操作集 ***************************************************************************
 * 打开:
 *  void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out)
 *  void open(const std::string& __s,ios_base::openmode __mode = ios_base::in | ios_base::out)
 *  参数:
 *      @char* __s: C语言风格文件名
 *      @string s : C++风格文件名
 *      @ios_base::openmode mode : 打开模式
 *              ios_base::in        写模式
 *              ios_base::out       读模式
 *              ios_base::trunc     创建
 *              ios_base::binary    二进制
 *              ios_base::app       追加
 *————————————————————————————————————————————————————————————————————————————————————————————
 * 关闭:
 *  void close()
 *————————————————————————————————————————————————————————————————————————————————————————————
 * 判断是否打开成功:
 *  bool is_open() const
 *  返回值:
 *      成功: true
 *      失败: false
 *——————————————————————————————————————————————————————————————————————————————————————————————
 *格式化读取:
 *  operator >>
 *格式化写入:
 *  operator <<
 *——————————————————————————————————————————————————————————————————————————————————————————————
 *块写入:
 *  write(const char_type* __s, streamsize __n)
 *块读取:
 *  read(char_type* __s, streamsize __n)
 *——————————————————————————————————————————————————————————————————————————————————————————————
 *字节写入:
 *  put(char_type __c)
 *字节读取:
 *  int_type get()
 *———————————————————————————————————————————————————————————————————————————————————————————————
 *读取一行:
 *  getline(char_type* __s, streamsize __n)
 * *************************************************************************************************/
#include <string.h>
int main()
{
    /* 1.实例化对象 */
    fstream fd;

    /* 2.打开文件 */
#if 0
    fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
#else
    fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
#endif
    /* 3.判断是否打开成功 */
    if(fd.is_open() == false)
    {
        cout << "文件打开失败:文件不存在" << endl;
        return -1;
    }

    /* 4.读写操作 */
#if 0

#else
    char buf[128] = "";
    fd.getline(buf,128);
    cout << "buf = " << buf << endl;
#endif
    /* 5.关闭文件 */
    fd.close();

    return 0;
}


int test3()
{
    /* 1.实例化对象 */
    fstream fd;

    /* 2.打开文件 */
#if 0
    fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
#else
    fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
#endif
    /* 3.判断是否打开成功 */
    if(fd.is_open() == false)
    {
        cout << "文件打开失败:文件不存在" << endl;
        return -1;
    }

    /* 4.读写操作 */
#if 0
    char buf[128] = "老师xxx";
    for(int i = 0; i < strlen(buf);i++)
    {
        fd.put(buf[i]);
    }
#else
    char ch = 0;
    while(fd.eof() == false)
    {
        ch = fd.get();
        cout << ch;
    }
    cout << endl;
#endif
    /* 5.关闭文件 */
    fd.close();

    return 0;
}



int test2()
{
    /* 1.实例化对象 */
    fstream fd;

    /* 2.打开文件 */
#if 0
    fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
#else
    fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
#endif
    /* 3.判断是否打开成功 */
    if(fd.is_open() == false)
    {
        cout << "文件打开失败:文件不存在" << endl;
        return -1;
    }

    /* 4.读写操作 */
#if 0
    char buf[128] = "老师,无敌";
    fd.write(buf,128); /*写入一块*/
#else
    char buf[128] = "";
    fd.read(buf,128);
    cout << "buf = " << buf << endl;
#endif
    /* 5.关闭文件 */
    fd.close();

    return 0;
}

int test0()
{
    /* 1.实例化对象 */
    fstream fd;

    /* 2.打开文件 */
#if 0
    fd.open("test.txt",ios_base::trunc | ios_base::in | ios_base::out); /*清空写*/
#else
    fd.open("test.txt",ios_base::in | ios_base::out); /*读写操作*/
#endif
    /* 3.判断是否打开成功 */
    if(fd.is_open() == false)
    {
        cout << "文件打开失败:文件不存在" << endl;
        return -1;
    }

    /* 4.读写操作 */

#if 0
    Student stu1("王老师",18);
    Student stu2("李老师",19);
    fd << stu1.m_name << " " << stu1.m_age << endl;
    fd << stu2.m_name << " " << stu2.m_age << endl;
#else
    while(fd.eof() == false)
    {
        Student stu1;
        fd >> stu1.m_name >> stu1.m_age;
        if(stu1.m_age != 0)
            cout << "姓名:" << stu1.m_name << "\t年龄:" << stu1.m_age << endl;
    }
#endif
    /* 5.关闭文件 */
    fd.close();

    return 0;
}