C++面向对象程序设计 - 运算符重载

news2025/1/16 5:37:55

        函数重载就是对一个已有的函数赋予新的含义，使之实现新的功能。因此一个函数名就可以用来代表不同功能的函数，也就是一名多用。运算符也可以重载，即运算符重载（operator overloading）。

一、运算符重载的方法

        运算符重载的方法是定义一个重载运算符的函数，在需要执行被重载的运算符时，系统就自动调用该函数，以实现相应的运算。运算符重载实质上是函数的重载。

        重载运算符的函数一般格式如下：

函数类型  operator 运算符名称（形参表列）{

        对运算符的重载处理

}

        这里通过 + 运算符进行两个复数相加，示例代码如下：

#include <iostream>
using namespace std;
class Complex{
	public:
		Complex(){
			real = 0; imag = 0;
		}
		Complex(double r, double i){
			real = r; imag = i;
		}
		Complex operator +(Complex &c2);	// 声明重载运算符 + 的函数
		void display();
	private:
		double real;
		double imag;
};
// 定义重载运算符 + 的函数
Complex Complex::operator +(Complex &c2){
	Complex c;
	c.real = real + c2.real;		// 两上复数的实部相加
	c.imag = imag + c2.imag;		// 两个复数的虚部相加
	return c;
}
void Complex::display(){
	cout <<"("<<real<<","<<imag<<"i)"<<endl;
}
int main(){
	Complex c1(3, 4), c2(5, -10), c3;
	c3 = c1 + c2;			// 运算符 + 用于复数运算
	cout <<"c1=";c1.display();
	cout <<"c2=";c2.display();
	cout <<"c1+c2=";c3.display();
	return 0;
}

运行结果如下：

        对于上述示例的运算符重载函数 operator + 还可以改写得更简练一些，代码如下：

#include <iostream>
using namespace std;
class Complex{
	public:
		Complex(){
			real = 0; imag = 0;
		}
		Complex(double r, double i){
			real = r; imag = i;
		}
		Complex operator +(Complex &c2);	// 声明重载运算符 + 的函数
		void display();
	private:
		double real;
		double imag;
};
// 定义重载运算符 + 的函数
Complex Complex::operator +(Complex &c2){
	return Complex(real + c2.real, imag + c2.imag);
}
void Complex::display(){
	cout <<"("<<real<<","<<imag<<"i)"<<endl;
}
int main(){
	Complex c1(3, 4), c2(5, -10), c3;
	c3 = c1 + c2;			// 运算符 + 用于复数运算
	cout <<"c1=";c1.display();
	cout <<"c2=";c2.display();
	cout <<"c1+c2=";c3.display();
	return 0;
}

        return语句中的Complex(real + c2.real, imag + c2.imag) 是建立一个临时对象，它是一个无名对象，在建立临时对象过程中调用构造函数，return语句将此临时对象作为函数返回值。

二、重载运算符的规则

        1）C++不允许用户自己定义新的运算符，只能对已有的C++运算符进行重载。

        2）C++中绝大部分的运算符允许重载。如下表

双目算术运算符+（加），-（减），*（乘），/（除），%（取模）
关系运算符==（等于），!=（不等于），<（小于），>（大于），<=（小于等于），>=（大于等于）
逻辑运算符||（逻辑或），&&（逻辑与），!（逻辑非）
单目运算符+（正），-（负），*（指针），&（取地址）
自增自减运算符++（自增），--（自减）
位运算符!（按位或），&（按位与），~（按位取反），^（按位异或），<<（左移），>>（右移）
赋值运算符=，+=，-=，*=，/=，%=，&=，!=，^=，<<=，>>=
空间申请与释放new，delete，new[]，delete[]
其他运算符()(函数调用)，->（成员访问），->*（成员指针访问），,（逗号），[]（下标）

        不能重载的运算符：

.成员访问运算符
.*成员指针访问运算符
::域运算符
sizeof长度运算符
?:条件运算符

        3）重载不能改变运算符运算对象（即操作数）的个数；例如 + 运算符有两个操作数（a + b），不能重载它使用得它只有一个操作数或三个操作数。

        4）重载不能改变运算符的优先级别。重载不能改变运算符的结合性；例如 * 和 / 优先于 + 和 - ，不论怎样进行重载，各大运算符的优先级别不会改变。

        5）重载不能改变运算符的结合性。结合性决定了当多个相同优先级的运算符出现在同一个表达式中时，应该如何分组。例如 + 和 * 都是左结合的，这意味着 a + b + c会被解释为 (a + b) + c，而不是 a + (b + c)。重载运算符不能改变这种结合性。

        6）重载运算符的函数不能有默认的参数，这是因为默认参数会改变运算符的语义，导致代码的混淆和不可预测的行为。

        7）重载的运算符必须和用户定义的自定义类型的对象一起使用，其参数至少应有一个类对象（或类对象的引用）。重载运算符的目的是为了增强自定义类型的操作能力，而不是改变内置类型的行为。因此，重载的运算符必须至少涉及一个自定义类型的对象。

        8）用于类对象的运算符一般必须重载，但有两个例外，运算符 = 和 & 不必用户重载。

        9）应当使重载运算符的功能类似于该运算符作用于标准类型数据时所实现的功能。

        10）运算符重载函数可以是类的成员函数，也可以是类的友元函数，还可以是既非类的成员函数也不是友元函数的普通函数。

        总之，这些规则确保了运算符重载的一致性和可预测性，同时也避免了可能的混淆和错误。

三、运算符重载函数作为类成员函数和友元函数

        运算符重载函数除了可以作为类的成员函数，还可以是非成员函数。此时将运算符“+”重载为适用于复数相加，重载函数不作为成员函数，而放在类外作为Complex类的友函数。代码如下：

#include <iostream>
using namespace std;
class Complex{
	public:
		Complex(){
			real = 0; imag = 0;
		}
		Complex(double r, double i){
			real = r; imag = i;
		}
        // 声明重载运算符 + 的函数
		friend Complex operator +(Complex &c1, Complex &c2);	
		void display();
	private:
		double real;
		double imag;
};
// 定义重载运算符 + 的函数
Complex operator +(Complex &c1, Complex &c2){
	return Complex(c1.real + c2.real, c1.imag + c2.imag);
}
void Complex::display(){
	cout <<"("<<real<<","<<imag<<"i)"<<endl;
}
int main(){
	Complex c1(3, 4), c2(5, -10), c3;
	c3 = c1 + c2;			// 运算符 + 用于复数运算
	cout <<"c1=";c1.display();
	cout <<"c2=";c2.display();
	cout <<"c1+c2=";c3.display();
	return 0;
}

        运行结果如下图：

四、重载双目运算符

        双目运算符（或称二元运算符）是C++中最常用的运算符，双目运算符有两个操作数，在运算符的左右两侧，如 3 + 5， a = b，i < 10等。

        这里先给一个示例，重载运算符 > ，< ，=等，代码如下：

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

class String{
	public:
		String(){
			p = NULL;
		}
		String(const char *str){
			p = str;
		}
		friend bool operator > (String &str1, String &str2);
		friend bool operator < (String &str1, String &str2);
		friend bool operator == (String &str1, String &str2);
	private:
		const char *p;
};
// 重载运算符 >
bool operator > (String &str1, String &str2){
	return strcmp(str1.p, str2.p)>0 ? true : false;
}
// 重载运算符 <
bool operator < (String &str1, String &str2){
	return strcmp(str1.p, str2.p)<0 ? true : false;
}
// 重载运算符 ==
bool operator == (String &str1, String &str2){
	return strcmp(str1.p, str2.p)==0 ? true : false;
}

int main(){
	String s1("Hello"), s2("World"), s3("Computer");
	cout <<(s1 < s2) <<endl;
	cout <<(s1 > s3) <<endl;
	cout <<(s2 == s3) <<endl;
	return 0;
}

        运算结果如下：

        需要注意的是此示例中是将字符串转换为一个char*类型， 在C++中，字符串常量是const char*类型（例如“Hello”，"World"），而将其直接赋值给char* 类型的变量会导致编译器报错【[Warning] ISO C++ forbids converting a string constant to 'char*' [-Wwrite-strings]】- C++禁止针字符串常量转换为'char*'。将只读的字符串常量赋值给char*类型修改为可变的内容，这是不被允许的，所以在定义String类中的私有数据成中和构造函数中形参声明，一定要在前面另上const。

        下面将以上代码进行优化，让显示的结果更为直观些，代码如下：

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

class String{
	public:
		String(){
			p = NULL;
		}
		String(const char *str){
			p = str;
		}
		friend bool operator > (String &str1, String &str2);
		friend bool operator < (String &str1, String &str2);
		friend bool operator == (String &str1, String &str2);
		friend void compare(String &str1, String &str2);
		void display(){
			cout <<p;
		}
	private:
		const char *p;
};
// 重载运算符 >
bool operator > (String &str1, String &str2){
	return strcmp(str1.p, str2.p)>0 ? true : false;
}
// 重载运算符 <
bool operator < (String &str1, String &str2){
	return strcmp(str1.p, str2.p)<0 ? true : false;
}
// 重载运算符 ==
bool operator == (String &str1, String &str2){
	return strcmp(str1.p, str2.p)==0 ? true : false;
}
// 更直观显示结果
void compare(String &str1, String &str2){
	if(operator > (str1, str2) == 1){
		cout <<str1.p <<'>' <<str2.p;
	} else{
		if(operator < (str1, str2) == 1){
			cout <<str1.p <<'<' <<str2.p;
		} else if(operator == (str1, str2) == 1){
			cout <<str1.p <<'=' <<str2.p;
		}
	}
	cout <<endl;
}

int main(){
	String s1("Hello"), s2("World"), s3("Computer");
	compare(s1, s2);
	compare(s1, s3);
	compare(s2, s3);
	return 0;
}

        运行结果如下：

        此时需要区分下strcmp 和 operator >，在c++中strcp是C标准库的函数，用于比较两个字符中（即char*指针向的字符串）；而operator >是一个运算符重载，可以在自定义的类中定义，用于比较对象。

        strcmp函数返回一个整数，表示两上字符串的字典关系：

  • 如果返回值小于0，表示值1指向的字符串在字典上小于值2指向的字符串。
  • 如果返回值等于0，表示两个字符串相等。
  • 如果返回值大于0，表示值1指向的字符串在字典上大于值2指向的字符串。

        示例中operator > 或 operator < 或 operator == 是String类中声明的3个重载函数为友元函数，并在类外分别定义了3个运算符重载函数。C++编译系统将程序中的表达式 s1 > s2 解释为 operator > (s1, s2)，所以上例代码中写法也就不难理解了。将compare函数也可以改为以下形式，代码如下：

void compare(String &str1, String &str2){
	if((str1 > str2) == 1){
		cout <<str1.p <<'>' <<str2.p;
	} else{
		if((str1 < str2) == 1){
			cout <<str1.p <<'<' <<str2.p;
		} else if((str1 == str2) == 1){
			cout <<str1.p <<'=' <<str2.p;
		}
	}
	cout <<endl;
}

五、重载单目运算符

        单目运算符只有一上操作数，如 !a，-b，&c，*p，还有常用的 ++i 和--i等。重载单目运算符的方法与重载双目运算符的方法类似的。但由于单目运算符只有一个操作数，因此运算符重载函数只有一个参数，如果运算符重载函数作为成员函数，则还可以省略此参数。

        这里通过一个计算器Timer类来演示一下单目运算符的重载，代码如下：

#include <iostream>
using namespace std;
class Timer{
	public:
		Timer(){
			hour = 0;
			minute = 0;
			second = 0;
		}
		Timer(int h, int m, int s): hour(h), minute(m), second(s){}
		Timer operator ++ ();		// 声明运算符重载
		// 定义输出时间函数
		void display(){
			cout <<hour <<":" <<minute <<":" <<second <<endl;
		}
	private:
		int hour;
		int minute;
		int second;
};
Timer Timer::operator ++(){
	// 分钟 满60秒进1分钟
	if(++second>=60) {
		second -= 60;
		++minute;
	}
	// 小时 满60分钟进1小时
	if(minute>=60){
		minute -= 60;
		++hour;
	}
	// 返回当前对象
	return *this;
}
int main(){
	Timer t1(1, 20, 0);
	for(int i = 0; i < 61; i++){
		++t1;
		t1.display();
	}
	return 0;
}

        运行一共输出61行，结果如下：

1:20:1
1:20:2
1:20:3
1:20:4
1:20:5
1:20:6

......
1:20:56
1:20:57
1:20:58
1:20:59
1:21:0
1:21:1

       在C++中，如果在自增（自减）运算符重载函数中，增加一个int型形参，就是后后置自增（自减）运算符函数。示例如下：

#include <iostream>
using namespace std;
class Timer{
	public:
		Timer(){
			hour = 0;
			minute = 0;
			second = 0;
		}
		Timer(int h, int m, int s): hour(h), minute(m), second(s){}
		Timer operator ++ ();		// 声明前置自增运算符重载函数
		Timer operator ++ (int);	//声明后置自增运算符重载函数
		// 定义输出时间函数
		void display(){
			cout <<hour <<":" <<minute <<":" <<second <<endl;
		}
	private:
		int hour;
		int minute;
		int second;
};
// 定义前置自增运算符重载函数
Timer Timer::operator ++(){
	// 分钟 满60秒进1分钟
	if(++second>=60) {
		second -= 60;
		++minute;
	}
	// 小时 满60分钟进1小时
	if(minute>=60){
		minute -= 60;
		++hour;
	}
	// 返回当前对象
	return *this;
}
// 定义后置自增运算符重载函数
Timer Timer::operator ++(int){
	// 分钟 满60秒进1分钟
	if(++second>=60) {
		second -= 60;
		++minute;
	}
	// 小时 满60分钟进1小时
	if(minute>=60){
		minute -= 60;
		++hour;
	}
	// 返回当前对象
	return *this;
}
int main(){
	Timer t1(1, 20, 0), t2(3, 10, 20);
	for(int i = 0; i < 61; i++){
		++t1;
		t1.display();
	}
	cout <<endl;
	for(int i = 0; i < 61; i++){
		t2++;
		t2.display();
	}
	return 0;
}

        运行结果如下：

// 前置结果

1:20:1
1:20:2
1:20:3
1:20:4
1:20:5
1:20:6
.......
1:20:56
1:20:57
1:20:58
1:20:59
1:21:0
1:21:1

// 后置结果

3:10:21
3:10:22
3:10:23
3:10:24
3:10:25
3:10:26
.......
3:11:17
3:11:18
3:11:19
3:11:20
3:11:21

        注意的时，如果Timer类中未声明和定义后置自增运算符重载，则系统编译时会报错【[Error] no 'operator++(int)' declared for postfix '++' [-fpermissive]】- 没有为后缀‘++’声明'operator++(int)'。

        "++"或"--"前置和后置的区别：前置是先自加，返回是修改后的对象本身；后置是返回自加前的对象，然后对象再自加。

六、重载流插入运算符和提取运算符

        C++的插入运算符“<<”和流提取运算符“>>”是C++在类库中提供的，所有C++编译系统都在类库中提供输入流类istream和输出流类otream。cin和cout分别是istream和ostream类的对象。在类库提供的头文件中已经对"<<"和">>"进行了重载，使之作为流插入运算符和流提取运算符，能用来输出和输入C++标准类型的数据。

        对"<<"和">>"重载的函数形式如下：

istream & operator >> (istream &, 自定义类 &);

ostream & operator << (ostream &, 自定义类 &);

        第一个参数必须是流类型引用，第二个参数是要进行操作的类，所以重载"<<"和">>"的函数作为友函数或普通的函数，而不能将它们定义为成员函数。

        这是因为作为成员函数，这些运算符只能访问一个对象（即该成员函数所属的类的实例），然而在流操作中，我们需要同时访问流对象和用户定义的对象。如果试图将 << 和 >> 作为成员函数重载，那么它只能访问到自定义的对象，而无法访问到流对象，这显示是无法满足需求的。

        通过将 << 和 >> 重载为非成员函数，可以让它们同时接受一个流对象和一个自定义的对象作为参数，这样就可以在函数中同时访问和操作这两个对象。此外，为了允许这些非成员函数访问类的私有或保护成员，通常需要将这些函数声明为类的友元函数。

        这里将在“一”、“二”中的基础上，用重载的">>"输入数值，"<<"输出复数，代码如下：

#include <iostream>
using namespace std;
class Complex{
	public:
		Complex(){
			real = 0; imag = 0;
		}
		Complex(double r, double i){
			real = r; imag = i;
		}
		Complex operator +(Complex &c2);	// 声明重载运算符 + 的函数
		friend ostream& operator <<(ostream&, Complex&);
		friend istream& operator >>(istream&, Complex&);
	private:
		double real;
		double imag;
};
// 定义重载运算符 + 的函数
Complex Complex::operator +(Complex &c2){
	return Complex(real + c2.real, imag + c2.imag);
}
// 定义运算符">>"重载函数
istream& operator >>(istream& input, Complex& c){
	cout <<"Please enter the value:" <<endl;
	input >>c.real >>c.imag;
	return input;
}
// 定义运算符"<<"重载函数
ostream& operator <<(ostream& output, Complex& c){
	cout <<"("<<c.real<<","<<c.imag<<"i)"<<endl; 
	return output;
}
int main(){
	Complex c1, c2, c3;
	cin >>c1 >>c2;
	c3 = c1 + c2;			// 运算符 + 用于复数运算
	cout <<endl;
	cout <<"c1=" <<c1;
	cout <<"c2=" <<c2;
	cout <<"c1+c2=" <<c3;
	return 0;
}

        运行后则会按运算符">>"重载后格式输入，以及运算符"<<"重载后格式输出，结果如下图：

        在C++中，运算符重载是很重要的、很有实用意义的，它使类的设计更加丰富多彩，扩大了类的功能和使用范围，使程序易于理解，易于对对象进行操作，它体现了为用户着想、方便用户使用的思路。

        也能体现到运算符重载中使用引用（reference）的重要性，利用引用作为函数形参可以不生成临时变量，减少了时间和空间的开销，通过传址的方式使形参成为实参的别名，调用过程中不是用传递值的方式 进行虚实结合。

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：http://www.coloradmin.cn/o/1617927.html

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈，一经查实，立即删除！

相关文章

DFS与回溯专题：二叉树的最大深度

DFS与回溯专题：二叉树的最大深度

DFS与回溯专题&#xff1a;二叉树的最大深度 题目链接: 104.二叉树的最大深度 题目描述 代码思路 设置两个变量&#xff0c;max来记录最大值&#xff0c;sum来记录路径的节点数量。利用dfs对二叉树进行搜索&#xff0c;遇到节点&#xff0c;则sum1&#xff1b;遇到叶子节点&…
阅读更多...
路由过滤与引入

路由过滤与引入

1、实验拓扑 2、实验要求 1、按照图示配置 IP 地址&#xff0c;R1&#xff0c;R3&#xff0c;R4 上使用 1oopback口模拟业务网段 2、运行 oSPF&#xff0c;各自协议内部互通 3、R1 和 R2 运行 RIPv2,R2&#xff0c;R3和R4在 RIP 和 oSPF 间配置双向路由引入,要求除 R4 上的业务…
阅读更多...
Java web应用性能分析服务端慢之Nginx慢

Java web应用性能分析服务端慢之Nginx慢

一般Nginx作为整个应用的入口&#xff0c;即做静态服务器&#xff0c;也做负载均衡、反向代理&#xff1b;同时也因为位置靠前&#xff0c;还可以通过Nginx对于访问的IP、并发数进行相应的限制。在Java web应用性能分析中&#xff0c;Nginx是重要环节&#xff0c;Nginx的性能也…
阅读更多...
SpringMvc(2)RequestMapping注解

SpringMvc(2)RequestMapping注解

RequestMapping注解 1 、RequestMapping的作用2、RequestMapping的出现位置3、类上与方法上结合使用4、RequestMapping注解的value属性4.1 value属性的使用4.2 Ant风格的value4.3 value中的占位符&#xff08;重点&#xff09; 5、RequestMapping注解的method属性5.2衍生Mappin…
阅读更多...
VsCode一直连接不上 timed out

VsCode一直连接不上 timed out

前言 前段时间用VsCode连接远程服务器&#xff0c;正常操作后总是连接不上&#xff0c;折磨了半个多小时&#xff0c;后面才知道原来是服务器设置的问题&#xff0c;故记录一下&#xff0c;防止后面的小伙伴也踩坑。 我使用的是阿里云服务器&#xff0c;如果是使用其他平台服务…
阅读更多...
第十四章大数据和数据科学4分

第十四章大数据和数据科学4分

14.1 引言 14.1.3 科学理念 1.数据科学 数据科学将数据挖掘、统计分析和机器学习与数据集成整合&#xff0c;结合数据建模能力&#xff0c;去构建预测模型、探索数据内容模式。 数据科学依赖于&#xff1a; 1&#xff09;丰富的数据源。具有能够展示隐藏在组织或客户行为中不…
阅读更多...
提升效率！微信自动统计数据报表，轻松实现！

提升效率！微信自动统计数据报表，轻松实现！

在数字化时代&#xff0c;提高工作效率是每个人的追求。下面就给大家分享一个能够自动统计微信号运营数据的神器——个微管理系统&#xff0c;让大家无需手动整理和计算&#xff0c;提高工作效率&#xff01; 1、好友统计报表 它分为通讯录好友统计、新增好友统计和删除好友统…
阅读更多...
Linux进程地址空间及其页表

Linux进程地址空间及其页表

文章目录 一、引言二、Linux进程地址空间的概念1、进程地址空间定义2、进程地址空间的组成3、进程地址空间与物理内存的关系 三、页表与内存映射1、页表的定义及作用2、页表的缺页中断 三、进程的写时拷贝 一、引言 在Linux中&#xff0c;进程管理是其核心功能之一&#xff0c…
阅读更多...
统一SQL 支持Oracle unpivot列转行

统一SQL 支持Oracle unpivot列转行

统一SQL介绍 https://www.light-pg.com/docs/LTSQL/current/index.html 源和目标 源数据库&#xff1a;Oracle 目标数据库&#xff1a;TDSQL-MySQL 操作目标 在Oracle中&#xff0c;可以使用unpivot将列转换成行&#xff0c;在TDSQL-MySQL中没有对应的功能&#xff0c;由…
阅读更多...
LateX的基础学习

LateX的基础学习

what can i say 在text.tex中写下 \documentclass{article} \begin{document]Hello \LaTeX. \end{document} 关闭记事本&#xff0c;cmd中dir保存&#xff0c;用latex text.tex来编译&#xff0c;可以命令行慢慢编译&#xff0c;这可以做成bat文件 为什么不直接开始在texst…
阅读更多...
OSPF认证方式，ISIS简介，ISIS路由器类型

OSPF认证方式，ISIS简介，ISIS路由器类型

OSPF&#xff1a;转发&#xff0c;泛洪&#xff0c;丢弃
阅读更多...
selenium‘拟人包装‘设置

selenium‘拟人包装‘设置

1、设置header,proxy 1.1关于user-agent 输入about:version 找到user-agent: import requests # 引用requests库 from selenium import webdriver#载入浏览器驱动#header&#xff0c;proxy设置 optionswebdriver.ChromeOptions()#实例化浏览器参数设置options.add_argument…
阅读更多...
clickhouse学习笔记04

clickhouse学习笔记04

ClickHouse高可用之ReplicatedMergeTree引擎介绍 ClickHouse高可用架构准备-环境说明和ZK搭建 RPM安装ClickHouse 上传我们的clickhouse rpm文件。 安装&#xff1a; 中途需要输入用户名和密码 可以不设置 直接回车。 启动&#xff1a; 查看状态&#xff1a; 查看端口是否占用…
阅读更多...
【鸿蒙NEXT】web组件debug模式

【鸿蒙NEXT】web组件debug模式

官方文档 使用Devtools工具调试前端页面 打开web debug模式 webview.WebviewController.setWebDebuggingAccess(true)chrome 访问 chrome://inspect/#devices Discover network targets 中添加 localhost:9222 创建cat.sh com.coooliang.yourappbundname 为你应用的bundlen…
阅读更多...
什么品牌的裤子好看又耐穿？夏季裤子品牌排行榜分享

什么品牌的裤子好看又耐穿？夏季裤子品牌排行榜分享

男生应该怎么样去挑选合适自己的裤子&#xff0c;这应该是不少男士朋友选裤子时最大的疑问了。因为市面上有着不少质量不好&#xff0c;版型不适合亚洲人的裤子了&#xff0c;如果随意去选择就很容易踩雷&#xff0c;那么今天就给大家分享一下关于如何选择裤子的方法&#xff0…
阅读更多...
JVM之本地方法栈和程序计数器和堆

JVM之本地方法栈和程序计数器和堆

本地方法栈 本地方法栈是为虚拟机执行本地方法时提供服务的 JNI&#xff1a;Java Native Interface&#xff0c;通过使用 Java 本地接口程序&#xff0c;可以确保代码在不同的平台上方便移植 不需要进行 GC&#xff0c;与虚拟机栈类似&#xff0c;也是线程私有的&#xff0c;…
阅读更多...
牛客网刷题 | BC60 判断是不是字母

牛客网刷题 | BC60 判断是不是字母

描述 KiKi想判断输入的字符是不是字母&#xff0c;请帮他编程实现。 输入描述&#xff1a; 多组输入&#xff0c;每一行输入一个字符。 输出描述&#xff1a; 针对每组输入&#xff0c;输出单独占一行&#xff0c;判断输入字符是否为字母&#xff0c;输出内容详见输出样例…
阅读更多...
第二节课，后端登录代码 校验

第二节课，后端登录代码 校验

一、注册逻辑 二、代码写的位置 I UserService.java 写业务逻辑的 2.1 代码1 2.1.1 注释生成 先按 /** 再按 回车 2.1.2 多补充一点 2.2 代码2 Implement method userRegister # 在这里实现用户注册的逻辑&#xff0c;例如将用户名和密码存储到数据库中 2.2.1 自动进入user…
阅读更多...
企业上了财务系统，有必要再上费控系统吗？

企业上了财务系统，有必要再上费控系统吗？

相信很多财务人员甚至是老板肯定有这样的疑惑&#xff1a;企业已经有了财务系统&#xff0c;为什么还要上费控软件呢&#xff1f;为什么越大的企业越倾向使用专业费控平台来管理企业费用&#xff1f; 当我们在讨论这个问题的时候&#xff0c;首先要搞清楚&#xff0c;这里所说的…
阅读更多...
OS国产化改造中LVM卷迁移指导

OS国产化改造中LVM卷迁移指导

一、前言 因OS改造涉及LVM卷&#xff0c;且vg卷包含磁盘数量较多&#xff0c;lv中数据较大&#xff08;100T左右&#xff09;&#xff0c;因此要在OS改造中确保LVM卷信息完整不丢失&#xff0c;保证其上数据安全尤为重要。本文旨在探讨lvm信息存储及迁移&#xff0c;以指导完成…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023