美文网首页
C++之再谈构造函数

C++之再谈构造函数

作者: bluewind1230 | 来源:发表于2018-01-28 16:11 被阅读0次
#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
    Cstudent() { cout << "student"<<endl; };
};
class Cteacher
{
public:
    Cteacher() { cout << "cteacher"<<endl; };
};
class Ctutor
{
public:
    Ctutor() { cout << "Ctutor"<<endl; };
protected:
    Cstudent m_objstudent;//另外一个类的数据
    Cteacher m_objteacher;//另外一个类的数据

};
int main()
{
    Ctutor tutor;
    return 0;
}
输出见下:
image.png
小结:

在定义时候,如果一个类的数据成员是另外一个类的对象的时候,在调用构造函数创建对象的时候,对作为数据成员的对象先要自动调用数据成员其自身的构造函数

  • 做一个小变化,将定义时的顺序做一个调整:


#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
    Cstudent() { cout << "student"<<endl; };
};
class Cteacher
{
public:
    Cteacher() { cout << "cteacher"<<endl; };
};
class Ctutor
{
public:
    Ctutor() { cout << "Ctutor"<<endl; };
protected:
    Cteacher m_objteacher;
    Cstudent m_objstudent;
    

};
int main()
{
    Ctutor tutor;
    return 0;
}
image.png
小结:

成员变量初始化取决于在类中的定义顺序.

构造函数与析构函数之间的几个对比:

析构函数的特点:

  • 无返回类型(析构与构造两者都没有)
  • 函数名与类名一样,析构函数前面有逻辑反运算符("~"),构造函数没有
  • 无参数（构造函数可以有参数,构造函数有了参数就不是默认构造了）
  • 不能随意调用(析构函数是可以调用的,只不过不能随意调用)
  • 不能重载,只能有一个析构函数(而构造函数可以重载)
  • 析构函数可以是虚函数(而构造函数不可以)
// C++复习.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <iostream>
using namespace std;
class Cstudent
{
public:
    Cstudent() { cout << "student"<<endl; };
    ~Cstudent() { cout << "student 析构" << endl; };
};
class Cteacher
{
public:
    Cteacher() { cout << "cteacher"<<endl; };
    ~Cteacher() { cout << "cteacher  析构" << endl; };
};
class Ctutor
{
public:
    Ctutor() { cout << "Ctutor"<<endl; };
    ~Ctutor() { cout << "Ctutor 析构" << endl; };
protected:
    Cteacher m_objteacher;
    Cstudent m_objstudent;
    

};
int main()
{
    Ctutor tutor;
    return 0;
}

输出:


image.png

由上图可以看出:

析构函数以为调用构造函数相反的顺序 被调用！

再看一个例子：

转换构造:
// 转换构造.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"

class CNumber {

public:
    CNumber() {                                   //1th

        printf("默认构造\n");
    }
    CNumber(int nNum) {                          //2th
        m_nNum = nNum;
        printf("转换构造\n");
        printf("%d\n", m_nNum);
    }
    CNumber(CNumber&C) {                          //3th
                                                  /*  m_nNum = nNum;*/
        printf("拷贝构造\n");
        /*printf("%d\n", m_nNum);*/
    }
    ~CNumber() {                                // 4th
        printf("析构\n");
    }
private:
    int m_nNum;
};

void fun(const CNumber& obj) {                   //9th  obj是调用函数fun时候创建匿名对象的别名
    printf("执行fun函数了\n");
}

    void fun1(const  CNumber& obj) {         //  注意:这里必须要加const,不然会报错,也要加&(引用符号)      
    printf("执行fun函数了\n");
}

int main()
{
    CNumber objA(12);                       // 5th   (这一步执行转换构造,不执行默认构造,因为它这里有一个参数,转换构造代替了默认构造的作用)           
    CNumber objB = 34;                         //6th(这一步也执行转换构造)  执行这一步的时候它会找到上面的转换构造，
    CNumber objC = objA;                               //再加上这一句就会调用拷贝构造
                                                       //同时生成对象objB,没有创建临时对象
    fun(5);                                     //8th
    /*fun1(3);*/
    return 0;                                  //7th
}
//5th->2th(转换构造)->5th->6th->2th(转换构造)->6th->8th->2th(转换构造)
//->8th->9th(执行全局函数)->8th->4th(析构)->7th->4th(析构)->7th->
//4th(析构)->7th->结束
//结论：转换构造函数的调用顺序：对象objA->对象objB->执行fun函数时候所创建的临时对象
//三次析构的顺序：执行fun函数时候所创建的临时对象->对象objB->对象objA
//一般情况下，有几个对象就至少执行几次析构

//5th 是显式调用
//6th, 8th  是隐式调用

运行结果:


image.png

执行到fun(5)这一步的时候:会在类里面寻找这样一个构造函数:它里面有没有一个单个参数的构造函数,如果有,那就是转换构造,将5转换成一个对象类型,如果没有,就会报错!

小结:

  • 有几个对象就至少执行几次析构
  • 转换构造函数以及拷贝构造的调用顺序：对象objA->对象objB->对象objC(调用拷贝构造)->执行fun函数时候所创建的临时对象
    (这一过程中实际上转换构造和拷贝构造代替了默认构造的功能,每创建一个对象都会调用一个构造函数(默认构造,转换构造,拷贝构造等皆可))
  • 执行fun函数时候所创建的临时对象->对象objC->对象objB->对象objA
转换构造的一个注意点:
一般而言其调用时机为:

只有一个参数,参数类型不是本类类型
以上面的例子为例:

1.CNumber objA(12);
2. CNumber objB = 34;
3.fun(5);
void fun(const CNumber& obj) {                   
    printf("执行fun函数了\n");
}
注意点(禁止调用的时机):

在单个参数的构造函数之前加上explicit关键字,就会阻止转换构造,同时也阻止l了在定义了对象时候,使用等号初始化对象

#include "stdafx.h"
class MyClass
{
public:
    explicit MyClass(int num) {
        m_nNum = num;
    };
    ~MyClass();

private:
    int m_nNum;

};



MyClass::~MyClass()
{
}

int main()
{
    MyClass objA(12);
    MyClass objB = 34;//此处会编译不通过,报错:无法从int转换为Myclass
    return 0;
}

拷贝构造

特征

1.拷贝构造函数名与类名同名,没有返回类型
2.拷贝构造函数只有一个形参数,该参数是该类的对象的引用,

(注意:这里为什么是引用类型？？？)

如果不是引用类型,即为CNumber C，此时又会调用构造函数,如此不同的反复循环下去!!!!所以这里一定要加一个引用符号！！！！！(后面有很多地方涉及到类类型的都是这个原因!!!!!!!)

  • 对象需要通过另外一个对象进行初始化；

1). CExample A(100);  
2). CExample B = A;   
3).CExample B(A);  
后两句都会调用拷贝构造函数。

上面例子中的:
 CNumber objC = objA；
 CNumber(CNumber&C) {               
        printf("拷贝构造\n");
        /*printf("%d\n", m_nNum);*/
    }
  • 对象以值传递的方式传入函数参数
// 拷贝构造1.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;

class CExample
{
private:
    int a;

public:
    //构造函数  
    CExample(int b)                            //3th
    {
        a = b;
        cout << "creat:调用构造 " << endl;
    }

    //拷贝构造  
    CExample(const CExample& C)              //4th
    {
        a = C.a;
        cout << "copy调用拷贝构造" << endl;
    }

    //析构函数                              //5th
    ~CExample()
    {
        cout << "delete: 进行析构" <<  endl;
    }

    void Show()
    {
        cout << a << endl;
    }
};

//全局函数，传入的是对象  !!!!!
void g_Fun(CExample C)                      //6th
{
    cout << "test,执行全局函数了" << endl;
}

int main()
{
    CExample test(1);                      //1th
                                           //传入对象  
    g_Fun(test);                          //2th
    getchar();                             //7th
    return 0;
}

//执行CExample test(1);时候，调用构造函数；然后调用g_Fun(test);调用g_Fun()时，
//会产生以下几个重要步骤：
//(1)test对象传入形参时，会先会产生一个临时变量，就叫 C 吧。
//(2)然后调用拷贝构造函数把test的值给C。(拷贝构造函数就是把一个对象的值拷给另一个), 整个这两个步骤有点像：CExample C(test);
//(3)等g_Fun()执行完后, 析构掉 C 对象。
//1th(定义并初始化)->3th(调用构造函数)->1th->2th(调用g_Fun函数)->4th(调用拷贝构造)->2th->6th(执行函数体)->5th(离开函数体就执行析构函数)->离开函数之后再调用一次析构(析构的对象应该是  CExample test)

上面的总结里面也说了:有几个对象就析构几次!!!

  • 过程:1th(定义并初始化)->3th(调用构造函数)->1th->2th(调用g_Fun函数)->4th(调用拷贝构造)->2th->6th(执行函数体)->5th(离开函数体就执行析构函数)->再调用一次析构(析构的对象应该是 CExample test)


    image.png
  • 函数的返回值为对象时,系统会自动调用拷贝构造函数对返回对象值创建一个临时对象,然后再将这个临时对象值赋给接收返回值的对象
// 拷贝构造2.cpp : 定义控制台应用程序的入口点。
//

#include "stdafx.h"
#include <ostream>
#include <iostream>
using namespace std;
class CExample
{
private:
    int a;

public:
    //构造函数  
    CExample(int b)                                           //3th
    {
        a = b;
        cout << "调用构造"<< endl;

    }

    //拷贝构造  
    CExample(const CExample& C)                  //4th
    {
        a = C.a;
        cout << "copy调用拷贝" << endl;
        /*cout << a << endl;
        cout << C.a << endl;*/                        //C.a=0
    }
    ~CExample()                                 //5th
    {
        cout << "delete:调用析构 " << a << endl;
        /*cout << "delete: " <<&C.a << endl;*/
    }

    void Show()
    {
        cout << a << endl;
    }
};

//全局函数 
CExample g_Fun()                          //2th,返回值为类 类型
{
    CExample temp(0);                    //temp是一个对象,创建一个对象并初始化,
    return temp;
}

int main()
{
    g_Fun();                            //1th
    
    return 0;
}

当g_Fun()函数执行到return时，会产生以下几个重要步骤：

  • (1).先会产生一个临时变量，就叫XXXX吧。
  • (2).然后调用拷贝构造函数把temp的值给XXXX。整个这两个步骤有点像：CExample XXXX(temp);
  • (3).在函数执行到最后先析构temp局部变量。

  • (4).等g_Fun()执行完后再析构掉XXXX对象。(析构顺序有待考证,先建立了哪个对象,后建立了哪个对象??)


    image.png
构造函数必须要初始化的几种情况:

a)没有默认构造函数的类对象;
b)const类型变量
c)引用类型变量
情况a)的实例(必须传入参数才能构造的对象)

class CBase
{
public:
    CBase(int a) {};//不是默认构造函数，默认构造函数没有形参
    ~CBase();
};

class CHello {
public :
    CHello() :Cbase(1) {};//没有默认构造函数的类对象必须初始化在初始化列表里面
private:
    int m_nNuma;
    CBase cbase;          //没有默认构造函数的类对象

};

只能在构造函数初始化列表(初始化列表在冒号后面)中进行初始化,(初始化列表的顺序:按照成员变量定义的顺序进行初始化)

Class CLocation{
Public:
     CLocation(int nX, int nY):m_X(nX),m_Y(nY)// 初始化列表在冒号后面
      {}
Private:
int m_X , m_Y            //初始化列表的顺序:按照成员变量定义的顺序进行初始化
}

相关文章

  • C++之再谈构造函数

    小结: 在定义时候,如果一个类的数据成员是另外一个类的对象的时候,在调用构造函数创建对象的时候,对作为数据成员的对...

  • windows逆向3

    VC 程序内存和编译的一些特征C++ 构造函数C++ 成员函数C++ 析构函数C++ 全局对象的构造C++ 全局对...

  • 构造函数和析构函数

    鸡啄米：C++编程入门系列之十四（类与对象：构造函数和析构函数）

  • C++ 构造过程

    构造函数 C++中每个类必须有一个构造函数，如果用户没有自行编写构造函数，则C++会自动提供一个无参数的构造函数，...

  • C++：面向对象基础

    构造函数 C++中有三种构造函数：默认构造函数，有参构造函数，拷贝构造函数 类对象的初始化 括号法//默认构造函数...

  • [C++之旅] 10 构造函数

    [C++之旅] 10 构造函数 构造函数的特点 构造函数在对象实例化时被自动调用 构造函数与类同名 构造函数没有返...

  • scala学习笔记-构造函数

    scala的构造函数分为主构造函数和辅助构造函数 【辅助构造函数】比较容易理解，它们同C++和Java的构造函数十...

  • c++面向对象-构造、析构、初始化列表

    构造函数 构造函数是指创建对象的时候，会调用的函数。C++构造函数可以重载，指针或者对象均可调用构造函数。 析构函...

  • c++之构造函数

    构造函数 构造函数也叫构造器，在对象创建的时候自动调用，一般用于对象成员的初始化。 构造函数与类名同，没有返回值,...

  • C++基础③new对象，继承，友元函数，函数的可变参数

    接续上篇C++基础②构造函数，析构函数，拷贝构造函数 前言 C++是一门面向对象的编程语言 ， 创建用以创建对象 ...

网友评论

      本文标题：C++之再谈构造函数

      本文链接：https://www.haomeiwen.com/subject/koqzaxtx.html

      延伸阅读

      深度阅读

      • 您也可以注册成为美文阅读网的作者，发表您的原创作品、分享您的心情！

      栏目导航

      热点阅读

      关于我们|服务条款|联系我们|C++之再谈构造函数|投稿指南|网站地图|RSS订阅|排版工具|手机版

      提供经典美文摘抄,优美散文欣赏,现代诗歌精选,短篇小说,心情随笔,表白情书范文,故事会在线阅读欣赏

      Copyright © 2014-2023 Haomeiwen.com All Rights Reserved. 好美文阅读网 版权所有

      备案信息：桂公网安备 45052102000051号 · 桂ICP备13007215号-3

      本站所收录作品、热点评论等信息部分来源互联网，目的只是为了系统归纳学习和传递资讯

      所有作品版权归原创作者所有，与本站立场无关，如不慎侵犯了你的权益，请联系我们告知，我们将做删除处理！