C++类的学习（进阶篇）

已于 2023-02-05 14:35:30 修改
阅读量108 收藏
点赞数
分类专栏： C++入门学习 文章标签： c++ 学习
于 2023-02-05 14:33:47 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_54706831/article/details/128890439
版权

类的学习基础篇

类的学习基础篇

类的学习进阶篇

首先来看一个实例

实例一

Mystring.h

#ifndef MYSTRING_H_
#define MYSTRING_H_

#include <iostream>
#include <cstring>
using std::cout;
using std::endl;

class Mystring
{
	private:
		char *m_str;	// 字符串
		int m_len;		// 表示字符串长度
		static int m_count;	// 静态成员变量，统计对象个数
		const static int CINLEN = 80;	// 输入的最大长度
	public:
		// 构造函数
		Mystring();		// 默认构造函数
		Mystring(const char *str);	// 构造函数
		Mystring(const Mystring &mystr);	// 复制构造函数

		// 析构函数
		~Mystring();	// 析构函数

		// 其他成员函数
		int length() const;

		// 运算符重载方法
		Mystring& operator=(const Mystring &mystr);	// 赋值运算符
		Mystring& operator=(const char *str);	// 赋值运算符
		char & operator[](int i);	// 重载中括号访问字符串，可读写对象
		const char & operator[](int i) const;	// 重载中括号访问字符串，只读

		// 静态成员函数
		static int get_count();		// 静态成员函数，返回统计的对象个数

		// 运算符重载的方法并作为类的友元
		friend std::ostream& operator<<(std::ostream &os, const Mystring& mystr);	// 输出
		friend bool operator<(const Mystring & mystr1, const Mystring & mystr2);	// 小于
		friend bool operator>(const Mystring & mystr1, const Mystring & mystr2);	// 大于
		friend bool operator==(const Mystring & mystr1, const Mystring & mystr2);	// 等于
		friend std::istream& operator>>(std::istream &is, Mystring& mystr);			// 输入
};
#endif

Mystring.cpp

#include "Mystring.h"
int Mystring::m_count = 0;

Mystring::Mystring()
{
	m_count++;
	cout << "调用构造函数，目前对象个数: " << m_count << endl;
	m_len = 0;
	m_str = new char[m_len + 1];
	m_str[0] = '\0';
	
}
Mystring::Mystring(const char *str)
{
	m_count++;
	cout << "调用构造函数，目前对象个数: " << m_count << endl;
	m_len = strlen(str);
	m_str = new char[m_len + 1];
	strcpy(m_str, str);
	
}
Mystring::~Mystring()
{
	m_count--;
	cout << "调用析构函数，目前对象个数: " << m_count << endl;
	delete [] m_str;;
	m_str = nullptr;
	
}
Mystring::Mystring(const Mystring &mystr)
{
	m_count++;
	cout << "调用复制构造函数，目前对象个数: " << m_count << endl;
	m_len = mystr.m_len;
	m_str = new char[m_len + 1];
	strcpy(m_str, mystr.m_str);
}

int Mystring::length() const
{
	return m_len;
}
Mystring& Mystring::operator=(const Mystring &mystr)
{
	if(this == &mystr)	// 如果赋值的对象是自己
	{
		return *this;
	}

	delete [] m_str;
	cout << "调用赋值运算符，目前对象个数: " << m_count << endl;
	m_len = mystr.m_len;
	m_str = new char[m_len + 1];
	strcpy(m_str, mystr.m_str);
	return *this;
}
// 定义一个接受常规字符串的赋值运算符，在调用时传入常规字符串，可以省去接受类对象的函数所产生的临时对象，以提高处理效率。
Mystring& Mystring::operator=(const char *str)
{
	delete [] m_str;
	cout << "调用赋值运算符，目前对象个数: " << m_count << endl;
	m_len = strlen(str);
	m_str = new char[m_len + 1];
	strcpy(m_str, str);
	return *this;

}
std::ostream& operator<<(std::ostream &os, const Mystring& mystr)
{
	os << mystr.m_str;
	return os;
}

std::istream& operator>>(std::istream &is, Mystring& mystr)
{
	char temp[Mystring::CINLEN];
	is.get(temp, Mystring::CINLEN);
	if(is)
	{
		mystr = temp;
	}
	while(is && is.get() != '\n');
	return is;
}

bool operator<(const Mystring & mystr1, const Mystring & mystr2)
{
	if(strcmp(mystr1.m_str, mystr2.m_str) < 0)
	{
		return true;
	}
	else
	{
		return false;
	}
}
bool operator>(const Mystring & mystr1, const Mystring & mystr2)
{
	return mystr2 < mystr1;
}
bool operator==(const Mystring & mystr1, const Mystring & mystr2)
{
	return (strcmp(mystr1.m_str, mystr2.m_str) == 0);
}

char & Mystring::operator[](int i)
{
	return m_str[i];
}
const char & Mystring::operator[](int i) const
{
	return m_str[i];
}

int Mystring::get_count()
{
	return m_count;
}

main.cpp

#include "Mystring.h"

// 按引用传参
void print_string1(const Mystring& mystr);

// 按值传参
void print_string2(const Mystring mystr);

// 按值返回对象
Mystring return_string_by_value(const Mystring& mystr);

int main()
{
    Mystring str1("hello world");
    cout << str1 << endl;
    cout << str1.length() << endl;
    std::cin >> str1;
    cout << str1 << endl;
    return 0;
}

void print_string1(const Mystring& mystr)
{
	cout << "按引用穿参: ";
	cout << mystr << endl;
}

void print_string2(const Mystring mystr)
{
	cout << "按值传参: ";
	cout << mystr << endl;
}
Mystring return_string_by_value(const Mystring& mystr)
{
	cout << "按值返回对象" << endl;
	return mystr;
}

静态成员

静态成员变量

  1. 无论创建了多少对象，程序都只创建一个静态变量副本。
  2. 不能在类声明中初始化静态成员变量（静态变量为const除外），因为声明描述了如何分配内存，但并不分配内存。
  3. 对于静态类成员变量，可以在类声明之外使用单独的语句来进行初始化，因为静态类成员是单独存储的，而不是对象的组成部分。

静态成员函数

  1. 不能通过对象调用静态成员函数，可以使用类名和作用域解析运算符来调用。
  2. 静态成员函数只能使用静态成员变量，因为静态成员函数不与特定的对象相关联。
class Mystring
{
    ...
    private:
        // 声明静态变量
        static int m_count;
        const static int CINLEN = 80;   // const静态变量可以在类声明中初始化
    public:
        static int get_count();		// 静态成员函数，返回统计的对象个数
    ...
};

// 初始化静态变量
int Mystring::m_count = 0;

// 定义
int Mystring::get_count()
{
	return m_count;     // 静态成员函数只能访问静态成员变量
}

// 调用
int count = Mystring::get_count(); // 使用类名和作用域解析运算符来调用静态成员函数

复制构造函数

复制构造函接受一个指向类对象的常量引用作为参数，用于将一个对象复制到新创建的对象中。

原型如下:

Class name(const Class_name &);

例如

Mystring(const Mystring &mystr);

何时调用复制构造函数

  1. 新建一个对象并将其初始化为同类现有对象时，复制构造函数都将被调用。
Mystring str1("hello world");
Mystring str2(str1);    // 调用复制构造函数
Mystring str3 = str1;   // 调用复制构造函数
Mystring str4 = Mystring(str1);         // 调用复制构造函数
Mystring *str5 = new Mstring(str1);     // 调用复制构造函数
  1. 每当程序生成了对象副本时，编译器都将使用复制构造函数。
    • 当函数按值传对象时，将会使用复制构造函数产生临时对象。
    void print_string2(const Mystring mystr);   // 按值传对象
    • 当函数按值返回对象时，将会使用复制构造函数产生临时对象。
    Mystring return_string3_by_value(const Mystring& mystr);    // 按值返回对象

默认复制构造函数

如果类中没有提供复制构造函数，C++会自动提供一个默认复制构造函数。

默认复制构造函数会逐个复制非静态成员，也就是浅拷贝。

对于Mystring这个类来说，默认复制构造函数实现如下：

Mystring(const Mystring &mystr)
{
    m_len = mystr.m_len;
    m_str = mystr.m_str;
}

如果使用默认复制构造函数

Mystring str1("hello world");
Mystring str2 = str1;   // 使用默认复制构造函数

首先，m_count这个静态变量不会增加。

其次，str1中的m_str和str2中的m_str都指向相同的地址，当程序结束调用析构函数时，会将同一块内存释放两次，从而可能导致程序崩溃。

注意

当类中存在需要使用new来分配内存的变量，一定要定义一个显示复制构造函数，来解决默认复制构造函数中存在的问题。

Mystring::Mystring(const Mystring &mystr)
{
	m_count++;
	cout << "调用复制构造函数，目前对象个数: " << m_count << endl;
	m_len = mystr.m_len;
	m_str = new char[m_len + 1];    // 深拷贝
	strcpy(m_str, mystr.m_str);
}

赋值运算符

当一个已初始化好的对象赋值给另一个已初始化好的对象，将会调用赋值运算符。

如果没有显示重写赋值运算符，C++将会提供一个默认的赋值运算符。

Class name & operator=(const Class_name &);

接受并返回一个指向类对象的引用。

默认赋值运算符也是浅拷贝，所以也可能导致默认复制构造函数一样的问题。

重写赋值运算符

Mystring& operator=(const Mystring &mystr); // 接受一个Mystring的对象
Mystring& operator=(const char *str);       // 接受常规字符串作为参数

Mystring& Mystring::operator=(const Mystring &mystr)
{
	if(this == &mystr)	// 如果赋值的对象是自己
	{
		return *this;
	}
	
	delete [] m_str;
	cout << "调用赋值运算符，目前对象个数: " << m_count << endl;
	m_len = mystr.m_len;
	m_str = new char[m_len + 1];
	strcpy(m_str, mystr.m_str);
	return *this;
}

// 定义一个接受常规字符串的赋值运算符，在调用时传入常规字符串，可以省去接受类对象的函数所产生的临时对象，以提高处理效率。
Mystring& Mystring::operator=(const char *str)
{
	delete [] m_str;
	cout << "调用赋值运算符，目前对象个数: " << m_count << endl;
	m_len = strlen(str);
	m_str = new char[m_len + 1];
	strcpy(m_str, str);
	return *this;
}
  1. 先判断是否是自我赋值;
  2. 再释放掉原来已初始化好的内存;
  3. 再进行深拷贝;
  4. 最后返回重新拷贝好的本对象引用。

new和delete的配对使用

在构造函数中使用new来分配内存时，必须在相应的析构函数中使用delete来释放内存。如果使用new[]来分配内存，则应使用delete[]来释放内存。

比较成员函数

friend bool operator<(const Mystring & mystr1, const Mystring & mystr2);	// 小于
friend bool operator>(const Mystring & mystr1, const Mystring & mystr2);	// 大于
friend bool operator==(const Mystring & mystr1, const Mystring & mystr2);	// 等于

将比较成员函数作为友元函数，可以使Mystring对象直接和常规字符串进行比较。

Mystring str("hello world");
if(str == "hello world")
{
    // ...
}
if("hello world" == str)
{
    // ...
}

使用中括号表示法访问字符

为了使Mystring可以像使用标准C风格字符串一样通过中括号来获取字符，可以重载中括号

char & operator[](int i);	// 重载中括号访问字符串，可读写对象
const char & operator[](int i) const;	// 重载中括号访问字符串，只读

char & Mystring::operator[](int i)
{
	return m_str[i];
}
const char & Mystring::operator[](int i) const
{
	return m_str[i];
}

Mystring str1 = "who";
str[0] = 'h';   // 读写，调用 char & operator[](int i);
const Mystring str2 = "who";
char a = str2[0];   // 只读，调用 const char & operator[](int i) const;

成员初始化列表

从概念上说，调用构造函数时，对象将在执行函数体中的代码之前被创建，而变量则在函数体中进行初始化。

但使用初始化成员列表，可以使变量在对象创建的时候被初始化。

#include <iostream>
using std::cout;
using std::endl;

class Test
{
    private:
        int m_data1;    // 普通变量
        const int m_data2;    // 非静态const数据成员
        int & m_data3;  // 引用的数据成员
    public:
        Test(int data1, int data2, int data3);

};
int main()
{
    Test t(1,2,3);
    return 0;
}

// 使用初始化成员列表
Test::Test(int data1, int data2, int data3)
    :m_data2(data2), m_data3(data3)     // 将在对象创建时进行初始化
{
    m_data1 = data1;    // 将在对象创建后进行初始化
}

注意

  1. 成员初始化列表只能用于构造函数；
  2. 必须用这种格式来初始化非静态const数据成员；
  3. 必须用这种格式来初始化引用的数据成员；
  4. 数据成员被初始化的顺序与它们出现在类声明中的顺序相同，与成员初始化列表排序顺序无关。
Hyunqi
关注
专栏目录
C++从入门到进阶的系列书籍推荐（22本书）
dvlinker的技术专栏
11-05 3万+
要多读书，读好书！一本书要多读几遍才好，每次都可能有新的收获！特别在是有一定的工作年限和工作经验之后！读书百遍，其义自见！ 下面就给大家推荐一下C++程序员进阶需要读的经典书籍： 1、C++入门书籍 C++是在C语言的基础上发展而来的，要学习C++之前需要先学习C语言。有了C语言基础之后再去学习C++。 1.1、C语言程序设计（谭浩强） 该书被公认为学习C语言程序设计的优秀教材，被全国大多数高校选用，是学习C语言的主流用书。本书比较通俗易懂，是初入者必备的书籍。 ........
Ubuntu下使用vscode进行C/C++开发：进阶篇
A_Jia_17的博客
03-25 530
在vscode上进行C/C++开发的进阶需求： 1）编写及调试源码时，可进行断点调试、可跨文件及文件夹进行函数调用。 2）可生成库及自动提取对应的头文件和库文件。 3） 可基于当前工程资源一键点击验证所提取的库文件的正确性。 4） 使用该库时，可结合find_package实现方便的调用。
c++运算符重载
Simple-Beauty的博客
04-16 172
运算符重载函数 class class_name { public: int x; // x轴坐标 int y; // y轴坐标 class_name(); class_name(int x0, int y0); // 定义类的时候，提供一个运算符重载的对应解析函数即可 class_name operator+(const class_name& other); }; class_name class_name::operator+(const class_na
C++程序员应了解的那些事（41）拷贝构造函数 与 赋值构造函数
qfturauyls的博客
09-19 330
【1. 何时调用复制构造函数】 复制构造函数用于将一个对象复制到新创建的对象中。也就是说，它用于初始化过程中，而不是常规的赋值过程中。类的复制构造函数原型通常如下： class_name(constclass_name&); 它接受一个指向类对象的常量引用作为参数。例如，String类的复制构造函数的原型如下： String(constString&); 新建一个对象并将其初始化为同类现有对象时，复制构造...
C++ 进阶篇复习：
fckbb的博客
05-31 921
类和对象：本篇仅对本人C++五月份的学习做一个大致的思维导图和总结，各个详细的知识点在具体文章中都有提到，本文不对所有的知识点做详细的解释，如有需要可以移步具体文章进行阅读理解。
[C++学习]类
Chris_Eddy的博客
11-01 529
第七章 类 在C++语言中，我们使用类定义自己的数据类型。通过定义新的类型来反映待解决问题中的各种概念。可以使我们更容易编写、调试和修改程序。 类的基本思想是数据抽象(data abstraction)和封装(encapsulation)。数据抽象是一种依赖于接口(interface)和实现(implementation)分离的编程(以及设计)技术。类的接口包括用户所能执行的操作；类的实现则包括类的数据成员、负责接口实现的函数体以及定义类所需的各种私有函数。 封装实现了类的接口和实现的分离。封装后的类隐藏了
C++学习笔记——C++的类
weixin_43809624的博客
09-22 441
第四章 C++的类 文章目录第四章 C++的类4.1类的定义及声明4.1.1基本概念4.1.2定义类时应注意的问题：4.1.3不同对象的构造和析构4.1.4程序不同结束形式对对象的影响：4.1.5接受与删除编译自动生成的函数4.2 成员访问权限及其访问4.3 内联、匿名类及位段4.4 new和delete4.5 隐含参数this4.6 对象的构造与析构 4.1类的定义及声明 4.1.1基本概念 类保留字：class、struct或union可用来声明和定义类。 类的声明：由保留字class、struct或
C++程序设计-原理-与-实践第2版—进阶篇.pdf
03-27
《C++程序设计-原理与实践第2版—进阶篇》是一本深入探讨C++编程语言的专著，旨在帮助读者从基础知识过渡到高级概念和技术。这本书详细讲解了C++的核心特性，以及如何利用这些特性来编写高效、可维护的代码。在阅读...
C++学习笔记（进阶篇）
m0_73664490的博客
11-13 581
本阶段为作者对C++面对对象编程的笔记，若有不足之处，请谅解
C++进阶（语法篇）
10-19
为了帮助刚入门的C++学习者深入理解这门语言，本文将从多个角度对C++的进阶语法进行详细介绍。 首先，学习C++的基础知识是至关重要的。C++的编译过程涉及到源代码到机器代码的转换，是学习C++的第一步。编程理念...
C++与QML的数据交互
qq_50679120的博客
09-11 464
这里没什么好说的，在C++中组合好json后，通过信号发送到qml中，qml中是可以解析json的。通过Q_PROPERTY属性，可以轻松地在QML中读取和修改数据，并将其更新到C++中，先创建一个类。在QML接收，直接通过data.can_id这样的形式去访问结构体中的元素。这两个也没什么好说的，在C++中直接发送信号就好了，在C++中声明并注册一个结构体。然后发送信号到QML中。
【C++】CLion配置cout打印语句快捷键
qq_38196449的博客
09-10 237
当我们sout时，自动出现打印语句。点击Apply 和 OK 保存。
C语言从头学59——学习头文件math.h（二）
m0_72128260的博客
09-11 432
继续学习头文件的数学函数。
＜C++＞ set、map模拟实现
prodigy623的博客
09-10 872
set、map仿STL模拟实现
C++位图的实现与详解
2301_80468112的博客
09-09 657
在讲解位图之前我们先来看一道很经典的面试题。给40亿个不重复的无符号整数，没排过序。给一个无符号整数，如何快速判断一个数是否在这40亿个数中。我们有以下两种种解决方法：1. 遍历，时间复杂度O(N)。（太慢）2. 排序(O(NlogN))，利用二分查找: logN。深入分析:解题思路2是否可行，我们先算算40亿个数据大概需要多少内存。
【C++ && Qt day11】
wzj46的博客
09-11 255
2、头文件窗口文件。
C++ Qt开发：运用QJSON模块解析数据
qq_35662333的博客
09-11 1021
转载Qt 是一个跨平台C++图形界面开发库，利用Qt可以快速开发跨平台窗体应用程序，在Qt中我们可以通过拖拽的方式将不同组件放到指定的位置，实现图形化开发极大的方便了开发效率，本章将重点介绍如何运用QJson组件的实现对JSON文本的灵活解析功能。JSON（JavaScript Object Notation）是一种轻量级的数据交换格式，它易于人阅读和编写，也易于机器解析和生成。该格式是基于JavaScript语言的一个子集，但它是一种独立于语言的数据格式，因此可以在许多不同的编程语言中使用。
C++ lambda闭包消除类成员变量
最新发布
随手写下笔记和感悟
09-11 435
消除了——通过将它们闭包到lambda表达式中，然后将这个lambda存起来重复使用。如果用引用捕获，栈变量会释放导致非法访存；可以借助函数式编程思想，来消除一些不必要的类成员变量。拿到一个类，一看成员变量好几十个，就问你怕不怕？在面向对象编程时，常常要添加类成员变量。然而类成员一旦多了之后，也会带来干扰。就无法修改值捕获的变量。
C++（二）----类和对象
weixin_73579966的博客
09-11 771
众所周知，C++与C语言不同的地方就是，C++引入了类和对象，可以在兼容C语言的同时面向对象编程，同时具备了封装、继承、多态三种特点（划重点）。面向对象可以说是C++最重要的部分了，而类和对象就是面向对象的基础，所以这一节我们学习类和对象。
C++编程学习与进阶指南
"C++学习笔记，是一份经典的PPT资料，涵盖了C++的学习内容，包括C++概述、C与C++的关系、面向对象程序设计以及第一个C++程序等。资料来源于《面向对象程序设计及C++》一书，由朱立华和朱建俞琼编著。此外，课程还...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值