《C++ primer plus》精炼（OOP部分）——对象和类（6）

最新推荐文章于 2024-07-11 22:03:57 发布
最新推荐文章于 2024-07-11 22:03:57 发布
阅读量97 收藏
点赞数
分类专栏： C++类和对象 文章标签： c++ 算法 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_72987309/article/details/133143512
版权

“学习不是生活的一部分，而是构建生活的全部。”——约翰·杜

文章目录

第12章：类和动态内存分配

在这一章中，我们逐步构造了一个自己的简易版String类，这个类在构造和析构函数中频繁使用new和delete运算符，因此可以引出一些在类中使用动态内存分配所隐含的问题。

第1版：Stringbad类

Stringbad类使用动态内存分配完成了构造和析构操作，但也引发了一些问题。下面是Stringbad类声明：

#include<iostream>
#ifndef STRINGBAD_H_
#define STRINGBAD_H_

class StringBad
{
private:
	char* str;//pointer to string
	int len;
	static int num_strings;//number of objects
public:
	StringBad(const char* s);
	StringBad();
	~StringBad();
	friend std::ostream& operator<<(std::ostream& os, const StringBad& st);
};

#endif

注意，在声明中加入了一个静态成员变量，这种变量独立于所有对象存储，被所有对象所共享，它表示已经创建的对象的个数。
以下是StringBad类的定义：

#include<cstring>
#include "stringbad.h"
using namespace std;
//初始化静态类成员
int StringBad::num_strings = 0;
//类方法
StringBad::StringBad(const char* s)
{
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	num_strings++;
	cout << num_strings << ":\"" << str << "\"object created\n";
}

StringBad::StringBad()
{
	len = 4;
	str = new char[4];
	strcpy(str, "C++");
	num_strings++;
	cout << num_strings << ":\"" << str << "\"object created\n";
}

StringBad::~StringBad()
{
	cout << "\"" << str << "\" object deleted, ";
	--num_strings;
	cout << num_strings << "left\n";
	delete[] str;
}

std::ostream& operator<<(std::ostream& os, const StringBad& st)
{
	os << st.str;
	return os;
}
  1. 在每个构造函数中，递增num_strings；每个析构函数中递减num_strings
  2. 以传入参数的构造函数为例，先用字符串s初始化len和str，初始化str时使用new运算符分配了足够存储字符串的内存。然后用strcpy函数进行字符串拷贝，递增num_strings，输出字符串信息。注意，不能直接用“str=s”，这样相当于拷贝了地址，而非字符串本身。
  3. 对于析构函数，则先输出要析构的字符串信息，递减num_strings，最后调用delete运算符进行内存释放。注意，当对象被析构时，str指针会被自动释放，但分配的内存不会，因此会造成内存泄露，所以在C++中要注意一个new对应一个delete，这点和java不同。

以下是对StringBad类的测试程序：

#include<iostream>
using std::cout;
#include"stringbad.h"

void callme1(StringBad&);//引用传参
void callme2(StringBad);//值传参

int main(void)
{
	using std::endl;
	{
		cout << "Starting an inner block.\n";
		StringBad headline1("Celery Stalks at Midnight");
		StringBad headline2("Letture Prey");
		StringBad sports("Spinach Leaves Bowl for Dollars");

		cout << "headline1: " << headline1 << endl;
		cout << "headline2: " << headline2 << endl;
		cout << "sports: " << sports << endl;
		callme1(headline1);
		cout << "headline1: " << headline1 << endl;
		callme2(headline2);
		cout << "headline2: " << headline2 << endl;
		cout << "Initialize one object to another:\n";
		StringBad sailor = sports;
		cout << "sailor: " << sailor << endl;
		cout << "Assign one object to another:\n";
		StringBad knot;
		knot = headline1;
		cout << "knot: " << knot << endl;
		cout << "Exiting the block.\n";
	}
	cout << "End of main()\n";
	return 0;
}

void callme1(StringBad& rsb)
{
	cout << "String passed by reference:\n";
	cout << "   \"" << rsb << "\"\n";
}

void callme2(StringBad sb)
{
	cout << "String passed by value:\n";
	cout << "   \"" << sb << "\"\n";
}

输出结果：
在这里插入图片描述
在这里插入图片描述
注意最后几行的输出信息，很明显出现了问题，初步判断是在调用析构函数时字符串的内容出了问题，而且num_strings最后的值是-2，也不对。
哪里出错了？

错误

StringBad类的错误是由特殊成员函数引起的。如果编译器判断程序使用对象时需要这些函数且程序员没有写，C++就会自动提供。C++中的特殊成员函数有：

  1. 默认构造函数
  2. 默认析构函数
  3. 复制构造函数
  4. 赋值运算符
  5. 地址运算符

这个程序的问题就在于编译器自动提供了复制构造函数和赋值运算符，但提供的不对。
注意下面的两段节选代码：

  1. 第一段
callme2(headline2)

对于这条语句，调用了callme2函数，以值传参的方式传入了headline2。我们都知道，值传参时隐式调用复制构造函数构造一个临时对象。但编译器自动提供的复制构造函数显然会是这样的：

StringBad(StringBad s)
{
	str=s.str;
	len=s.len;
}

这会导致两个问题：

  1. num_strings没有递增，但临时对象在析构时也要调用构造函数，会造成num_strings递减。
  2. 直接将s的字符串指针地址传给临时对象，这样的话临时对象析构时会将s的字符串释放掉，使其无法识别。

我们称编译器自动提供的拷贝构造函数为浅拷贝，只复制了字符串地址而没有复制字符串本身，因此我们需要提供一个深拷贝的构造函数：

StringBad(StringBad s)
{
	num_strings++;//解决第一个问题
	len=s.len;
	str=new char[len+1];
	std::strcpy(str,st.str);//进行字符串本身的复制，解决第二个问题
	cout<<num_strings<<":\""<<str<<"\" object created\n";
}
  1. 第二段
StringBad sailor = sports;
knot = headline1;

这两条语句调用了编译器自动提供的赋值运算符重载函数。第一条语句可能有两种实现，第一种是直接进行赋值运算符；第二种是先拷贝构造一个sports的临时对象，然后再使用赋值运算符，这两种解决方式显然都会出问题，因为都调用了错误的函数。
编译器自动提供的赋值运算符重载显然应该是这样：

StringBad operator=(StringBad s)
{
	str=s.str;
	len=s.len;
	return *this;//返回被赋值的类对象
}

这犯了同一个毛病，直接将字符串的地址进行赋值，而没有复制整个字符串进行赋值。注意，赋值运算符并没有新增一个StringBad类对象，不需要递增num_strings。
需要提供一个自己写的赋值运算符重载：

StringBad operator=(StringBad s)
{
	len=s.len;
	str=new char[len+1];
	std::strcpy(str,st.str);//进行字符串本身的复制
	return *this;//返回被赋值的类对象
}

将这两个函数加入后，StringBad类就可以正常使用。

小知识点：new和delete的对应使用

在使用new运算符时，有两种方法：

str=new char;
str=new char[1];

这两种方法分配的内存量一样，区别在于前者要用delete运算符释放内存，后者用delete[]运算符释放内存。注意，任何隐式使用new运算符的方法都调用new而非new[]。

delete str;//兼容new运算符
delete[] str//兼容new[]运算符

delete[]运算符也兼容空指针，因此以下的代码能通过编译：

str=0;//将str置空
delete[] str;

第二版：String类

解决了这两个问题后，我们可以完善String类。下面是String类的头文件：

#include <iostream>
#ifndef STRING_H_
#define STRING_H_
class String
{
private:
	char* str;//对string的指针
	int len;//string的长度
	static int num_strings;//字符串的数量,由变量由所有对象共享
	static const int CINLIM = 80;//设置输入缓冲区限制
public:
	String(const char* s);
	String();
	String(const String& st);
	~String();
	int length()const//返回被存储的字符串的长度
	{
		return len;
	}
	//下面三个友元函数对字符串进行比较
	friend bool operator<(const String& st, const String& st2);
	friend bool operator>(const String& st1,const String& st2);
	friend bool operator==(const String& st, const String& st2);
	//提供简单的输入功能
	friend std::istream& operator>>(std::istream& is, String& st);
	//下面两个函数提供用中括号访问字符串中各个字符的功能
	char& operator[](int i);
	const char& operator[](int i)const;
	static int HowMany();//展示静态类数据成员num_string
	friend std::ostream& operator<<(std::ostream& os, const String& st);
	String& operator=(const String& st);
	String& operator=(const char*);
};
#endif
  1. 仿照标准程序库中的String类重载了>,<,==三个运算符，以字典序比较两个字符串。
  2. 也是仿照String类重载了[]运算符，通过[]运算符能访问字符串中特定的元素。分别重载const版本和普通版本是为了访问const字符串，如果没有声明为const的函数，用[]运算符访问const字符串时将出错：
cout<<const_string[1];//如果这个类对象是const类型的，那么就必须用const版本的函数
  1. 注意这一个函数：
static int HowMany();//展示静态类数据成员num_string

这是一个和num_strings相似的静态函数，这个函数只能由类调用，不能通过对象调用，也因为这个原因它只能调用类的静态数据成员：

String::HowMany();//通过String类直接调用
  1. 增加参数为const char*的赋值运算符重载，使得程序能直接赋值=运算符给String对象，而不用先构造出临时对象再赋值。
  2. 静态数据成员CINLIM表示对输入（cin）的限制（limit），具体做法看实现。

以下是String类的实现：

#define _CRT_SECURE_NO_WARNINGS 1
#include<cstring>
#include "string.h"
using namespace std;
//初始化静态类成员
int String::num_strings = 0;
//类方法，从C的String构造String
String::String(const char* s)
{
	len = strlen(s);//设置长度
	str = new char[len + 1];//分配存储空间
	strcpy(str, s);//初始化指针
	num_strings++;//设置字符串数量
}

String::String()
{
	len = 0;
	str = new char[1];
	str[0] = '\0';
	num_strings++;
}

String::String(const String& st)
{
	num_strings++;//设置静态变量
	len = st.len;//设置相同长度
	str = new char[len + 1];//开辟内存
	strcpy(str, st.str);//将字符串复制到新的地址
}

String::~String()
{
	--num_strings;//required
	delete[]str;//required
}

bool operator<(const String& st1, const String& st2)
{
	return(strcmp(st1.str, st2.str) < 0);
}

bool operator>(const String& st1, const String& st2)
{
	return st2 < st1;
}

bool operator==(const String& st1, const String& st2)
{
	return(strcmp(st1.str, st2.str) == 0);
}

istream& operator>>(istream& is, String& st)
{
	char temp[String::CINLIM];
	is.get(temp, String::CINLIM);
	if (is)
		st = temp;
	while (is && is.get() != '\n')
		continue;
	return is;
}

char& String::operator[](int i)
{
	return str[i];
}

const char& String::operator[](int i)const
{
	return str[i];
}

int String::HowMany()
{
	return num_strings;
}

ostream& operator<<(ostream& os, const String& st)
{
	os << st.str;
	return os;
}

String& String::operator=(const String& st)
{
	if (this == &st)//对象指向自己
		return *this;//如果不额外声明一个if，那么给对象重新赋值时，释放内存操作可能删除对象的内容
	delete[]str;//释放旧的字符串,以将新的字符串复制到地址
	//进行新的赋值操作
	len = st.len;
	str = new char[len + 1];//为新字符串开辟内存空间
	strcpy(str, st.str);
	return *this;//返回对调用对象的引用
}

String& String::operator=(const char* s)
{
	delete[]str;
	len = strlen(s);
	str = new char[len + 1];
	strcpy(str, s);
	return *this;
}

其他的看一看也就行了，自己写都能写出来，主要是>>运算符的重载，有一个get函数：

is.get(temp, String::CINLIM);

get函数读取CINLIM个字符到字符串temp中。读取失败则将is置为false。

构造函数中使用new时的注意事项

  1. 构造函数中使用new，则析构函数中需要使用delete
  2. new对应delete，new[]对应delete[]
  3. 多个构造函数必须用同一种方式使用new，即要么都用new，要么都用new[]，因为析构函数只能有一个，其中要么用delete，要么用delete[]。
  4. 当判断浅拷贝和浅赋值不够用时，需要自定义深度拷贝和深度赋值运算符重载函数。

请添加图片描述
我是霜_哀，在算法之路上努力前行的一位萌新，感谢你的阅读！如果觉得好的话，可以关注一下，我会在将来带来更多更全面的知识讲解！

霜_哀
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++Primer Plus附录源码等文件.zip
12-27
《C++ Primer Plus》是Stephen Prata撰写的一本广受欢迎的C++编程教材，第六版提供了深入浅出的C++语言教程，旨在帮助初学者和有一定经验的程序员掌握这一强大的编程语言。附录中的源码文件是作者为配合书中的教学...
C++ Primer Plus 第6版 中文版课后代码习题答案
03-10
《C++ Primer Plus 第6版 中文版》是一本深入浅出的C++学习书籍，其课后代码习题答案是学习过程中不可或缺的部分。这本书旨在帮助读者从零基础开始掌握C++编程语言，通过实例和习题来巩固理论知识，提升编程技能。...
《C++ primer plus》精炼（OOP部分）——对象和类（1）
霜-哀的博客
08-28 90
新专栏，以OOP（面向对象编程）思想角度介绍C++类和对象，本篇为第一期。
《C++ primer plus》精炼（OOP部分）——对象和类（8）
霜-哀的博客
10-03 157
开始介绍类继承，引入多态思想。
《C++ primer plus》精炼（OOP部分）——对象和类（2）
霜-哀的博客
09-10 138
对象和类精炼第二部分
《C++ primer plus》精炼（OOP部分）——对象和类（7）
霜-哀的博客
09-27 145
对第12章做收尾并通过顾客处理系统的例子说明其运用
《C++ primer plus》精炼（OOP部分）——对象和类（4）
霜-哀的博客
09-16 313
友元与运算符重载补充加实例
《C++ primer plus》精炼（OOP部分）——对象和类（3）
霜-哀的博客
09-13 91
讲解抽象数据类型（ADT）的思想及运算符重载语法
《C++ primer plus》精炼（OOP部分）——对象和类（5）
霜-哀的博客
09-17 235
类和对象第11章结尾
【侯捷 C++ 面向对象高级开发】课程笔记以及个人注释（附带课程资源）
qq_42234461的博客
10-03 2630
前言 华南理工大学读本科的时候，大一大二入门了C++，但是始终不深。现在继续在华工深造，希望继续深入C++。 今天我正式开始继续好好学习C++的历程。将在CSDN持续更新。 当前安排 先重拾基础。《C++ primer》/《Effective C++》 / 侯接视频。**21年底前完成所有的基础工作。一共两个多月。**C++ primer工具书也再次浏览了一遍，大而广的东西没能够深入，因为没有应用场景，因此这个工具书待到遇到再回来看看。 深入开源项目。Redis/Muduo等。将在下年深入进行，这年
读书计划
cmyself的专栏
08-09 653
 我是天材，天生要做软件的材料。知识像薪火的传递，希望能点燃我这块木头。这些书在chinaitlab都有电子版的。chinapub上也有纸版的卖。最好是先浏览电子版然后买纸板的。好书值得那些银两。如果看了这些书有软饭吃。那就更加需要汇钱孝敬作者了。中国人讲究饮水思源。因为我们编程是在特定操作系统上的再开发。所以操作系统的书是需要看的。虽然开始的时候枯燥，一头雾水。但是到一直到后面都会很受用
C++ primer Plus的pdf资源
11-02
C++ primer Plus的pdf资源
C++ Primer Plus_V6_example.zip
06-24
《C++ Primer Plus 第6版》是一本深受程序员喜爱的C++学习书籍，它深入浅出地介绍了C++编程语言的基础知识和高级特性。这本书的配套示例代码库"example.zip"包含了丰富的实例，旨在帮助读者更好地理解和掌握C++编程...
初始C++
2302_81016149的博客
07-08 776
在C语言我们学习函数的时候，我们学习过生命周期这个概念。那么，什么是生命周期呢？生命周期通常指的是一个对象或变量从创建到销毁所经历的时间段。那么，命名空间是什么？咱们可以这样理解：在这个空间的生命周期内，对这个空间内的全部标识符起一个名字，可对其进行引用，可类似与C语言中的结构体。#include<stdlib.h>//此处不包此头文件代码可正常运行，那该如何解决此处情况呢？int main()//此处编译不通过原因为：在不包头文件前为变量，包含后为函数。return 0;
python-torch加载c++与内核函数
weixin_40777649的博客
07-11 286
python 在线加载.cu 文件python 加载.cu 文件方式2二、实现python 在线加载.cu 文件python 加载c++ 方法采用的是torch.utils.cpp_extension包的扩展方法。直接加载cu文件，则采用torch.utils.cpp_extension.load() 方法。"fused",sources=[],具体： fused_bias_act.cpp//scalar_t y;
C++ 多态
wxk2227814847的博客
07-10 618
多态是C++语言的三大特性之一，另两个特性是封装和继承。多态性使得对象可以根据运行时的实际类型来表现出不同的行为，从而实现灵活和可扩展的设计。在软件开发过程中，多态能够提高代码的复用性和可维护性，减少重复代码，并提供更加抽象和通用的接口。本文将详细探讨C++中的多态，包括其定义、构成、虚函数、抽象类以及实现原理，帮助读者全面理解这一重要概念。
C++|智能指针
最新发布
weixin_68201503的博客
07-11 576
1.每个shared_ptr对象，其都包含着一个指针，该指针所指向空间内容用来计数有多少个指针指向该空间，即有多少个对象管理同一份资源，当多个对象管理同一份资源，那么他们的指针就会指向同一份空间，空间内容记录着这些数量，每增加一个对象管理相同资源，则计数也会加1。那么weak_ptr是怎样解决问题的了，其实很简单，weak_ptr不在对引用计数进行管理了，所以shared_ptr对象初始化时的引用计数都是为1，在进行析构的时候，引用计数都会减到0，然后释放对应的_ptr,_pcount。
C语言-动态内存管理
m0_73605503的博客
07-07 1147
在C语言编程中，动态内存管理是一个至关重要的概念。它不仅涉及到程序如何高效地使用内存资源，还影响到程序的稳定性和性能。通过动态分配内存，程序可以根据运行时的需求灵活地调整内存使用，这对于处理不确定的数据量和实现高效的资源利用尤为重要。在这篇文章中，我们将深入探讨C语言中的动态内存管理机制，了解如何使用标准库函数如 malloc、calloc、realloc 和 free，并讨论一些常见的内存管理陷阱和最佳实践。
C++ Primer Plus Sixth Edition
03-09
C++ Primer Plus Sixth Edition，英文第六版

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

霜_哀

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

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

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

打赏作者

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

抵扣说明：

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

余额充值