C++从入门到精通 第十章（运算符重载）

已于 2024-03-10 14:41:57 修改
阅读量898 收藏 22
点赞数 26
分类专栏： C++从入门到精通 文章标签： c++ 开发语言
于 2024-02-21 02:46:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Zevalin/article/details/136201655
版权

 写在前面：

  1. 本系列专栏主要介绍C++的相关知识，思路以下面的参考链接教程为主，大部分笔记也出自该教程，笔者的原创部分主要在示例代码的注释部分。
  2. 除了参考下面的链接教程以外，笔者还参考了其它的一些C++教材（比如计算机二级教材和C语言教材），笔者认为重要的部分大多都会用粗体标注（未被标注出的部分可能全是重点，可根据相关部分的示例代码量和注释量判断，或者根据实际经验判断）。
  3. 由于C++基本继承了C语言的所有内容，建议读者先阅读C语言系列的专栏，有一些重点是仅在C语言系列专栏中有介绍的（比如二级指针、预处理等）。
  4. 如有错漏欢迎指出。

参考教程：黑马程序员匠心之作|C++教程从0到1入门编程,学习编程不再难_哔哩哔哩_bilibili

一、概述

（1）运算符重载是计算机语言固有多态性的体现。

（2）运算符重载概念：对已有的运算符重新进行定义，赋予其另一种功能，以适应不同的数据类型

（3）C++把重载的运算符视为特殊的函数，称为运算符函数，运算符函数就是函数重载的一种特殊情况。

（4）运算符函数作为非成员函数重载时，由于没有隐含的this指针，因此所有的操作数均出现在形参表中。

（5）重载的运算符保持其原有的操作数个数不变，比如“*”既可重载为一元运算符，又可重载为二元运算符，但“=”只能重载为二元运算符。

（6）对于内置的数据类型的表达式的的运算符是不可能改变的。（因此不用担心重载运算符会将运算符本身的功能覆盖）

（7）运算符重载应注意的几个问题：

①重载的运算符应保持其原有的基本语意。

②重载的运算符应尽可能保持其原有的特性，运算符的操作数个数、优先级和结合性必须保持，此外还需注意运算符是否要求第一操作数为左值操作数、是否修改第一操作数、操作的结果是否为有左值数据，并且要保证不改变第二操作数。

③运算符的重载应当配套，某些运算符之间关系密切，存在着某种逻辑上的联系，因此若需要重载其中的某一个，往往就意味着同组的其它运算符也需要重载。

④将具有副作用的运算符重载为非成员函数时，其第一参数代表第一操作数，应该按引用传递，以便使改变第一操作数的值称为可能，除了这种情况以外，其它参数既可以声明为非引用参数，也可以声明为引用参数。

⑤作为成员函数还是作为非成员函数重载：

[1]=、[]、()、->以及所有的类型转换运算符只能作为成员函数重载。

[2]如果允许第一操作数不是同类对象，而是其它数据类型，则只能作为非成员函数重载（如输入输出流运算符>>和<<）。

[3]若希望系统在必要时能够利用只需一个实参的构造函数自动对第一操作数进行转换，应将该运算符作为非成员函数重载，这种情况下运算符函数的参数应该是非引用参数，其它情况下运算符函数一般应作为成员函数重载。

⑥不要滥用运算符重载。

二、重载加法运算符“+”

（1）重载加法运算符“+”可以实现两个自定义数据类型相加的运算。

（2）“+”可以作为非成员函数重载，也可以作为成员函数重载（作为成员函数重载时，一个操作数由函数形参提供，一个操作数由this指针能够访问的数据成员提供）。

（3）加法应该生成两个对象相加的结果，但是不改变两个对象本身，因此应该在函数内定义一个新的对象存储二者相加的结果，将其作为返回值返回。

#include<iostream>
using namespace std;

class Person
{
public:
	
	int m_A;
	int m_B;
	Person PersonAdd(Person &p)   //通过自己写成员函数，实现两个对象相加属性后返回新的对象
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}
	/*Person operator+(Person &p)   //通过成员函数重载+号;和下面那个全局函数重载+二选一
	{
		Person temp;
		temp.m_A = this->m_A + p.m_A;
		temp.m_B = this->m_B + p.m_B;
		return temp;
	}*/
};
Person operator+(Person &p1, Person &p2)   //通过全局函数重载+
{
	Person temp;
	temp.m_A = p1.m_A + p2.m_A;
	temp.m_B = p1.m_B + p2.m_B;
	return temp;
}

Person operator+(Person &p1, int num)    //运算符重载也可以发生函数重载
{
	Person temp;
	temp.m_A = p1.m_A + num;
	temp.m_B = p1.m_B + num;
	return temp;
}

void test01()
{
	Person p1;
	Person p2;
	p1.m_A = 10;
	p2.m_A = 10;
	p1.m_B = 20;
	p2.m_B = 30;
	Person p3 = p1 + p2;     
	//Person p3 = p1.operator+(p2);  成员函数重载本质调用
	//Person p3 = operator+(p1 ,p2); 全局函数重载本质调用
	Person p4 = p3 + 10;
	//Person p4 = operator+(p3 ,10);
	cout << p3.m_A << "  " << p3.m_B << endl;
	cout << p4.m_A << "  " << p4.m_B << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

三、重载减法运算符“-”

（1）重载减法运算符“-”可以实现两个自定义数据类型相减的运算。

（2）“-”可以作为非成员函数重载，也可以作为成员函数重载（作为成员函数重载时，一个操作数由函数形参提供，一个操作数由this指针能够访问的数据成员提供）。

（3）减法应该生成两个对象相减的结果，但是不改变两个对象本身，因此应该在函数内定义一个新的对象存储二者相减的结果，将其作为返回值返回。

#include<iostream>
using namespace std;

class Person
{
public:
	
	int m_A;
	int m_B;
	Person PersonSub(Person &p)   //通过自己写成员函数，实现两个对象相减属性后返回新的对象
	{
		Person temp;
		temp.m_A = this->m_A - p.m_A;
		temp.m_B = this->m_B - p.m_B;
		return temp;
	}
	/*Person operator-(Person &p)   //通过成员函数重载-号;和下面那个全局函数重载-二选一
	{
		Person temp;
		temp.m_A = this->m_A - p.m_A;
		temp.m_B = this->m_B - p.m_B;
		return temp;
	}*/
};
Person operator-(Person &p1, Person &p2)   //通过全局函数重载-
{
	Person temp;
	temp.m_A = p1.m_A - p2.m_A;
	temp.m_B = p1.m_B - p2.m_B;
	return temp;
}

Person operator-(Person &p1, int num)    //运算符重载也可以发生函数重载
{
	Person temp;
	temp.m_A = p1.m_A - num;
	temp.m_B = p1.m_B - num;
	return temp;
}

void test01()
{
	Person p1;
	Person p2;
	p1.m_A = 10;
	p2.m_A = 10;
	p1.m_B = 20;
	p2.m_B = 30;
	Person p3 = p1 - p2;     
	//Person p3 = p1.operator-(p2);  成员函数重载本质调用
	//Person p3 = operator-(p1 ,p2); 全局函数重载本质调用
	Person p4 = p3 - 10;
	//Person p4 = operator-(p3 ,10);
	cout << p3.m_A << "  " << p3.m_B << endl;
	cout << p4.m_A << "  " << p4.m_B << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

四、重载取负运算符“-”

（1）重载取负运算符“-”可以实现自定义数据类型取相反数的运算。

（2）“-”可以作为非成员函数重载，也可以作为成员函数重载（作为成员函数重载时，唯一的操作数由this指针能够访问的数据成员提供）。

（3）取负应该生成对象取相反数的结果，但是不改变对象本身，因此应该在函数内定义一个新的对象存储对象取负的结果，将其作为返回值返回。

#include<iostream>
using namespace std;

class Person
{
public:

	int m_A;
	int m_B;
	Person operator-()   //通过成员函数重载-号;和下面那个全局函数重载-二选一
	{
		Person temp;
		temp.m_A = -(this->m_A);
		temp.m_B = -(this->m_B);
		return temp;
	}
};
/*Person operator-(Person &p)   //通过全局函数重载-
{
	Person temp;
	temp.m_A = -(p.m_A );
	temp.m_B = -(p.m_B);
	return temp;
}*/

void test01()
{
	Person p1;
	p1.m_A = 10;
	p1.m_B = 20;
	Person p2 = -p1;
	//Person p2 = p1.operator-();  成员函数重载本质调用
	//Person p2 = operator-(p1); 全局函数重载本质调用
	cout << p2.m_A << "  " << p2.m_B << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

五、重载左移运算符“<<”

（1）重载左移运算符配合友元可以实现输出自定义数据类型。

（2）“<<”只可以作为非成员函数重载。

#include<iostream>
using namespace std;

class Person
{
	friend ostream & operator<<(ostream &cout, Person &p);
public:
	Person(int a, int b)
	{
		m_A = a;
		m_B = b;
	}
private:	
	int m_A;
	int m_B;
	//void operator<<(cout){}   通常不会用成员函数重载<<运算符，因为无法实现cout在左侧
};
ostream & operator<<(ostream &cout, Person &p)   //本质是operator << (cout,p)，简化为cout << p
{
	cout << "m_A = " << p.m_A << "  m_B = " << p.m_B ;
	return cout;
}

void test01()
{
	Person p(10,10);
	cout << p << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

六、重载右移运算符“>>”

（1）重载右移运算符配合友元可以实现输入自定义数据类型。

（2）“>>”只可以作为非成员函数重载。

#include<iostream>
using namespace std;

class Person
{
	friend istream & operator>>(istream &cout, Person &p);
public:
	Person(int a = 0, int b = 10)
	{
		m_A = a;
		m_B = b;
	}
	~Person()
	{
		cout << m_A << " " << m_B;
		system("pause");
	}
private:
	int m_A;
	int m_B;
	//void operator>>(cin){}   通常不会用成员函数重载>>运算符，因为无法实现cin在左侧
};
istream & operator>>(istream &cin, Person &p)   //本质是operator >> (cin,p)，简化为cin >> p
{
	cin >> p.m_A >> p.m_B;
	return cin;
}

void test01()
{
	Person p;
	cin >> p;
	
}

int main() {

	test01();

	//system("pause");

	return 0;
}

七、重载递增运算符“++”

（1）递增运算符分为前置递增和后置递增两种，前置递增返回引用，后置递增返回值。（前置递增可以“连续”，后置递增则不行）

（2）为了区分两种递增，重载这两个运算符时必须在格式上有所区别：重载后置递增时必须多一个虚拟参数“int”。

（3）“++”可以作为非成员函数重载，也可以作为成员函数重载。

#include<iostream>
using namespace std;

class MyInteger
{
	friend ostream& operator << (ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_A = 0;
		m_B = 0;
	}
	MyInteger& operator++()    //重载前置++运算符
	{
		m_A++;   //直接对成员变量进行递增
		return *this;
	}
	MyInteger operator++(int)    //重载后置++运算符，int代表占位参数，可以用于区分前置和后置递增
	{
		MyInteger temp = *this;   //先记录当前结果
		m_A++;                    //再对成员变量进行递增
		return temp;              //最后将记录结果做返回
	}
private:	
	int m_A;
	int m_B;
};
ostream& operator << (ostream& cout, MyInteger myint)
{
	cout << "m_A=" << myint.m_A;
	return cout;
}

void test01()
{
	MyInteger myint;
	cout << myint << endl;
	cout << ++myint << endl;
	cout << ++(++myint) << endl;
	cout << myint++ << endl;
	cout << myint << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

八、重载递减运算符“--”

（1）递减运算符分为前置递减和后置递减两种，前置递减返回引用，后置递减返回值。（前置递减可以“连续”，后置递减则不行）

（2）为了区分两种递减，重载这两个运算符时必须在格式上有所区别：重载后置递减时必须多一个虚拟参数“int”。

（3）“--”可以作为非成员函数重载，也可以作为成员函数重载。

#include<iostream>
using namespace std;

class MyInteger
{
	friend ostream& operator << (ostream& cout, MyInteger myint);
public:
	MyInteger()
	{
		m_A = 0;
		m_B = 0;
	}
	MyInteger& operator--()    //重载前置--运算符
	{
		m_A--;   //直接对成员变量进行递减
		return *this;
	}
	MyInteger operator--(int)    //重载后置--运算符，int代表占位参数，可以用于区分前置和后置递减
	{
		MyInteger temp = *this;   //先记录当前结果
		m_A--;                    //再对成员变量进行递减
		return temp;              //最后将记录结果做返回
	}
private:
	int m_A;
	int m_B;
};
ostream& operator << (ostream& cout, MyInteger myint)
{
	cout << "m_A=" << myint.m_A;
	return cout;
}

void test01()
{
	MyInteger myint;
	cout << myint << endl;
	cout << --myint << endl;
	cout << --(--myint) << endl;
	cout << myint-- << endl;
	cout << myint << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

九、重载赋值运算符“=”

（1）赋值运算符只能作为成员函数重载。

（2）对于任何类，即使没有重载赋值运算符，仍然可以使用运算符=，在这种情况下，默认的赋值操作就是同类对象之间对应成员的逐一赋值（如果类中有属性指向堆区，做赋值操作时也会出现深浅拷贝问题）。

（3）重载赋值运算符时应注意：

①返回值应声明为引用，而函数体中总是用语句“return *this;”返回。

②如果形参声明为指向同类对象的引用或指针，应判别所指向的对象是否与被赋值的对象为同一对象。

③如果被赋值对象占用了动态空间或其它资源，应首先释放这些资源，以便接收新的资源。

④如果形参声明为指针或引用，通常应加上const修饰符。

⑤如果形参声明为指针，应判别是否为空，以便做出特殊处理。

⑥一个类如果需要重载赋值运算符，通常也就需要定义自己特有的拷贝构造函数，反之亦然。

#include<iostream>
using namespace std;

class Person
{
	friend ostream& operator << (ostream& cout, Person p);
public:
	Person(int age)
	{
		m_A = new int(age);
		m_B = 0;
	}
	Person& operator=(const Person &p)
	{
		//先判断是否有属性数据在堆区，如果有就先释放，再进行深拷贝
		if (m_A != NULL)
		{
			delete m_A;
			m_A = NULL;
		}
		m_A = new int(*p.m_A);   //深拷贝
		m_B = p.m_B;             //浅拷贝
		return *this;
	}
private:
	int *m_A;
	int m_B;
};
ostream& operator << (ostream& cout, Person p)
{
	cout << "m_A=" << *p.m_A;
	return cout;
}

void test01()
{
	Person p1(18);
	Person p2(20);
	Person p3(10);
	cout << p1 << endl;
	cout << p2 << endl;
	p2 = p1;                //赋值操作
	cout << p2 << endl;
	p1 = p2 = p3;           //相当于p1 = (p2 = p3)，p2 = p3的结果为p3
	cout << p1 << endl;
	cout << p2 << endl;
	cout << p3 << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

十、重载复合赋值运算符

（1）重载复合赋值运算符，如+=、-=等，也应遵循上述赋值运算符的注意事项。

（2）与赋值运算符不同的是，复合赋值运算符既可以作为成员函数重载，也可以作为非成员函数重载。

（3）以重载“+=”运算符为例：

#include<iostream>
using namespace std;

class Person
{
public:

	int m_A;
	int m_B;
	Person& operator+=(Person &p)   //通过成员函数重载+=号;和下面那个全局函数重载+=二选一
	{
		this->m_A = this->m_A + p.m_A;
		this->m_B = this->m_B + p.m_B;
		return *this;
	}
};
/*Person& operator+=(Person &p1, Person &p2)   //通过全局函数重载+=
{
	p1.m_A = p1.m_A + p2.m_A;
	p1.m_B = p1.m_B + p2.m_B;
	return p1;
}*/

void test01()
{
	Person p1;
	Person p2;
	p1.m_A = 10;
	p2.m_A = 10;
	p1.m_B = 20;
	p2.m_B = 30;
	p2 += p1;
	cout << p1.m_A << "  " << p1.m_B << endl;
	cout << p2.m_A << "  " << p2.m_B << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}

十一、重载关系运算符

（1）重载关系运算符，可以让两个自定义类型对象进行对比操作。

（2）重载的关系运算符函数应返回逻辑值。

（3）关系运算符既可以作为成员函数重载，也可以作为非成员函数重载。

（4）以重载“==”运算符和“!=”运算符为例：

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

class Person
{
public:
	Person(string name,int age)
	{
		m_Age = age;
		m_Name = name;
	}
	bool operator==(Person &p)
	{
		if (this->m_Name == p.m_Name&&this->m_Age == p.m_Age)
		{
			return true;
		}
		return false;
	}
	bool operator!=(Person &p)
	{
		if (this->m_Name != p.m_Name||this->m_Age != p.m_Age)
		{
			return true;
		}
		return false;
	}
	
private:
	int m_Age;
	string m_Name;
};

void test01()
{
	Person p1("张三", 18);
	Person p2("张三", 18);
	Person p3("刘六", 18);
	if (p1 == p2)
	{
		cout << "p1和p2是相等的" << endl;
	}
	else
	{
		cout << "p1和p2是不相等的" << endl;
	}
	if (p1 != p3)
	{
		cout << "p1和p3是不相等的" << endl;
	}
	else
	{
		cout << "p1和p3是相等的" << endl;
	}
}

int main() {

	test01();

	system("pause");

	return 0;
}

十二、重载函数调用运算符“()”

（1）函数调用运算符也可以重载。由于重载后使用的方式非常像函数的调用，因此称为仿函数。

（2）仿函数没有固定写法，非常灵活。

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

class MyPrint
{
public:
	void operator()(string test)
	{
		cout << test << endl;
	}
private:
	int m_Age;
	string m_Name;
};
class MyAdd
{
public:
	int operator()(int num1, int num2)
	{
		return num1 + num2;
	}
};

void test01()
{
	MyPrint myPrint;
	myPrint("hello world");    //由于使用起来非常类似于函数调用，因此它被称为仿函数
	MyAdd myadd;
	int ret = myadd(100, 100);
	cout << "ret = " << ret << endl;
	cout << MyAdd()(100, 100) << endl;   //匿名对象MyAdd(),当前行执行完立刻被释放
}

int main() {

	test01();

	system("pause");

	return 0;
}

十三、重载类型转换符

（1）类型转换符必须作为成员函数重载。

（2）在重载类型转换符时，由于运算符本身已经表示出了返回值类型，因此不需要返回值类型的声明。

（3）以重载长整型转换符为例：

#include<iostream>
using namespace std;

class Person
{
public:

	char m_A;
	int m_B;
	operator long() const
	{
		return m_A;
	}
};

void test01()
{
	Person p1;
	p1.m_A = 'a';
	p1.m_B = 20;
	cout << long(p1) << endl;  //打印“97”
}

int main() {

	test01();

	system("pause");

	return 0;
}

十四、重载下标访问运算符“[]”

下标访问运算符必须作为成员函数重载。

#include<iostream>
using namespace std;

class Person
{
public:

	int m_A;
	int m_B;
	int a[10];

	int& operator[] (int i)
	{
		return a[i];
	}
};

void test01()
{
	Person p1;
	p1.m_A = 90;
	p1.m_B = 20;
	p1.a[2] = 30;
	cout << p1[2] << endl;
}

int main() {

	test01();

	system("pause");

	return 0;
}
Zevalin爱灰灰
关注
  • 26
    点赞
  • 踩
  • 22
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
C++Primer第五版——习题答案+详解(完整版)
MISAYAONE的博客
12-21 32万+
C++Primer第五版——习题答案详解 看的也比较快，但是有很多东西确实用不上，所以很多都没有深入的探讨，但是知识点覆盖的很全面，每一道题涉及的知识点我都写上简单的解释了。 文中代码的中文注释也尽量都写上，自己皆编译通过。 水平有限，如有有误之处，希望大家不吝指教！ 下面的链接是 第一章：全部题目(第一章基础较多)http:/
C++从入门到精通 第十二章（C++流）
Zevalin的博客
02-21 893
C++流有4个预定义流对象，它们的名称及与之联系的I/O设备如下，其中cin为istream类对象，其余3个为ostream类对象。cin标准输入cout标准输出cerr标准出错信息输出clog带缓冲的标准出错信息输出（1）程序运行时产生的数据都属于临时数据，程序一旦运行结束都会被释放，通过文件可以将数据持久化。（2）C++中对文件操作需要包含头文件。（3）文件类型分为两种：①文本文件——文件以文本的ASCII码形式存储在计算机中。②二进制文件——文件以文本的二进制。
AS3殿堂之路、AS3从入门到精通 读书笔记
fremn
07-16 2025
我在公司实习时叫我看的《殿堂之路》，语法那块看起来还好但始终觉得这书有点不爽，也浪费了我很多时间。后来毕设的时候看见参考文献有《从入门到精通这本书》看后果断要给力点。今天突然想起去豆瓣搜索下评分确实要高。但是也发现了很多更好的书，当初如果不急着学AS3现在学到的东西肯定多点。     以后学知识搜书籍，先豆瓣一下吧，再挑下适不适合自己。比如学linux有《一站式c》、《私房菜》、《lin
shell从入门到精通
HelloWowofei的博客
09-17 1667
前言 学习目标 熟悉Linux系统常用命令与工具，掌握Shell脚本语言语法结构，能独立编写Shell脚本，完成自动化运维常规任务，提高工作效率，为以后学习其他语言打下坚实的基础。 目标人群 运维工程师、开发工程师、Linux系统爱好者或已经具备其他编程语言的人群。 操作系统 本文档实验均采用CentOS7_X64系统。 目录 第一章Shell基础知识 1.1 Shell简介 1.2 Shell基本分两大类
C#入门经典（第七版） 学习笔记
Haipai1998的博客
01-02 5767
学习资料：C#入门经典（第七版） 学习计划：一天至少一章，主要是熟悉语法以及背后的原理 编译环境IDE：VSC (Visual Stduio Community) PS：老忘记的事情 类里面要写清楚数据是可访问类型是哪种 foreach一个list，取出来的是object类型，要强制转换成对应派生类 第二章 编写C#程序 Console.ReadKey()：等待一个响应，即任意敲击键盘...
go语言基础精修（尚硅谷笔记）
zhaicheng55的博客
11-22 1949
适用于使用过go语言但是没从头到尾学习过go的人第二遍学习的go语言入门到精通
C#基础教程-c#实例教程，适合初学者
热门推荐
huang714
08-22 8万+
C#基础教程-c#实例教程，适合初学者。 第一章 C#语言基础 本章介绍C#语言的基础知识，希望具有C语言的读者能够基本掌握C#语言，并以此为基础，能够进一步学习用C#语言编写window应用程序和Web应用程序。当然仅靠一章的内容就完全掌握C#语言是不可能的，如需进一步学习C#语言，还需要认真阅读有关C#语言的专著。 1.1 C#语言特点 Microsoft.NET(以下简称.NET)框...
python 两点曲线_Python已经成为排名第一的编程语言！附带最新Python400集视频教学...
weixin_39927158的博客
10-21 293
　　 同样是学习编程语言，当然要选择目前业内最先进、最热门、将来应用最广泛、最有前景的编程语言。在2017年的编程语言排行榜中，Python排名第一。　　Python拥有海量的开发库，方便控制各种品牌硬件，快速为不同场合的智能需求构建应用系统。Python是FRC编程模块的基础。　　Python 是一门更注重可读性和效率的语言，尤其是相较于 Java，PHP 以及 C++ 这样的语言，它...
【大学四年自学Java的学习路线】写了一个月，这是一份最适合普通大众、非科班的路线，祝你零基础快速找到一份满意的工作_网程好8353f5
2401_84617431的博客
04-27 886
零基础自学 Java，大概多久可以找到工作?最近又有一个读者“在你的世界各地”向我提了上面这个问题。但说实话，这个问题并不太好问答。因为 Java 是一门“历史悠久”的编程语言，它的学习资料多到令人眼花缭乱。但不能为自己找借口啊，毕竟读者就是上帝。于是我花了一个月的时间，精心为你准备了一份万字长文，史上最佳的 Java 自学指南，保证你能找到一份满意的工作。先来梳理一下读者强调的关键词，有 3 个，分别是“零基础”、“自学”、“找到工作”。
Visual C++从入门到精通第三版.pdf
05-11
比较好的入门书.共享给大家.从最基础的C++讲起到VC高级应用. 比较好的入门书.共享给大家.从最基础的C++讲起到VC高级应用.
C++ 入门到精通 教学用PPT.rar_C++ 从入门到精通学习PPT
07-15
C++ 从入门到精通的全套PPT，对初学者学习非常有帮助
【C++】——Stack与Queue（含优先队列（详细解读）
最新发布
m0_74092462的博客
06-09 778
优先队列是一种容器适配器，根据严格的弱排序标准，它的第一个元素总是它所包含的元素中最大的。stack是一种容器适配器，专门用在具有后进先出操作的上下文环境中，其删除只能从容器的一端进行元素的插入与提取操作。 队列是一种容器适配器，专门用于在FIFO上下文(先进先出)中操作，其中从容器一端插入元素，另一端提取元素。
C语言编译与链接
N201871643的博客
06-05 146
6.1 编写可移植的代码考虑到不同的操作系统和硬件可能需要不同的库文件，编写易于移植的代码是非常重要的。避免硬编码路径和使用跨平台兼容的库可以大大提高程序的可移植性。6.2 使用工具和脚本自动化构建过程使用像Make这样的构建工具可以帮助自动化编译和链接过程，使得在开发大型项目时更加高效。
c++ - 模板(二)
2302_79539362的博客
06-05 942
TYPE是类型按道理来说没有问题，但是编译器在检查到这里是就会出现歧义，不知道TYPE是类型还是静态变量，所以就会报错。给模板初始值与给函数初始值类似，当需要给一部分缺省值时，参数缺省值必须从右向左给，中间不能留着参数不给缺省值。非类型形参，就是用一个常量作为类(函数)模板的一个参数，在类(函数)模板中可将该参数当成常量来使用。另一种解决方法就是直接写一个该类型的函数，这个函数会与模板函数构成重载，并且符合的话会被优先使用。在没有被实例化时，编译器只会对函数进行语法等检查，不会查看类内部细节，如上面的。
C++中的左值和右值
weixin_47987343的博客
06-04 231
左值通常与变量和持久数据关联。右值通常与临时数据和表达式的结果关联。右值引用提供了一种操作右值并优化资源管理和性能的方式。
深度搜索算法2（c++）
mmz1207的博客
06-08 701
学校是 N x N 的坐标方格 grid 中，每一个方格的值 grid(i,j)表示在位置 (i,j) 的高度。每组数据的第一行是两个整数W和H，分别表示x方向和y方 向瓷砖的数量。你站在其中一块黑色的瓷砖上，只能向相邻的黑 色瓷砖移动。输出 对每组数据，分别输出一行，显示你从初始位置出发能到达的瓷砖数(记数 时包括初始位置的瓷砖)。时间为16时，水位为16，此时才能保证(0,0) 和(4,4)是联通的（请自行找出一条通路）。第一行有一个整数N，以下是一个N*N 的方阵，代表各处的高度。
C++| 一维线性插值、imadjust函数
qq_40306845的博客
06-07 679
用C++讲解和实现Matlab中的linear和imadjust函数。
STL中stack和queue模拟实现+容器适配器
2202_75331338的博客
06-06 847
deque（双端队列）：是一种双开口的“连续”空间的数据结构，双开口的含义是：可以在头尾两端进行插入和删除操作，且时间复杂度为O(1)，与vector比较，头插效率高，不需要搬移元素，与list比较，空间利用率比较高。deque并不是真正连续的空间，而是由一段段连续的小空间拼接而成的，实际deque类似于一个动态的二维数组双端队列底层是一段假象的连续的空间，实际是分段连续的，为了维护其“整体连续”以及随机访问的假象，落在看deque的迭代器身上，因此deque的迭代器设计就比较复杂，如下图所示；
c++第十章运算符重载
11-18
第十章主要介绍了C++中运算符重载的相关知识，包括运算符重载的概念、运算符重载的方法、运算符重载的限制等。 以下是C++中运算符重载的一些方法和示例： 1.成员函数重载运算符 ```c++ class Complex { public: ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

Zevalin爱灰灰

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

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

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

打赏作者

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

抵扣说明：

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

余额充值