——————————————-
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,析构函数就不会被运行。