49. 构造与析构（上）

于 2024-08-15 10:02:38 发布
阅读量369 收藏 10
点赞数 11
文章标签： java 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_52137184/article/details/141212809
版权

对象的初始化

生活中存在的对象都是被初始化后才上市的，初始状态是对象普遍存在的一个状态的

一般而言所有的对象都需要一个确定的初始状态

  • 解决方案

    • 为每个类都提供一个public的initialize函数

    • 对象创建后立即调用initialize函数进行初始化

initialize只是一个普通的函数，必须显示的调用，一旦由于失误的原因，对象没有初始化，那么结果将是不确定的（随机值），没有初始化的对象，其内部成员变量的值是不定的。（上述初始化方式不推荐，请看C++中的构造函数）

C++中的构造函数

C++中的类可以定义与类名相同的特殊成员函数

这种与类名相同的成员函数叫做构造函数

构造函数在定义时可以有参数，但是没有任何返回类型的声明

构造函数的调用

  • 一般情况下C++编译器会自动调用构造函数

  • 在一些情况下则需要手工调用构造函数

Test t1(4);//自动调用构造函数 .推荐推荐
Test t2 = 5;//自动调用构造函数 
Test t3 = Test(6);//主动调用构造函数
Test tA[3] = {Test(1), Test(2), Test(3)};//主动调用构造函数

例：

#include <stdio.h>

class Test
{
private:
    int i;
    int j;
    int k;
    
public:
    Test(int v)
    {
        i = v;
        j = v;
        k = v;
    }
    
    void print()
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }
};

int main()
{
    Test t1(4);//自动调用构造函数★推荐这个调用有参构造函数
    Test t2 = 5;//自动调用构造函数
    Test t3 = Test(6);//主动调用构造函数
    
    t1.print();
    t2.print();
    t3.print();
  
    //主动调用构造函数//Test(int v)
    Test tA[3] = {Test(1), Test(2), Test(3)};
    for(int i=0; i<3; i++)
    {
        tA[i].print();
    }
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}
result：
i = 4, j = 4, k = 4
i = 5, j = 5, k = 5
i = 6, j = 6, k = 6
i = 1, j = 1, k = 1
i = 2, j = 2, k = 2
i = 3, j = 3, k = 3
Press any key to continue...

成员函数的重载

  • 类的成员函数和普通函数一样可以进行重载，并遵守相同的重载规则

#include <stdio.h>

class Test
{
private:
    int i;
    int j;
    int k;
    
public:
    Test()
    {
        i = 0;
        j = 0;
        k = 0;
    }
    
    Test(int v)
    {
        i = v;
        j = v;
        k = v;
    }
/*
	Test()，Test(int v)构造函数重载
	当谈论构造函数的重载时，是指通过定义多个具有不同参数列表的构造函数来支持多种对象初始化方式的能力。
*/    


    void print()
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }
    
    void print(int v)
    {
        printf("v = %d\n", v);
    }
};

int main()
{
    Test t1(4);//4，4，4
    Test t2 = 5;//5,5,5
    Test t3 = Test(6);//6,6,6
    Test t4;//0,0,0
    
    t4.print();
    t1.print();
    t2.print();
    t3.print();
    
    Test tA[3];//Test()
    
    for(int i=0; i<3; i++)
    {
        tA[i].print();
    }
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}
result：
i = 0, j = 0, k = 0
i = 4, j = 4, k = 4
i = 5, j = 5, k = 5
i = 6, j = 6, k = 6
i = 0, j = 0, k = 0
i = 0, j = 0, k = 0
i = 0, j = 0, k = 0
Press any key to continue...

两个特殊的构造函数

  • 无参构造函数

    • 当类中没有定义构造函数时，编译器默认提供一个无参构造函数，并且其函数体为空

  • 拷贝构造函数

    • 当类中没有定义拷贝构造函数时，编译器默认提供一个拷贝构造函数，简单的进行成员变量的值复制。    Test(const Test& obj) 是拷贝构造函数，因为它接受一个对同类对象的常量引用作为参数。

注意：

  • 当类中没有定义任何一个构造函数，C++编译器会为提供无参构造函数和拷贝构造函数

  • 当类中定义了任意的非拷贝构造函数时，C++编译器不会为提供无参构造函数

      • 如果类中没有显式定义拷贝构造函数，编译器会尝试自动生成一个。

      • 当需要自定义复制行为时，最好显式定义拷贝构造函数。

#include <stdio.h>

/*
    注意：
    1. 当类中没有定义任何一个构造函数，C++编译器会为提供无参构造函数和拷贝构造函数
    2. 当类中定义了任意的非拷贝构造函数时，C++编译器不会为提供无参构造函数 
*/

class Test
{ 
public:
    Test()
    {
        printf("Test()\n");
    }
    
/*
	Test() 和 Test(const Test& obj) 不是函数重载
	Test(const Test& obj) 是拷贝构造函数，因为它接受一个对同类对象的常量引用作为参数。
	在C++中，拷贝构造函数是一个特殊的构造函数，用于创建一个新对象作为现有对象的副本。
    
*/
    Test(const Test& obj)
    {
        printf("Test(const Test& obj)\n");
    }
};

int main()
{
    Test t1;//Test()
    Test t2 = t1;//Test(const Test& obj)
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}
result：
Test()
Test(const Test& obj)
Press any key to continue...

当类中没有定义任何一个构造函数，编译器提供无参构造函数和拷贝构造函数（会主动将成员变量的值进行复制）

#include <stdio.h>


class Test
{ 
private:
    int i = 1;
    int j = 2;
    int k = 3;
    
public:
    void print()
    {
        printf("i = %d, j = %d, k = %d\n", i, j, k);
    }
};

int main()
{
    Test t1;
    Test t2 = t1;//没有，自己造，浅拷贝
    
    t1.print();
    t2.print(); 
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}
result：
i = 1, j = 2, k = 3
i = 1, j = 2, k = 3
/*
	当类中没有定义任何一个构造函数，C++编译器会为提供无参构造函数和拷贝构造函数（会主动将成员变量的值进行复制）
*/
Press any key to continue...

数组类的创建(进阶版在下一章)

Array.h

#ifndef _ARRAY_H_
#define _ARRAY_H_

class Array
{
private:
    int mLength;//数组长度
    int* mSpace;//数组空间

public:
    Array(int length);//构造函数
    Array(const Array& obj);//拷贝构造函数
    int length();//访问private
    void setData(int index, int value);//初始化数组值
    int getData(int index);//获得数组值
    void destory();
};

#endif

Array.cpp


#include "Array.h"

Array::Array(int length)
{
    if( length < 0 )
    {
        length = 0;
    }
    
    mLength = length;
    mSpace = new int[mLength];
}

Array::Array(const Array& obj)//★这里的拷贝构造函数不能使用默认的
{
    mLength = obj.mLength;
    
    mSpace = new int[mLength];//开辟一个新空间去存放数组
    
    for(int i=0; i<mLength; i++)
    {
        mSpace[i] = obj.mSpace[i];
    }
}

int Array::length()//返回数组类长度
{
    return mLength;
}

void Array::setData(int index, int value)
{
    mSpace[index] = value;
}

int Array::getData(int index)
{
    return mSpace[index];
}

void Array::destory()
{
    mLength = -1;
    delete[] mSpace;
}

main.cpp

#include <stdio.h>
#include "Array.h"

int main()
{
    Array a1(10);//数组长度，开辟空间
    
    for(int i=0; i<a1.length(); i++)//赋值
    {
        a1.setData(i, i);
    }
    
    for(int i=0; i<a1.length(); i++)//得到值
    {
        printf("Element %d: %d\n", i, a1.getData(i));
    }
    
    Array a2 = a1;//调用拷贝构造函数，这里用深拷贝
    
    for(int i=0; i<a2.length(); i++)
    {
        printf("Element %d: %d\n", i, a2.getData(i));
    }
    
    a1.destory();
    a2.destory();
    
    printf("Press any key to continue...");
    getchar();
    return 0;
}

g++ -o main main.cpp Array.cpp

./main.exe

Element 0: 0
Element 1: 1
Element 2: 2
Element 3: 3
Element 4: 4
Element 5: 5
Element 6: 6
Element 7: 7
Element 8: 8
Element 9: 9
Element 0: 0
Element 1: 1
Element 2: 2
Element 3: 3
Element 4: 4
Element 5: 5
Element 6: 6
Element 7: 7
Element 8: 8
Element 9: 9
Press any key to continue...

浅拷贝和深拷贝

浅拷贝会导致拷贝的对象和原对象共享同一块内存空间（可能会导致内存被重复释放，使得程序崩溃）

小结

构造函数是C++中用于初始化对象状态的特殊函数

构造函数在对象创建时自动被调用

构造函数和普通成员函数都遵循重载规则

拷贝构造函数是对象正确初始化的重要保证

思考

可以直接调用构造函数吗？直接调用构造函数（避免！！！）会有什么情况发生呢？（应当避免写此类代码：不要在一个构造函数里面调用另一个构造函数）

  • 可以直接调用构造函数，直接调用构造函数将得到一个临时对象。

#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;
}
result：
Test(const char* s)
Test()   //生成临时对象。调用构造函数
~Test()  //临时对象马上结束，调用析构函数
mI = 15138816, mJ = -1, mS = Delphi Tang
~Test()
Press any key to continue...

  • 构造函数只能 被编译器自动调用 或者 声明一个类的对象时手动调用

  • 上述程序中的情形不是这两者。这样调用会导致产生临时对象。

  • Test()一结束，临时对象马上被销毁，调用析构

  • mI和mJ没有被赋值，是随机的

ᥬTff᭄
关注
  • 11
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
c++继承中的构造与析构
weixin_43293737的博客
01-14 235
继承中的构造顺序：先调用父类构造函数 再调用 子类构造函数 继承中的析构顺序：析构的顺序和构造相反（先析构子类对象，再析构父类对象） 1、子类对象在创建时会首先调用父类的构造函数 2、父类构造函数执行结束后，执行子类的构造函数 3、当父类的构造函数有参数时且没有无参构造函数时，需要在子类的初始化列表中显示调用（在类的组合使用中，也涉及到初始化列表的使用，不同的是，组合类已经声明了另一个...
Effective C++之2.构造析构赋值运算
01-20
在C++编程中，理解和掌握构造函数、析构函数、拷贝构造函数和赋值运算符的使用...以上就是《Effective C++》中关于构造析构赋值运算的部分核心概念，理解并遵循这些最佳实践将有助于编写更健壮、更易于维护的C++代码。
2. 构造与析构
轻鸢简掠
09-25 482
2. 构造与析构 本篇主要解答以下问题： 构造函数是什么？ 要不要写构造函数？ 析构函数是什么？ virtual的作用，虚析构函数的作用 2.1 构造函数 构造函数是一个名字和类相同，没有返回类型的函数，其目的是初始化对象。 C++中常见的构造函数有： 默认构造函数。以Student类为例，默认构造函数的原型为 代码中没有显式的定义构造函数的时候，编译器会隐式的合成默认构造函数。按类型给定初始值，初始化类成员。如果定义了构造函数则不会出现默认构造函数，若仍需要，则需明确写出，如上图的第11行。
构造与析构
qq_45604814的博客
03-28 2232
一.构造函数 构造函数就是对类对象进行初始化赋值。构造函数由编译器自动调用，且整个过程只调用一次。 1.构造函数性质 没有返回值也不写void 可以有参数和函数重载。 构造函数函数名与类名一致。 构造函数由编译器自动调用，且整个过程只调用一次。 语法格式： #include<iostream> using namespace std; class A{ public: A() { cout<<"构造函数A()"<<endl; } A(in
虚拟电话（构造与析构）
m0_62627802的博客
04-30 1658
题目描述 虚拟电话包含属性：电话号、状态、机主姓名。 1、电话号是一个类，它包含号码和类型，其中号码是整数类型，类型用单个字母表示用户类别，A表示政府，B表示企业、C表示个人。类操作包括构造、属性的获取和设置等方法，根据需要自行编写。 2、状态用一个数字表示，1表示在用，0表示未用， 3、机主姓名是一个字符串 电话操作包括：构造、析构、打印和查询。 1、构造函数需要考虑复合类成员的构造，并且输出提示信息。假设电话号码为12345678，则构造函数输出"12345678 construct
类的构造与析构
wwhhhhll的博客
12-23 1028
一、类对象成员的构造 1、先构造成员 2、再构造自身（调用构造函数） 二、派生类构造函数 派生类可能有多个基类，也可能包括多个成员对象，在创建派生类对象时，派生类的构造函数除了要负责本类成员的初始化外，还要调用基类和成员对象的构造函数，并向它们传递参数，以完成基类子对象和成员对象的建立和初始化。 1、派生类只能采用构造函数初始化列表的方式向基类或成员对象的构造函数传递参数，形式如下： 派生类构造函数名(参数表):基类构造函数名(参数表),成员对象...
类的构造与析构顺序
dingz
08-10 781
首先，我们来看一段代码： #include<iostream> using namespace std; class A { public: A() { cout << "A's constructor." << endl; } ~A() { cout << "A's destructor." << endl; } }; class B { public: B() { cout << "B's con
构造方法与析构方法区别
shenshizhong的专栏
08-19 4812
Java构造方法 类有一个特殊的成员方法叫作构造方法，它的作用是创建对象并初始化成员变量。在创建对象时，会自动调用类的构造方法。 构造方法定义规则：Java 中的构造方法必须与该类具有相同的名字，并且没有方法的返回类型（包括没有void）。另外，构造方法一般都应用 public 类型来说明，这样才能在程序任意的位置创建类的实例也就是对象。 示例：下面是一个 Rectangle 类的构造方法，
【汇编 C++】类的构造与析构
qq_52572621的博客
10-09 1679
本文章将会可能会涉及到汇编的知识，不过没有关系，我会讲的尽量通俗易懂；另外本篇文章开始前，建议了解下什么是函数重载，这个概念很简单的--有相同的函数名，但参数列表不相同的函数，就是函数重载；和类具有相同名称，并且没有返回值类型的函数，就是类的构造函数{Test() // 和类具有相同的名、并且没有返回值{}};}类的构造函数名前加上'~'这个符号，就是类的析构函数{Test(){printf("你调用了一次类的构造函数\n");}
C++杂讲 类 的构造 与 析构
万里晴空
05-26 640
目录 知识点1【构造和析构函数的概述】 知识点2【构造函数】 1、定义构造函数： 2、构造函数的调用时机 3、构造函数的分类以及调用 构造函数分类： 4、无参构造和有参构造的关系 知识点4【拷贝构造函数】（重要） 1、知识点的引入 2、旧对象 给新对象 初始化 就会调用拷贝构造 3、如果用户不提供拷贝构造 系统会提供 默认拷贝构造 4、自定义拷贝构造、默认拷贝构造、默认无参构造的关系 5、注意： 知识点5【构造函数的调用规则】 1、如果用户提供了有参构造 将屏蔽 系统的..
派生类的构造与析构_派生类的构造与析构_
10-03
在分析给定的文件名"派生类的构造与析构.cpp"时，我们可以推测这是一个包含C++源代码的文件，其中可能包含了关于派生类构造和析构的示例代码。通过对这个文件的阅读和学习，开发者可以更直观地理解上述理论知识，并...
php学习笔记 面向对象的构造与析构方法
10-28
对象中成员的访问(在一个对象的内部方法中，去访问本对轩昂中的其他方法和成员属性)
构造与析构顺序
10-24
构造与析构在C++中，有一种特殊的成员函数，它的名字和类名相同，没有返回值，不需要用户显式调用（用户也不能调用），而是在创建对象时自动执行。这种特殊的成员函数就是构造函数（Constructor）。 初始化对象的...
Java基础之原反补码
最新发布
u012135697的博客
08-14 135
整数类型数据在计算机底层进行存储或运算，以补码方式进行！ 正整数的原反补码，一模一样！
SpringBoot快速入门（手动创建）
m0_74124657的博客
08-11 462
代码如下//引导类项目的入口//注解添加导入进来你可以浏览器中查看自己编写的代码，看是否正确localhost：你命名的端口号（默认是8080。后面你也可以在配置文件修改）
springboot民办高校科研项目管理系统-计算机毕业设计源码54009
VX_DZbishe的博客
08-11 509
论文主要是对基于springboot的民办高校科研项目管理系统进行了介绍，包括研究的现状，还有涉及的开发背景，然后还对系统的设计目标进行了论述，还有系统的需求以及整个的设计方案，对系统的设计以及实现，也都论述的比较细致，最后对基于springboot的民办高校科研项目管理系统进行了一些具体测试。本次报告，首先分析了研究的背景、作用、意义，为研究工作的合理性打下了基础。
集合（1）
supercool7的博客
08-12 778
表示不同的类型集合，Collection、Map、List、Set、Queue、Deque等，以及辅助性质的接口Iterator、LinkIterator、Comparator、Comparable这些接口是为迭代和比较元素而准备。对接口的具体实现，主要常用的有：ArrayList、LinkedList、HashMap、HashSet、TreeMap等等。理解Java集合体系可以从三个层次：最上层的接口、中间的抽象类、最后的实现类。是所有集合框架的根接口，包含了对集合进行基本操作的方法。
构造方法，JavaBean，对象内存图，基础数据类型和引用数据类型
qq_63126439的博客
08-14 155
栈内存处理完数据之后会退出，指向推内存的箭头都会消失，当没有人指向他的时候，堆内存中的数据也会被移除。带参构造方法和无参数构造方法，两者方法名相同，但参数不同，这叫做构造方法的重载。方法区，新增元空间，把原来的方法区的多种功能进行了拆分。创造对象的时候，虚拟机会自动调用构造方法，作用是给成员变量进行初始化的。只要是看见new就会在堆内存创建新的空间，两个空间是独立的，互不影响。基础数据类型，在变量当中存储真实的数据值，和其他空间没有任何关系。使用其他空间的数值，自己的空间存储的是地址值。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值