3. const对象和成员函数

使用关键字const来说明对象，这样的对象成为常对象，它的数据成员值在整个生存周期不能改变，所以常对象必须进行初始化，而且不能更新。格式如下：

const <类名> <对象名>(<初值>)

常对象只能调用常成员函数。

常成员函数格式如下：

<类型说明符> <函数名>(<参数表>) const;

其中，关键字const加在参数表后面，它是函数类型的一部分。在该函数的实现部分也要加const关键字。

注意：
如果常成员函数在类内说明类外定义，则在函数的实现部分也要加上const关键字。
常成员函数不能更新对象的数据成员，也不能调用该类中没有用const修饰的成员函数。
如果将对象声明为常对象，则通过常对象只能调用它的常成员函数，而不能调用其它成员函数。
const关键字可以被用于参与对重载函数的区分，也就是说有没有const是两个不同的函数。
常数据成员：
注意：对于普通数据成员的初始化，既可以在函数体中进行，也可以在初始化列表中完成，常值数据成员，对象成员，从基类继承来的数据成员等特殊成员的初始化必须采用初始化表。

应用： 当类的某个数据成员在建立时被初始化后，就不允许加以改变，则该数据成员应声明为常数据成员。

方法：在该声明前加上const修饰

如下：

class Student{
    const int NO;
    int age;
public:
    void SetAge(int a);
    void SetNo(int a);
    Student() :NO(1) { cout << "调用Student构造函数" << endl; };

};

当不初始化NO数据成员时会提示错误，没有默认构造函数。

注意：带有初始化表的构造函数被调用时，先执行初始化表，再执行函数体。
实例：
设
有若干学生数据，包括学号，姓名，数学成绩和c++成绩，求每位学生的总分，及每门课程的平均分
代码分析如下：

首先是单个学生信息的类：

class Student {
    char *name;
    char *num;
    float m_score;
    float c_score;
    float sum_score;//总分
    static int Student_Num;//学生总数，在每个构造函数中加1.
    static float All_mscore;//数学成绩总分
    static float All_cscore;//c成绩总分
    static float Ave_mscore;//数学成绩平均分
    static float Ave_cscore;//c成绩平均分
    Student *next;//指向链表中下一个数据类
    friend class Student_List;//链表作为该类的友元类
public:
    Student(const char *name, const char *num, float m, float c);
    Student() {}
    void print_info();
    ~Student();
};
构造函数如下：

Student::Student(const char * name,const char * num, float m, float c)
{
    this->name = new char[my_strlen(name) + 1];
    this->num = new char[my_strlen(num) + 1];
    my_strcmp(this->name,name);
    my_strcmp(this->num, num);
    this->m_score = m;
    this->c_score = c;

    All_mscore += m_score;
    All_cscore += c_score;
    Ave_mscore = (Ave_mscore* Student_Num + m_score) / (Student_Num + 1);
    Ave_cscore = (Ave_cscore* Student_Num + c_score) / (Student_Num + 1);
    Student_Num++;
}

因为不知道姓名和学号有多少位，所以在类中定义为字符指针，然后在构造函数中采用new创建存储空间，以节省空间。

析构函数如下：

Student::~Student()
{
    delete[] name;
    delete[] num;
}

因为在构造函数中申请了动态空间，所以需要在析构函数中delete掉。此时没有定义拷贝构造函数，所以不可以直接拷贝类。

然后是链表的类：

class Student_List {
    Student *head;//链表头的类指针
public:
    Student_List(){ head = NULL; }
    ~Student_List();//析构函数
    int create_List(int n);//创建一个链表
    void print_list()const;//因为输出信息，所以不改变数值，所以采用const常成员函数

};

其中，析构函数为：

Student_List::~Student_List()
{
    Student *p;
    while (head)
    {
        p = head;
         head=head->next;
         delete p;
    }
}

将创建的链表中所有的Student对象都delete掉。

创建链表函数如下：

int Student_List::create_List(int n)
{
    Student *p1, *p2;
    char name[10], num[10];
    float m, c;
    std::cout << "开始创建一张学生信息表\n";
    for (; n > 0;n--) {
        std::cout << "输入学生姓名：";
        std::cin >> name;
        std::cout << "输入学生学号：";
        std::cin >> num;
        std::cout << "输入学生数学成绩：";
        std::cin >> m;
        std::cout << "输入学生c++成绩：";
        std::cin >> c;
        p1=new Student(name, num, m, c);
        if (head == NULL)
    {
        head = p1;
        p2 = p1;
    }
        p2->next = p1;
        p2 = p1;

    }

    return 0;
}

这样就创建了一个单向链表。

主函数如下：

int main()
{
    //Student s1("liming","13110052",80,60), s2("马儿", "13110056", 90, 80);
    //s1.print_info();
    //s2.print_info();
    Student_List li;
    li.create_List(5);
    li.print_list();
    return 0;
}