【C++面向对象】2.构造函数、析构函数

已于 2024-04-02 16:27:34 修改
阅读量497 收藏
点赞数 1
分类专栏： C++ 编程语言 文章标签： c++ 算法
于 2023-10-19 21:56:25 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44431690/article/details/133935083
版权

文章目录

【 1. 构造函数 】

  • 类的构造函数是类的一种特殊的成员函数，它会 在每次创建类的新对象时执行。
  • 构造函数的名称与类的名称是完全相同的，并且 不会返回任何类型，也不会返回 void。构造函数可 用于为某些成员变量设置初始值。

1.1 带参构造函数–传入数据

  • 法1
class Complex
{
	private: 
		double x;
		double y;
	public:
		Complex(); //无参构造函数
		Complex(double, double); //带参构造函数
		void Complex_Printf(void); //输出函数
};

//在类的外部定义构造函数
Complex::Complex(double a, double b) 
{
	x = a;
	y = b;
}

class Complex
{
	private: 
		double x;
		double y;
	public:
		Complex(); //无参构造函数
		Complex(double a, double b) //在类的内部定义构造函数
		{
			x = a;
			y = b;
		}
		void Complex_Printf(void); //输出函数
};
  • 法2
//带参构造函数--形式2-赋默认值
Complex::Complex(double a=3.1, double b=6.2) 
{
	x = a;
	y = b;
}
  • 法3
//带参构造函数--法3
Complex::Complex(double a,double b) :x(a), y(b) { };
  • 法4
//带参构造函数--法4-赋默认值
Complex::Complex(double a=3.1,double b=6.2) :x(a), y(b) { };

1.2 无参构造函数–不传入数据

  • 法1
class Complex
{
	private: 
		double x;
		double y;
	public:
		Complex(); //无参构造函数
		Complex(double, double); //带参构造函数
		void Complex_Printf(void); //输出函数
};
//无参构造函数：默认值x=2,y=1
Complex::Complex()
{
	x=2;
	y=1;
};
  • 法2
//无参构造函数：默认值x=2,y=1
Complex::Complex() :x(2), y(1) { };

1.3 实例

1.3.1 实例1-单个文件类的定义方法

#include <iostream>

using namespace std;

class Box
{
private:
    double length;     // Length of a box
    double breadth;    // Breadth of a box
    double height;     // Height of a box
public:

    // 带参构造函数-法1 
    Box(double l, double b, double h)
    {
        length = l;
        breadth = b;
        height = h;
    }
    
    // 带参构造函数-法2-赋默认值
    /*Box(double l=2.0, double b=3.0, double h=4.0)
    {
       length = l;
       breadth = b;
       height = h;
    }*/

    // 带参构造函数-法3
    //Box(double l, double b, double h) :length(l), breadth(b), height(h) { };
    
    //带参构造函数-法4-赋默认值
    //Box(double l=2.0, double b=3.0, double h=4.0) :length(l), breadth(b),height(h) { };

    无参构造函数-法1
    //Box::Box()
    //{
    //   x=2;
    //   y=1;
    //};

     无参构造函数-法2
    //Box() :length(10), breadth(2), height(5) { };

    double Volume()
    {
        return length * breadth * height;
    }
};

int main(void)
{

    Box Box1(1.0, 2.2, 3.0);
    /* 适用于：
    带参构造函数-法1
    带参构造函数-法2-赋给定值
    带参构造函数法3
    带参构造函数-法4-赋给定值
    */

    //   Box Box1;
       /* 适用于：
       带参构造函数-法2-赋默认值
       带参构造函数-法4-赋默认值
       无参构造函数法1
       无参构造函数法2
       */

    cout << Box1.Volume() << endl;

    return 0;
}

1.3.2 实例2-多个文件类的定义方法

// 【Complex.h】
#pragma once

class Complex
{
	private: 
		double x;
		double y;
	public:
		Complex(); //无参构造函数
		Complex(double, double); //带参构造函数
		void Complex_Printf(void); //输出函数
};

// 【 Complex.cpp 】
#include "Complex.h"
#include <iostream>
using namespace std;

//无参构造函数：默认值x=2,y=1
Complex::Complex() :x(2), y(1) {};

//带参构造函数：赋初值
Complex::Complex(double a, double b) 
{
	x = a;
	y = b;
}

//输出函数,根据实部x和虚部y，输出对应的复数
void  Complex::  Complex_Printf(void)
{
	if      (!x && !y)        cout << '0' << endl;			     //{0}  {0}   ：0
	else if (x  && !y)        cout << x << endl;                 //{≠0}{0}   ：x
	else if (!x && y == -1)   cout << '-i' << endl;              //{0}  {-1}  ：-i
	else if (!x && y == 1)    cout << 'i' << endl;               //{0}  {1}	  ：i
	else if (!x)              cout<<y<<'i'<<endl;				 //{0}  {else}：yi
	else if (x && y == 1)     cout << x << "+i" << endl;         //{≠0}{1}   ：x+i
	else if (x && y == -1)    cout << x << "-i" << endl;         //{≠0}{-1}  ：x-i
	else if (y > 0)           cout << x << '+' << y << 'i'<<endl;//{≠0}{>0}  ：x+yi ,y>0
	else                      cout << x <<y << 'i' << endl;		 //{≠0}{<0}  ：x-yi ,y<0
}

// 【 Main.cpp 】
#include <iostream>
#include "Complex.h"
using namespace std;

int main(void)
{
	Complex a;
	Complex b(0, 0);
	Complex c(0.2, 3.7);
	Complex d(0, 1);
	Complex e(2, 0);
	Complex f(3, -5);
	a.Complex_Printf();
	b.Complex_Printf();
	c.Complex_Printf();
	d.Complex_Printf();
	e.Complex_Printf();
	f.Complex_Printf();
	return 0;
}

在这里插入图片描述

1.4 数组类的构造-在构造函数内输入数组

  • 实例
    第一行输入一个整数n，表示数组的大小，第二行输入n个整数，表示数组，最后输出所有数组元素。
#include <iostream>
using namespace std;
class Array {
private:
	int n;//数组大小 
	int* a;//数组 
public:
	// 构造函数
	Array()
	{
		cin >> n;
		a = new int[n];
		for (int j = 0; j < n; ++j)
			cin >> a[j];
	}
	// 析构函数
	~Array() {
		delete[]a;
	}
	// 输出数组
	void show() {
		for (int i = 0; i < n; i++) cout << a[i] << ' ';
	}
};
int main() {
	Array a;
	a.show();
	return 0;
}

在这里插入图片描述

【 2. 拷贝构造函数 】

  • 拷贝构造函数是一种特殊的构造函数，它在创建对象时，是 使用同一类中之前创建的对象来初始化新创建的对象。
  • 拷贝构造函数的形参必须是引用，但并不限制为const，一般普遍的会加上const限制。
  • 如果在类中没有定义拷贝构造函数，编译器会自行定义一个。如果类带有指针变量，并有动态内存分配，则它必须有一个拷贝构造函数。
  • 拷贝构造函数通常用于：
    • 通过 使用另一个同类型的对象来初始化新创建的对象。
    • 复制对象把它作为参数传递给函数。
    • 复制对象，并从函数返回这个对象。
  • 拷贝构造函数的常见形式：
classname (const classname &obj) 
{
   // 构造函数的主体
}

2.1 深拷贝、浅拷贝

  • 浅拷贝
    同一类型的对象之间可以赋值，使得 两个对象的成员变量的值相同，两个对象仍然是独立的两个对象，这种情况被称为 浅拷贝。一般情况下，浅拷贝没有任何副作用，但是 当类中有指针，并且指针指向动态分配的内存空间，析构函数做了动态内存释放的处理，会导致内存问题。
  • 深拷贝
    当类中有指针，并且此指针是动态分配空间，析构函数做了 释放处理，往往需要自定义拷贝构造函数， 自行给指针动态分配空间，这种情况称为 深拷贝。

2.2 实例

2.2.1 实例1 - class作为形参

  • Line line(10); // 创建一个Line类的对象line，会调用构造函数，输出 “调用构造函数”
  • display(line); // 使用 line 作为参数传入display函数中时，系统首先会调用拷贝构造函数为 line 进行复制创建得到一个临时副本，输出 “调用拷贝构造函数并为指针 ptr 分配内存”
    系统使用该副本在 display 函数中 进行操作，输出 “line 大小 ：10”，display 函数结束后该副本作为局部变量被回收，输出 “释放内存”
  • 对象 Line 在主程序结束前 也将被回收，输出 “释放内存”
#include <iostream>

using namespace std;

class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数

   private:
      int *ptr;
};

// 构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}

// 拷贝构造函数 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}

// 析构函数 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}

// 成员函数 
int Line::getLength( void )
{
    return *ptr;
}

// 外部函数 
void display(Line obj); 

// 程序的主函数
int main( )
{
   Line line(10);
   display(line);
   return 0;
}

// 一个外部函数 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}

在这里插入图片描述

2.2.2 实例2 - class1=class2

  • Line line1(10); // 创建一个Line类的对象line1，会调用构造函数，输出 “调用构造函数”
  • Line line2 = line1; // 创建一个Line类的对象line2 且 line2=line1，即 lin2 是由 lin1 复制得到，即调用了拷贝构造函数，输出 “调用拷贝构造函数并为指针 ptr 分配内存”
  • display(line1); // 使用 line1 作为参数传入display函数中时，系统首先会调用拷贝构造函数为 line1 进行复制创建得到一个临时副本，输出 “调用拷贝构造函数并为指针 ptr 分配内存”
    系统使用该副本在 display 函数中 进行操作，输出 “line 大小 ：10”
    display 函数结束后该副本作为局部变量被回收，输出 “释放内存”
  • 同样地， display(line2); // 使用 line2 作为参数传入display函数中时，系统首先会调用拷贝构造函数为 line2 进行复制创建得到一个临时副本，输出 “调用拷贝构造函数并为指针 ptr 分配内存”
    系统使用该副本在 display 函数中 进行操作，输出 “line 大小 ：10”
    display 函数结束后该副本作为局部变量被回收，输出 “释放内存”
  • 对象 Line1 和Line2 在主程序结束前 也将被回收，分别输出 “释放内存”
#include <iostream>

using namespace std;

class Line
{
   public:
      int getLength( void );
      Line( int len );             // 简单的构造函数
      Line( const Line &obj);      // 拷贝构造函数
      ~Line();                     // 析构函数

   private:
      int *ptr;
};

// 构造函数
Line::Line(int len)
{
    cout << "调用构造函数" << endl;
    // 为指针分配内存
    ptr = new int;
    *ptr = len;
}

// 拷贝构造函数 
Line::Line(const Line &obj)
{
    cout << "调用拷贝构造函数并为指针 ptr 分配内存" << endl;
    ptr = new int;
    *ptr = *obj.ptr; // 拷贝值
}

// 析构函数 
Line::~Line(void)
{
    cout << "释放内存" << endl;
    delete ptr;
}

// 成员函数 
int Line::getLength( void )
{
    return *ptr;
}

void display(Line obj); 


// 程序的主函数
int main( )
{
   Line line1(10);

   Line line2 = line1; // 这里也调用了拷贝构造函数

   display(line1);
   display(line2);

   return 0;
}

// 外部函数 
void display(Line obj)
{
   cout << "line 大小 : " << obj.getLength() <<endl;
}

在这里插入图片描述

2.2.3 实例3 - 深拷贝构造函数

  • 注意这里 为 字符串动态申请内存时，需要考虑到字符串的最后一个字符 ‘\0’： new char [strlen(name)+1] 。
#include <iostream>
#include <cstring>
#pragma warning(disable : 4996)
using namespace std;
class Person {
    public:
        char* name; // 姓名
        int age;    // 年龄
		// 构造函数
        Person(const char* name, int age) {
            this->name = new char[strlen(name) + 1];
            strcpy(this->name, name);
            this->age = age;
        }
		// 拷贝构造函数
        Person(Person &p)
        {
            this->name=new char[strlen(p.name)+1];
            strcpy(this->name,p.name);
            this->age=p.age;
        }
		// 成员函数
        void showPerson() {
            cout << name << " " << age << endl;
        }
		// 析构函数
        ~Person() {
            if (name != nullptr) {
                delete[] name;
                name = nullptr;
            }
        }
};
int main() {
    char name[100] = { 0 };
    int age;
    cin >> name;
    cin >> age;
    Person p1(name, age);
    Person p2 = p1;
    p2.showPerson();
    return 0;
}

在这里插入图片描述

【 3. 析构函数 】

  • 类的析构函数是类的一种特殊的成员函数， 类的析构函数会在每次删除所创建的对象时执行。

  • 析构函数的 名称与类的名称是完全相同的，只是在前面加了个 波浪号（~） 作为前缀，它 不会返回任何值，也 不能带有任何参数。

  • 析构函数 有助于在跳出程序（比如关闭文件、释放内存等）前释放资源。

  • 如果程序里没有构造函数和析构函数，编译器在编译的时候会自动生成构造函数和析构函数，只是函数内没有任何操作。

  • 实例

#include <iostream>

using namespace std;

class Line
{
   public:
      void setLength( double len );
      double getLength( void );
      Line();   // 这是构造函数声明
      ~Line();  // 这是析构函数声明

   private:
      double length;
};

// 成员函数定义，包括构造函数
Line::Line(void)
{
    cout << "Object is being created" << endl;
}
Line::~Line(void)
{
    cout << "Object is being deleted" << endl;
}

void Line::setLength( double len )
{
    length = len;
}

double Line::getLength( void )
{
    return length;
}
// 程序的主函数
int main( )
{
   Line line;

   // 设置长度
   line.setLength(6.0); 
   cout << "Length of line : " << line.getLength() <<endl;

   return 0;
}

在这里插入图片描述

MR_Promethus
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
头歌--C++ 面向对象 - 构造函数与析构函数
m0_56638814的博客
04-12 2309
头歌--C++ 面向对象 - 构造函数与析构函数
C++中的构造函数、析构函数剖析
01-04
C++中的构造函数、析构函数剖析，面向对象函数
17_C++_面向对象_构造函数_析构函数
m0_48948682的博客
08-04 646
C++面向对象的构造函数和析构函数
C++ 面向对象 - 构造函数与析构函数
m0_61820263的博客
06-10 922
C++ 面向对象 - 构造函数与析构函数
头歌：C++ 面向对象 - 构造函数与析构函数
qq_65628600的博客
05-22 5303
第一题： #include<iostream> #include<string> using namespace std; class Student { public: int SID; string Name; Student();//无参的构造函数：Student()，在函数中将学号初始化为0，姓名初始化为王小明 Student(int sid,string name); ~Student(
【面向对象】构造函数与析构函数详解
qq_43840665的博客
02-01 1469
构造函数与析构函数详解。
C++面向对象-2-类的构造函数和析构函数
Anthony_tester的博客
01-11 992
上一篇学习了C++中的类定义，用了两个练习题来演示一个class的属性和行为的定义和调用，以及展开了权限控制和一个类的属性还可以是其他类的一个实例。其中有好多代码是set和get, 写多了有时候很烦，当然写set和get方法是一个好习惯。例如Point，我们需要setX和setY, 有没有一个方法直接SetPoint(X,Y)呢， 这个就本篇要学习的类的构造函数。 区别：struct vs...
C++面向对象编程之二：构造函数、拷贝构造函数、析构函数
天道酬勤
03-08 1000
C++利用构造函数和析构函数，完成对象的初始化和清理工作。对象的初始化和清理工作，是编译器强制我们要做的事情，如果我们不提供构造函数和析构函数，编译器会提供3个函数：1. 默认无参构造函数。2. 默认拷贝构造函数。3. 默认析构函数。构造函数：在对象初始化时，对对象的成员属性赋初始值。构造函数由编译器自动调用，不用手动调用。 拷贝构造函数：在对象初始化时，将一个已有的对象的所有成员属性拷贝到这个被创建的对象上。拷贝构造函数由编译器自动调用，不用手动调用。 析构函数：在对象销毁前系统自动调用，执行一些清理工作
【C++】构造函数、析构函数、拷贝构造函数
m0_55752775的博客
11-17 1680
C++的构造函数、析构函数、拷贝构造函数
C++：构造函数、析构函数、拷贝函数
weixin_52011465的博客
07-18 613
​一个对象或者变量没有初始状态，对其使用后果是未知同样的使用完一个对象或变量，没有及时清理，也会造成一定的安全问题。总结如果属性有在堆区开辟的，一定要自己提供拷贝构造函数，防止浅拷贝带来的问题。如果用户定义有参构造函数，c++不在提供默认无参构造，但是会提供默认拷贝构造。静态成员就是在成员变量和成员函数前加上关键字static，称为静态成员。C++类中的成员可以是另一个类的对象，我们称该成员为对象成员。对象的初始化和清理工作是编译器强制要我们做的事情，因此如果。B类中有对象A作为成员，A为对象成员。...
⚡【C++要笑着学】(7) 默认成员函数：构造函数 | 析构函数 | 拷贝构造函数
热门推荐
⚡ 柠檬叶子团队
03-15 3万+
朋友们好啊，今天终于更新了。我是柠檬叶子C，本章将继续讲解C++中的面向对象的知识点，本篇主要讲解默认成员函数中的构造函数、析构函数和拷贝构造函数。还是和以前一样，我们将由浅入深地去讲解，以 "初学者" 的角度去探索式地学习。会一步步地推进讲解，而不是直接把枯燥的知识点倒出来，应该会有不错的阅读体验。如果觉得不错，可以 "一键三连" 支持一下博主！
C++中的new/delete、构造/析构函数、dynamic_cast分析
01-01
1，new 关键字和 malloc 函数区别（自己、功能、应用）：  1，new 关键字是 C++ 的一部分： ... 1，面向对象中一般用 new，不用 malloc；  4，malloc 以字节为单位进行内存分配；  5，new 在申请内存空
构造函数和析构函数
08-30
C++学习资料，学习面向对象语言的朋友可以看看，绝对有用，个人很喜欢
CPP.rar_C++面向对象
09-21
一个月挑战C++ C++面向对象编程入门：构造函数与析构函数
类构造函数与析构函数
10-26
C++面向对象的编程入门篇--类构造函数与析构函数C++面向对象的编程入门篇--类构造函数与析构函数
C++ 学习笔记
最新发布
普罗米修斯的博客
04-08 860
当 value 类型为 char* 时，cout会从 value 这个 char * 地址开始遍历地址对应的元素直至遇到 ‘\0’ 字符。
【C++基础】13. 输入输出流
普罗米修斯的博客
07-28 672
C++ 预定义了一些 I/O 流对象来实现输入输出，这些 I/O 流对象关联相应设备（键盘、显示器等）并实现程序和设备之间的数据传输。 C++ 预定义的 I/O 流对象有4个：cout 、cin 、cerr 和 clog，其中： cout 代表标准输出流，关联显示器； cin 代表标准输入流，关联键盘； cerr 和 clog 代表标准错误流，也关联显示器。 iostream 和 using namespace std 由于流对象的输入输出功能在 iostream 类库中实现，流对象则在名字空间 std
【C++基础】12. 命名空间
普罗米修斯的博客
11-16 555
命名空间的定义使用关键字 namespace，后跟命名空间的名称，下面的命名空间定义可以是定义一个新的命名空间，也可以是为已有的命名空间增加新的元素，如下所示：// 代码声明 }为了调用带有命名空间的函数或变量，需要在前面加上命名空间的名称，如下所示：// code 可以是变量或函数实例：// 第一个命名空间// 第二个命名空间// 调用第一个命名空间中的函数// 调用第二个命名空间中的函数return 0;
C测试-普通变量和数组的内存分配顺序
普罗米修斯的博客
02-22 544
如下所示的一段代码，依次定义了 i，j，a[5]，k 这几个整型数据，再依次打印出 i，j ，数组 a ，k 各个元素的地址。 #include"stdio.h" int main() { int i; int j; int a[5]; int k=3; printf("整型变量i的地址:%d\n整型变量j的地址:%d\n",&i,&j);/*输出 i,j 的地址*/ printf("数组首元素地址:%d\n",a);/*输出数.
c++ 面向对象 - 构造函数与析构函数
06-28
C++面向对象编程中，构造函数和析构函数是两个非常重要的概念。 构造函数是一种特殊的函数，它在对象被创建时自动调用，用于初始化对象的数据成员。构造函数的名称与类名相同，没有返回值类型，可以有参数，可以有...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

MR_Promethus

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值