类和对象（上篇）-EW帮帮网

类和对象（上篇）

namespace

本质是定义出一个域，与全局域各自独立，使不同的域也可以定义同名变量

局部域和全局域会影响变量的生命周期，命名空间域和类域不会影响变量的生命周期

namespace只能定义在全局，可以嵌套定义

int main()

{

	printf("%d\n", N::a); //指定命名空间访问

	return 0;

}


using N::b // using将命名空间中某个成员展开 

using namespace N; // 展开命名空间中全部成员

在I/O需求比较高的地方，可以通过下面的代码提高I/O效率

ios_base :: sync_with_stdio(false);

cin.tie(nullptr); cout.tie(nullptr);

语法上引用不开空间，指针要开空间

类的默认成员函数

初始化和清理
1. 构造函数：主要完成初始化工作
2. 析构函数：主要完成清理工作
拷贝复制
1. 拷贝构造：使用同类对象初始化创建对象
2. 赋值重载：把一个对象赋值给另一个对象
取地址重载：普通对象和const对象取地址

构造函数

特殊的成员函数，其含义并非和名字一样是开空间创建对象，而是对象实例化时初始化对象（替代了init函数的功能）

构造函数的特点：

函数名与类名一致
无返回值。（没有任何返回值，void也不用写）
对象实例化时系统会自动调用对应的构造函数
构造函数可以重载
类中如果没有显式定义构造函数，编译器会自动生成一个无参的默认构造函数，一旦用户显示定义编译器将不再生成
无参构造函数、全缺省构造函数、我们不写构造时编译器默认⽣成的构造函数，都叫做默认构造函数。但是这三个函数有且只有⼀个存在，不能同时存在。 无参构造函数和全缺省构造函数虽然构成函数重载，但是调⽤时会存在歧义。要注意很多同学会认为默认构造函数是编译器默认生成那个叫默认构造，实际上无参构造函数、全缺省构造函数也是默认构造，总结⼀下就是不传实参就可以调⽤的构造就叫默认构造。
我们不写，编译器默认生成的构造，对内置类型成员变量的初始化没有要求，也就是说是否初始化是不确定的，看编译器。对于自定义类型成员变量， 要求调用这个成员变量的默认构造函数初始化。如果这个成员变量，没有默认构造函数，那么就会报错，我们要初始化这个成员变量，需要用初始化列表才能解决。

C++类型分为内置类型（int/char/double）和自定义类型（class/struct）

#include<iostream>
using namespace std;
class Date
{
public:
	//1.无参构造函数
	Date()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}
	//2.带参构造函数
	Date(int year, int month, int day)
	{
		_year = year;
		_month = month;
		_day = day;
	}
	//3.全缺省构造函数
	Date(int year = 1, 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()
{
    // 如果留下三个构造中的第⼆个带参构造，第⼀个和第三个注释掉
    // 编译报错：error C2512: “Date”: 没有合适的默认构造函数可⽤
	Date d1; // 调⽤默认构造函数
	Date d2(2025, 1, 1); // 调⽤带参的构造函数

	/*注意：如果通过⽆参构造函数创建对象时，对象后⾯不⽤跟括号，
	否则编译器⽆法区分这⾥是函数声明还是实例化对象
	warning C4930: “Date d3(void)”:未调⽤原型函数(是否是有意⽤变量定义的?)
	*/
	Date d3();

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

	return 0;
}

‍

析构函数

析构函数不是完成对对象本身的销毁，C++规定对象在销毁时会自动调用析构函数，完成对象中资源的清理释放工作。类似于destroy功能

析构函数的特点

析构函数名是在类名前加上~
无参数无返回值
一个类只能有一个析构函数。未显式定义系统会自动生成默认的析构函数
对象生命周期结束时，系统会自动调用析构函数
我们不写编译器自动生成的析构函数对内置类型成员不做处理，自定类型成员会调用他的析构函数
我们显示写析构函数，对于自定义类型成员也会调用他的析构，也就是说自定义类型成员无论什么情况都会自动调用析构函数
没有申请资源可以不写析构函数，直接用编译器默认析构函数，有资源申请时，一定要自己写析构，否则会造成资源泄露，如stack
一个局部域的多个对象，后定义的先析构

#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()
	{
		cout << "~Stack()" << endl;
		free(_a);
		_a = nullptr;
		_top = _capacity = 0;
	}
private:
	STDataType* _a;
	size_t _capacity;
	size_t _top;
};
// 两个Stack实现队列
class MyQueue
{
	public :
	//编译器默认⽣成MyQueue的析构函数调⽤了Stack的析构，释放的Stack内部的资源
    // 显⽰写析构，也会⾃动调⽤Stack的析构
		/*~MyQueue()
		{}*/
private:
	Stack pushst;
	Stack popst;
};
int main()
{
	Stack st;
	MyQueue mq;
	return 0;
}

使用构造函数和析构函数对于我们的**标题匹配题**有一些帮助，不会再忘记调用Init和Destory函数了

这里的之前C语言代码是没办法通过的因为还需要自己实现一下栈，所以这道题用C++要方便很多

#include<iostream>
using namespace std;
// ⽤最新加了构造和析构的C++版本Stack实现
 bool isValid(string s) {
        stack<char> st;
        for (char ch : s)         
        {
            if (ch == '[' || ch == '(' || ch == '{')
            {
                st.push(ch);
            }
            else
            {
                if (st.empty())
                    return false;

                char top = st.top();
                st.pop();
                if ((ch == ']' && top != '[') ||
                    (ch == '}' && top != '{') ||
                    (ch == ')' && top != '('))
                    return false;
            }
        }
        return st.empty();
    }
}; 
// ⽤之前C版本Stack实现
bool isValid(const char* s) {
	ST st;
	STInit(&st);
	while (*s)
	{
		// 左括号⼊栈
		if (*s == '(' || *s == '[' || *s == '{')
		{
			STPush(&st, *s);
		} else // 右括号取栈顶左括号尝试匹配
		{
		if (STEmpty(&st))
		{
		STDestroy(&st);
		return false;
		} 
		char top = STTop(&st);
		STPop(&st);
		// 不匹配
		if ((top == '(' && *s != ')')
		|| (top == '{' && *s != '}')
		|| (top == '[' && *s != ']'))
		{
		STDestroy(&st);
		return false;
		}
		} 
			++s;
	} // 栈不为空，说明左括号⽐右括号多，数量不匹配
		bool ret = STEmpty(&st);
	STDestroy(&st);
	return ret;
} 
int main()
{
	cout << isValid("[()][]") << endl;
	cout << isValid("[(])[]") << endl;
	return 0;
}

拷贝构造函数

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

拷贝构造函数的特点

拷贝构造函数时构造函数的一个重载。
第一个参数必须是类类型对象的引用，不能使用传值的方式（语法上会引发无穷递归调用）解决无穷递归可以通过加引用或者指针（拷贝的就是对象的地址，是内置类型不需要在传参时调用拷贝构造），后面的参数必须要有缺省值
自定义类型对象进行传值传参必须调用拷贝构造，这个可以解释第二点为什么会发生无穷递归。
自动生成的拷贝构造对内置类型成员变量会完成值拷贝（浅拷贝，一个字节一个字节的拷贝）
对于Stack这样虽然也是自定义类型但是_a指向了资源，就需要自己实现深拷贝（对指向的资源也进行拷贝），如果一个类显示实现了析构并释放资源，那么他就需要显示写拷贝构造，否则就不需要。
传值返回会产生一个临时对象调用拷贝构造，传值引用返回，返回的的返回对象的别名，没有产生拷贝。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使用引用返回是有问题的，这时的引用相当于⼀个野引用，类似⼀个野指针⼀样。传引用返回可以减少拷贝，但是⼀定要确保返回对象，在当前函数结束后还在，才能用引用返回。

#include<iostream>
using namespace std;
class Date {
public:
	//构造函数
	Date(int year, int month, int day)
	{
		cout << "Constructor called" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造函数
	Date(const Date& date)
	{
		cout << "Copy constructor called" << endl;
		_year = date._year;
		_month = date._month;
		_day = date._day;
	}
	//析构函数
	~Date()
	{
		cout << "Destructor called" << endl;
	}
	//打印
	void Print()
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	Date date1(2025,1,1);
	Date date2(date1);
	date1.Print();
	date2.Print();
	return 0;
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

拷贝构造函数的使用条件

在C++中，有三种对象需要调用拷贝构造函数

一个对象用于给另一个对象进行初始化（赋值初始化)

Date date1(2025,1,1);
Date date2(date1);
//也可以用下面这种方式
Date date3 = date1;

一个对象作为函数参数，以值传递的方式传入函数体,C++规定自定义类型对象进行拷贝行为必须调用拷贝构造，这里的date1传值传参给date要调用拷贝构造完成拷贝，传引用传参可以减少这里的拷贝。

void setDate(Date date)
{
		cout << "setDate called" << endl;
}
int main()
{
	Date date1(2025,1,1);
	setDate(date1);
}

一个对象作为函数返回值，以值传递的方式从函数返回,getDate返回了一个局部对象temp的引用作为返回值，getDate函数结束，temp对象就销毁了，相当于一个野引用。在上面的特点六也有提到。

Date getDate()
{
	Date temp(2020, 1, 1);
	return temp;
}
int main()
{
	Date date1(2025,1,1);
	getDate();
}

浅拷贝与深拷贝

浅拷贝

浅拷贝是按位拷贝对象，它会创建一个新对象，如果属性是基本类型，拷贝的就是基本类型的值；如果属性是内存地址（引用），拷贝的就是内存地址，一个对象改变，就会影响另一个对象，只复制指向某个对象的指针，而不复制对象本身

在对象复制时，只对对象中的数据成员进行简单的赋值，默认拷贝构造函数也是浅拷贝。

//这段代码运行会报错的
#include<iostream>
#include<assert.h>
using namespace std;
class Solution {
public:
	Solution() {
		s = new int(10);
	}
	~Solution() {
		assert(s!= nullptr);
		delete s;
	}
private:
	int* s;
};
int main()
{
	Solution s1;
	Solution s2(s1);
	return 0;
}

这段代码的报错原因就是进行对象复制时，没办法进行正确的内存的动态分配

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如图所示，这是在创建s1对象后，在new100就会有这样的内存分配情况

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

在复制s2时，因为执行的是浅拷贝，只是将成员的值进行复制，两个指针指向的是堆里的同一个空间，显然当我们销毁对象时，两个对象的析构函数会对同一个内存空间释放两次，所以才会报错，但是如果我们需要两个s指向的空间有相同的值的时候就需要使用“深拷贝”。

深拷贝

深拷贝会另外创建一个一模一样的对象，新旧对象不共享内存，拷贝第一层级的对象属性或数组元素；递归拷贝所有层级的对象属性和数组元素；当对象和它所引用的对象一起拷贝时即发生深拷贝。

#include<iostream>
#include<assert.h>
using namespace std;
class Solution {
public:
	Solution()
	{
		s = new int(10);
	}
	Solution(const Solution& other) 
	{
		
		s = new int(*other.s);
	}
	~Solution() {
		assert(s!= nullptr);
		delete s;
	}
private:
	int* s;
};
int main()
{
	Solution s1;
	Solution s2(s1);
	return 0;
}

这样就可以通过深拷贝来解决上面的浅拷贝重复销毁带来的报错问题了。

赋值运算符重载

一般来说赋值运算符重载函数的参数是函数所在类的const类型的引用，因为可以保护函数中用来赋值的原值不被修改；同时如果不加const就只能接受非const的实参，反之都可以接受。

运算符重载

当运算符被用于类类型的对象时，可以通过运算符重载来实现新的含义。在类类型对象使用运算符时，必须转换成调用对应运算符重载，如果没有对应的运算符重载就会报错。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

如果一个重载运算符函数时成员函数，则它的第一个运算对象默认传给隐式的this指针，所以运算符重载作为成员函数时，参数比运算对象少一个。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

内置类型的运算符，重载不能改变其含义

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

不能通过连接语法中没有的符号来创建新的操作符：⽐如operator#。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

. :: sizeof ? : .* 注意以上5个运算符不能重载。
重载操作符⾄少有⼀个类类型参数，不能通过运算符重载改变内置类型对象的含义，如： int operator+(int x, int y)

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。C++规定，后置++重载时，增加⼀个int形参，跟前置++构成函数重载，方便区分。
重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第⼀个形参位置，第⼀个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第⼀个形参位置就可以了，第⼆个形参位置当类类型对象。

#include <iostream>
using namespace std;

class Date {
public:
    Date(int year = 1, int month = 1, int day = 1)
        : _year(year), _month(month), _day(day) {}

    // 友元声明，允许全局函数访问私有成员
    friend ostream& operator<<(ostream& os, const Date& d);
    friend istream& operator>>(istream& is, Date& d);

private:
    int _year;
    int _month;
    int _day;
};

// 全局函数重载<<
ostream& operator<<(ostream& os, const Date& d) {
    os << d._year << "-" << d._month << "-" << d._day;
    return os;
}

// 全局函数重载>>
istream& operator>>(istream& is, Date& d) {
    is >> d._year >> d._month >> d._day;
    return is;
}

int main() {
    Date d;
    cout << "请输入日期（年 月 日）：";
    cin >> d; // 调用重载的>>运算符
    cout << "你输入的日期是：" << d << endl; // 调用重载的<<运算符
    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) {
    }

    // 不符合习惯的成员函数重载
    ostream& operator<<(ostream& os) const {
        os << _year << "-" << _month << "-" << _day;
        return os;
    }
    istream& operator>>(istream& is) {
        is >> _year >> _month >> _day;
        return is;
    }
private:
    int _year;
    int _month;
    int _day;
};

int main() {
    Date d;
    cout << "请输入日期（年 月 日）：";
    d >> cin; 
    cout << "你输入的日期是：";
    d << cout; 
    cout << endl;
    return 0;
}

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

两个代码的运行结果都是一致的，但是第二个编写就很不习惯。大家平时练习代码的时候还是尽量保持良好的编写习惯比较好。

在学习C++中就避免不了类与对象这个概念，那么当我们进行运算符重载时如果我们放在全局中，会发生什么呢？

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

很显然，我们的全局函数没办法访问private成员，那我们该如何解决呢？

将所有的private成员都设成public、

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

类提供getxxx函数

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

设置友元函数

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

重载为成员函数：这个方法就会变成我们上面所提到过的那个奇怪的编写顺序。慎用！

赋值运算符

默认赋值运算符重载函数的作用

当程序没有显式地提供一个以本类或本类的引用为参数的赋值运算符重载函数时，编译器会自动生成这样一个赋值运算符重载函数。只有程序显式提供了以本类或本类的引用为参数的赋值运算符重载函数时，编译器才不会提供默认的版本。可见，所谓默认，就是“以本类或本类的引用为参数”的意思。

#include<iostream>
#include<string>
using namespace std;

// Data类用于封装一个整数，并演示构造函数和赋值运算符重载
class Data
{
private:
    int data; // 存储整数数据
public:
    // 默认构造函数，未初始化data
    Data() {};

    // 带参构造函数，初始化data成员变量
    Data(int _data)
        :data(_data)
    {
        cout << "constructor" << endl;
    }

    // 重载赋值运算符，实现用int类型赋值给Data对象
    Data& operator=(const int _data)
    {
        cout << "operator=(int _data)" << endl;
        data = _data;
        return *this;
    }
};

int main()
{
    // 使用带参构造函数初始化data1
    Data data1(1);
    // 使用默认构造函数初始化data2和data3
    Data data2, data3;
    cout << "=====================" << endl;
    // 使用重载的operator=，将int赋值给data2
    data2 = 1;
    cout << "=====================" << endl;
    // 使用重载的operator=，将data2赋值给data3
    data3 = data2;
    return 0;
}

如上面的程序所示，如果没有默认赋值运算重载函数的话，data3 = data2这条语句就会报错，同时我们看到下方的编译结果如果我们不编写重载赋值运算符同样也是可以编译通过的。不过编译结果会从左边变成右边这样。

外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传

这种情况也就证明，当用一个非类X的值（比如上面的int值）为类X的对象赋值时

如果匹配的构造函数和赋值运算重载函数同时存在，就会调用赋值运算符重载函数。反之如果只有构造函数存在，就调用构造函数。

提示！！！


Date date2;
date2 = date1;

//这两种赋值在调用函数上是有区别的。
/*前者是先对date2进行声明和定义，调用无参构造函数，赋值是在date2已经存在的情况，调用的是拷贝赋值运算符重载函数；
后者则是用date2来初始化date3，调用的是拷贝构造函数。*/

Date date3 = date2;

那么在什么时候我们需要显式提供赋值运算符重载函数呢？

在用非类X给类X对象赋值时，当然这种情况我们也可以不提供通过提供相应的构造函数来完成赋值任务；当用类X对象给类X对象赋值且类X的成员变量中含有指针时，为了避免上面所提到的浅拷贝深拷贝问题，必须显式提供赋值运算符重载函数。

赋值运算符重载函数不能被继承

#include <iostream>
#include <string>
using namespace std;
/* 基类 A：只包含一个整型成员 X 以及一个赋值运算符重载 */
class A
{
public:
    int X;                 // 数据成员

    A() {}                 // 默认构造函数

    /* 重载“=”，允许把 int 直接赋给 A 对象 */
    A& operator=(const int x)
    {
        X = x;             // 将右操作数写入 X
        return *this;      // 返回自身引用，以支持链式赋值
    }
};
/* 派生类 B：公有继承 A，未增加任何数据成员 */
class B : public A
{
public:
    /* 构造时先调用基类 A 的默认构造函数 */
    B() : A() {}
};

int main()
{
    A a;        
    B b;       
    a = 45;     // 调用 A::operator=(int)，相当于 a.X = 45

    // b = 67;              // ❌ 编译错误：B 自己没有 operator=(int)，
                           // 也不会自动继承基类的赋值运算符重载函数

    (A)b = 67;             // ✔ 先进行切片转换，把 b 当成 A 的引用，
                           // 再调用 A::operator=(int)，最终 b.X 变为 67

    return 0;
}

根据代码的注释，b=67这句是编译错误的，前面提到，当没有匹配日的赋值运算符重载函数时，就会调用该句匹配的构造函数，编译错误就说明基类的operator=函数并没有被派生类继承。其不能被继承的原因是因为相较于基类，派生类往往需要添加一些自己的成员变量、函数，如果允许继承的话，在派生类不提供自己的赋值运算符重载函数时，就只能调用基类的，但是基类的函数只能处理基类的数据成员，这种情况下，派生类的数据该何去何从。所以C++规定，赋值运算符重载函数不能被继承。

赋值运算符重载函数要避免自赋值

避免自赋值可以提高效率，尤其是在基类成员变量间的赋值，会调用基类的赋值运算符重载函数，这里的开销是很大的。
如果类的成员变量中含有指针，那么自赋值就很麻烦了，通常指针所指向的空间都是new来的，在重新分配空间时要将原来的空间清除掉，否则会造成内存泄漏，如果指针给指针赋值的话（比如_s = s）我们先将_s的空间清除，再给s分配空间，如果是自赋值，那么_s和s就指向的是同一个空间，那我将_s的空间清除，同时也导致s的空间被销毁了，这不是一团糟嘛。

结语

以上是我对类和对象（中）篇的一些个人总结，如果有问题或者补充欢迎评论区留言或者私信我！我会持续更新，敬请期待！！！

类和对象（上篇）