【C++类和对象（中）】—— 我与C++的不解之缘（四）

最新推荐文章于 2024-09-26 12:00:11 发布
最新推荐文章于 2024-09-26 12:00:11 发布
阅读量2.1k 收藏 104
点赞数 126
分类专栏： C++ 文章标签： c++ 开发语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/LH__1314/article/details/141072034
版权

前言：

接下来进行类和对象中的学习，了解类和对象的默认成员函数

一、类和对象默认成员函数

        默认成员函数就是用户没有显示实现，编译器会自动生成的成员函数。

一个类，我们不显示实现的情况下，编译器就会默认生成一下留个默认成员函数。

        这里前4个（构造函数、析构函数、拷贝构造和赋值重载）是重难点。

C++11以后还会增加两个默认成员函数，移动构造和移动赋值。

默认成员函数十分重要，从以下两个方面去深入了解：

  1. 我们不写时，编译器默认生成的函数行为是什么，是否满足我们的需求
  2. 编译器默认生成的函数不满足我们的需求，我们需要直接实现，那么如何自己实现呢？

        1.1、构造函数

        构造函数，是特殊的成员函数；这里需要注意，虽然名字叫做构造函数，但是构造函数的主要任务不是开辟空间创建对象（我们经常使用的局部对象是栈帧创建时，空间就已经开辟 好了），而是对象实例化时初始化对象。

        这里构造函数本质上是替代实现的Stack和Data类中所写的 Init 函数，构造函数自动调用这一特点就完美替代了 Init 函数。

1.1.1、构造函数的特点

构造函数的特点如下：

1、函数名和类名相同。

2、无返回值（返回值不需要写，void也不需要）。

3、对象实例化时系统会自动调用对应的构造函数。

4、构造函数可以重载

5、如果类没有显示定义构造函数，C++编译器会自动生成一个无参的默认构造函数；如果显示写了构造函数，编译器就不会再生成。

6、无参构造函数、全缺省构造函数、我们不写时编译器默认生成的构造函数，这三个都叫做默认构造函数。

7、我们不写，编译器默认生成的构造函数，对内置类型成员变量的初始化没有要求（是否初始看编译器）；对于自定义类型成员变量，要求调用这个成员函数的默认构造函数初始化（如果这个成员变量没有默认构造函数，就会报错（这里要初始化这个成员变量，需要使用初始化列表来解决，后面会学习到））。

1.1.2、构造函数

        这里来看一下构造函数的前几个特点。

首先就是，构造函数的函数名和类名相同而且无返回值（不需要写返回值）

class Data
{
public:
	Data()
	{
		_year = 1;
		_month = 1;
		_day = 1;
	}

private:
	int _year;
	int _month;
	int _day;

};

        这里Data类里面的Data函数就是显示实现的构造函数（显示实现了构造函数，编译器就不会默认生成）；

再来看，构造函数可以重载，我们就可以这样写：

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

private:
	int _year;
	int _month;
	int _day;

};

        这里两个构造函数就形成了重载，再创建对象时，不给参数就会调用第一个构造函数，给参数就会调用第二个参数。

最后，来看对象实例化时会自动构造函数：

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

private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Data d1;
	Data d2(2006, 7, 20);

	return 0;
}

1.1.3、默认构造函数

默认构造函数有三种：

        无参构造函数、全缺省构造函数和我们不写时编译器默认生成的构造函数。

这三个函数有且只有一个存在（不能同时存在）；

        这里虽然无参构造函数和全缺省构造函数形成函数重载，但是在函数调用时会存在歧义：

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

private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Data d1;

	return 0;
}

这里总结一下，编译传实参就可以调用的构造就是默认构造。

1.1.4、编译器默认生成的默认构造函数        

        编译器默认生成的构造函数，对于内置类型（整型，浮点型，字符类型，指针等）初始化没有要求，可能会初始化，也可能不做任何处理；对于自定义类型成员变量初始化会调用这个成员变量的默认构造函数（如果不存在默认构造就报错）。

        所以，大多情况下我们都需要自己实现构造函数。

        1.2、析构函数

        析构函数与构造函数的功能相反，析构函数不是完成对象本身的销毁（局部对象是存在栈帧的，函数结束栈帧就销毁了，局部对象就自动释放了）；C++规定在销毁时会自动调用析构函数，完成对像中资源的清理释放工作。

        相关函数的功能类比之前 Stack 栈实现的DesTroy 销毁功能，对申请资源进行释放。

1.2.1、析构函数特点

1、析构函数名是在类名前面加上字符 ~

2、无参数返回值（与构造函数一样，不需要加void）。

3、一个类只能有一个析构函数，如果没有显示定义，系统就会自动生成默认的析构函数。

4、对象生命周期结束时，系统就会自动调用析构函数。

5、与构造函数类似，我们不显示写，编译器默认生成的对内置类型不做处理，自定义类型就会调用它的析构函数。

6、这里需要注意，我们显示写了析构函数，对于自定义类型也会调用它的析构函数（也就是说，无论说明情况下，自定义类型都会自动调用析构函数。

7、如果类没有申请资源，析构函数可以不写，直接使用编译器生成的默认析构函数，就比如Data（日期类）；如果默认生成的析构就满足我们的需求，不用写，比如MyQueue（用两个栈实现的队列）；如果有资源申请，一定要自己写析构，否则就会造成资源泄漏，比如Stack（栈）。

8、一个局部域的多个对象，C++ 规定后定义的先调用析构

1.2.2、析构函数

自己实现析构函数，这里拿栈Stack类来举例：

class Stack
{
public:
	//构造函数
	Stack(int capacity = 4)
	{
		cout << "Stack" << endl;
		_arr = (int*)malloc(sizeof(int) * capacity);
		if (_arr == NULL)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}

	//析构函数
	~Stack()
	{
		cout << "~Stack" << endl;
		if (_arr)
			free(_arr);
		_arr = nullptr;
		_capacity = _top = 0;
	}
private:
	int* _arr;
	int _top;
	int _capacity;
};

        这里，对象生命周期结束时会自动调用析构函数，看一下释放真的调用了？

int main()
{
	Stack st;

	return 0;
}

1.2.3、自定义类型自动调用其析构函数

        对于自定义类型，无论我们写函数不写析构，都会自动调用其析构函数。

class Stack
{
public:
	//构造函数
	Stack(int capacity = 4)
	{
		cout << "Stack" << endl;
		_arr = (int*)malloc(sizeof(int) * capacity);
		if (_arr == NULL)
		{
			perror("malloc fail");
			return;
		}
		_capacity = capacity;
		_top = 0;
	}

	//析构函数
	~Stack()
	{
		cout << "~Stack" << endl;
		if (_arr)
			free(_arr);
		_arr = nullptr;
		_capacity = _top = 0;
	}
private:
	int* _arr;
	int _top;
	int _capacity;
};
class MyQueue
{
public:

private:
	Stack pushst;
	Stack popst;
};
int main()
{

	MyQueue mq;

	return 0;
}

        

        这里可以看到，自定义类型构造和析构都调用了它的构造函数和析构函数。

        1.3、拷贝构造函数

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

1.3.1、拷贝构造的特点

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

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

3、拷贝构造的第一个参数必须是类类型对象的引用，使用传值方式编译器直接报错，因为语法逻辑上会引发无穷递归。

4、如果未显示定义拷贝构造，编译器会自动生成拷贝构造函数；

5、  像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器⾃动⽣成的拷⻉构造就可以完 成需要的拷⻉，所以不需要我们显⽰实现拷⻉构造。

        像Stack这样的类，虽然也都是内置类型，但 是_a指向了资源，编译器⾃动⽣成的拷⻉构造完成的值拷⻉/浅拷⻉不符合我们的需求，所以需要我们⾃⼰实现深拷⻉(对指向的资源也进⾏拷⻉)。

        像MyQueue这样的类型内部主要是⾃定义类型 Stack成员，编译器⾃动⽣成的拷⻉构造会调⽤Stack的拷⻉构造，也不需要我们显⽰实现

MyQueue的拷⻉构造。
6、    传值返回会产⽣⼀个临时对象调⽤拷⻉构造，传值引⽤返回，返回的是返回对象的别名(引⽤)，没有产⽣拷⻉。但是如果返回对象是⼀个当前函数局部域的局部对象，函数结束就销毁了，那么使⽤ 引⽤返回是有问题的，这时的引⽤相当于⼀个野引⽤，类似⼀个野指针⼀样。传引⽤返回可以减少 拷⻉，但是⼀定要确保返回对象，在当前函数结束后还在，才能⽤引⽤返回。

1.3.2、拷贝构造参数

        C++规定自定义类型对象拷贝时必须调用拷贝构造：

class Data
{
public:
	//构造
	Data(int year = 1 , int month = 1, int day = 1)
	{ 
		cout << "Data(int year, int month, int day)" << endl;
		_year = year;
		_month = month;
		_day = day;
	}
	//拷贝构造
	Data(Data& d)
	{
		cout << "Data(Data&)" << endl;
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
private:
	int _year;
	int _month;
	int _day;

};
int main()
{
	Data d1(2006, 7, 20);
	Data d2(d1);
	Data d3 = d1;
	return 0;
}

        拷贝构造函数的第一个参数必须是类类型对象的引用，如果使用传值调用：

就会像下面这样，名称传参都会调用拷贝构造，调用完传参再次调用拷贝构造，无穷递归下去。

1.3.3、编译器默认生成的拷贝构造函数

        编译器默认生成的拷贝构造，对内置类型成员会完成值拷贝/浅拷贝（一个字节一个字节的拷贝），对自定义类型成员变量就会调用它的拷贝构造函数。

二、赋值运算符重载

        2.1、运算符重载

1、当运算符被用于类类型的对象时，C++语言允许我们通过运算符重载的形式指定新的含义。C++规定类类型对象使用运算符时，必须转换成调用对应运算符重载，若没有对应的运算符重载，则会编译报错。

2、运算符重载是具有特殊名字的函数，他的名字是由operator和后面要定义的运算符共同构成。和其他函数一样，它也具有其返回类型和参数列表以及函数体。

3、重载运算符函数的参数个数和该运算符作用的运算对象数量一样多。一元运算符有一个参数，二元运算符有两个参数，二元运算符的左侧运算对象传给第一个参数，右侧运算对象传给第二个参数。

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

5、运算符重载以后，其优先级和结合性与对应的内置类型运算符保持一致。

6、不能通过连接语法中没有的符号来创建新的操作符:比如operator@。

7、.*    ::   sizeof   ?:   .   注意以上5个运算符不能重载。(选择题里面常考，要记一
重载操作符至少有一个类类型参数，不能通过运算符重载改变内置类型对象的含义，如: int
operator+(int x,int y)

8、一个类需要重载哪些运算符，是看哪些运算符重载后有意义，比如Date类重载operator-就有意义，但是重载operator+就没有意义。

9、  重载++运算符时，有前置++和后置++，运算符重载函数名都是operator++，无法很好的区分。
        C++规定，后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。

10、重载<<和>>时，需要重载为全局函数，因为重载为成员函数，this指针默认抢占了第一个形参位置，第一个形参位置是左侧运算对象，调用时就变成了对象<<cout，不符合使用习惯和可读性。重载为全局函数把ostream/istream放到第一个形参位置就可以了，第二个形参位置当类类型对象。

有了运算符重载，对于自定义类型的对象，我们就可以像内置类型那样，直接进行+/-/+=/-= 等操作。（要 根据自定义类的需求写）。

应用举例：

        这里以日期类为例，实现一个运算符重载 ==

//运算符重载
// == 
bool Data::operator==(Data& d)
{
	if (_year == d._year && _month == d._month && _day == d._day)
	{
		return true;
	}
	return false;
}

常见的运算符重载

        我们基本上可以重载所以的算术运算符、关系运算符和赋值运算符等，

算术运算符：+、-、*、/ ，用于自定义类型的算术运算。
关系运算符：==、!=、<、>、<=、>= ，用于自定义类型的比较操作。
赋值运算符：=，用于自定义类型的赋值操作。（当自定义类型（栈）包含动态分配的内存时，需要深拷贝以避免悬挂指针等问题。）
自增自减运算符：++、--，用于自定义类型的自增和自减操作。
下标运算符：[ ]，用于自定义类型的数组或类似数组的操作。
流插入和提取运算符：<<、>>，用于自定义类型的输入输出操作。
函数调用运算符：()，允许自定义类型的对象像函数一样被调用。
成员访问运算符：->，一般 与智能指针或类似智能指针的类一起使用，用于访问指针所指向对象的成员。

前置++和后置++重载

C++规定

后置++重载时，增加一个int形参，跟前置++构成函数重载，方便区分。

前置++ 先使用再+1；而后置++是先+1再使用。

//前置++
Data& operator++();
//后置++
Data& operator++(int);

        2.2、赋值运算符重载

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

1、赋值运算符重载是一个运算符重载，规定必须重载为成员函数。赋值运算重载的参数建议写成1.const 当前类类型引用，否则会传值传参会有拷贝

2、有返回值，且建议写成当前类类型引用，引用返回可以提高效率，有返回值目的是为了支持连续赋值场景。

3、没有显式实现时，编译器会自动生成一个默认赋值运算符重载，默认赋值运算符重载行为跟默认拷3贝构造函数类似，对内置类型成员变量会完成值拷贝/浅拷贝(一个字节一个字节的拷贝)，对自定义类型成员变量会调用他的赋值重载函数。

4、  像Date这样的类成员变量全是内置类型且没有指向什么资源，编译器自动生成的赋值运算符重载就4可以完成需要的拷贝，所以不需要我们显示实现赋值运算符重载。

        像Stack这样的类，虽然也都是内置类型，但是 a指向了资源，编译器自动生成的赋值运算符重载完成的值拷贝/浅拷贝不符合我们的需求，所以需要我们自己实现深拷贝(对指向的资源也进行拷贝)。

        像MyQueue这样的类型内部主要是自定义类型Stack成员，编译器自动生成的赋值运算符重载会调用Stack的赋值运算符重载也不需要我们显示实现MyQueue的赋值运算符重载。

这里还有一个小技巧，如果一个类显示实现了析构并释放资源，那么他就需要显示写赋值运算符重载，否则就不需要。

        现在就来哦实现日期类巩固这方面的知识。

        2.3、日期类的实现

Data.h：

#pragma once
#include<iostream>
#include<assert.h>
class Data
{
	friend std::ostream& operator<<(std::ostream& out, const Data& d);
	friend std::istream& operator>>(std::istream& in, Data& d);
public:
	//构造函数
	Data(int year = 1, int month = 1, int day = 1)
	{
		_year = year;
		_month = month;
		_day = day;
	}

	//析构
	
	//拷贝构造
	Data(Data& d)
	{
		_year = d._year;
		_month = d._month;
		_day = d._day;
	}
	//输出
	void Print();

	//运算符重载
	bool operator==(Data& d);
	bool operator!=(Data& d);
	bool operator<(Data& d);
	bool operator<=(Data& d);
	bool operator>(Data& d);
	bool operator>=(Data& d);

	Data& operator+=(int day);
	Data& operator+(int day);
	Data& operator-=(int day);
	Data& operator-(int day);
	int operator-(Data& d);

	Data& operator++();
	Data& operator++(int);
	Data& operator--();
	Data& operator--(int);

	//ostream& operator<<(ostream& out);
private:
	int _year;
	int _month;
	int _day;
};

Data.cpp：

#include"Data.h"
using namespace std;

//获得当前月份天数
int GetMonthDay(int year, int month)
{
	assert(month > 0 && month < 13);
	static int arr[13] = { -1,31,28,31,30,31,30,31,31,30,31,30,31 };
	if (month == 2 && ((year % 4 == 0 && year % 100 != 0) || (year % 40 == 0)))
	{
		return 29;
	}
	return arr[month];
}
//输出
void Data::Print()
{
	cout << _year << "年" << _month << "月" << _day << "日" << endl;
}
//运算符重载
// == 
bool Data::operator==(Data& d)
{
	if (_year == d._year && _month == d._month && _day == d._day)
	{
		return true;
	}
	return false;
}
// !=
bool Data::operator!=(Data& d)
{
	return !(*this == d);
}

// < 
bool Data::operator<(Data& d)
{
	if (_year < d._year)
	{
		return true;
	}
	else if (_year == d._year && _month < d._month)
	{
		return true;
	}
	else if (_year == d._year && _month == d._month && _day < d._day)
	{
		return true;
	}

	return false;
}
//  <=
bool Data::operator<=(Data& d)
{
	return (*this) == d || (*this) < d;
}
// >
bool Data::operator>(Data& d)
{
	if (_year > d._year)
	{
		return true;
	}
	else if (_year == d._year && _month > d._month)
	{
		return true;
	}
	else if (_year == d._year && _month == d._month && _day > d._day)
	{
		return true;
	}

	return false;
}
// +=
bool Data::operator>=(Data& d)
{
	return (*this) == d || (*this) > d;
}
Data& Data::operator+=(int day)
{
	_day += day;
	while (_day > GetMonthDay(_year, _month))
	{
		_day -= GetMonthDay(_year, _month);
		_month++;
		if (_month == 13)
		{
			_month = 1;
			_year++;
		}
	}
	return *this;

}
// +
Data& Data::operator+(int day)
{
	Data tmp = *this;
	tmp += day;
	return tmp;
}

// -=
Data& Data::operator-=(int day)
{
	_day -=day;
	while (_day <= 0)
	{
		_month--;
		if (_month == 0)
		{
			_month = 12;
			_year--;
		}
		_day += GetMonthDay(_year, _month);
	}
	return (*this);
}
// - 天数
Data& Data::operator-(int day)
{
	Data d(*this);
	d -= day;
	return d;
}

// - 日期
int Data::operator-(Data& d)
{
	Data min(*this);
	Data max(d);
	if ((*this) > d)
	{
		min = d;
		max = *this;
	}int count = 0;
	while (min != max)
	{
		count++;
		min += 1;
	}
	return count;
	
}
//++
//前置++
Data& Data::operator++()
{
	(*this) += 1;
	return *this;
}
//后置++
Data& Data::operator++(int)
{
	Data d(*this);
	(*this) += 1;
	return d;
}

//前置--
Data& Data::operator--()
{
	(*this) -= 1;
	return *this;
}
//后置--
Data& Data::operator--(int)
{
	Data d(*this);
	(*this) -= 1;
	return d;
}

// <<
//ostream& Data::operator<<(ostream& out)
//{
//	out << _year << "年 " << _month << "月 " << _day << "日 " << endl;
//	return out;
//}
std::ostream& operator<<(std::ostream& out, const Data& d)
{
	cout << d._year << "年" << d._month << "月" << d._day << "日" << endl;

	return out;
}
//  >>
std::istream& operator>>(std::istream& in, Data& d)
{
	cout << "依次输入 年 月 日" << endl;
	in >> d._year >> d._month >> d._day;
	return in;
}

三、取地址运算符重载

        3.1、const 成员函数

1、 将const修饰的成员称之为从const成员函数，const成员放到成员函数参数列表的后面。

2、 const实际修饰该成员函数的this指针，表明在该成员函数中不能对类的任何成员进行修改。

3、 const修饰Data类的Print成员函数，

Print隐含的this指针由Data* const this 变为const Data* const this

#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(const Date* const this) const
	void Print() const
	{
		cout << _year << "-" << _month << "-" << _day << endl;
	}
private:
	int _year;
	int _month;
	int _day;
};
int main()
{
	// 这⾥⾮const对象也可以调⽤const成员函数是⼀种权限的缩⼩
	Date d1(2024, 7, 5);
	d1.Print();
	const Date d2(2024, 8, 5);
	d2.Print();
	return 0;
}

        3.2、 取地址运算符重载

        取地址运算符重载分为普通取地址运算符重载和const取地址运算符重载，一般这两个函数编译器自动生成的就可以够我们用了，不需要去显示实现。

class Data
{
public:
	Data* operator&()
	{
		return this;
	}
	const Data* operator&()const
	{
		return this;
	}
private:
	int _year;
	int _month;
	int _day;
};

这里我们不想要访问到类对象的地址，也可以返回nullptr。

努力学习的小廉
关注
专栏目录
【C++入门（上）】—— 我与C++的不解之缘（一）
LH__1314的博客
08-03 1562
定义命名空间，需要使用到namespace关键字，后面跟命名空间的名字，然后接一对{}即可，{}中即为命名空间的成员。命名空间中可以定义变量/函数/类型等等。namespace本质上是定义出一个域，这个域跟全局域各自独立，不同的域可以定义同名变量，所以下面的rand就不存在冲突（可以解决如上图所示命名冲突问题）。C++ 中域有函数局部域、全局域、命名空间与和类域；域影响的编译时语法查找一个变量/函数/类型出处（声明和定义）的编辑，所以有了域的隔离，名字冲突问题就解决了。
【C++类和对象（上）】—— 我与C++的不解之缘（三）
LH__1314的博客
08-07 987
class 为定义类的关键字，Stack为类的名字，{}中为类的主体（注意类定义结束后的分好不能省略），类体中内容称为类的成员：类中的变量称为类的属性(或者 类的成员变量)；类中的函数称为类的方法(或者 类的成员函数)。为了区分成员变量，（习惯上会加上一个特殊标识，前面或者后面加上_或m(这只是惯例，C++ 没有要求)）。C++中struct也可以定义类，C++兼容C语言struct的用法，而且把struct 升级成了类（可以定义成员函数），一般还是使用class 来定义类。
【C++类和对象（下）】——我与C++的不解之缘（五）
LH__1314的博客
08-25 1689
时隔多日，继续学习C++，类和对象；大致内容：初始化列表，explicit关键字，static成员，友元，匿名对象。
【C++STL简介】——我与C++的不解之缘（八）
LH__1314的博客
09-15 1086
STL（standard template libaray 标准模版库）：是C++标准库的重要组成部分，不仅是一个可复用的组件库，而且还是一个包罗数据结构与算法的软件框架。
【C++入门（下）】—— 我与C++的不解之缘（二）
LH__1314的博客
08-06 1278
引用不是新定义一个变量，而是给已存在的变量取了一个别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用一块内存空间。类型 & 引用别名 = 引用对象;int& b = a;//这里b是a的别名//也可以给b去别名int& c = b;int& d = c;return 0;
【C++模版初阶】——我与C++的不解之缘（七）
LH__1314的博客
09-07 902
class 类模板名// 类内成员定义在之前，我们实现的数据结构，线性表、栈和队列等中，我们只能存储一种类型的数据。如果我们想要存储其他类型，就要重新实现一个数据结构；有了模版，我们只需要写出来一个模具，让编译器自动生成存储不同类型的类。这里简单实现一下。//类模版public:_top = 0;exit(1);_arr = tmp;_top--;
【C/C++内存管理】——我与C++的不解之缘（六）
LH__1314的博客
09-07 1961
对于内置类型，new/delete 和malloc/free 差别不是很大；而对于自定义类型，最大的区别就是，new和delete除了会开辟空间还会调用自定义类型的构造函数和析构函数。delete p2;return 0;可以看到，malloc和free并没有调用构造函数和析构函数；这里，new和delete调用了自定义类型的构造函数和析构函数。
2024年躺平，花大半年的时间，就弄了这一件事儿：《C++面试真题宝典》
09-23 656
C++文化
从缺陷中学习c++
09-09
本文档试图从一个独特的角度出发——即从缺陷中学习，以此来帮助读者更好地理解和掌握C/C++。 #### 缺陷之一：内存管理不当 C/C++最著名的特点之一是程序员需要手动管理内存。这既是优点也是缺点。优点在于程序员...
浅谈JavaSE性能优化（1）——BufferedImage与像素级渲染
qq_44906416的博客
04-29 1660
浅谈JavaSE性能优化（1）——BufferedImage与像素级渲染
【C++】拆分详解 - string类
bubble_shadow的博客
09-23 998
string类的文档介绍注：此处及下文部分，蓝色下划线标识文本均为超链接，点击即可跳转字符串是表示字符序列的类标准的字符串类提供了对此类对象的支持，其接口类似于标准字符容器的接口，但添加了专门用于操作单字节字符字符串的设计特性。string类是使用char(即作为它的字符类型，使用它的默认char_traits和分配器类型(关于模板的更多信息，请参阅basic_string)。
C++ 异步编程中：future与promise、packaged_task、async
zxf347085420的博客
09-23 981
std::launch::async | std::launch::deferred参数：是默认行为(可省略)。=》std::async真的是来帮忙的，你不用再想到底该怎么用std::future、std::promise和 std::packaged_task了，在已经有了td::future、std::promise和std::packaged_task的情况下，实现异步或多线程间通信，事实上std::promise::set_xxx函数会改变std::promise的状态为ready，
pyqt瀑布流布局
weixin_54217201的博客
09-21 478
最近研究瀑布流布局，发现都是收费的，所以只能自己写算法写布局。所以啥都不说直接上代码。
c++ 使用 Graham 扫描的凸包（Convex Hull using Graham Scan）
csdn_aspnet的专栏
09-26 1073
对于剩余的点，我们跟踪最近的三个点，并找到它们形成的角度。如果这些点的方向（按相同顺序考虑它们）不是逆时针的，我们丢弃 c，否则我们保留它。因此，第六步逐个处理点需要 O(n) 时间，假设堆栈操作需要 O(1) 时间。总体复杂度为 O(n) + O(nLogn) + O(n) + O(n)，即 O(nLogn)。在每个步骤中，算法都会检查添加到凸包中的最后两个点是否形成右转。格雷厄姆扫描算法是一种简单而有效的算法，用于计算一组点的凸包。凸包用于各种计算几何算法，例如查找最近的点对和计算一组点的直径。
ARM 之十八 详解 MDK、IAR、Eclipse 的 C 标准库及重定向输入输出
技术干货
09-23 131
在嵌入式系统开发中，我们通常会将标准输入输出作为一个控制台功能添加到我的嵌入式应用程序中。这样我就有了一个命令行接口，可以检查和修改目标系统。我们最常用的方法就是将标准输入输出进行重定向，今天就来重点学习一下！
C++ 知识要点：对象内存模型
叫好与叫座虽然不是对立面，但想在同一个作品中达到双重效果很难。
09-21 679
在C++中，通过和->访问对象成员的主要区别在于它们的访问方式和语法。用于直接对象，而->用于通过指针间接访问对象。尽管在底层实现和性能上可能存在微小的差异，但这些差异通常被现代编译器的优化所掩盖。更重要的是要考虑代码的可读性、维护性和安全性。在实际的C++实现中，不同的编译器可能会采用不同的策略来记录虚基类子对象的偏移信息。一些编译器可能会选择将偏移信息嵌入到虚函数表中，而另一些则可能会使用额外的指针。这些选择通常取决于编译器的设计目标、性能考虑以及与其他特性的兼容性。
简易STL实现 | Set 的实现
最新发布
AsherGu的博客
09-26 318
如何使用；代码实现及其他（包括之前红黑树可以运行实现）
C++实验：面向对象程序设计——类与对象的应用
“实验一 C++类和对象的应用.doc”是一个面向广州大学学生的C++实验报告，旨在通过实际操作加深学生对C++类和对象的理解，包括类的封装、构造函数、析构函数、函数重载以及默认参数函数的运用。实验使用了Visual ...
评论 96
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值