CPP复习笔记 3

最新推荐文章于 2021-10-20 11:35:22 发布

wangjunicode

最新推荐文章于 2021-10-20 11:35:22 发布

阅读量1.4k

点赞数 2

分类专栏： CPP复习

本文链接：https://blog.csdn.net/wangjun_huster/article/details/70185222

版权

CPP复习专栏收录该内容

5 篇文章 0 订阅

订阅专栏

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

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 算法产生新名字，这里不再赘述。

成员函数的调用

从上图可以看出，成员函数最终被编译成与对象无关的全局函数，如果函数体中没有成员变量，那问题就很简单，不用对函数做任何处理，直接调用即可。

如果成员函数中使用到了成员变量该怎么办呢？成员变量的作用域不是全局，不经任何处理就无法在函数内部访问。

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，析构函数就不会被执行。

wangjunicode

关注

2
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
CPP复习笔记 3

CPP函数编译原理和成员函数的实现从上节的分析中可以看出，对象的内存中只保留了成员变量，除此之外没有任何其他信息，程序运行时不知道 stu 的类型为 Student，也不知道它还有四个成员函数 setname()、setage()、setscore()、show()，C++ 究竟是如何通过对象调用成员函数的呢？C++函数的编译C++和C语言的编译方式不同。C语言中的函数在编译时名字不变，或者只是简单
复制链接

扫一扫