精华内容
下载资源
问答
  • c++构造函数和析构函数
    2022-01-16 18:12:02

    (1)C++构造器可以为虚拟函数吗?

    不行。因为构造器调用的时候会设置当前类的虚表地址,然后如果构造函数本身为虚拟函数,那么调用构造函数就需要提前访问虚表,此时虚表不存在。

    (2)构造函数中可以调用虚拟函数吗?

    可以,但是调用虚拟函数就是调用跟调用普通函数效果一样。

    因为子类在创建的时候是先调用父类的构造器,父类的构造器先设置好父类的虚表地址,然后再执行构造器中的代码,然后在回到子类构造器,先将虚表地址替换为子类的虚表地址,然后执行子类构造器的代码。

    因此如果在父类构造器中调用虚函数,那么此时是从父类的虚表中查找函数地址,查找到的还是父类的虚函数地址。因此会调用父类的虚函数,而不会调用子类的虚函数。

    (3)析构函数中可以调用虚拟函数吗?

    可以。但是调用虚拟函数跟调用普通函数没啥区别。

    因为析构的时候先执行子类的析构函数,再执行父类的析构函数,在执行当前类的析构函数的时候会先将虚表地址设置为当前类的虚表地址,然后再从虚表里查找函数地址,因此找到的只能是当前的虚函数的地址。

    (4)父类的析构函数为什么要为虚函数?

    因为如果父类析构函数不为虚函数,那么当对象析构的时候只会调用指针当前类型的析构函数,不会调用父类或者子类的析构函数,会导致资源泄漏。

    如果父类的析构函数为虚函数,那么子类的析构函数在析构的时候会先调用子类的析构函数,再调用父类的析构函数。这样子就不会存在资源泄漏。

    注:

    (1)将子类和父类构造器和析构器调用串起来是编译器实现的

    (2)子类和父类都有自己的虚表。子类或者父类的构造器和析构器在最开始都是将虚表设置为当前类的虚表。然后才真正调用构造函数和析构函数里的代码。

    更多相关内容
  • 构造函数  先看看构造函数的调用顺序规则,只要我们在平时编程的时候遵守这种约定,任何关于构造函数的调用问题都能解决;构造函数的调用顺序总是如下:  1.基类构造函数。如果有多个基类,则构造函数的调用顺序...
  • 学习笔记:C++构造函数和析构函数

    构造函数:

    1. 构造函数在创建对象时被调用。

    2. 无法使用对象来调用构造函数,因为在构造函数构造出对象之前,对象是不存在的。

    3. 构造函数的名称和类名相同。

    4. 可以创建多个同名的构造函数,条件是每个函数的参数列表都不同。

    5. 构造函数没有声明类型。

    6. 通常构造函数用于初始化类对象成员,初始化应与构造函数的参数列表匹配。

    7. 构造函数的参数不是类的成员,而是赋给类成员的值。

    8. 默认构造函数没有参数,如果程序没有提供任何构造函数,编译器提供默认构造函数;如果程序有其它构造函数,则由程序员自己提供默认构造函数。

    假如定义了一个Stock类,以下是构造函数:

    Stock::Stock()

    {

    }

    Stock::Stock(参数1)

    {

    }

    Stock::Stock(参数1,参数2)

    {

    }

    Stock::Stock(参数1,参数2,...)

    {

    }

    调用时根据参数类型匹配构造函数。

    例:

    Stock Stock1("Nano", 12, 20.0);

    调用构造函数 Stock::Stock(const char * co, int n, double pr), 创建一个名为 Stock1的对象。

    Stock Stock2 = Stock("Nano", 12, 20.0);

    调用构造函数 Stock::Stock(const char * co, int n, double pr), 创建一个名为 Stock2的对象。根据编译器不同,可能会产生一个临时对象,在赋值给Stock2后丢弃临时对象。

    Stock2 = Stock("Nano", 12, 20.0);

    Stock2已存在,调用Stock::Stock(const char * co, int n, double pr)产生一个临时对象,在赋值给Stock2后丢弃临时对象。

    Stock Stock3;

    调用默认构造函数 Stock::Stock(), 创建一个名为 Stock3的对象。

    Stock Stock3 = Stock();和  Stock *pr = new Stock;

    都是调用默认构造函数 Stock::Stock()。

    注意: Stock Stock3 (); 是定义了一个返回为Stock的函数,不是构造对象。

    析构函数:

    1. 在删除对象时调用析构函数。

    2. 每个类只有一个析构函数。

    3. 析构造函数的名称为类名前加~。

    4. 如果构造函数使用了new,则必须提供使用delate的析构函数。

    5. 析构函数没有返回类型,包括void类型也没有。

    假如定义了一个Stock类,以下是析构函数:

    Stock::~Stock()

    {

    }

    参考 C++ Primer Plus

    展开全文
  • c++构造函数和析构函数

    千次阅读 2021-04-30 16:33:58
    一、构造函数和析构函数的特点 构造函数和析构函数是一种特殊的公有成员函数,每一个类都有一个默认的构造函数和析构函数; 构造函数在类定义时由系统自动调用,析构函数在类被销毁时由系统自动调用; 构造函数的...

    一、构造函数和析构函数的特点

    • 构造函数和析构函数是一种特殊的公有成员函数,每一个类都有一个默认的构造函数和析构函数;
    • 构造函数在类定义时由系统自动调用,析构函数在类被销毁时由系统自动调用
    • 构造函数的名称和类名相同,一个类可以有多个构造函数,只能有一个析构函数。不同的构造函数之间通过参数个数和参数类型来区分;
    • 我们可以在构造函数中给类分配资源,在类的析构函数中释放对应的资源。

    二、不带参数的构造函数

    C++类在创建时,系统会默认创建一个不带参数的构造函数,我们可以重新定义这个构造函数。默认构造函数在类被创建时自动调用,,定义的类在main函数返回后被销毁,此时系统会自动调用析构函数,回收分配给类的资源。

    class Person
    {
        public:
            int age;
            Person();
            ~Person();
        private:
            int weight;
        protected:
            int hight;
    };
    Person::Person()//重定义默认构造函数
    {
       cout << "constructor!" << endl;
    }
    Person::~Person()//重定义默认析构函数
    {
        cout << "destructor!" << endl;
    }
    int main()
    {
        class Person person;//定义类后系统自动调用构造函数
        return 0;//函数返回,类被销毁,系统自动调用析构函数
    }
    

    QT执行结果:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-KUXB4RKU-1619771618206)(BFF9B60565114114BAF56D2637CF0235)]

    三、构造函数的使用

    构造函数的名称必须和类名相同,一个类中可以有多个构造函数,不同的构造函数之间通过参数的类型和参数的个数来区分,系统会根据初始化时传入的参数类型和个数决定执行哪个构造函数。

    class Person
    {
        public:
            int age;
            Person();
            Person(int flag);
            Person(int flag0,int flag1);
            Person(char flag);
            ~Person();
        private:
            int weight;
        protected:
            int hight;
    };
    Person::Person()
    {
       cout << "constructor!" << endl;
    }
    Person::Person(int flag)
    {
       cout << "constructor int!" << flag << endl;
    }
    Person::Person(int flag0,int flag1)
    {
       cout << "constructor int!" << flag0 <<" "<<flag1<< endl;
    }
    Person::Person(char flag)
    {
       cout << "constructor char!" << flag << endl;
    }
    Person::~Person()
    {
        cout << "destructor!" << endl;
    }
    int main()
    {
        class Person person;//执行 Person();
        class Person person1('c');//执行 Person(char flag);
        class Person person2(100);//执行Person(int flag);
        class Person person3(100,200);//执行Person(int flag0,int flag1);
        cout << "Hello World!" << endl;
        return 0;
    }
    

    QT执行结果:
    [外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-vPU8JlCY-1619771618215)(E94191E03483479199DB01ED038EF590)]

    四、使用构造函数初始化类的成员

    • 类的构造函数可以直接访问类内部的所有成员,可以通过构造函数初始化类的成员。
    • 类成员的初始化方式有两种,第一种是直接在构造函数中给变量赋值,第二种是使用类似于类成员引用的方式初始化。

    方式一:

    Person::Person(int ag,int we,int hi)
    {
        age = ag;
        weight = we;
        hight = hi;
       cout << "age:!" << age <<" weight:"<<weight<<" hight:"<<hight<< endl;
    }
    

    方式二:

    Person::Person(int ag,int we,int hi):age(ag),weight(we),hight(hi)
    {
       cout << "age:!" << age <<" weight:"<<weight<<" hight:"<<hight<< endl;
    }
    

    五、带默认参数的构造函数

    我们在类中定义如下构造函数:

    class Person
    {
        public:
            int age;
            Person(int we,int hi);//和下面的构造函数会产生歧义,故两者只能存在一个
            Person(int we,int hi,int ag=10);
    };
    
    • Persion函数的最后一个参数ag的值默认为10,这种就是带默认参数的构造函数。构造函数的默认参数必须位于函数参数的最右边,否则编译器会报错。
    • 带默认参数的构造函数不能和具有相同类型相同个数的可变参数的其它构造函数同时存在,否则会产生歧义,编译器也会报错。
    展开全文
  • C++ 构造函数和析构函数

    千次阅读 2019-09-25 23:41:03
    对象的初始化和清理 构造函数 没有返回值,没有void,函数名称 : 类名...系统会默认调用构造函数和析构函数,而且只会调用一次 如果程序员没有提供构造和析构,系统会默认提供,空实现 -------------------...

     

    对象的初始化和清理


    构造函数
            没有返回值,没有void,函数名称 : 类名相同,可以发生重载,可以有参数

    析构函数
            没有返回值,没有void,函数名称 : ~类名,不可以发生重载,不可以有参数


    系统会默认调用构造函数和析构函数,而且只会调用一次
    如果程序员没有提供构造和析构,系统会默认提供,空实现
     

     

    --------------------------------------------------------------------------------------------------------------------------

    构造函数 和 析构函数,必须定义在public里面,才可以调用

    ---------------------

    构造函数的分类及调用
        1.1 按照参数分类
            1.1.1 无参构造(默认构造)   , 有参构造
        1.2 按照类型分类
            1.2.1 昔通构造函数(无参 或 有参) ,   拷贝构造函数
        1.3 无参构造写法和调用
            1.3.1 Person p1 ; 注意不能写 Person p1() 。 定义p1的后面如果加了一个括号,不会调用默认构造函数,因为编译器认为这个是函数声明
        1.4 有参构造写法和调用
            1.4.1 Person p2(10)或者 Person p2= Person(10), 前者为括号法,后者为显式调用方法
                      将匿名对象起了p4 (调用一次有参构造)和 p5(调用一次拷贝构造函数)的名字
            1.4.2 Person(10)匿名对象,执行当前行后就会释放这个对象
                
        1.5 拷贝构造函数
            1.5.1 Person(const Person &p),const引用避免修改p的属性
            1.5.2 Perons p1(p2)或者 Person p1= Person(p2), 分别对应括号法和显式两种方法
            1.5.3 不能用拷贝构造函数初始化匿名对象
                1.5.3.1如果写成 Person(p1),这种写法等价于 Person p1,为对象的声明

               当左值:

                1.5.3.2写到右值可以做拷贝构造函数

               当右值:
        1.6 Person p = 100隐式类型转换,相当于调用 Person p = Person(100)

                

    --------------------------------------------------------------------------------------------------------------------------

    拷贝构造函数,Person(const Person &p)

    如果去掉引用“&” ,会进入死循环(原因:去掉“&”后,变成了值传递(开辟新的空间),还会调用拷贝构造函数,所以会死循环无限调用拷贝函数)

    --------------------------------------------------------------------------------------------------------------------------

    拷贝构造函数调用时机
    1、用已经创建好的对象来初始化新的对象
    2、以值传递的方式给函数参数传值
    3、以值方式返回局部对象
          release模式下,编译器会做优化

    1.

    2.

    3.

    Debug 和 Release模式会有区别

    (Release模式编译器会帮我们做优化,构造函数的运行结果看起来可能不是我们希望的):

    --------------------------------------------------------------------------------------------------------------------------

    构造函数的调用规则

    1. 如果提供了有参的构造,那么系统就不会提供默认的构造了,但是会提供拷贝构造函数

    2. 如果提供了拷贝构造函数,那么系统就不会提供其他的构造函数了(默认构造函数也不再提供了,如果需要自己写了)

    -----------------

    构造函数调用规则
    默认情况下,c++编译器至少为我们写的类增加3个函数
        1.默认构造函数无参,函数体为空
        2.默认析构函数无参,函数体为空
        3.默认拷贝构造函数,对类中非静态成员属性简单值拷贝
    如果用户定义拷贝构造函数,c++不会再提供任何默认构造函数
    如果用户定义了普通构造(非拷贝),c++不再提供默认无参构造,但是会提供默认拷贝构造

    --------------------------------------------------------------------------------------------------------------------------

    深拷贝与浅拷贝

    1. 系统默认提供的拷贝构造 会进行简单的值拷贝
    2. 如果属性里有指向堆区空间的数据,那么简单的浅拷贝会导致重复释放内存的异常
    3. 解决上述问题,需要我们自己提供拷贝构造函数,进行深拷贝

    --------------------------------------------------------------------------------------------------------------------------

    构造函数和其他函数不同,除了有名字,参数列表,函数体之外还有初始化列表。

    初始化列表语法

    1. 在构造函数后面 +  : 属性(值、参数), 属性(值、参数)…

    如下代码,实现了3种方法初始化,其中第二种传值(写死)(自定义默认构造),第三种方法传参(自定义有参构造)

    --------------------------------------------------------------------------------------------------------------------------

    类对象作为成员的案例

    1. 当B类对象作为A类内部成员属性的时候,构造顺序是先构造A类内部的对象B,然后再构造A类自己
    2. 析构顺序与构造相反

    class Person

    {

    public:

    private:

        study  study_something;

        paly  play_something;

    }

    voide test01()

    {

    Person p1;

    /*

    构造函数调用顺序: study 类的默认构造函数 -> paly 类的默认构造函数->Person 类的默认构造函数

    析构函数调用顺序:Person 类的默认构造函数 -> paly 类的默认构造函数->study 类的默认构造函数

    */

    }

    --------------------------------------------------------------------------------------------------------------------------

    explicit关键字

    1. 作用:防止构造函数中的隐式类型转换

     

    c++提供了关键字explicit,禁止通过构造函数进行的隐式转换。声明为explicit的构造函数不能在隐式转换中使用。

    [explicit注意]

    1. explicit用于修饰构造函数,防止隐式转化。
    2. 是针对单参数的构造函数(或者除了第一个参数外其余参数都有默认值的多参构造)而言。

    class MyString{

    public:

    explicit MyString(int n){

    cout << "MyString(int n)!" << endl;

    }

    MyString(const char* str){

    cout << "MyString(const char* str)" << endl;

    }

    };

     

    int main(){

     

    //给字符串赋值?还是初始化?

    //MyString str1 = 1;

    MyString str2(10);

     

    //寓意非常明确,给字符串赋值

    MyString str3 = "abcd";

    MyString str4("abcd");

     

    return EXIT_SUCCESS;

    }

    --------------------------------------------------------------------------------------------------------------------------

    new 运算符 和 delete运算符

    为了在运行时动态分配内存,c在他的标准库中提供了一些函数,malloc以及它的变种calloc和realloc,释放内存的free,这些函数是有效的、但是原始的,需要程序员理解和小心使用。为了使用c的动态内存分配函数在堆上创建一个类的实例,我们必须这样做:

    class Person{

    public:

    Person(){

    mAge = 20;

    pName = (char*)malloc(strlen("john")+1);

    strcpy(pName, "john");

    }

    void Init(){

    mAge = 20;

    pName = (char*)malloc(strlen("john")+1);

    strcpy(pName, "john");

    }

    void Clean(){

    if (pName != NULL){

    free(pName);

    }

    }

    public:

    int mAge;

    char* pName;

    };

    int main(){

     

    //分配内存

    Person* person = (Person*)malloc(sizeof(Person));

    if(person == NULL){

    return 0;

    }

    //调用初始化函数

    person->Init();

    //清理对象

    person->Clean();

    //释放person对象

    free(person);

     

    return EXIT_SUCCESS;

    }

    问题(C语言动态分配内存的缺点):

    1. 程序员必须确定对象的长度。
    2. malloc返回一个void*指针,c++不允许将void*赋值给其他任何指针,必须强转。
    3. malloc可能申请内存失败,所以必须判断返回值来确保内存分配成功。
    4. 用户在使用对象之前必须记住对他初始化,构造函数不能显示调用初始化(构造函数是由编译器调用),用户有可能忘记调用初始化函数。

    c的动态内存分配函数太复杂,容易令人混淆,是不可接受的,c++中我们推荐使用运算符new 和 delete.

    new operator

    当我们创建数组的时候,总是需要提前预定数组的长度,然后编译器分配预定长度的数组空间,在使用数组的时,会有这样的问题,数组也许空间太大了,浪费空间,也许空间不足,所以对于数组来讲,如果能根据需要来分配空间大小再好不过。

    所以动态的意思意味着不确定性。

    为了解决这个普遍的编程问题,在运行中可以创建和销毁对象是最基本的要求。当然c早就提供了动态内存分配(dynamic memory allocation),函数malloc和free可以在运行时从堆中分配存储单元。

    然而这些函数在c++中不能很好的运行,因为它不能帮我们完成对象的初始化工作。

    C++中解决动态内存分配的方案是把创建一个对象所需要的操作都结合在一个称为new的运算符里。当用new创建一个对象时,它就在堆里为对象分配内存并调用构造函数完成初始化

    Person* person = new Person;

     

    相当于:

     

    Person* person = (Person*)malloc(sizeof(Person));

    if(person == NULL){

    return 0;

    }

    person->Init();

    New操作符能确定在调用构造函数初始化之前内存分配是成功的,所有不用显式确定调用是否成功。

    现在我们发现在堆里创建对象的过程变得简单了,只需要一个简单的表达式,它带有内置的长度计算、类型转换和安全检查。这样在堆创建一个对象和在栈里创建对象一样简单。

    delete operator

    new表达式的反面是delete表达式。delete表达式先调用析构函数,然后释放内存。正如new表达式返回一个指向对象的指针一样,delete需要一个对象的地址。

    delete只适用于由new创建的对象。

    如果使用一个由malloc或者calloc或者realloc创建的对象使用delete,这个行为是未定义的。因为大多数new和delete的实现机制都使用了malloc和free,所以很可能没有调用析构函数就释放了内存。

    如果正在删除的对象的指针是NULL,将不发生任何事,因此建议在删除指针后,立即把指针赋值为NULL,以免对它删除两次,对一些对象删除两次可能会产生某些问题。

    class Person{

    public:

    Person(){

    cout << "无参构造函数!" << endl;

    pName = (char*)malloc(strlen("undefined") + 1);

    strcpy(pName, "undefined");

    mAge = 0;

    }

    Person(char* name, int age){

    cout << "有参构造函数!" << endl;

    pName = (char*)malloc(strlen(name) + 1);

    strcpy(pName, name);

    mAge = age;

    }

    void ShowPerson(){

    cout << "Name:" << pName << " Age:" << mAge << endl;

    }

    ~Person(){

    cout << "析构函数!" << endl;

    if (pName != NULL){

    delete pName;

    pName = NULL;

    }

    }

    public:

    char* pName;

    int mAge;

    };

     

    void test(){

    Person* person1 = new Person;

    Person* person2 = new Person("John",33);

     

    person1->ShowPerson();

    person2->ShowPerson();

     

    delete person1;

    delete person2;

    }

    用于数组的new和delete

    使用new和delete在堆上创建数组非常容易。

    //创建字符数组

    char* pStr = new char[100];

    //创建整型数组

    int* pArr1 = new int[100]; 

    //创建整型数组并初始化

    int* pArr2 = new int[10]{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 };

     

    //释放数组内存

    delete[] pStr;

    delete[] pArr1;

    delete[] pArr2;

    当创建一个对象数组的时候,必须对数组中的每一个对象调用构造函数,除了在栈上可以聚合初始化,必须提供一个默认的构造函数。

    /*eg:

    以上代码

    new char[100];)会调用100次默认构造函数

    (delete[] pStr; )  会调用100次析构函数

    */

    class Person{

    public:

    Person(){

    pName = (char*)malloc(strlen("undefined") + 1);

    strcpy(pName, "undefined");

    mAge = 0;

    }

    Person(char* name, int age){

    pName = (char*)malloc(sizeof(name));

    strcpy(pName, name);

    mAge = age;

    }

    ~Person(){

    if (pName != NULL){

    delete pName;

    }

    }

    public:

    char* pName;

    int mAge;

    };

     

    void test(){

    //栈聚合初始化

    Person person[] = { Person("john", 20), Person("Smith", 22) };

    cout << person[1].pName << endl;

        //创建堆上对象数组必须提供构造函数

    Person* workers = new Person[20];

    }

     

    delete void*可能会出错

     如果对一个void*指针执行delete操作,这将可能成为一个程序错误,除非指针指向的内容是非常简单的,因为它将不执行析构函数.以下代码未调用析构函数,导致可用内存减少。

    class Person{

    public:

    Person(char* name, int age){

    pName = (char*)malloc(sizeof(name));

    strcpy(pName,name);

    mAge = age;

    }

    ~Person(){

    if (pName != NULL){

    delete pName;

    }

    }

    public:

    char* pName;

    int mAge;

    };

     

    void test(){

    void* person = new Person("john",20);

    delete person;

    }

    问题:malloc、free和new、delete可以混搭使用吗?也就是说malloc分配的内存,可以调用delete吗?通过new创建的对象,可以调用free来释放吗?

    使用new和delete采用相同形式

    Person* person = new Person[10];

    delete person;

    以上代码有什么问题吗?(vs下直接中断、qt下析构函数调用一次)

    使用了new也搭配使用了delete,问题在于Person有10个对象,那么其他9个对象可能没有调用析构函数,也就是说其他9个对象可能删除不完全,因为它们的析构函数没有被调用。

    我们现在清楚使用new的时候发生了两件事: 一、分配内存;二、调用构造函数,那么调用delete的时候也有两件事:一、析构函数;二、释放内存。

    那么刚才我们那段代码最大的问题在于:person指针指向的内存中到底有多少个对象,因为这个决定应该有多少个析构函数应该被调用。换句话说,person指针指向的是一个单一的对象还是一个数组对象,由于单一对象和数组对象的内存布局是不同的。更明确的说,数组所用的内存通常还包括“数组大小记录”,使得delete的时候知道应该调用几次析构函数。单一对象的话就没有这个记录。单一对象和数组对象的内存布局可理解为下图:

     

    本图只是为了说明,编译器不一定如此实现,但是很多编译器是这样做的。

    当我们使用一个delete的时候,我们必须让delete知道指针指向的内存空间中是否存在一个“数组大小记录”的办法就是我们告诉它。当我们使用delete[],那么delete就知道是一个对象数组,从而清楚应该调用几次析构函数。

    结论:

        如果在new表达式中使用[],必须在相应的delete表达式中也使用[].如果在new表达式中不使用[], 一定不要在相应的delete表达式中使用[].

     

    new 运算符 和 delete运算符

    1. Person * p =  new Person 会返回一个Person指针
    2. 默认调用构造函数,开辟空间,返回不是void* ,不需要强制转换
    3. delete释放
    4.  new 对象 用void* 去接收,释放不了对象,不会调用析构函数
    5. new出来的是数组 ,如何释放?  delete [] …
    6. new出来的是数组,肯定会调用默认构造(数组里面有多少个对象,就调用多少次默认构造函数;其中调用了10次构造函数,delete [] pArray调用10次析构函数)

    --------------------------------------------------------------------------------------------------------------------------

    展开全文
  • C++构造函数和析构函数的调用顺序举例一.调用方法和区别1、构造函数的调用顺序: 基类构造函数、对象成员构造函数、派生类本身的构造函数 2、析构函数的调用顺序:
  • 今天小编就为大家分享一篇关于C++构造函数和析构函数的使用与讲解,小编觉得内容挺不错的,现在分享给大家,具有很好的参考价值,需要的朋友一起跟随小编来看看吧
  • 调用构造函数和析构函数的顺序:先构造的后析构,后构造的先折构。它相当于一个栈,先进后出。 代码如下:#include<iostream>#include<string>using namespace std;class Student{ public: Student(string,string,...
  • 虚函数的调用是通过虚函数表来查找的,而虚函数表由类的实例化对象的vptr指针(vptr可以参考C++的虚函数表指针vptr)指向,该指针存放在对象的内部空间中,需要调用构造函数完成初始化。如果构造函数是虚函数,那么...
  • 派生类不能继承基类的构造函数和析构函数。当基类中的构造函数带有参数时,派生类的构造函数必须定义,以便把参数传给基类。由于析构函数是不带参数的,所以在派生类中要不要定义析构函数与基类无关。在定义派生类...
  • c++构造函数和析构函数的调用顺序

    千次阅读 2019-04-22 14:33:45
    在使用构造函数和析构函数时,需要特别注意对他们的调用时间和调用顺序,在一般情况下,调用析构函数的次序正好与调用构造函数的次序相反,最先被调用的构造函数,其对应(同一对象中的)析构函数最后被调用,而最后...
  • 通过malloc分配的对象不会调用构造函数,用new(类 对象名这种方法)可以调用构造函数 **错误结论:**默认情况下,编译器会为每一个类生成空的无参的构造函数 正确理解:在某些特定的情况下,编译器才会为类生成空...
  • 【C++】C++构造函数和析构函数

    千次阅读 2017-06-26 20:51:06
    C++提供构造函数来处理对象的初始化。 构造函数是一种特殊的成员函数,不需要用户来调用,定义对象时被自动执行。 构造函数名字与类名相同,无返回类型(void也不能有哦)。可以由用户自己定义实现,根据需要设计对...
  • C++ 构造函数和析构函数可以是虚函数嘛?

    千次阅读 多人点赞 2019-03-22 21:26:37
    虚函数的调用是通过虚函数表来查找的,而虚函数表由类的实例化对象的vptr指针(vptr可以参考C++的虚函数表指针vptr)指向,该指针存放在对象的内部空间中,需要调用构造函数完成初始化。如果构造函数是虚函数,那么...
  • 这个问题来自于《Effective C++》条款9:永远不要在构造函数或析构函数中调用虚函数 。 简要结论:  1. 从语法上讲,调用完全没有问题。  2. 但是从效果上看,往往不能达到需要的目的。  Effective 的解释是:...
  • 构造函数: 一种特殊的成员函数,主要用于为对象分配空间,进行初始...析构函数:</font> 执行与构造函数相反的操作,通常用于执行一些清理任务,如释放分配给对象的内存空间,在写C++程序函数时每次 return 0; 之后,会自动的
  • 一、构造函数的执行顺序: 二、析构函数的执行顺序 三、用一段代码来说明 #include <iostream> using namespace std; class B1 { public: B1(int i=100){ cout<<"constructing B1 "<<i...
  • c++中的构造函数和析构函数
  • C++构造函数和析构函数的调用顺序

    万次阅读 多人点赞 2018-09-04 00:05:03
    1、构造函数的调用顺序  基类构造函数、对象成员构造函数、派生类本身的构造函数  2、析构函数的调用顺序 派生类本身的析构函数、对象成员析构函数、基类析构函数(与构造顺序正好相反)  3、特例  局部...
  • 先说结论:C++中,构造函数不可以是虚函数,而析构函数可以且常常是虚函数。 虚函数的定义:类成员函数前面添加virtual关键字,则函数被称为虚函数。 1、构造函数不可以是虚函数 当类中声明虚函数时,编译器会在...
  • 本程序包含构造函数和析构函数,可以把构造函数和析构函数的作用区分开
  • 构造函数和析构函数 构造函数和析构函数分别完成对象的初始化和清理 如果没有手动指定构造和析构函数,编译器会自动实现一个空的构造和析构函数。 创建对象时,编译器会自动调用构造函数,对象销毁时,编译器会自动...
  • C++浅谈构造函数和析构函数

    多人点赞 2021-03-06 17:06:25
    构造函数 构造函数是一个特殊的成员函数,名字与类名相同,创建类类型对象时由编辑器自动调用,保证每个数据成员都有一个合适的初始值,并且在对象的生命周期内只调用一次。 构造函数是特殊的成员函数,需要注意的是...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 82,714
精华内容 33,085
关键字:

c++构造函数和析构函数

c++ 订阅