八、构造与析构函数

最新推荐文章于 2019-09-18 22:46:00 发布
最新推荐文章于 2019-09-18 22:46:00 发布
阅读量438 收藏
点赞数
分类专栏： C++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LGC_LG/article/details/53986280
版权

一、对象初始化
如何给对象进行初始化：
为每个类都提供一个public的initialize函数，对象创建后立即调用initialize函数进行初始化

#include<iostream>
using namespace std;
class student
{
private:
    int i;
public:
    void initialize()
    {
        i = 5;
    }
    int get()
    {
        return i;
    }
};
int main()
{
    student t1;
    t1.initialize();//定义对象后需马上调用初始化函数
    cout<<t1.get()<<endl;
    cin.get();
    return 0;
}

能工作了，但不爽：
initialize只是一个普通的函数，必须显示的调用
一旦失误，对象没有初始化，那么结果是不确定的（没有初始化的对象，其内部成员变量的值是不确定的）
如上面的程序，创建对象后不调用initialize函数会输出随机值
二、c++里的构造函数（与类名相同，可以有参数但无返回值）
没有返回值和返回值是void是完全不同的
1.构造函数的调用：
一般情况下c++编译器会自动调用构造函数，但在一些情况下则需要手工调用构造函数

#include<iostream>
using namespace std;
class student
{
private:
    int i;
public:
    student(int v)//构造函数，可以有参数，但无返回值
    {
        i = v;
    }
    int get()
    {
        return i;
    }
};
int main()
{
    student t1(3);//自动初始化
    student t2=4;//自动初始化
    student t3 = student(5);//手动初始化
    cout<<t1.get()<<endl;//3
    cout<<t2.get()<<endl;//4
    cout<<t3.get()<<endl;//5
    cin.get();
    return 0;
}
三种方法无本质区别

*必须手动初始化的情况：
Test tA[3] = {t1(3),t2(4),t3(5)};这是一个类数组*
三、成员函数的重载：
类的成员函数一样可以重载，并遵守相同的重载规则，构造函数也可以重载（调用重载构造函数时也遵循规则）

#include<iostream>
using namespace std;
class student
{
private:
    int i;
    int j;
    int k;
public:
    student(int v)//构造函数，可以有参数，但无返回值
    {
        i = v;
        j = v;
        k = v;
    }
    student()
    {
        i = 3;
        j = 4;
        k = 5;
    }
    void print()//普通的成员函数
    {
        cout<<i<<endl;
        cout<<j<<endl;
        cout<<k<<endl;
    }
    void print(int v)
    {
        cout<<i<<endl;
        cout<<j<<endl;
        cout<<k<<endl;
        cout<<"hello"<<endl;
    }
};
int main()
{
    student t1;//调用的构造函数是student()
    student t2(8);//调用的构造函数是student(int v)
    t2.print();
    t1.print(5);//调用的是void print(int v)，因为有参数传进去
    t1.print();//调用的是void print()，因为没有参数传进去
    cin.get();
    return 0;
}

student tA[3];//为何此处没有初始化也可以呢，因为类里的student()没有参数，就默认调用这个函数了
四、两个特殊的构造函数(无参构造函数和拷贝构造函数)
1.无参构造函数：
当类中没有定义构造函数时，编译器提供一个无参构造函数，并且其函数体为空
2.拷贝构造函数：
当类中没有定义拷贝函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量成员变成员变量的值的复制

#include<iostream>
using namespace std;
class Test
{ 
private:
    int a;
public:
    Test(int b)//构造函数
    {
        a = b;
    }
    void show()
    {
        cout<<a<<endl;
    }
};
int main()
{
    Test t1(100);
    Test t2 = t1; 
    t2.show();//打印100，调用了默认的拷贝构造函数，将t1里的值拷贝到了t2
    cin.get();
    return 0;
}
#include<iostream>
using namespace std;
class Test
{ 
private:
    int a;
public:
    Test(int b)//构造函数
    {
        a = b;
    }
    Test(const Test& obj) //拷贝构造函数的形态
    {
        cout<<"hello"<<endl;
    }
    void show()
    {
        cout<<a<<endl;
    }
};
int main()
{
    Test t1(100);
    Test t2 = t1; //打印出hello，调用了自定义的拷贝构造函数
    t2.show();//打印乱码，有了自定义的拷贝构造函数，不再调用默认的，而自定义里面的拷贝构造函数没有将a的值拷贝过来，故     cin.get();// 输出乱码
    return 0;
}

五、数组类的创建
Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_
class Array
{
private:
    int mlenth;
    int *mspace;
public:
    Array(int lenth);
    int Lenth();
    void SetData(int index, int data);
    int GetData(int index);
    void Destroy();
};
#endif

Array.cpp

#include"Array.h"
Array::Array(int lenth)
{
    if(0 > lenth)
    {
        lenth = 0;
    }
    else
    {
        mlenth = lenth;
        mspace = new int[lenth];
    }
}
int Array::Lenth()
{
    return mlenth;
}
void Array::SetData(int index, int data)
{
    mspace[index] = data;
}
int Array::GetData(int index)
{
    return mspace[index];
}
void Array::Destroy()
{
    mlenth = -1;
    delete[] mspace; 
}
#include<iostream>
#include"Array.h"
using namespace std;
int main()
{
    Array a1(10);
    for(int i = 0; i < 10; i++)
    {
        a1.SetData(i, i);
    }
    for( int i = 0; i < 10; i++ )
    {
        cout<<a1.GetData(i);
    }
    Array a2(10);
    for(int i = 0; i < 10; i++)
    {
        a2.SetData(i, i);
    }
    for( int i = 0; i < 10; i++ )
    {
        cout<<a2.GetData(i);
    }
    a1.Destroy();
    a2.Destroy();
    cin.get();
    return 0;
}

*注：以上代码有一个非常严重的bug，a1.Destroy()和a2.Destroy();对同一片内存释放了两次
因为使用默认的拷贝构造函数只是简单的值拷贝
解决方法：自定义一个拷贝构造函数：*

#ifndef _ARRAY_H_
#define _ARRAY_H_
class Array
{
private:
    int mlenth;
    int *mspace;
public:
    Array(int lenth);
    Array(Array const& obj);//自定义一个拷贝函数
    int Lenth();
    void SetData(int index, int data);
    int GetData(int index);
    void Destroy();
};
#endif
#include"Array.h"
Array::Array(int lenth)
{
    if(0 > lenth)
    {
        lenth = 0;
    }
    else
    {
        mlenth = lenth;
        mspace = new int[lenth];
    }
}
Array::Array(Array const& obj)
{
    mlenth = obj.mlenth;
    mspace = new int[mlenth];//自定义的拷贝函数里边又申请了一片内存
    if(mlenth > 0)
    {
        for(int i = 0; i<mlenth; i++)
        {
            mspace[i] = obj.mspace[i];
        }
    }
}
int Array::Lenth()
{
    return mlenth;
}
void Array::SetData(int index, int data)
{
    mspace[index] = data;
}
int Array::GetData(int index)
{
    return mspace[index];
}
void Array::Destroy()
{
    mlenth = -1;
    delete[] mspace; 
}
#include<iostream>
#include"Array.h"
using namespace std;
int main()
{
    Array a1(10);
    for(int i = 0; i < 10; i++)
    {
        a1.SetData(i, i);
    }
    for( int i = 0; i < 10; i++ )
    {
        cout<<a1.GetData(i);
    }
    Array a2(10);
    for(int i = 0; i < 10; i++)
    {
        a2.SetData(i, i);
    }
    for( int i = 0; i < 10; i++ )
    {
        cout<<a2.GetData(i);
    }
    a1.Destroy();
    a2.Destroy();
    cin.get();
    return 0;
}

六、c++中的类可以使用其它类来定义成员变量

#include<iostream>
using namespace std;
class M
{
private:
    int a;
public:
    M()
    {
        a = 5;
    }
    int get()
    {
        return a;
    }
};
class N
{
private:
    M a1;//类N的成员变量是其他类的对象
public:
    void print()
    {
        cout<<a1.get()<<endl;//成功打印出5
    }
};
int main()
{
    N a2;
    a2.print();
    cin.get();
    return 0;
}

七、初始化列表（对成员变量进行初始化）
注：成员变量的初始化顺序与声明有关，与在初始列表中的顺序无关
初始化列表先于构造函数的函数体执行

#include<iostream>
using namespace std;
class M
{
private:
    int a;
public:
    M(int i)
    {
        a = i;
        cout<<"hello1"<<endl;
    }
    int get()
    {
        return a;
    }
};
class N
{
private:
    M a1;//先声明a1
    const int c;
public:
    N():c(5),a1(10)//注意参数列表的格式，且参数列表的执行顺序与声明时的顺序有关，参数列表先于构造函数执行
    {
        cout<<"hello2"<<endl;
    }
};
int main()
{
    N a2;
    cin.get();
    return 0;
}

注：
类中的const成员是肯定会被分配空间的
类中的const成员变量只是一个只读变量
编译器无法直接得到const成员变量的初始值，因此无法进入符号表成为真正意义上的常量
初始化与赋值不同：
初始化是用已存在的对象或值对 正在创建的对象 进行初值设置
赋值是用已存在的对象或值对 已经存在的对象 进行值设置

七、对象的销毁
那么如何进行对象的销毁？
解决方法：
(1).为每个类都提供一个public的destroy函数
对象不再需要时需要立即调用destroy函数进行清理（如前面的数组类的创建的例子）
但是类似的问题：
destroy只是一个普通的函数，必须显示的调用
如果对象销毁前没有做清理工作，那么很可能造成资源的泄露

(2). c++的类定义可以定义一个特殊的成员函数清理对象
这个特殊的成员函数叫做析构函数
定义：~ClassName()
析构函数没有任何的参数也没有任何的返回值类型
析构函数在对象被销毁时自动被调用

#include <stdio.h>
class Test
{
private:
    int mI;
public:
    Test(int i) : mI(i)
    {
        printf("Test(), mI = %d\n", mI);
    }

    ~Test()//析构函数
    {
        printf("~Test(), mI = %d\n", mI);
    }
};
void run()
{
    Test t1(1);
    Test t2(2);
}
int main()
{
    run();

    printf("Press any key to continue...");
    getchar();

    return 0;
}

八：数组类的进化
将Destroy()函数改成析构函数即可，程序执行完会自动调用
九：构造与析构函数的调用秩序
当类中有成员变量是其他类的对象时
首先调用成员变量的构造函数，且调用顺序与声明顺序相同
之后调用自身类的构造函数
析构函数的调用秩序与对应的构造函数调用秩序相反

#include<iostream>
using namespace std;
class M
{
private:
    int a;
public:
    M(int i)
    {
        a = i;
        cout<<"hello1"<<endl;
    }
    int get()
    {
        return a;
    }
};
class G
{
public:
    G(int i)
    {
        cout<<"hello3"<<endl;
    }
};
class N
{
private:
    M a1;
    G a2;
    const int c;
public:
    N():c(5),a2(10),a1(1)
    {
        //cout<<c<<endl;//说明参数列表先于构造函数执行
        //c = 6;//发生错误，说明c是只读变量
        cout<<"hello2"<<endl;
    }
};
int main()
{
    N a2;
    cin.get();
    return 0;
}

先打印hello1，再打印hello2，最后是hello3

十、是否可以直接调用构造函数？
可以直接调用，会得到一个临时对象，但是这个临时对象马上就被析构了
构造函数只能被编译器自动调用或者声明一个对象时手工调用
如落不然会生成了一个临时对象，那行结束后马上被析构

#include <stdio.h>
class Test
{
private:
    int mI;
    int mJ;
    const char* mS;
public:
    Test()
    {
        printf("Test()\n");

        mI = 0;
        mJ = 0;
    }

    Test(const char* s)
    {
        printf("Test(const char* s)\n");

        Test();//这行时生成一个临时对象然后马上就被销毁了

        mS = s;
    }

    ~Test()
    {
        printf("~Test()\n");
    }

    void print()
    {
        printf("mI = %d, mJ = %d, mS = %s\n", mI, mJ, mS);
    }
};
void run()
{
    Test t = Test("Delphi Tang"); // Test t("Delphi Tang");

    t.print();
}
int main()
{
    run();

    printf("Press any key to continue...");
    getchar();
    return 0;
}

这里写图片描述

LGC_LG
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
C++ “复制构造”比“先构造，后赋值”更加高效
Spr Chan的博客
02-17 901
题目 Student为表示学生的类且未重载赋值操作符，则下述程序中有调用复制构造函数的是： //程序 a int main() { Student t1; Student t2(t1); //1 Student t3 = t1; //2 return 0; } //程序 b int main() { Student t1; Student t2(t1); //1 St...
C++第一节:类、对象、构造函数、setget
小明同学的博客
07-24 3862
1、类的介绍： 1.1 类是对象的类型，对象是类的实例 1.2 成员变量：用来区分同一个类的不同对象，可以是各种类型，简单类型、指针、引用、复合类型、其他类 1.3 静态成员，描述整个类的特征；非静态成员变量，描述不同对象的特征 1.4 常量成员，必须在创建一个对象的时候，初始化它的常量成员，且不能修改 1.5 成员函数：用来操作一个类的对象的函数；静态成员函数：属于整个类的成员函数 1.6 private 私有，把类的数据成员对外隐藏，使之从外部
对象的构造与析构（二）
diaofoulu2041的博客
09-18 173
目录 1. 析构函数 2. 对象的构造与析构顺序 多个对象之间 单个对象内部 3. const对象与const成员函数 const对象 const成员函数 4. 成员函数、成员变量与对象的...
慎重使用Get/Set成员函数(一)问题的提出
黄国强的专栏
04-27 1036
Get/Set这两个函数都很明显的暴露了内部的数据存储的形式和值，使面向对象形同虚设
程序设计基石与实践之数据成员与set和get函数
松子茶的专栏
01-06 1779
在博文<<程序实践:定义具有成员函数的类 >>介绍了GradeBook类表示可供教师管理学生考试成绩的成绩簿,在本博介结具有一个数据成员,一个Set函数和一个 Get函数的GradeBook类 .关于Program Language更多讨论与交流，敬请关注本博客和新浪微博songzi_tea.
构造函数和析构函数
思想上移，行动下移
02-12 1300
构造函数是一个特殊的方法，一般用来初始化一个类实例的数据成员。运行时根据传递给构造函数的输入参数确定调用哪一个构造函数。 注意事项： 1，构造函数名 和类名总是相同的。 2，构造函数没有返回值。 3，和任何类成员一样，构造函数也有public、protected、internal或private访问类型，一般地，构造函数总是public类型，如果是private类型，则表明该类不能被实例
C++的全局构造与析构函数
01-20
即C++ 的全局对象构造函数在main 函数之前执行，而C++ 全局对象的析构函数在main函数之后被执行。 　Linux系统中，一般程序的入口是“ _start ， 这个函数是Linux系统库(Glibc)的一部分。当我们的程序与Glibc库链接...
php构造函数与析构函数
01-21
本文章向大家介绍php构造函数与析构函数。 php构造函数 1.是对象创建完成后，“第一个”“自动调用”的方法 2.构造方法的定义，方法名是一个固定的， 在php4中:和类名相同的方法就是构造方法 在php5中:构造方法...
构造函数与析构函数
02-16
每个类都具有构造函数和析构函数。其中，构造函数在定义对象时被调用，析构函数在对象释放时被调用。如果用户没有提供构造函数和析构函数，系统将提供默认的构造函数和析构函数。...这是析构函数与普通函数最大的区别。
C++中构造函数与析构函数的调用顺序详解
12-31
在一般情况下，调用析构函数的次序正好与调用构造函数的次序相反：最先被调用的构造函数，其对应的(同一对象中的)析构函数最后被调用，而最后被调用的构造函数，其对应的析构函数最先被调用。 简单来说，其构造函数...
C++构造函数详解
miaojian_430的专栏
02-23 1089
        c++类的构造函数详解                        一、 构造函数是干什么的class Counter{public:         // 类Counter的构造函数         // 特点：以类名作为函数名，无返回类型         Counter()         {                m_value = 0;         }    
第二十七课：二阶构造模式----------狄泰软件学院
LGC_LG的博客
01-30 1467
一、关于构造函数1.类的构造函数用于对象的初始化 2.构造函数与类名相同并且没有返回值 3.构造函数在对象被创建时自动被调用二、几个问题1.如何判断构造函数的执行结果？ 2.在构造函数中执行return语句会发生什么？ 3.构造函数执行结束意味着对象构造成功？#include <iostream> using namespace std; class Test { int mi;
第三十二课：初探c++标准库----------狄泰软件学院
LGC_LG的博客
01-30 1218
一、重载操作符，将变量或常量左移到一个对象中#include <stdio.h>const char endl = '\n';class Console { public: Console& operator << (int i)//返回引用的可以连续操作 { printf("%d", i); return *this; } Consol
第十八课：对象的构造（中）----------狄泰软件学院
LGC_LG的博客
01-18 962
一、带有参数的构造函数#include <iostream> using namespace std; class Test { public: Test() { printf("Test()\n"); } Test(int v) { printf("Test(int v), v = %d\n", v); } }
九、类的静态成员变量
LGC_LG的博客
01-03 829
一、成员变量的回顾通过对象名能够访问public成员变量 每个对象都可以有只属于自己的成员变量 成员变量不能在对象之间共享二、类的静态成员变量和静态成员函数1、静态成员变量属于整个类（注意补水对象而是类）所有，不需要依赖任何对象，不会因为对象的产生或者销毁而被产生和销毁，需要在类外单独分配空间，存储位置为全局数据区 2、静态成员变量的访问方法： 可以通过类名直接访问public静态成员（可以
第三十五课：函数对象分析----------狄泰软件学院
LGC_LG的博客
02-03 748
一、编写一个函数1.函数可以获得斐波那契数列每项的值 2.每次调用返回一个值 3.函数可根据需要重复使用#include<iostream> using namespace std; int fib() { static int a0 = 0; static int a1 = 1; int ret = a1; a1 = a0 + a1; a0 = ret;
第十七课：对象的构造（上）----------狄泰软件学院
LGC_LG的博客
01-18 680
一、对象中的成员变量是多少？类也属于自定义类型，故其定义出来的对象也是变量，既然是变量就会在内存中占有一席之地。 1.若定义局部的对象调用公有函数，可得i是随机值（会在栈上） 2.若定义全局的对象调用公有函数，可得i的值为0（会在全局数据区占用存储空间） 3.若定义一个类指针指向一个类的对象，在堆空间上产生一个对象，可得i的值为随机值（记得delete掉）#include<iostream>
第十九课：对象的构造（下）----------狄泰软件学院
LGC_LG的博客
01-18 671
一：两个特殊的构造函数无参构造函数（没有参数的构造函数） 当类中没有定义构造函数时（注意这里是没有提供构造函数），编译器默认提供一个无参构造函数，并且其函数体为空，若类中定义了则不再提供 拷贝构造函数（参数为const class_name&） 当类中没有定义拷贝构造函数（注意这里是没有提供拷贝构造函数），编译器默认提供一个拷贝构造函数，简单进行成员变量成员变量成员变量值的复制Class T/
C++构造与析构函数深度解析
析构函数与构造函数相反，它在对象生命周期结束时（例如，对象超出作用域或被显式删除）自动调用，用于清理对象可能占用的资源。在上述示例中，`f`函数返回时，局部对象`q`和`r`被销毁，析构函数被调用两次。而在...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值