——————————————-

CPP函数编译原理和成员函数的实现

从上节的分析中能够看出。对象的内存中仅仅保留了成员变量，除此之外没有不论什么其它信息，程序运行时不知道 stu 的类型为 Student，也不知道它还有四个成员函数 setname()、setage()、setscore()、show()，C++ 到底是怎样通过对象调用成员函数的呢？

C++函数的编译

C++和C语言的编译方式不同。C语言中的函数在编译时名字不变，或者仅仅是简单的加一个下划线_（不同的编译器有不同的实现），比如，func() 编译后为 func() 或 _func()。

而C++中的函数在编译时会依据它所在的命名空间、它所属的类、以及它的參数列表（也叫參数签名）等信息进行又一次命名。形成一个新的函数名。这个新的函数名仅仅有编译器知道，对用户是不可见的。对函数重命名的过程叫做名字编码（Name Mangling）。是通过一种特殊的算法来实现的。

Name Mangling 的算法是可逆的，既能够通过现有函数名计算出新函数名。也能够通过新函数名逆向推演出原有函数名。Name Mangling 能够确保新函数名的唯一性，仅仅要函数所在的命名空间、所属的类、包括的參数列表等有一个不同，最后产生的新函数名也不同。

假设你希望看到经 Name Mangling 产生的新函数名。能够仅仅声明而不定义函数，这样调用函数时就会产生链接错误。从报错信息中就能够看到新函数名。请看以下的代码：

#include <iostream>
using namespace std;
void display();
void display(int);
namespace ns{
    void display();
}
class Demo{
public:
    void display();
};
int main(){
    display();
    display(1);
    ns::display();
    Demo obj;
    obj.display();
    return 0;
}

该例中声明了四个同名函数，包括两个具有重载关系的全局函数。一个位于命名空间 ns 下的函数，以及一个属于类 Demo 的函数。

它们都是仅仅声明而未定义的函数。

在 VS 下编译源码能够看到相似以下的错误信息：

小括号里就是经 Name Mangling 产生的新函数名。它们都以?

開始，以差别C语言中的_。

上图是 VS2010 产生的错误信息，不同的编译器有不同的 Name Mangling 算法。产生的函数名也不一样。

__thiscall、cdecl 是函数调用惯例.

除了函数，某些变量也会经 Name Mangling 算法产生新名字，这里不再赘述。

成员函数的调用

从上图能够看出。成员函数终于被编译成与对象无关的全局函数，假设函数体中没有成员变量。那问题就很easy，不用对函数做不论什么处理，直接调用就可以。

假设成员函数中使用到了成员变量该怎么办呢？成员变量的作用域不是全局，不经不论什么处理就无法在函数内部訪问。

C++规定，编译成员函数时要额外加入一个參数。把当前对象的指针传递进去，通过指针来訪问成员变量。

假设 Demo 类有两个 int 型的成员变量，各自是 a 和 b，而且在成员函数 display() 中使用到了。例如以下所看到的：

void Demo::display(){
    cout<<a<<endl;
    cout<<b<<endl;
}

那么编译后的代码相似于：

void new_function_name(Demo * const p){
    //通过指针p来訪问a、b
    cout<<p->a<<endl;
    cout<<p->b<<endl;
}

使用obj.display()调用函数时，也会被编译成相似以下的形式：

new_function_name(&obj);

这样通过传递对象指针就完毕了成员函数和成员变量的关联。这与我们从表明上看到的刚好相反，通过对象调用成员函数时。不是通过对象找函数。而是通过函数找对象。

这一切都是隐式完毕的，对程序猿来说全然透明。就好像这个额外的參数不存在一样。

最后须要提醒的是。Demo * const p中的 const 表示指针不能被改动，p 仅仅能指向当前对象，不能指向其它对象。

——————————————-

CPP构造函数（Constructor）

在C++中，有一种特殊的成员函数，它的名字和类名同样。没有返回值。不须要用户显式调用（用户也不能调用），而是在创建对象时自己主动运行。这样的特殊的成员函数就是构造函数（Constructor）。

上一例中我们通过成员函数 setname()、setage()、setscore() 分别为成员变量 name、age、score 赋值，这样做尽管有效，但显得有点麻烦。有了构造函数，我们就能够简化这项工作，在创建对象的同一时候为成员变量赋值。请看以下的代码：

#include <iostream>
using namespace std;
class Student {
private:
    char *m_name;
    int m_age;
    double m_score;

public:
    Student() {
        m_name = "Tom";
        m_age = 19;
        m_score = 98.6;
    }

    void show();
};

void Student::show() {
    cout<<m_name<<"‘s age is "<<m_age<<", score is "<<m_score<<endl;
}

int main (void) {
    Student *stu = new Student;
    stu->show();
    delete stu;
    return 0;
}

#include <iostream>
using namespace std;
class Student {
private:
    char *m_name;
    int m_age;
    double m_score;
public:
    Student(char *name, int age, double score);
    void show();
};

Student::Student(char *name, int age, double score) {
    m_name = name;
    m_age = age;
    m_score = score;
}
void Student::show() {
    cout<<m_name<<"‘s age is "<<m_age<<", score is "<<m_score<<endl;
}

int main (void) {
    Student *stu1 = new Student("Tom", 18, 97.5);//创建对象时向构造函数传參
    stu1->show();
    delete stu1;

    Student stu2("Jim", 19, 99.8);//创建对象时向构造函数传參
    stu2.show();
    return  0;
}

该例在 Student 类中定义了一个构造函数Student(char *, int, float)。它的作用是给三个 private 属性的成员变量赋值。

要想调用该构造函数，就得在创建对象的同一时候传递实參。而且实參由( )包围，和普通的函数调用很相似。

在栈上创建对象时，实參位于对象名后面，比如Student stu(“小明”, 15, 92.5f)。

在堆上创建对象时，实參位于类名后面。比如new Student(“李华”, 16, 96)。

构造函数必须是 public 属性的，否则创建对象时无法调用。

当然。设置为 private、protected 属性也不会报错，可是没有意义。

构造函数没有返回值，由于没有变量来接收返回值。即使有也毫无用处。这意味着：

无论是声明还是定义，函数名前面都不能出现返回值类型，即使是 void 也不同意；

函数体中不能有 return 语句。

构造函数的重载

和普通成员函数一样。构造函数是同意重载的。

一个类能够有多个重载的构造函数，创建对象时依据传递的实參来推断调用哪一个构造函数。

构造函数的调用是强制性的。一旦在类中定义了构造函数，那么创建对象时就一定要调用，不调用是错误的。

假设有多个重载的构造函数，那么创建对象时提供的实參必须和当中的一个构造函数匹配。反过来说，创建对象时仅仅有一个构造函数会被调用。

对演示样例1中的代码。假设写作Student stu或者new Student就是错误的。由于类中包括了构造函数，而创建对象时却没有调用。

更改演示样例1的代码，再加入一个构造函数（演示样例2）：

#include <iostream>
using namespace std;
class Student {
private:
    char *m_name;
    int m_age;
    double m_score;
public:
    Student();
    Student(char *name, int age, double score);
    void show();
    void setname(char *name);
    void setage(int age);
    void setscore(double score);
};

Student::Student() {
    m_name = NULL;
    m_age = 0;
    m_score = 0;
}
Student::Student(char *name, int age, double score) {
    m_name = name;
    m_age = age;
    m_score = score;
}
void Student::show() {
    if (m_name == NULL) {
        cout<<"未初始化定义"<<endl;
    } else {
        cout<<m_name<<"‘s age is "<<m_age<<", score is "<<m_score<<endl;
    }
}
void Student::setname(char *name) {
    m_name = name;
}
void Student::setage(int age) {
    m_age = age;
}
void Student::setscore(double score) {
    m_score = score;
}

int main () {
    Student stu1;
    stu1.show();
    stu1.setname("Jim");
    stu1.setage(1);
    stu1.setscore(77.6);
    stu1.show();
    Student stu2("Tom", 18, 99.5);
    stu2.show();
    Student *stu3 = new Student();
    stu3->show();
    return 0;
}

构造函数Student(char *, int, float)为各个成员变量赋值。构造函数Student()将各个成员变量的值设置为空，它们是重载关系。依据Student()创建对象时不会赋予成员变量有效值。所以还要调用成员函数 setname()、setage()、setscore() 来给它们又一次赋值。

构造函数在实际开发中会大量使用。它往往用来做一些初始化工作，比如对成员变量赋值、预先打开文件等。

默认构造函数

假设用户自己未定义构造函数，那么编译器会自己主动生成一个默认的构造函数，仅仅是这个构造函数的函数体是空的，也没有形參。也不运行不论什么操作。

比方上面的 Student 类，默认生成的构造函数例如以下：

Student(){}

一个类必须有构造函数，要么用户自定义，要么编译器自己主动生成。

一旦用户自定义了构造函数，无论有几个，也无论形參怎样。编译器都不再自己主动生成。在演示样例1中。Student 类已经有了一个构造函数Student(char *, int, float)，也就是我们自定义的。编译器不会再额外加入构造函数Student()。在演示样例2中我们才手动加入了该构造函数。

实际上编译器仅仅有在必要的时候才会生成默认构造函数。而且它的函数体一般不为空。默认构造函数的目的是帮助编译器做初始化工作。而不是帮助程序猿。这是C++的内部实现机制，这里不再深究，刚開始学习的人能够依照上面说的“一定有一个空函数体的默认构造函数”来理解。

最后须要注意的一点是，调用没有參数的构造函数也能够省略括号。对于演示样例2的代码，在栈上创建对象能够写作Student stu()或Student stu。在堆上创建对象能够写作Student *pstu = new Student()或Student *pstu = new Student。它们都会调用构造函数 Student()。

曾经我们就是这样做的。创建对象时都没有写括号。事实上是调用了默认的构造函数。

——————————————-

CPP构造函数的參数初始化表

构造函数的一项重要功能是对成员变量进行初始化，为了达到这个目的，能够在构造函数的函数体中对成员变量一一赋值，还能够採用參数初始化表。

#include <iostream>
using namespace std;

class Student {
private:
    char *m_name;
    int m_age;
    double m_score;
public:
    Student(char *name, int age, double score);
    void show();
};
Student::Student(char *name, int age, double score):m_name(name), m_age(age), m_score(score) {

}
void Student::show() {
    cout<<m_name<<"‘s age is "<<m_age<<", score is "<<m_score<<endl;
}
int main() {
    Student *stu1 = new Student("Jim", 22, 97.4);
    stu1->show();

    delete stu1;
    return 0;
}

如本例所看到的，定义构造函数时并没有在函数体中对成员变量一一赋值，其函数体为空（当然也能够有其它语句），而是在函数首部与函数体之间加入了一个冒号:。后面紧跟m_name(name), m_age(age), m_score(score)语句，这个语句的意思相当于函数体内部的m_name = name; m_age = age; m_score = score;语句。也是赋值的意思。

使用參数初始化表并没有效率上的优势，仅仅是书写方便，尤其是成员变量较多时，这样的写法很简明明了。

參数初始化表能够用于所有成员变量，也能够仅仅用于部分成员变量。

以下的演示样例仅仅对 m_name 使用參数初始化表。其它成员变量还是一一赋值：

Student::Student(char *name, int age, float score): m_name(name){
    m_age = age;
    m_score = score;
}

初始化 const 成员变量

參数初始化表另一个很关键的数据，那就是初始化 const 成员变量。初始化 const 成员变量的唯一方法就是使用參数初始化表。比如 VS/VC 不支持变长数组（数组长度不能是变量），我们自定义了一个 VLA 类。用于模拟变长数组，请看以下的代码：

#include <iostream>
using namespace std;

class VLA {      //variable-length array
private:
    const int m_len;
    int *m_arr;
public:
    VLA(int len);
    void show();
};
VLA::VLA(int len):m_len(len) {
    m_arr = new int[len];
    for (int i = 0; i < len; i++) {
        m_arr[i] = i;
    }
}
void VLA::show() {
    for (int i = 0; i < m_len; i++) {
        cout<<m_arr[i]<<" ";
    }
    cout<<endl;
}

int main() {
    int len = 10;
    VLA *vla = new VLA(len);//变长数组相当与能够用变量作为数组的维度
    vla->show();
    delete vla;
    return 0;
}

——————————————-

C++析构函数（Destructor）

创建对象时系统会自己主动调用构造函数进行初始化工作，同样。销毁对象时系统也会自己主动调用一个函数来进行清理工作。比如释放分配的内存、关闭打开的文件等，这个函数就是析构函数。

析构函数（Destructor）也是一种特殊的成员函数，没有返回值，不须要程序猿显式调用（程序猿也没法显式调用）。而是在销毁对象时自己主动运行。

构造函数的名字和类名同样。而析构函数的名字是在类名前面加一个~符号。

注意：析构函数没有參数。不能被重载，因此一个类仅仅能有一个析构函数。

假设用户未定义，编译器会自己主动生成一个默认的析构函数。

上节我们定义了一个 VLA 类来模拟变长数组，它使用一个构造函数为数组分配内存，这些内存在数组被销毁后不会自己主动释放，所以很有必要再加入一个析构函数，专门用来释放已经分配的内存。

#include <iostream>
using namespace std;
class VLA {
private:
    const int m_len;
    int *m_arr;
public:
    VLA(int len);
    ~VLA();
    void show();
};
VLA::VLA(int len):m_len(len) {
    m_arr = new int[len];
    for (int i = 0; i < len; i++) {
        m_arr[i] = i;
    }
}
VLA::~VLA() {
    delete []m_arr;
}
void VLA::show() {
    for (int i = 0; i < m_len; i++) {
        cout<<m_arr[i]<<" ";
    }
    cout<<endl;
}

int main() {
    int len;
    cin>>len;
    VLA *vla = new VLA(len);
    vla->show();
    delete vla;
    return 0;
}

~VLA()就是 VLA 类的析构函数，它的唯一作用就是在删除对象后释放已经分配的内存。

—————————————–

思考：为什么用delete释放对象内存后还要一次调用析构函数来清理内存呢？

当一个对象使用new运算符动态创建的时候，在使用delete运算符释放它时。delete会自己主动调用析构函数……

呃，好吧，那是书上说的。我承认即使不是new运算符动态创建的。我硬是用指针指向它，再delete，还是会调用析构函数。

事实上我们能够来看一下析构函数的定义：当对象脱离其作用域时（比如对象所在的函数已调用完毕），系统自己主动运行析构函数。析构函数往往用来做“清理善后” 的工作（比如在建立对象时用new开辟了一片内存空间，应在退出前在析构函数中用delete释放）。

我们delete事实上就相当于使得对象的生命结束。对象生命结束时都会自行调用析构函数。我的想法就是这样，仅仅要对象生命结束时都会自行调用析构函数。你不必觉得这是delete调用的。

。。能够觉得是对象本身自行调用的。

—————————————–

析构函数的运行时机

析构函数在对象被销毁时调用，而对象的销毁时机与它所在的内存区域有关。

在所有函数之外创建的对象是全局对象。它和全局变量相似，位于内存分区中的全局数据区，程序在结束运行时会调用这些对象的析构函数。

在函数内部创建的对象是局部对象，它和局部变量相似，位于栈区，函数运行结束时会调用这些对象的析构函数。

new 创建的对象位于堆区。通过 delete 删除时才会调用析构函数；假设没有 delete，析构函数就不会被运行。