运算符重载

最新推荐文章于 2021-02-12 12:35:34 发布
最新推荐文章于 2021-02-12 12:35:34 发布
阅读量98 收藏
点赞数
分类专栏： C++二次整理 文章标签： c++ 运算符重载
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38684512/article/details/112404138
版权

运算符重载

复数类重载

#include<iostream>
using namespace std;

/*
	C++运算符重载：使对象的运算表现得和编译器内置类型一致
	模板代码，可以使得运算符执行类模板进行运算

	template<typename T>
	T sum(T a,T b)
	{
		return a+b;		//a+.(b) a.operator+(b)
	}

*/
//复数类
class CComplex
{
public:
	CComplex (int r=0, int i=0)
		:_real(r)
		, _vir(i)
	{

	}

	//指导编译器怎么做CComplex类对象的加法操作
	//不能返回对象的引用，首先两个+法操作的对象不能改变，局部对象的引用不能返回
	CComplex operator+(const CComplex& com)
	{
		//->堆上等地址使用 .对象本身使用
		/*CComplex<T> temp;
		temp._real = this->_real + com._real;
		temp._vir = this->_vir + com._vir;
		return temp;*/

		//优化 减少临时对象的构造和析构
		return CComplex(this->_real + com._real, this->_vir + com._vir);
	}

	//++ -- 单目运算符  
	//operator++()		前置++ 
	//operator++(int)	后置++

	CComplex& operator++()
	{
		_real += 1;
		_vir += 1;
		return *this;
	}

	CComplex operator++(int)
	{
		//局部对象，不能返回引用
		//CComplex comp = *this;
		//_real += 1;
		//_vir += 1;
		//return comp;
		return CComplex(_real++, _vir++);
	}
	//不需要返回值 参数不用改变
	void operator+=(const CComplex& src)
	{
		_real += src._real;
		_vir += src._vir;
	}
	void show()
	{
		cout << "this" << this << endl;
		cout << "real:" << _real << endl;
		cout << "vir:" << _vir << endl;
	}
private:
	int _real;
	int _vir;
	//友元函数，可以访问私有成员变量
	friend CComplex operator+ (const CComplex& lhs, const CComplex& rhs);
	friend	ostream& operator<<(ostream& out, const CComplex& src);3
	friend istream& operator>>(istream &in, CComplex &srx);
};

CComplex operator+ (const CComplex &lhs,const CComplex &rhs)
{
	return CComplex(lhs._real + rhs._real, lhs._vir + rhs._vir);
}

//cout ::operator << (cout,comp1) void << endl不可以，所以只能返回cout类型
ostream& operator<<(ostream& out, const CComplex& src)
{
	out << "_real" << src._real << "_vir" << src._vir << endl;
	return out;
}
istream& operator>>(istream &in, CComplex &srx)
{
	in >> src._real>>src._vir;
	return in;
}
int main()
{
	CComplex comp1(10, 10);
	CComplex comp2(20, 20);
	//comp1.operator+(comp2)			加法运算符的重载函数
	CComplex comp3 = comp1 + comp2;
	comp3.show();
	//编译器在类模板中寻找 带整型参数的构造函数 把整数转成CComplex类型（传入参数的用传入参数，没传入参数的用默认值） 形参类型强制转换
	CComplex comp4 = comp1 + 20;
	comp4.show();
	//30 无法调用运算符重载，没有任何理由去做类型转换，
	//编译器做对象运算的时候，会调用对象的运算符重载函数（优先调用成员方法，无成员方法就在全局作用域找合适的运算符重载函数）
	//全局函数 发生类型转换，没法调用成员方法
	CComplex comp5 = 30 + comp2;
	comp5.show();


	//后置++		operator++(int)
	comp5 = comp1++;
	comp5.show();
	comp1.show();
	//前置++		operator++()
	comp5 = ++comp1;
	comp5.show();
	comp1.show();
	//comp1.operator+=(comp2)	::operator+=(comp1,comp2)
	comp1 += comp2;
	comp1.show();

	
	return 0;
}


//模板打印碰见自定义类型，如何处理
template<typename T>
void show(T a)
{

	cout << a << endl;
}

模拟C++String类代码

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

class String
{
public:
	String(const char* p = nullptr)
	{
		if (p != nullptr)
		{
			//strlen 只计算有效字符串的个数，不计算末尾'\0'所以要+1
			_pstr = new char[strlen(p) + 1];
			strcpy(_pstr, p);
		}
		else
		{
			_pstr = new char[1];
			*_pstr = '\0';
		}
	}
	
	~String()
	{
		delete[] _pstr;
		_pstr = nullptr;
	}

	String(const String& src)
	{
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
	}

	String& operator=(const String& src)
	{
		if (this == &src)
		{
			return *this;
		}

		delete[] _pstr;
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
		return *this;
	}

	//只读，定义为常方法 普通对象和常对象都可以调用
	bool operator>(const String& str) const
	{
		return strcmp(_pstr, str._pstr) > 0;
	}
	bool operator<(const String& str) const
	{
		return strcmp(_pstr, str._pstr) < 0;
	}
	bool operator==(const String& str) const
	{
		return strcmp(_pstr, str._pstr) == 0;
	}
	//有效字符的个数，不包括'\0'
	int length()const
	{
		return strlen(_pstr);
	}
	//为了可以修改，返回引用,可以读可以改
	char& operator[](int index)
	{
		return _pstr[index];
	}
	//常对象，返回值不许修改，只读
	const char& operator[](int index)const
	{
		return _pstr[index];
	}
	const char* c_str()const
	{
		return _pstr;
	}
private:
	//String本质是对char* 指针的一个封装
	char* _pstr;
	friend String operator+(const String& lhs, const String& rhs);
	friend ostream& operator<<(ostream& out, const String& str);
};

//不delete会发生内存泄露，改后效率低下
/*
String operator+(const String& lhs,const String& rhs)
{
	char* ptmp = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(ptmp, lhs._pstr);
	strcat(ptmp, rhs._pstr);
	String tmp(ptmp);
	delete[]ptmp;
	return tmp;
}
*/
String operator+(const String& lhs, const String& rhs)
{
	String tmp;
	tmp._pstr = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(tmp._pstr, lhs._pstr);
	strcat(tmp._pstr, rhs._pstr);
	return tmp;

}

ostream& operator<<(ostream& out, const String& str)
{
	out << str._pstr;
	return out;
}
//char arr[] = "jkshshk"
int main()
{
	String str1;				//默认构造
	String str2 = "aaa";		//提供了const char*类型的构造函数
	String str3 = "bbb";		//
	String str4 = str2 + str3;
	String str5 = str2 + "ccc";	//默认类型转换构造后面字符串的对象
	String str6 = "ddd" + str2;	//不默认，需要构造全局函数，无法调用运算符重载，没有理由进行类型转换

	cout << "str6:" << str6 << endl;
	if (str5 > str6)
	{
		cout << str5 << " > " << str6 << endl;
	}
	else
	{
		cout << str5 << " < " << str6 << endl;
	}

	int len = str6.length();
	for (int i = 0; i < len; ++i)
	{
		//将对象当作数组名来使用，访问字符串底层指定序号的字符，提供了下标运算符重载函数
		cout << str6[i] << " ";
	}

	//string--->char*
	char buf[1024] = { 0 };
	strcpy(buf, str6.c_str());

	return 0;
}

对象迭代器iterator

String

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

class String
{
public:
	String(const char* p = nullptr)
	{
		if (p != nullptr)
		{
			//strlen 只计算有效字符串的个数，不计算末尾'\0'所以要+1
			_pstr = new char[strlen(p) + 1];
			strcpy(_pstr, p);
		}
		else
		{
			_pstr = new char[1];
			*_pstr = '\0';
		}
	}

	~String()
	{
		delete[] _pstr;
		_pstr = nullptr;
	}

	String(const String& src)
	{
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
	}

	String& operator=(const String& src)
	{
		if (this == &src)
		{
			return *this;
		}

		delete[] _pstr;
		_pstr = new char[strlen(src._pstr) + 1];
		strcpy(_pstr, src._pstr);
		return *this;
	}

	//只读，定义为常方法 普通对象和常对象都可以调用
	bool operator>(const String& str) const
	{
		return strcmp(_pstr, str._pstr) > 0;
	}
	bool operator<(const String& str) const
	{
		return strcmp(_pstr, str._pstr) < 0;
	}
	bool operator==(const String& str) const
	{
		return strcmp(_pstr, str._pstr) == 0;
	}
	//有效字符的个数，不包括'\0'
	int length()const
	{
		return strlen(_pstr);
	}
	//为了可以修改，返回引用,可以读可以改
	char& operator[](int index)
	{
		return _pstr[index];
	}
	//常对象，返回值不许修改，只读
	const char& operator[](int index)const
	{
		return _pstr[index];
	}
	const char* c_str()const
	{
		return _pstr;
	}
	//给String字符串类型提供迭代器的实现
	class iterator
	{
	public:
		iterator(char* p = nullptr)
			:_p(p)
		{
		}
		//迭代器的不相等就是底层指针的不相等
		bool operator!=(const iterator& it)
		{
			return _p != it._p;
		}
		//前置++为什么效率快，因为不产生临时对象
		void operator++()
		{
			++_p;
		}
		char& operator*()
		{
			return *_p;
		}
	private:
		char* _p;
	};

	//容器的方法，不是迭代器的方法
	//begin容器底层首元素的迭代器表示，end容器末尾元素后继位置的迭代器的表示
	iterator begin()
	{
		return iterator(_pstr);
	}
	iterator end()
	{
		return iterator(_pstr+length());
	}
private:
	//String本质是对char* 指针的一个封装
	char* _pstr;
	friend String operator+(const String& lhs, const String& rhs);
	friend ostream& operator<<(ostream& out, const String& str);
};

//不delete会发生内存泄露，改后效率低下
/*
String operator+(const String& lhs,const String& rhs)
{
	char* ptmp = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(ptmp, lhs._pstr);
	strcat(ptmp, rhs._pstr);
	String tmp(ptmp);
	delete[]ptmp;
	return tmp;
}
*/
String operator+(const String& lhs, const String& rhs)
{
	String tmp;
	tmp._pstr = new char[strlen(lhs._pstr) + strlen(rhs._pstr) + 1];
	strcpy(tmp._pstr, lhs._pstr);
	strcat(tmp._pstr, rhs._pstr);
	return tmp;

}

ostream& operator<<(ostream& out, const String& str)
{
	out << str._pstr;
	return out;
}
//char arr[] = "jkshshk"
int main()
{
	//迭代器的功能：提供一种统一得方式，来透明得遍历容器
	//透明：不需要知道迭代器底层得数据结构实现，不同数据结构得遍历被封装在++运算符里

	string str1 = "hellow world!";
	//str1 是容器，底层放了一组char类型的字符 
	//问题 如何遍历字符串容器

	//容器的迭代器类型（容器类型的嵌套类）
	//string::iterator it = str1.begin();
	//使用自动推导 简化代码
	auto it = str1.begin();
	
	for (; it != str1.end(); ++it)
	{
		cout << *it << " ";
	}
	cout << endl;
	cout << str1 << endl;

	//C++11
	//用于foreach的方式 遍历容器的内部元素的值
	//底层还是通过迭代器来遍历得
	for (char ch : str1)
	{
		cout << ch;
	}
	return 0;
}

在这里插入图片描述

vector

#include<iostream>
using namespace std;

//迭代器得所有遍历细节都被封装在++运算符重载中
//统一的方式遍历一个容器中所有得元素


template<typename T>
class Allocator
{
public:
	Allocator() {}
	~Allocator() {}

	T* allocate(size_t size)
	{
		return (T*)malloc(sizeof(T) * size);
	}
	void deallocate(void* p)
	{
		free(p);
	}
	void construct(T* p, const T& val)
	{
		new(p)T(val);
	}
	void destory(T* p)
	{
		p->~T();
	}
private:
};

template<typename T,typename Alloc = Allocator<T>>
class vector
{
public:
	vector(T size = 10, const Alloc& alloc = Allocator<T>())
		:m_alloctor(alloc)
	{
		m_first = m_alloctor.allocate(10);
		m_last = m_first;
		m_endl = m_first + size;
	}
	~vector()
	{
		for (T* p = m_first; p != m_last; ++p)
		{
			m_alloctor.destory(p);
		}
		m_alloctor.deallocate(m_first);
		m_first = m_last = m_endl = nullptr;
	}

	vector(const vector<T>& val)
	{
		int len = val.m_last - val.m_first;
		int size = val.m_endl - val.m_first;
		m_first = m_alloctor.allocate(size);
		for (int i = 0; i < size; i)
		{
			m_alloctor.construct(m_first + i, val.m_first + i);
		}
		m_last = m_first + len;
		m_endl = m_first + size;
	}
	vector<T>& operator=(const vector<T>& val)
	{
		if (this == &val)
		{
			return *this;
		}

		for (T* p = m_last; p != m_first; --p)
		{
			m_alloctor.destroy(p);
		}
		m_alloctor.deallocate(m_first);

		int len = val.m_last - val.m_first;
		int size = val.m_endl - val.m_first;
		m_first = m_alloctor.allocate(size);
		for (int i = 0; i < size; ++i)
		{
			m_alloctor.construct(m_first + i, val.m_first + i);
		}
		m_last = m_first + len;
		m_endl = m_first + size;
	}

	void push_back(const T& val)
	{
		if (full())
		{
			expand();
		}
		m_alloctor.construct(m_last, val);
		cout << "Push back:" << m_last << endl;
		m_last++;
	}
	void pop_back()
	{
		if (empty())
		{
			return;
		}
		m_last--;
		m_alloctor.destroy(m_last);
	}

	T back() const
	{
		return *(m_last - 1);
	}

	bool full() const { return m_last == m_endl; }
	bool empty() const { return m_last == m_first; }

	//迭代器
	//将vector当作数组下标来使用，重载[]运算符
	T& operator[](int index)
	{
		if (index < 0 || index >= (m_last-m_first))
		{
			throw"OutOfRangeException";
		}
		return m_first[index];
	}

	//迭代器，一般实现成容器的嵌套类型
	//不同的容器底层数据结构不同，那个具体的迭代方式不同，向外边提供的是迭代器运算符重载函数，把底层数据结构的差异性，都封装在了迭代器的重载函数中
	class iterator
	{
		public:
			iterator(T* ptr = nullptr)
				:_ptr(ptr)
			{

			}
			bool operator!=(const iterator& it)
			{
				return _ptr != it._ptr;
			}
			void operator++()
			{
				_ptr++;
			}
			//如果解引用不修改 可以改为常成员
			T& operator*()
			{
				return *_ptr;
			}
			const T& operator*()const
			{
				return *_ptr;
			}
		private:
			T* _ptr;
	};
	iterator begin() { return iterator(m_first); }
	iterator end() { return iterator(m_last); }
private:
	T* m_first;
	T* m_last;
	T* m_endl;
	Alloc m_alloctor;
	void expand()
	{
		int size = m_endl - m_first;

		T* ptmp = m_alloctor.allocate(2 * size);
		for (int i = 0; i < size; ++i)
		{
			m_alloctor.construct(ptmp + i, m_first[i]);
		}
		for (T* p = m_first; p != m_last; ++p)
		{
			m_alloctor.destory(p);
		}
		m_alloctor.deallocate(m_first);
		m_first = ptmp;
		m_last = m_first + size;
		m_endl = m_first + 2 * size;
	}
};

int main()
{
	vector<int> vec;
	for (int i = 0; i < 20; ++i)
	{
		vec.push_back(rand() % 100 + 1);
	}

	vector<int>::iterator it = vec.begin();
	for (; it != vec.end(); ++it)
	{
		cout << *it << endl;
	}

	//for each 底层原理是通过容器的迭代器来实现的
	for (auto a : vec)
	{
		cout << a<< endl;
	}

	//底层数组是连续的，提供中括号运算符重载是有意义的，随机访问效率 O[1]
	//底层不连续，就不支持中括号运算符重载，非线性
	//但是迭代器是通用的
	for (int i = 0; i < 20; ++i)
	{
		cout << vec[i] << endl;
	}

	cout << endl;
	return 0;
}

迭代器失效问题

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


/*
	迭代器失效问题
	扩容：原来的迭代器全部失效

	1.迭代器为什么会失效：
		调用eraser，当前到末尾全失效
		调用insert，当前到末尾全失效
		如果引起容器扩容，原来容器所有的迭代器全部失效
	2.迭代器失效了之后，问题该怎么解决
		对插入/删除点的迭代器进行更新操作
	3.不同容器的迭代器不能进行进行比较运算，两个不同内存的迭代器位置肯定不同

*/
int main()
{
	vector<int> vec;
	for (int i = 0; i < 20; ++i)
	{
		vec.push_back(rand() % 100 + 1);
	}

	for (int v : vec)
	{
		cout << v<<" ";
	}
	cout << endl;
	//将vector容器中所有的偶数全部删除
	auto it = vec.begin();
	for (; it != vec.end();)
	{
		if (*it % 2 == 0)
		{
			//迭代器失效，第一次调用erase以后，迭代器it就失效了
			//vec.erase(it);
			//break;
		
			//使用eraser等函数的返回值，返回了一个合法的迭代器（当前位置）
			//C++提供的函数，通过返回合法的迭代器解决了迭代器失效问题
			it = vec.erase(it);
			//由于是删除，生成了新的迭代器，就不需要++
		}
		else
		{
			++it;
		}
	}
	for (int v : vec)
	{
		cout << v<<" ";
	}
	cout << endl;

}

在vector中寻找迭代器失效的原理
他们说快写一首情歌
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
复数运算符重载
03-26
在C#编程语言中，运算符重载是一种特殊的技术，允许程序员为自定义类型赋予标准运算符的新含义。当我们创建一个表示复数的类时，为了使得复数的加法、减法、乘法和除法等操作直观易用，就需要重载相应的运算符。复数...
C++|运算符重载
Youth_R的博客
08-17 280
#include <iostream> using namespace std; class CComplex { public: CComplex(int r = 0, int i = 0) : mreal(r), mimage(i) {} CComplex operator+(const CComplex &src) { /*CComplex comp; comp.mreal = this->mreal + src.mreal; comp.mimage
C++运算符重载规则详解
09-03
C++运算符重载是语言特性之一，允许程序员为已存在的运算符赋予新的含义，以适应自定义数据类型的运算需求。然而，运算符重载并不是无限制的，它遵循一些特定的规则，以确保代码的清晰性和正确性。 首先，C++中大...
运算符重载运算符重载
10-31
C++类的运算符重载，包括 = ++ -- -(负号运算符) + - * / % == != < > <= >= << >>
python 运算符重载
最新发布
10-10
运算符重载 以Rational class 为例，重载运算符 a/b a//b a += b a == b a a > b a != b a a >= b
C++ 裸指针和智能指针
qq_38684512的博客
12-07 7155
C++ 裸指针和智能指针裸指针的缺陷及实例演示忘记释放指针指向的资源代码逻辑过早结束 导致释放资源的代码执行不到代码运行过程中，代码发生异常了，直接出当前函数栈帧了通过裸指针，访问对象时，无法判断对象是否存活，还是已经析构掉了多个指针指向同一块内存释放导致的失效指针的问题智能指针的优势不带引用计数的智能指针auto_ptr 裸指针的缺陷及实例演示 忘记释放指针指向的资源 class Menory ...
C/C++ 函数符号生成规则
qq_38684512的博客
12-07 888
C/C++ 函数符号生成规则C编译器函数名修饰规则_cdecl调用约定(C标准调用约定)_stdcall约定调用(windows标准调用约定)fastcall调用约定（快速调用约定）C++编译器函数名修饰规则_cdecl调用约定_stdcall调用约定fastcall调用约定_thiscall调用约定(类成员方法的约定)参数表类型代号类参数白开始标志 函数符号是编译器在编译期间创建的一个字符串 用...
C++虚拟地址空间和编译过程
qq_38684512的博客
11-18 538
三块核心内容进程的虚拟地址空间内存划分和布局虚拟地址空间虚拟内存地址布局函数调用堆栈详细过程程序编译链接原理深入了解计算机系统程序员的自我修养 进程的虚拟地址空间内存划分和布局 虚拟地址空间 任何的编程语言 产生两种东西：指令和数据 产生在磁盘上的可执行文件 将程序从磁盘上加载到内存当中 不可能直接加载到物理内存 X86 32位 Linux环境下的 加载到内存 Linux系统会给当前进程分配一个2^32次方大小的空间4G （虚拟地址空间） 它存在，你能看得见，他是物理的 它存在，你看不见，他是透明的
C++创建一个类的注意事项
qq_38684512的博客
12-11 289
C++面向对象内存对齐.和->的区别类和对象、this指针构造函数和析构函数深拷贝和浅拷贝 内存对齐 节省CPU在IO上的访问次数 从理论上讲，对任何变量的访问都可以从任何地址开始， 但是实际的计算机系统对基本类型数据在内存中的存放有限制， 他们会要求这个元素首地址的值是4/8的倍数， 大部分处理器并不是按字节块来存取内存的. 它一般会以双字节,四字节,8字节,16字节甚至32字节为单位来存取内存，我们将上述这些存取单位称为内存存取粒度， 如果没有内存对齐机制，数据可以任意存放，一个int变量存
C++ /C动态开辟I行J列的动态数组 并释放空间
qq_38684512的博客
12-07 231
动态开辟并释放空间C语言实现C++ 实现 C语言实现 int row; int col; scanf_s("%d", &row); scanf_s("%d", &col); int** p = (int**)malloc(sizeof(int) * row); printf_s("创建二维数组~\n"); for (int i = 0; i < row; +...
C++11中的bind绑定器和function函数对象
qq_38684512的博客
02-12 188
绑定器和函数对象bind1st/bind2nd简单用法bind1st/bind2nd底层实现 bind1st/bind2nd简单用法 #include <iostream> #include <vector> #include <algorithm> #include<functional> #include <ctime> using namespace std; /* 绑定器和函数对象（对象有小括号运算符重载函数） 1.C++ STL中
C和C++的区别
qq_38684512的博客
11-18 161
C/C++异同同同为本地编译型语言同为强类型语言异面向过程和面向对象C++支持带默认值参数的函数C++函数支持重载动态内存管理 同 同为本地编译型语言 编译型语言： 直接编译成本地机器码 运行效率快 Go 脚本语言 脚本解释器运行在本地操作系统上 Python Java PHP 同为强类型语言 强/静态类型语言：C/C++/Java 变量定义必须指定类型，定义后类型不能改变 弱/动态类型语言：Py...
C++目录
qq_38684512的博客
11-17 157
C++ 目录C/C++ 区别C++类和对象代码编译模板编程运算符重载继承和多态异常处理STL标准库模板多线程编程MYSQL 关系型数据库重点汇总 C/C++ 区别 C++类和对象 代码编译 模板编程 运算符重载 继承和多态 异常处理 STL标准库模板 多线程编程 MYSQL 关系型数据库 重点汇总 ...
C++ STL标准模板库
qq_38684512的博客
02-03 136
STLstandard template libaray标准模板库函数对象 standard template libaray标准模板库 一、标准容器 1.顺序容器 vector 向量 deque 双端队列 list 链表 2.容器适配器 stack 栈 queue 队列 priority_queue 优先级队列 3.关联容器 无序关联容器 链式哈希表O(1) unordered_set 无序的单重集合 unordered_map 无序的单重映射表 unordered_multiset 无序的多重集合 u
继承与多态
qq_38684512的博客
01-10 129
继承和多态综述继承的本质和原理 综述 1.继承的本质和原理 2.派生类的构造过程 3.重载，覆盖，隐藏 4.静态绑定和动态绑定 5.多态vfptr和vftable 6.抽象类的设计原理 7.多重继承及问题 8.虚基类vbptr和vbtable 9.RTTI 10.C++四种类型强转 继承的本质和原理 #include<iostream> using namespace std; /* 继承的本质和原理 本质：代码的复用， 类和类之间的关系，组合和继承 组合：
单例模式 C++
qq_38684512的博客
12-03 123
单例模式 C++特点懒汉式饿汉式多线程下的 特点 保证一个类仅有一个实例，并提供一个访问它的全局访问点，该实例被所有程序模块共享 懒汉式 饿汉式 多线程下的 ...
C++语法基础和关键字const
qq_38684512的博客
12-02 109
C++ 基础new/delete malloc/free引用和指针const指针和引用的结合函数重载 inline函数 参数带默认值的函数参数带默认值的函数inline内联函数函数模板 new/delete malloc/free 引用和指针 const指针和引用的结合 函数重载 inline函数 参数带默认值的函数 参数带默认值的函数 #include<iostream> using namespace std; /* 问题1：默认值为什么从右向左给 问题2：调用效率的问题 立即数
C++运算符重载详解
"C++编程技术中的运算符重载部分，主要介绍了运算符重载的概念、方法、规则以及如何重载不同类型的运算符，包括作为成员函数和友元函数的重载，以及重载单目、双目运算符和流插入、流提取运算符等。" 在C++编程中，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值