C++:类与对象(中)

已于 2024-08-23 18:13:37 修改
阅读量690 收藏 14
点赞数 18
文章标签： c++ 开发语言
于 2024-08-23 15:46:33 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LCL200356/article/details/141462820
版权

目录

1.默认成员函数

2.构造函数

3.析构函数 

 4.拷贝构造函数

5.运算符重载

5.1运算符重载

 5.2赋值运算符重载

1.默认成员函数

默认成员函数就是用户没有显式实现，编译器会自动生成的成员函数称为默认成员函数。一个类，我们不写的情况下编译器会默认以下6个成员函数，需要注意的是这6个中最重要的是前4个，最后两个取地址重载不重要。其次就是C++11以后还会增加两个默认成员函数，移动构造和移动赋值。

2.构造函数

构造函数时特殊的成员函数，需要注意的是，构造函数虽然名称叫构造，但是构造函数的主要任务并不是开空间创建对象(我们常使用的局部对象是函数栈帧创建时，空间就开好了)，而是对象实例化时初始化对象。构造函数的本质是要代替我们以前Stack和Date类中写的Init函数功能，构造函数自动调用的特点就完美的替代了Init。

 

#include<iostream>
using namespace std;
class Date
{
public:
	//无参构造函数
	Date()
	{
		_year = 1;
		_month =1;
		_day = 1;
	}
	//带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//全缺省构造函数
	//Date(int year = 1990, int month = 1, int day = 1)
	//{
	//	_year = year;
	//	_month = month;
	//	_day = day;
	//}
	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1;//调用默认构造函数

	Date d2(2024,8,23);//调用带参构造函数
	

	//注意：如果通过无参函数创建对象时，对象后面不用跟括号，否则编译器无法区分这里是函数声明还是实例化对象
	Date d3();




	d1.Print();
	d2.Print();



	return 0;
}
#include<iostream>
using namespace std;

typedef int	STDateType;
class Stack
{
public:
	//构造函数
	Stack(int n = 4)
	{
		_arr = (STDateType*)malloc(sizeof(STDateType) * n);
		if (_arr == nullptr)
		{
			perror("malloc fail!");
			exit(1);
		}
		_capacity = n;
		_top = 0;
	}
private:
	STDateType* _arr;
	int _capacity;
	int _top;
};

//两个Stack实现队列
class Myqueue
{
public:
	//编译器默认生成MyQueue的构造函数调用的是Stack的构造，完成的两个成员的初始化
private:
	Stack pushst;
	Stack popst;
};

int main()
{
	Myqueue mq;
	return 0;
}

3.析构函数 

析构函数的功能与构造函数刚好相反，析构函数不是完成对对象本身的销毁，比如局部对象存在函数栈帧的，函数结束栈帧销毁，他就释放了，这不需要我们管。C++规定对象在销毁时会自动调用析构函数，完成对象中资源清理释放工作相当于我们之前数据结构中的Destroy功能。注意只有申请了资源才需要释放，像Date类没有申请资源的不需要析构函数。

析构函数的特点：

 

#include<iostream>
using namespace std;

typedef int	STDateType;
class Stack
{
public:
	//构造函数
	Stack(int n = 4)
	{
		_arr = (STDateType*)malloc(sizeof(STDateType) * n);
		if (_arr == nullptr)
		{
			perror("malloc fail!");
			exit(1);
		}
		_capacity = n;
		_top = 0;
	}
	//析构函数
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_arr);
		_arr = nullptr;
		_capacity = _top = 0;
	}
private:
	STDateType* _arr;
	int _capacity;
	int _top;
};

//两个Stack实现队列
class Myqueue
{
public:
	//编译器默认生成MyQueue的构造函数调用的是Stack的构造，完成的两个成员的初始化

	//即使写了析构，也会自动调用Stack的析构
	//~Myqueue()
	//{

	//}
private:
	Stack pushst;
	Stack popst;
};

int main()
{
	Stack st;
	Myqueue mq;
	return 0;
}

C++中的构造函数和析构函数的应用在我们写代码的时候比C语言方便许多。

举个例子：括号匹配问题

C语言方法实现：

bool isValid(char* s) {
    //初始化
    ST st;
    STInite(&st);
    //遍历字符串s
    char* ps=s;
    while(*ps!='\0')
    {

        if((*ps=='{')||
        (*ps=='[')||
         (*ps=='('))
         {
            //左括号，入栈
            STPush(&st,*ps);
         }
         else
         {
            //如果只有一个括号,直接返回false
            if(STEmpty(&st))
            {
                return false;
            }
            //栈不为空才能取出元素
            char tmp=STTop(&st);
            if((tmp=='('&&*ps==')')||
            (tmp=='['&&*ps==']')||
            (tmp=='{'&&*ps=='}'))
                {
                    //出栈
                    STPop(&st);
                }
                else
                {
                    STDestroy(&st);
                    //不匹配
                    return false;
                }
         }
         ps++;
    }
    bool ret=STEmpty(&st)==true;
    //销毁
    STDestroy(&st);
    return ret;
}

C++实现: 

bool isValid(char* s)
{
	Stack st;
	while (*s)
	{
		//是左括号就入栈
		if (*s == '[' || *s == '(' || *s = '{')
		{
			st.Push(*s);
		}
		else
		{
			//右括号比左括号多
			if (st.Empty())
			{
				return false;
			}
			//从栈里面取左括号开始匹配
			char top = st.Top();
			st.Pop();

			//顺序错误
			if ((*s == ']' && *s != '[') || (*s == '}' && *s != '{') || (*s == ')' && *s != '('))
			{
				return false;
			}
		}
		s++;
	}
	return st.Empty();
}

 4.拷贝构造函数

如果一个构造函数的第一个参数是自身类类型的引用，且任何额外的参数都有默认值，则此构造函数也叫做拷贝构造函数，也就是说拷贝构造函数是一种特殊的构造函数。

拷贝构造的特点:

1.拷贝构造函数是构造函数的一个重载。

2.拷贝构造函数的第一个参数必须是类类型对象的引用，使用传值的方式编译器直接报错，因为语法逻辑会引发无穷递归。拷贝构造函数也可以多个参数，但是第一个参数必须是类类型的引用，后面的参数必须是缺省值。

3.C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，所以这里自定义类型传值传参和传值返回都会调用拷贝构造完成。

4.若未显示定义拷贝构造，编译器会自动生成拷贝构造函数。自动生成的拷贝构造对内置类型成员变量会完成值拷贝 ，对自定义类型成员变量会调用他的拷贝构造。

5.只有申请了资源的类才需要些拷贝构造，像日期类这种没有申请资源且内置成员变量全都是内置类型不需要我们显示实现拷贝构造。像MyQueue这种类型内部是自定义类型Stack成员，则编译器会自动调用Stack的拷贝构造函数。有个小技巧，如果一个类显示实现了析构并释放了资源，那么他就需要显示拷贝构造。

6.传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的是返回对象的别名，没有产生拷贝。但是如果返回的对象是当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回就会造成，野引用。传值返回可以减少拷贝，但是有可能会造成野引用。

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1990, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//拷贝构造，传引用
	Date(const Date& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}

	//传地址
	Date(Date* d)
	{
		_year = d->_year;
		_month = d->_month;
		_day = d->_day;
	}

	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};

void Func1(Date d)
{
	cout << &d << endl;
	d.Print();
}

Date& Func2()
{
	Date tmp(2024, 7, 5);
	tmp.Print();
	return tmp;
}



int main()
{
	Date d1(2024, 8, 23);//调用构造函数

	Func1(d1);//这里通过d1传值给d调用拷贝构造完成，传引用的话可以减少这里的拷贝
	cout << &d1 << endl;

	Date d2 = d1;//拷贝构造

	Date d3(&d1);//这里可以完成拷贝，但是不是拷贝构造，就是个普通的构造

	Date ret = Func2();//因为函数返回的是局部对象的引用，会造成野引用
	ret.Print();


	d1.Print();
	d2.Print();
	d3.Print();
	return 0;
}
#include<iostream>
using namespace std;
typedef int STDataType;
class Stack
{
public:
	Stack(int n = 4)
	{
		_a = (STDataType*)malloc(sizeof(STDataType) * n);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败");
			return;
		}
		_capacity = n;
		_top = 0;
	}
	Stack(const Stack& st)
	{
		// 需要对_a指向资源创建同样⼤的资源再拷⻉值
		_a = (STDataType*)malloc(sizeof(STDataType) * st._capacity);
		if (nullptr == _a)
		{
			perror("malloc申请空间失败!!!");
			return;
		}
		memcpy(_a, st._a, sizeof(STDataType) * st._top);
		_top = st._top;
		_capacity = st._capacity;
	}
	void Push(STDataType x)
	{
		if (_top == _capacity)
		{
			int newcapacity = _capacity * 2;
			STDataType* tmp = (STDataType*)realloc(_a, newcapacity *
				sizeof(STDataType));
			if (tmp == NULL)
			{
				perror("realloc fail");
				return;
			}
			_a = tmp;
			_capacity = newcapacity;
		}
		_a[_top++] = x;
	}
	~Stack()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};

// 两个Stack实现队列
class MyQueue
{
public:
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st1;
	st1.Push(1);
	st1.Push(2);
	// Stack不显⽰实现拷⻉构造，⽤⾃动⽣成的拷⻉构造完成浅拷⻉
	// 会导致st1和st2⾥⾯的_a指针指向同⼀块资源，析构时会析构两次，程序崩溃
	Stack st2 = st1;
	MyQueue mq1;
	// MyQueue⾃动⽣成的拷⻉构造，会⾃动调⽤Stack拷⻉构造完成pushst/popst
	// 的拷⻉，只要Stack拷⻉构造⾃⼰实现了深拷⻉，他就没问题
	MyQueue mq2 = mq1;
	return 0;
}

5.运算符重载

5.1运算符重载

举个例子：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1990, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	 }


	void Print()
	{
		cout << _year << "/" << _month << "/" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};


int main()
{
	Date d1(2024, 8, 23);
	Date d2(2024, 8, 20);
	//运算符重载函数可以显示调用
	d1.operator==(d2);

	d1 == d2;//编译器会自动转换成d1.operator==(d2);

	return 0;
}

前置++和后置++：

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
	bool operator==(const Date& d)
	{
		return _year == d._year
			&& _month == d._month
			&& _day == d._day;
	}
	Date& operator++()
	{
		cout << "前置++" << endl;
		//...
		return *this;
	}
	Date operator++(int)
	{
		Date tmp;
		cout << "后置++" << endl;
		//...
		return tmp;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 7, 5);
	Date d2(2024, 7, 6);
	// 运算符重载函数可以显⽰调⽤
	d1.operator==(d2);
	// 编译器会转换成 d1.operator==(d2);
	d1 == d2;
	// 编译器会转换成 d1.operator++();
	++d1;
	// 编译器会转换成 d1.operator++(0);
	d1++;
	return 0;
}

 5.2赋值运算符重载

赋值运算符重载是一个默认成员函数，用于两个已经存在的对象直接进行拷贝赋值，这里要注意拷贝构造区分，拷贝构造是一个已经存在的拷贝初始化个另一个要创建的对象。

 

#include<iostream>
using namespace std;
class Date
{
public:
	Date(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}

	Date& operator=(const Date& d)
	{
		//防止自己给自己赋值
		if (this != &d)
		{
			_year = d._year;
			_month = d._month;
			_day = d._day;
		}
		return *this;
	}
private:
	int _year;
	int _month;
	int _day;
};

int main()
{
	Date d1(2024, 5, 6);
	Date d2(2024, 6, 6);

	d1 = d2;
	d1.Print();

	return 0;
}

想睡觉 . 我也想睡觉 .
关注
  • 18
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
C++:类和对象思维导图
03-29
这是关于C++类和对象特性的思维导图，更加详细的解释请查看我的个人博客
C++ 类与对象习题
10-14
根据给定的文件信息，我们可以总结出关于C++类与对象的基本知识点，这些知识点对于初学者来说至关重要。接下来，我们将详细解析题目中的知识点，并进一步拓展相关的概念。 ### 1. 类的基本组成部分 #### 关键词...
(C++)类与对象
weixin_53812805的博客
05-22 1万+
一、类与对象的思想 面向对象的特点：封装、继承、多态 面向对象编程的特点： （1）易维护：可读性高，即使改变了需求，由于继承的存在，只需要对局部模块进行修改，维护起来非常方便，维护的成本也比较低。 （2）质量高：可以重用以前项目中已经被测试过的类，使系统满足业务需求从而具有更高的质量 （3）效率高：在软件开发时，根据设计的需求要对现实世界的事物进行抽象，从而产生了类 （4）易扩展：由于继承、封装、多态的特性，可设计出高内聚、低耦合的系统结构，使系统更加灵活、更容易扩展，而且成本也比较低。 1、
C++基础1：类与对象基础
三桂gg的博客
07-18 6425
1.类与对象 概念 比喻 对象/实例 楼房 实例化 建造 类 建筑图纸 面向对象四大特征 特征 说明 类比 抽象 抽出具体事物的普遍性的本质 分门别类：鸟类、哺乳类、鱼类 封装 把数据与处理(函数)包在一起 通信录(增加、删除) 继承 数据与处理(函数)的传承 财富与绝技、混血儿(肤色/头发、 两种语言 多态 同一个事物(函数)的多种形态 手...
C++类和对象详细总结
m0_56910081的博客
04-11 1万+
类与对象概念 什么是对象 对象是一个实体，我们眼睛看到的所有实体都可以看成一个实体对象 什么是类 类是用来对实体（对象）进行描述的。（对象有什么属性，有什么功能）类是一种自定义类型 什么是方法： 方法是实现类功能的一个具体实现，该类有什么样的功能？类的所有功能都要通过调用方法来实现。 自定义类型（类的关键字：class） C中我们学过struct（结构体）自定义类型。c++为了兼容c语言，在这里我们也可以使用struct来定义类。和c不同的是，c++中的struct可以在内部放置函数，除此以
C++编程语言中string类介绍
热门推荐
liitdar的博客
08-21 31万+
string类是C++标准库的一个重要的部分，主要用于字符串处理。可以使用输入输出流方式直接进行string操作，也可以通过文件等手段进行string操作。同时，C++的算法库对string类也有着很好的支持，并且string类还和C语言的字符串之间有着良好的接口。
C++的类和对象
Cosmicsea的博客
05-21 5246
C++面向对象的三大特性：封装、继承、多态 C++认为万事万物皆可为对象，对象有其属性和行为 具有相同性质的对象，可以抽象为类 封装 类在设计时，可以把属性和行为放在不同的权限下，加以控制 public：公共权限，类内可访问、类外可访问， protected：保护权限，类内可访问、类外不可访问，儿子可以访问父亲的保护内容 private：私有权限，类内可访问、类外不可访问，儿子不可以访问父亲的私有内容 struct和class的区别在于 struct的默认权限是public cla
C++类对象进行排序
taoxing
08-29 5001
写在前面 C++类对象按照某一个属性进行排序很早以前就学习过，但是时间久了开始有点遗忘了，现在就把最常用的一共方法进行以下总结。 一. 二.
C++类对象的创建方式
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-11 5982
C++类对象的创建方式
c++：继承（超详解）
qq_62718027的博客
07-22 7万+
目录一：什么是继承二：继承的格式继承的总结：二：子类和父类（基类和派生类）1.子类和父类的相互赋值：2.同名的成员变量3.同名成员函数三：子类中默认的成员函数1.构造函数2.析构函数3.拷贝构造4.赋值运算符重载 四：单继承和多继承单继承： 多继承：菱形继承解决方法一：解决方法二：单继承和多继承的总结：定义：继承(inheritance)机制是面向对象程序设计中使代码可以复用的最重要的手段，它允许程序员在保持原有类特性的基础上进行扩展，增加功能。这样产生的新类，称派生类（或子类），被继承的类称基类（或父类）
C++编程语言中类对象的赋值与复制介绍（一）
liitdar的博客
08-20 4万+
本系列文章主要介绍C++编程语言中类对象的赋值和复制操作，以及两者之间的区别，另外还会介绍“深拷贝”与“浅拷贝”的相关知识。本文为系列文章的第一篇，主要介绍C++编程语言中类对象的赋值的相关知识。
C++：继承与派生
qq_53826699的博客
06-07 5158
继承与派生的概念 基类与派生类 访问权限控制 派生类的构造函数、析构函数 构造函数与析构函数 duo'ji'c
C++实验一-类与简单对象.doc
11-15
C++实验一-类与简单对象 本实验报告的主要目的是让学生理解类和对象的概念，掌握类与对象的定义方法，理解类的成员的访问控制的含义，公有和私有成员的区别，掌握构造函数和析构函数的含义与作用、定义方式和实现...
c++ 类和对象总结
01-20
对象：客观世界里的一切事物都可以看作是一个对象，每一个对象应当具有属性（静态特征，比如一个班级，一个专业，一个教室）和行为（动态特征，例如：学习，开会，体育比赛等）两个要素。 对象是由一组属性和一组...
c++ 类与对象
11-10
c++类与对象实习举例。
C++匿名函数lamba简介
yao_tao11的博客
08-18 663
Lambda 表达式是 C++11 引入的一个功能，允许你在代码中定义匿名函数（即没有名字的函数）。这种表达式可以用于简化函数对象的定义，并使得代码更简洁。Lambda 表达式特别适用于局部的、一次性的函数对象，如用于 STL 算法中。捕获方式含义[ ]空捕获列表，Lambda不能使用所在函数中的变量.[names]names是一个逗号分隔的名字列表，这些名字都是Lambda所在函数的局部变量。默认情况下，这些变量会被拷贝，然后按值传递，名字前面如果使用了&，则按引用传递[&]
C++(11)类语法分析(2)
Once_day的回忆
08-17 1222
Author：Once Day Date：2024年8月17日漫漫长路，才刚刚开始…全系列文章请查看专栏: 源码分析_Once-Day的博客-CSDN博客参考文档:基础类的介绍请参考文章：C++(10)类语法分析(1)-CSDN博客运算符重载是C++的一个强大特性，它允许为用户定义的类型自定义运算符的行为。通过运算符重载，我们可以使自定义类型的对象支持各种运算符，如算术运算符、比较运算符、输入输出运算符等，从而提高代码的可读性和表现力。运算符重载的语法，运算符重载的实现方式是定义一个特殊的成员函数或全局函数
C语言：文件（写入，读取）
最新发布
2301_80311224的博客
08-21 581
区分二者很简单，我们可以选定一个文件，以记事本打开，如果其中的内容你能看懂，他就是一个文本文件，相反，如果是一堆你看不懂的东西，那他就是二进制文件。w+：既能读又能写，若文件不存在则创建，若文件存在则清空。若成功打开会返回文件指针，若失败则返回NULL。w：写入，若文件不存在则创建，若文件存在则清空。r：只读取，若文件不存在，fopen调用失败。a+：既能读又能写，若文件不存在则创建。在打开和关闭文件中，进行操作文件。a：追加写入，若文件不存在则创建。r+：既能读又能写，文件必须存在。
C语言——函数递归
2406_83392683的博客
08-18 399
递归是一种解决问题的方法，在C语言中，就是。但是，如果递归无限地进行下去，就会出现栈溢出，上述就是一个典型例子。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值