操作类对象

1. 类的指针和引用
（1）指针和引用
    在c语言中，指针是进行高效访问内存的手段，但是即便如此仍然涉及空间开辟和赋值
    操作。在c++中，引入了比指针更加高效的传参方式，那就是引用，不需要任何的赋值
    操作。

指针和引用作为高效使用内存的方式，在c++中，对于类和对象来说同样有着频繁的使用。


（2）引用并不能完全替代指针
    实际上引用虽然比指针的效率更高，但是引用并不能完全的替代指针。引用有一个缺
    点就是，引用只能初始化，不能赋值，但是指针不是的，指针可以通过重新赋值指针
    任何需要的空间。


（3）指针在类中的应用
    （1）传参
    （2）类的成员
        （1）函数指针
        （2）普通类型指针
        （2）对象指针 

2. 类的访问权限修饰符
访问权限限制符有三种，public，private，protected，用于限制成员的访问权限，
是类封装不可取少的关键字，前面说过，类成员默认就是private修饰。

这三种符号在一起联合使用时，有九种组合，但实际上如果采用记忆的当时去记住这
九种组合并不可取。

如果想要完全弄清楚这三个符号作用的话，它们是有规律可循的，这个规律需要分为
有继承和没有继承的两种情况来展开讲述。


（1）没有继承时的情况
（1）public
    在没有继承时，public表示来成员可以被外部访问，外部只需要通过./->/::进行访问。

（2）protected/private
    在不考虑继承的情况下，private和protected权限的效果一样，表示隐藏成员，外
    部不能直接通过./->/::对成员进行访问，只能通过公共成员函数接口访问隐藏成员。
    private和protected到底有什么区别，涉及继承的时候才能完全的讲清楚。

    类中的公共成员大多都是用作接口的成员函数，而类中几乎所有的数据成员都是使用
    private或者protected进行隐藏的。


（2）有继承时的情况
当涉及继承时，这三个符号在修饰父类和子类的专属成员时（不包含子类继承自父类
的成员），其作用与上面所描述的一致。

子类分别有public/private/protected这三种继承父类的方式，哪些子类中继承自父
类的成员，它们在子类中的新权限会受到继承方式的影响。

public/private/protected这三种继承父类的方式具体是怎么影响继承的，我们讲到
继承时再做详细讲解


3. 动态分配对象空间
（1）静态对象空间
（2）局部对象空间
（3）动态分配空间
    这个在前面章节实际上已经讲到过。
5. 类的嵌套
（1）内部嵌套定义对象成员
    例子：
        #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>

    using namespace std;

    class Birthday
    {
    public:
            Birthday(const string year="2000", const string month="12", \
                    const string day="12"):year(year), month(month), day(day) {}
            string get_year() {
                    return year;
            }
            string get_month() {
                    return month;
            }
            string get_day() {
                    return day;
            }

    private:
            string year;
            string month;
            string day;  
    };  

    class Student
    {
    public:
            Student(const string name="name", int num=1, const string year="2008", \
                    const string month="1", const string day="1")
                    : name(name), num(num), birthday(year, month, day) { }

            Birthday &get_birthday() {
                    return birthday;
            }

    private:
            string name;
            int num;
            Birthday birthday;
    };

    int main(void)
    {
            Student stu1("zhangsan", 33);

            cout<<"年:"<< stu1.get_birthday().get_year() << endl;
            cout<<"月:"<< stu1.get_birthday().get_month() << endl;
            cout<<"日:"<< stu1.get_birthday().get_day() << endl;

            return 0;
    }       

    例子分析：

    本例子中，定义了两个类，一个是Student类，另一个是Birthday类，其中
    在Student类中定义了一个Birthday类的成员。

    注意本例子中对Student类中的Birthday成员的初始化方式。

（2）使用对象指针的方式
例子：

仍然使用上面的例子，但是需要做些改动。
Birthday birthday;
改为
Birthday *birthday;

Birthday的构造函数的初始化列表中的birthday(year, month, day)
改为
birthday(new Birthday(year, month, day))


将stu的定义和年月日的打印
Student stu1("zhangsan", 33);
    cout<<"年:"<< stu1.get_birthday().get_year() << endl;
    cout<<"月:"<< stu1.get_birthday().get_month() << endl;
    cout<<"日:"<< stu1.get_birthday().get_day() << endl;
改为
Student *stu1 = new Student("zhangsan", 33);
    cout<<"年:"<< stu1->get_birthday()->get_year() << endl;
    cout<<"月:"<< stu1->get_birthday()->get_month() << endl;
    cout<<"日:"<< stu1->get_birthday()->get_day() << endl;

最后别忘了加一个释放动态对象空间的语句。
delete stu1;

例子分析：
以上改动完成之后就实现了动态分配对象空间，动态对对象空间开辟自堆空间，
与c语言中利用malloc函数在堆中开辟空间没有任何区别。 

实际上这个例子中存在一个程序隐患，因为stu1对象的birthday指向的对象空间并没
有被释放，这就会导致内存泄漏，是非常大的隐患。


（3）定义类的内部类
（1）什么是内部类
    直接通过一个例子理解什么是内部类，还是以上面的例子为例，我们将
    Birthday定义为Student的内部类。

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>

    using namespace std;

    class Student
    {
    private:
            class Birthday
            {
            public:
                    Birthday(const string year="2000", const string month="12", \
                            const string day="12"):year(year), month(month), day(day) {}
                    string get_year() {
                            return year;
                    }
                    string get_month() {
                            return month;
                    }
                    string get_day() {
                            return day;
                    }

            private:
                    string year;
                    string month;
                    string day;
            };

        public:
            Student(const string name="name", int num=1, const string year="2008", \
                    const string month="1", const string day="1")
                    : name(name), num(num), birthday(new Birthday(year, month, day)) { }
            Birthday *get_birthday() {
                    return birthday;
            }



    private:
            string name;
            int num;
            Birthday *birthday;
    };

    int main(void)
    {
            Student *stu1 = new Student("zhangsan", 33);

            cout<<"年:"<< stu1->get_birthday()->get_year() << endl;
            cout<<"月:"<< stu1->get_birthday()->get_month() << endl;
            cout<<"日:"<< stu1->get_birthday()->get_day() << endl;

            delete stu1;

            return 0;
    }   


    例子分析：在本例子中，我们将Birthday类定义为了Student类的私有内部
    类，其他的操作与前面例子并没有什么区别。

（2）内部类的意义
    如果我们某写类需要使用属于自己的专属的内部子类时，我们就可以为其定
    义内部类。

（3）隐藏的和公共的内部类
    （1）隐藏内部类
        我们定义内部类时，主要就是为了专享使用该内部类，因此我们一
        般都会将其修饰为private或者protected，将它内部类隐藏起来，
        外部是不能使用该类来实例化对象的。

        上面所举的内部类的例子就是典型的隐藏内部类。

    （2）公共的内部类
        内部类也可以将其声明为public，如果声明为public的话，在外部
        就可以访问该内部类。

        如果我们将上面例子中的内部类改为public的话，在main函数中就可
        以使用定义的内部类Birthday来实例化对象，定义形式如下：
        Student::Birthday brthday;      

        如果将内部类声明为public的话，与直接在外部定义该类的使用效果
        差不多，所以都会将其直接定义为外部类。我们如使用的内部类时，
        很多情况下都会将其隐藏。


（4）通过友元实现专属内部类一样的效果

    只用友元实现专属内部类的效果时，还是以上面的例子为例，实现步骤是：
    （1）将内部Birthday类改为外部类
    （2）将Birthday的所有成员全部定义为隐藏
    （3）将Student类声明为Birthday类的友元

    通过以上这三步，Birthday就变成了Student的专属类，因为Birthday的构造函数
    是隐藏的，也没有其它实例化的接口，因此在外部无法实例化Birthday对象，
    只有友元Student才能调用Birthday的构造函数实例化Birthday的对象。


    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>

    using namespace std;
    class Birthday
    {    
            Birthday(const string year="2000", const string month="12", \
                    const string day="12"):year(year), month(month), day(day) {}
            string get_year() {
                    return year;
            }   
            string get_month() {
                    return month;
            }   
            string get_day() {
                    return day;
            }   

            string year;
            string month;
            string day;  

            friend class Student;
    };

    class Student
    {
    public:
            Student(const string name="name", int num=1, const string year="2008", \
                    const string month="1", const string day="1")
                    : name(name), num(num), birthday(new Birthday(year, month, day)) { }
            Birthday *get_birthday() {
                    return birthday;
            }

            string get_year() {
                    return birthday->get_year();
            }
            string get_month() {
                    return birthday->get_month();
            }
            string get_day() {
                    return birthday->get_day();
            }

    private:
            string name;
            int num;
            Birthday *birthday;
    };

    int main(void)
    {
            Student *stu1 = new Student("zhangsan", 33);

            cout<<"年:"<< stu1->get_year() << endl;
            cout<<"月:"<< stu1->get_month() << endl;
            cout<<"日:"<< stu1->get_day() << endl;

            delete stu1;

            return 0;
    }

    例子分析：在本例子中，由于Birthday类的成员全部设置为了隐藏，因此
    main函数中的如下语句是无法通过编译的，
            cout<<"年:"<< stu1->get_birthday()->get_year() << endl;
            cout<<"月:"<< stu1->get_birthday()->get_month() << endl;
            cout<<"日:"<< stu1->get_birthday()->get_day() << endl;

    这是因为，我们试图在外部访问Birthday中私有的getter函数，这显然是不
    行的，由于我们将Student设置为了Birthday的友元，因此我们需要完全借助
    Student类的对象才能访问Birthday中的成员，因此我们在Student中加了三
    个访问Birthday获取器的代理成员函数：
        string get_year() {
                    return birthday->get_year();
            }
            string get_month() {
                    return birthday->get_month();
            }
            string get_day() {
                    return birthday->get_day();
            }
    当然我们呢也可以直接将函数中的
        return birthday->get_year();
        return birthday->get_month();
        return birthday->get_day();
    改为
        return birthday->year;
        return birthday->month;
        return birthday->day;

    然后再main函数中通过调用Student中的三个代理访问Birthday成员的函数
    才能将Birtday的成员数据打印出来，调用方式如下：
        cout<<"年:"<< stu1->get_year() << endl;
            cout<<"月:"<< stu1->get_month() << endl;
            cout<<"日:"<< stu1->get_day() << endl;

（5）当类进行嵌套时，构造函数的执行的顺序
    （1）构造函数中涉及初始化和赋值的问题
        在上一章中我们强调过，在构造函数的{ }涉及的是赋值操作，但是
        构造函数中的初始化列表涉及的是初始化操作的，它们的区别是，
        初始化是由编译器一早就安排好的，效果就是一旦开辟空间就立即
        向空间写值。而的赋值操作是先开辟空间然后再向空间赋值。

        构造函数中赋值与初始化的区别将直接影响类在嵌套时，它们的
        构造函数被调用的顺序。

    （2）例子
        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        #include <iostream>
        #include <string>
        #include <cassert>

        using namespace std;
        class A
        {
            public:
                A(int a=1){
                        cout<<"A的构造函数"<<endl;
                }   
        };

        class B
        {
                A *a; 
        public:
                B(int b=1):a(new A(1)) {
                        cout<<"B的构造函数"<<endl;
                }           
        };

        class C
        {
                B *b; 
        public:
                C(int c=1) {
                        cout<<"C的构造函数"<<endl;
                        b = new B(1);
                }
        };

        int main(void)
        {
                C c(1);

                return 0;
        }

    运行结果：
        C的构造函数
        A的构造函数
        B的构造函数


    例子分析：
    例子中C类包含了B类的对象，B类包含了A类的对象，但是为什么构造函数
    被执行的顺序是CAB呢？

    执行的顺序如下：
    当在main函数中执行C c(1);              回到main函数
        |                           A
        |                       |
        V                       |
    C类的构造函数被调用                  |
    执行 cout<<"C的构造函数"<<endl;                |
    执行 b = new B(1);                            C类的构造函数执行完毕
        |                       A
        V                       |
    B类的构造函数被调用                  |
    利用a(new A(1))初始化对象a                 执行 cout<<"B的构造函数"<<endl;
        |                       A
        V                       |
    A类构造函数被调用                   |
    执行 cout<<"A的构造函数"<<endl;                |
    A构造函数执行结束--------------------------------------->


    从上面的分析看出，构造函数的初始化列表优先于{ }中的的赋值语句的执行。
    构造函数被调用执行是一个递归的过程。      

    4. 重要的析构函数
（1）前面动态分配对象空间例子中的隐患

在前面动态分配对象空间的例子中，其实是有问题的，那就是Student中Birthday指
针指向的Birthday类对象，该对象空间分配于堆空间，因此需要释放，但是我们并
没有释放它，这个问题将会留给后面需要讲到的析构函数去解决。   

（2）析构函数 
（1）析构函数的作用
    每个对象空间被释放时，都会调用析构函数，析构函数的目的主要是为了
    实现对对象的扫尾操作。

    对于类中的分配于堆空间的类类型的成员对象来说，其空间是不会自动被释
    放的，因为这是程序员的事情，而这些释放空间的操作往往就放在析构函数
    中来做。

（2）默认的析构函数
    实际上，如果我们自己不定义析构函数的话，每个类都有一个默认的析构
    函数，这个析构函数是在编译时提供的，这个析构函数是不可见的。


（3）析构函数的格式
    与构造函数几乎相同，只是需要在函数名亲前面加~，析构函数没有形参
    ，但是实际上它会得到一个默认参数，就是this指针，因为析构函数需要
    操作成员，这些成员需要使用this访问，只是一般情况下，并不会显式使
    用this访问成员。

    析构函数定义格式如下（以前面的Student类为例）：

    ~Student（） {
    ......//默认析构函数没有内容
    }
    或者
    Student::~Student（） {
    ......//默认析构函数没有内容
    }


（4）调用析构函数
    （1）析构函数什么时候被调用

        当对象空间被释放时，析构函数将会被调用

        （1）静态对象：当整个程序结束时，分配于静态空间的对象才会被释放
            （1）全局变量
            （2）静态局部变量

        （2）自动局部对象
            函数调用结束后，自动局部对象的空间即会被释放

        （3）自动分配的对象
            自动分配对象空间的释放
            （1）程序结束后，一定会释放
            （2）主动调用delete释放

            而这的区别是delete释放空间时会调用析构函数，但是程序结束
            后释放自动分配对象空间的方式则不会调用析构函数。

            实际开发中，很多程序基本都会长时间运行，甚至说永远运行，
            在这一类的程序中，如果存在大量的自动分对象的话，一定要主
            动释放，否则严重的内存泄漏会直接导致程序崩溃。

    （2）举例
        还是前面的学生例子，但是将其main函数的内容改成如下形式。
        #include <stdio.h>
        #include <stdlib.h>
        #include <string.h>
        #include <iostream>
        #include <string>
        #include <cassert>

        using namespace std;
        class Birthday
        {    
                Birthday(const string year="2000", const string month="12", \
                        const string day="12"):year(year), month(month), day(day) {}
                string get_year() {
                        return year;
                }   
                string get_month() {
                        return month;
                }   
                string get_day() {
                        return day;
                }   

                string year;
                string month;
                string day;  

                friend class Student;
        };

        class Student
        {
        public:
                Student(const string name="name", int num=1, const string year="2008", \
                        const string month="1", const string day="1")
                        : name(name), num(num), birthday(new Birthday(year, month, day)) { }

            ~Student() {
                cout << "Student的析构函数" << endl;
                delete birthday;
            }

                Birthday *get_birthday() {
                        return birthday;
                }

                string get_year() {
                        return birthday->get_year();
                }
                string get_month() {
                        return birthday->get_month();
                }
                string get_day() {
                        return birthday->get_day();
                }

        private:
                string name;
                int num;
                Birthday *birthday;
        };

        void fun() {
                Student *stu1 = new Student("zhangsan", 33);
                Student stu2("zhangsan", 33);
            static Student stu3("zhangsan", 33);

                cout<<"年:"<< stu1->get_year() << endl;
                cout<<"月:"<< stu1->get_month() << endl;
                cout<<"日:"<< stu1->get_day() << endl;

                delete stu1;

        }

        Student stu4("zhangsan", 33);
        int main(void)
        {
                fun();
        //      while(1);
                return 0;
        }

        例子分析：
        fun函数中的stu1是自动分配的，需要delete才能释放，并会调用析构函数
        fun函数中的stu2是fun函数的局部变量，当函数运行结束后会自动释放，并会调用析构函数
        fun函数中stu3是静态局部变量，只有当整个程序运行结束之后才会释放，并会调用析构函数
        全局变量stu4是静态变量，同样的，也只有当整个程序运行结束之后才会释放，并会调用析构函数

        对他们进行空间释放并调用析构函数的顺序是：
        先是stu2
        再是stu1
        最后程序结束时才是stu3和stu4

    （5）类有嵌套时，析构函数的调用顺序
        （1）当类嵌套时析构函数的调用顺序
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>

    using namespace std;
    class A
    {
    public:
            A(int a=1){ }
            ~A() {
                    cout<<"A的析构函数"<<endl;
            }
    };
    class B
    {
            A *a;
    public:
            B(int b=1):a(new A(1)) { }           
            ~B() {
                    cout<<"B的析构函数"<<endl;
                    delete a;
            }   
    };

    class C
    {
            B b;
    public:
            C(int c=1):b(1){
            }
            ~C() {
                    cout<<"C的析构函数"<<endl;
            }

    };

    int main(void)
    {
            C *c1 = new C(1);
            delete c1;
            cout<<"释放C1的堆空间并调用析构函数\n"<<endl;

            C c2(1);
            cout<<"程序结束，C1的静态空间被释放并调用析构函数"<<endl;

            return 0;
    }


    运行结果：

    释放C1的堆空间并调用析构函数
        C的析构函数
        B的析构函数
        A的析构函数

    程序结束，C1的静态空间被释放并调用析构函数
        C的析构函数
        B的析构函数
        A的析构函数


    例子分析：
    从例子的运行结果来看，很容易发现，析构函数的调用是从最外层的对象开始的。

    但是如果将B类的析构函数的delete a代码注释掉，你会发现A的析构函数没有被
    调用，也就说明B类中的A类指针指向的对象成员的空间没有被释放。

    因此可以看出，对于在类中有自动分配的对象成员时，在析构函数中显式调用
    delete释放对内存。        


（5）析构函数的权限
    正常情况下需要将析构函数设置为public，否者将无法编译将无法通过。

    但是有一种情况是可以将析构声明为隐藏的，比如A类的所有成员都是隐藏的，
    包括析构函数也是隐藏的，但是另一个B类是A类的友元的时候，A类隐藏的析构
    函数也可以被调用，           

    例子：
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>

    using namespace std;
    class A
    {
           A(int a=1){ }
            ~A() {
                   cout<<"A的析构函数"<<endl;
            }
    };

    class B
    {
            A *a;
    public:
           B(int b=1):a(new A(1)) { }           
           ~B() {
                    cout<<"B的析构函数"<<endl;
                    delete a;
            }   
    };

    int main(void)
    {
            B b(1);

            return 0;
    }

    编译结果，编译错误：
    a.cpp:11: error: ‘A::A(int)’ is private
    a.cpp:22: error: within this context
    a.cpp: In destructor ‘B::~B()’:
    a.cpp:13: error: ‘A::~A()’ is private
    a.cpp:26: error: within this context

    编译错误提示，A的构造函数和析构函数都是隐藏的，因此B类将不能调用
    A类的构造函数进行进行初始化成员，也不能调用析构函数析构操作。

    面对这个情况有两个解决办法：
    办法1：将构造函数和析构函数都声明为public
    办法2：将B类声明为A类的友元，即便A类的构造函数和析构函数是隐藏的
    也没有关系。  
        class A
        {
            A(int a=1){ }
                ~A() {
                        cout<<"A的析构函数"<<endl;
                }
            friend class B;
        };



6. 再次探讨副本构造函数（拷贝构造函数）的重要性

上一章节提到，当从A对象复制出完全相同的B对象时（比如对象的值传递），就会
调用副本构造函数进行复制。

但是默认的拷贝函数进行的只是浅拷贝操作，当类对象包含堆堆空间的成员时，默
认的浅拷贝会带来隐患，需要进行深拷贝，这就需要我们重写副本构造函数。

特别是在类对象包含自动分配的成员对象时，重写拷贝构造函数几乎是必须的操作。

例子：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <iostream>
#include <string>
#include <cassert>

using namespace std;
class Province
{
public:
        string name;
        Province(const string name=" "):name(name) { } 
        ~Province() { } 
};

class Country
{
    public:
        Province *province;
        Country(const string name=" "):province(new Province(name)) { } 

        ~Country() {
                delete province;
        }   
};

int main(void)
{
        Country c1("shandong");
        Country c2 = c1;

        cout<<"通过c1打印省名:"<<(c1.province)->name<<endl;
        cout<<"通过c2打印省名:"<<(c2.province)->name<<endl;
        c2.province->name = "hebei";
        cout<<"\n通过c2改变省名后"<<endl;
        cout<<"通过c1打印省名:"<<(c1.province)->name<<endl;
        cout<<"通过c2打印省名:"<<(c2.province)->name<<endl;

        return 0;
}

运行结果：

通过c1打印省名:shandong
通过c2打印省名:shandong

通过c2改变省名后
通过c1打印省名:hebei
通过c2打印省名:hebei
段错误



例子分析：

本例子使用的是默认副本构造函数，因此将c1赋值给c2时，是浅拷贝操作，所以你会
发现在通过c2修改了省份名字后，c1打印的省份名字也修改了。

实际上后面出现的段错误也是由浅拷贝引起的，因为c1和c2的pronvice成员指向的是
同一个Province对象，因此在c1和c2空间被释放时，province成员指向自动分配的对
象会被释放两次，因此造成段错误。



修改方法：

在Country中加入如下自定义的副本构造函数，把将pronvice指向新的自动分配的对象
空间。

    Country(const Country &country) {
                this->province = new Province();
                this->province->name = country.province->name;
        } 



7. 利用c++知识实现学生链表案例

（1）c++实现链表的方式
    很多数据结构的书都会讲解以c语言实现的链表，数据节点使用结构体实现，很明显也可以
    利用c++来实现来链表，数据节点则使用类对象代替结构体变量。


（2）c++中我们并不需要自己实现各种数据结构 
    当然在c++中我们实际上没有必要自己自己实现链表，因为在c++中的STL容器已经帮我们实
    现了非常强大的链表数据结构，只需要学会使用即可。

（3）自己实现c++链表的意义
    （1）有利于理解对象和结构体的异同
    （1）通过c和c++所实现链表的对比，也可以加深我们对于链表的理解
    （2）同时也可以借机了解c++中STL容器的list是如何实现的

（4）这里写的c++链表与STL容器的list的区别
    这里实现的链表例子与STL的list最大区别在于，这里没有使用类模板（泛型），因此这里自
    定义实现的链表只能用来存放确定类型的数据，无法存放任意类型的数据。

    因此如果想实现一个完美的链表的话，就必须引入泛型（函数模板/类模板）.

（5）理解c中为什么没有统一的数据结构的实习那
    因为c中缺乏泛型机制，所以c中没有定义统一的数据结构，在c中常见的情况就是针对不同的
    结构体类型，总是要实现不同的链表等的数据结构图。

    因此我们才说，数据结构这么课的内容在c语言中的使用是最为频繁的。




（6）例子

  如果涉及io操作，这里沿用c语言提供的io流的操作函数。


写一个studata.h，定义存放数据类。
studata.h
    #ifndef H_STUDATA_H
    #define H_STUDATA_H


    using namespace std;
    class Studata
    {
    public:
            int num;
            string name;

            Studata(int num=0, const string name=" "):num(num), name(name) {}
            int get_num() const{ return num; }
            string get_name() const{ return name; }
            void set_num(int num) { this->num = num; }
            void set_name(string name) { this->name = name; }
    };
    #endif                                                                                                                         




写一个stunode.h，节点类定义。 
stunode.h
    #ifndef H_STUNODE_H
    #define H_STUNODE_H
    #include "studata.h"

    using namespace std;

    class Stunode
    {
            Studata *studata;
            Stunode *prev;
            Stunode *next;

    public:
            Stunode(int num=0, const string name=" ", Stunode *prev=NULL, \
                    Stunode *next=NULL):studata(new Studata(num, name)) {}
            Stunode(const Studata &studata) {
                    this->studata = new Studata();
                    this->studata->set_num(studata.get_num());
                    this->studata->set_name(studata.get_name());
                    prev = next = NULL;
            }
            ~Stunode() {
                    delete studata;
            }

            /*获取器*/
            Stunode *get_prev() const {return prev;}
            Stunode *get_next() const {return next;}
            Studata *get_studata() const {return studata;}
            /*设置器*/
            void set_prev(Stunode *stunode) {this->prev = stunode;}
            void set_next(Stunode *stunode) {this->next = stunode;}
            void set_studata(Studata *studata) {this->studata = studata;}
    };
    #endif



写一个dlist.h,定义封装整个链表操作的类。
dlist.h
    #ifndef H_DLIST_H
    #define H_DLIST_H

    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>
    #include <errno.h>
    #include "stunode.h"

    using namespace std;
    class Dlist
    {
            Stunode *hp;
            Stunode *current;
            Stunode *tmp;

    public:
            Dlist() {
                    hp = current = new Stunode();//空头节点 
                    hp->set_prev(hp);
                    hp->set_next(hp);
                    tmp = NULL;
            }

                void err_fun(string filename, int line, string funname, int err_no) {
                    cerr<<filename<<" "<<line<<" "<<funname<<" fail"<<":"<<strerror(err_no)<<endl;
                    exit(-1);
            }

            void init_Dlist(string filename);
            void insert_tail();
            void insert_head();
            void display();
            Studata find(int index);
            //void operator[](int i);
    };
    #endif



写一个dlist.cpp，操作链表的函数都定义在里面。
dlist.cpp   
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>
    #include <errno.h>
    #include "dlist.h"

    using namespace std;
    Studata Dlist::find(int index)
    {
            int i=0;
            for(current=hp->get_next(); ; current=current->get_next(), i++)
            {
                    if(current == hp) return (Studata)0;
                    else if(i == index) return *(current->get_studata());

                    //cout<<current->get_studata()->get_num()<<"\t"<<current->get_studata()->get_name()<<endl;
            }
    }
    void Dlist::display()
    {
            for(current=hp->get_next(); hp!=current; current=current->get_next())
            {
                    cout<<current->get_studata()->get_num()<<"\t"<<current->get_studata()->get_name()<<endl;
            }
    }

    void Dlist::insert_tail()
    {
            hp->get_prev()->set_next(tmp);
            tmp->set_prev(hp->get_prev());

            hp->set_prev(tmp);
            tmp->set_next(hp);
    }

    void Dlist::insert_head()
    {
            hp->get_next()->set_prev(tmp);
            tmp->set_next(hp->get_next());

            hp->set_next(tmp);
            tmp->set_prev(hp);
    }

    void Dlist::init_Dlist(string filename)
    {
            FILE *fp = NULL;
            fp = fopen(filename.c_str(), "r");
            if(NULL == fp) err_fun(__FILE__, __LINE__, "fopen", errno);

            while(1)
            {
                    int num;
                    char name[40];
                    fscanf(fp, "%d %s\n", &num, name);
                    //printf("%d %s\n", num, name);
                    tmp = new Stunode(num, name);
                    insert_tail();
                    if(1 == feof(fp)) break;
            }
    }



main.cpp
    #include <stdio.h>
    #include <stdlib.h>
    #include <string.h>
    #include <iostream>
    #include <string>
    #include <cassert>
    #include <errno.h>
    #include "dlist.h"

    using namespace std;
    int main(void)
    {
            Studata data;
            Dlist dlist;

            dlist.init_Dlist("./stu.txt");
            dlist.display();
            data = dlist.find(2);
            cout << data.get_num()<<data.get_name() <<endl;

            return 0;
    }


/* 存放学生数据的文件 */
stu.txt
    1       aaa
    4       fff
    3       sss
    5       www
    2       vvv