【C++学习手札】一文带你初识运算符重载

                                         食用指南：本文在有C基础的情况下食用更佳   

                                        🍀本文前置知识： C++类 

                                        ♈️今日夜电波：クリームソーダとシャンデリア—Edo_Ame江户糖

                                                                1:20 ━━━━━━️💟──────── 3:40
                                                                    🔄   ◀️   ⏸   ▶️    ☰ 

                                      💗关注👍点赞🙌收藏您的每一次鼓励都是对我莫大的支持😍 

目录

💓一、运算符重载基本概念

什么是运算符重载？

运算符重载简要干货

可重载的运算符有哪些？ 

💗二、前置知识-友元函数 

 什么是友元函数？

 友元函数的语法

 💞三、运算符重载

运算符重载的语法

一步一步带你实现运算符重载（以<<为例）

运算符重载作为成员函数以及全局函数的实现（以+为例）

全局函数

成员函数

💕四、++和--运算符重载 （重要、常用）

💘具体实现用例 

一、运算符重载基本概念

什么是运算符重载？

        运算符重载， 就是对已有的运算符重新进行定义， 赋予其另一种功能， 以适应不同
的数据类型。
        运算符重载(operator overloading)只是一种”语法上的方便”,也就是它只是另一种函
数调用的方式。

        在 c++中， 可以定义一个处理类的新运算符。 这种定义很像一个普通的函数定义，只是函数的名字由关键字 operator 及其紧跟的运算符组成。 差别仅此而已。 它像任何其他函数一样也是一个函数， 当编译器遇到适当的模式时， 就会调用这个函数。

运算符重载简要干货

        运算符重载的目的：简化操作 让已有的运算符 适应适应不同的数据类型。
        语法：函数的名字由关键字operator及其紧跟的运算符组成
        比如：重载+运算符 ==>     operator+ 重载=号运算     ==>     operator=
        注意：重载运算符 不要更改 运算符的本质操作（+是数据的相加 不要重载成相减）

         栗子：（以下为重载了<<运算符的类）

class Data
{
	friend ostream& operator<<(ostream& out, Data& ob);//友元函数，经常与运算符重载搭配使用
private:
	int a;
	int b;
public:
	Data()
	{
		cout << "无参的构造函数" << endl;
		a = 0;
		b = 0;
	}
	Data(int a, int b) :a(a), b(b)
	{
		cout << "有参构造" << endl;
		//this‐>a = a;
			//this‐>b = b;
	}
	void showData(void)
	{
		cout << "a = " << a << ", b= " << b << endl;
	}
	~Data()
	{
		cout << "析构函数函数" << endl;
	}
};

ostream& operator<<(ostream& out, Data& ob)
 {
	 out << "a = " << ob.a << ", b = " << ob.b;
	 return out;
 }

        解释：

        为了简化类中访问私有数据较为困难的问题，运用友元函数（下小点会提到）同重载运算符的结合，得以运用我们较为常用的<<直接输出数据。

可重载的运算符有哪些？ 

        几乎 C 中所有的运算符都可以重载， 但运算符重载的使用时相当受限制的。 特别是不能使用 C 中当前没有意义的运算符(例如用**求幂)不能改变运算符优先级， 不能改变运算符的参数个数。 这样的限制有意义， 否则， 所有这些行为产生的运算符只会混淆而不是澄清寓语意。

        一张图囊括~ 

二、前置知识-友元函数 

 什么是友元函数？

一句话概括：C++允许 友元 访问 私有数据。

 友元函数的语法

friend+定义的函数

      注意：  friend关键字只出现在声明处 其他类、类成员函数、全局函数都可声明为友元 友元函数不是类的成员，不带this指针 友元函数可访问对象任意成员属性，包括私有属性。

        栗子： （创建一个房间类，你只准许你的朋友进入你的卧室，但是客厅是谁都可以进的）

class Room
	 {
	 //将goodGayVisit作为类的友元函数
		 //goodGayVisit 访问 类中所有数据 但是 它不是类的成员
		 friend void goodGayVisit(Room & room);
 private:
	 string bedRoom;//卧室
 public:
	 string sittingRoom;//客厅
 public: 
	 Room()
	 {
	 this-> bedRoom = "卧室";
	 this-> sittingRoom = "客厅";
	 }
	};

 // 普通全局函数 作为 类的友元
 //好基友 访问 我的房间
 void goodGayVisit(Room & room)
 {
	 cout << "好基友访问了你的" << room.sittingRoom << endl;
	 cout << "好基友访问了你的" << room.bedRoom << endl;//ok
	 }
 void test01()
 {
	 Room myRoom;
	 goodGayVisit(myRoom);
}

        friend在这里可以访问对象任意成员属性，包括私有属性。因此，本来不能访问的私有数据，在friend的情况下就可以访问了！结果如下：

        此为普通全局函数 作为 类的友元 。当然，也有类的某个成员函数 作为 另一个类的友元；一个类整体 作为 另一个类的友元等等。

        而我们的友元函数大多应用在重载运算符上！

         本文仅仅对友元函数做简单介绍，如果大家需要详解，请在评论区或者私信踢我一脚o(╯□╰)o，作者肯定会出一篇的！

 三、运算符重载

运算符重载的语法

（根据自身改变的返回类型）operator + 重载的运算符（根据实际情况改变的传参）

  1. 函数声明：运算符重载是通过在类中定义特殊的成员函数来实现的。这些成员函数被称为运算符重载函数。例如，如果要重载"+"运算符，则需要在类中声明一个名为"operator+"的函数。

  2. 函数名：运算符重载函数的命名规则是以"operator"关键字开始，后面跟着要重载的运算符符号。例如，要重载"+“运算符，函数名应为"operator+”。

  3. 参数列表：运算符重载函数的参数列表取决于所重载的运算符。例如，对于二元运算符如"+", “-”, “*”, “/“等，参数列表应包含一个额外的参数，表示右操作数。对于一元运算符如”++”, "– – "等，参数列表不需要额外的参数。

  4. 返回类型：运算符重载函数的返回类型取决于所重载的运算符。例如，对于"+"运算符，返回类型通常是所操作对象的类型。

  5. 成员函数或友元函数：运算符重载函数可以作为类的成员函数或友元函数来定义。成员函数形式的运算符重载函数将使用对象本身作为左操作数，而友元函数形式的运算符重载函数将不使用任何对象。

一步一步带你实现运算符重载（以<<为例）

        注意：此代码未能实现重载 下文为对用cout来输出类的一个引入

#define _CRT_SECURE_NO_WARNINGS 01
#include <iostream>
#include<string.h>
 using namespace std;
 class Person
 {
 private:
	 char* name;
	 int num;
 public:
	 Person(char* name, int num)
		 {
		 this-> name = new char[strlen(name) + 1];
		 strcpy(this-> name, name);
		 this-> num = num;
		 cout << "有参构造" << endl;
		 }
	 //普通的成员函数
		 void printPerson(void)
		 {
		 cout << "name = " << name << ", num = " << num << endl;
		 }
	 ~Person()
		 {
		 if (this-> name != NULL)
			 {
			 delete[] this-> name;
			 this-> name = NULL;
			 }
		 cout << "析构函数" << endl;
		 }
	 };
 int main(int argc, char* argv[])
 {
	 char arr[] = "lucy";
	 Person ob1(arr, 18);
	 //普通的成员函数 遍历信息
	 //ob1.printPerson();
		
	 //cout默认输出方式 无法识别 自定义对象 输出格式
	cout<<ob1<<endl;//err
	return 0;
 }

        运行改代码，我们发现编译器报错！如下图：

         这个时候我们就需要对运算符进行重载了！

        那么问题又来了？如何重载运算符呢？根据上文所提到的语法，我们做出以下的操作：

        运用operator来重载<<运算符

 ostream& operator<<(ostream& out, Person& ob)//out=cout, ob =ob1
	  {
	  //重新实现 输出格式
		  out << ob.name << ", " << ob.num;
		  //每次执行为 返回值得到cout
		  return out;
	  }

        注意：ostream为cout的类型，定义ostream&为返回类型是为了作为起到链接的效果，如:

cout<<ob1<<ob2<<endl;ostream&返回out，然后再次被后面所调用，一直反复调用下去。

        然而，进行了运算符重载，就能实现我们想要的效果了吗？答案是不能，见下图：

         造成这样的原因是什么呢？还是类的封装问题，私有的数据不能被外界所访问！这时，我们就需要用到友元函数来帮助我们实现了！

         于是，我们将operator<<设置成友元：

#define _CRT_SECURE_NO_WARNINGS 01
#include <iostream>
#include<string.h>
 using namespace std;
 class Person
 {
	 //设置成友元函数 在函数内 访问Person类中的所有数据
	  friend ostream & operator<<(ostream & out, Person & ob);
 private:
	 char* name;
	 int num;
 public:
	 Person(char* name, int num)
		 {
		 this-> name = new char[strlen(name) + 1];
		 strcpy(this-> name, name);
		 this-> num = num;
		 cout << "有参构造" << endl;
		 }
	 //普通的成员函数
		 void printPerson(void)
		 {
		 cout << "name = " << name << ", num = " << num << endl;
		 }
	 ~Person()
		 {
		 if (this-> name != NULL)
			 {
			 delete[] this-> name;
			 this-> name = NULL;
			 }
		 cout << "析构函数" << endl;
		 }
	 };
 ostream& operator<<(ostream& out, Person& ob)//out=cout, ob =ob1
	  {
	  //重新实现 输出格式
		  out << ob.name << ", " << ob.num;
		  //每次执行为 返回值得到cout
		  return out;
	  }
 int main(int argc, char* argv[])
 {
	 char arr[] = "lucy";
	 Person ob1(arr, 18);
	 //普通的成员函数 遍历信息
	 //ob1.printPerson();
		
	 //cout默认输出方式 无法识别 自定义对象 输出格式
	cout<<ob1<<endl;//err
	return 0;
 }

        实现效果如下：

运算符重载作为成员函数以及全局函数的实现（以+为例）

全局函数

        这里同上面的栗子大致一样，不过多叙述

#include <iostream>
 #include<string.h>
 using namespace std;
 class Person
 {
	 //设置成友元函数 在函数内 访问Person类中的所有数据
	 friend ostream & operator<<(ostream & out, Person & ob);
	 friend Person operator+(Person & ob1, Person & ob2);
 private:
	 char* name;
	 int num;
 public:
	 Person(){
		 this-> name = NULL;
		 this-> num = 0;
		 cout << "无参构造" << endl;
		 }
	 Person(char* name, int num)
		 {
		 this-> name = new char[strlen(name) + 1];
		 strcpy(this-> name, name);
		 this-> num = num;
		 cout << "有参构造" << endl;
		 }
	 //普通的成员函数
		 void printPerson(void)
		 {
		 cout << "name = " << name << ", num = " << num << endl;
		 }
	 ~Person()
		 {
		 if (this-> name != NULL)
			 {
			 delete[] this-> name;
			 this-> name = NULL;
			 }
		 cout << "析构函数" << endl;
		 }
	 };

 //全局函数作为友元 完成运算符重载<<
 ostream & operator<<(ostream & out, Person & ob)//out=cout, ob =ob1
 {
	 //重新实现 输出格式
		 out << ob.name << ", " << ob.num;
	
		 //每次执行为 返回值得到cout
		 return out;
	 }
 //全局函数作为友元 完成运算符重载+
 Person operator+(Person & ob1, Person & ob2)//ob1 ob2
 { //name+name(字符串追加)
 char* tmp_name = new char[strlen(ob1.name) + strlen(ob2.name) + 1];
 strcpy(tmp_name, ob1.name);
 strcat(tmp_name, ob2.name);

 //num+num（数值相加）
 int tmp_num = ob1.num + ob2.num;
 Person tmp(tmp_name, tmp_num);

 //释放tmp_name的空间
 if (tmp_name != NULL)
 {
	 delete[] tmp_name;
	 tmp_name = NULL;
	 }

 return tmp;
 }


 void test02()
 {
	 char arr[] = "lucy";
	 Person ob1(arr, 18);  
	 char arr2[] = "bob";
	 Person ob2(arr2, 19);
	
		 cout << ob1 << endl;
		cout << ob2 << endl;
	 //Person ob3 = operator+(ob1,ob2);
		 Person ob3 = ob1 + ob2;
	 cout << ob3 << endl;
	 }
 int main(int argc, char* argv[])
 {
	 test02();
	 return 0;
 }

成员函数

#include <iostream>
 #include<string.h>
 using namespace std;
 class Person
 { //设置成友元函数 在函数内 访问Person类中的所有数据
 friend ostream & operator<<(ostream & out, Person & ob);
 private:
	 char* name;
	 int num;
 public:
	 Person()
		 {
		 this-> name = NULL;
		 this-> num = 0;
		 cout << "无参构造" << endl;
		 }
	 Person(char* name, int num)
		 {
		 this-> name = new char[strlen(name) + 1];
		 strcpy(this-> name, name);
		 this-> num = num;
		 cout << "有参构造" << endl;
		 }
	 //成员函数 完成运算符重载 ob1用this代替 ob2用参数ob代替
		 Person operator+(Person & ob)
		 {
		 //this ==> &ob1
			
			 //name+name(字符串追加)
		 char* tmp_name = new char[strlen(this-> name) + strlen(ob.name) + 1];
		 strcpy(tmp_name, this-> name);
		 strcat(tmp_name, ob.name);
		
			 //num+num（数值相加）
		 int tmp_num = this-> num + ob.num;
		 Person tmp(tmp_name, tmp_num);
		
			 //释放tmp_name的空间
			 if (tmp_name != NULL)
			 {
			 delete[] tmp_name;
			 tmp_name = NULL;
			 }
		 return tmp;
		 }
	
		 //普通的成员函数
		 void printPerson(void)
		 {
		 cout << "name = " << name << ", num = " << num << endl;
		 }
	 ~Person()
		 {
		 if (this-> name != NULL)
			 {
			 delete[] this-> name;
			 this-> name = NULL;
			 }
		 cout << "析构函数" << endl;
		 }
	 };

 //全局函数作为友元 完成运算符重载<<
 ostream & operator<<(ostream & out, Person & ob)//out=cout, ob =ob1
 {
	 //重新实现 输出格式
		 out << ob.name << ", " << ob.num;
	
		 //每次执行为 返回值得到cout
		 return out;
	 }

 void test03()
 {
	 char arr[] = "lucy";
	 char arr2[] = "bob";
	 Person ob1(arr, 18);
	 Person ob2(arr2, 19);
	
		 //Person ob3 = ob1.operator+(ob2);
		 Person ob3 = ob1 + ob2;
	 cout << ob3 << endl;
	 }

 int main(int argc, char* argv[])
 { test03();

 return 0;
 }

        在运算符重载运算符时，如果我们以成员函数的方式定义，则可以直接访问类中的数据，无需再使用友元函数来定义。因此我们在重载运算符时最好是以成员函数的方式重载！

四、++和--运算符重载 （重要、常用）

        不知道大家有没有一个疑惑如果我们实现前置+ +、后置+ +以及前置- -、后置--，运用operator时如何区分他们呢？

        此时，我们又要提到一个概念，当编译器看到++a(前置++)，它就调用operator++(a),当编译器看到a++（后置++），它就会去调用operator++(a,int)。 - -也是同样的道理，具体实现如下：

具体实现用例 

#include <iostream>

using namespace std;
 class Data
 {
	 friend ostream & operator<<(ostream & out, Data & ob);
 private:
	 int a;
	 int b;
 public:
	Data()
		 {
		 cout << "无参的构造函数" << endl;
		 a = 0;
		 b = 0;
		 }
	 Data(int a, int b) :a(a), b(b)
		 {
		 cout << "有参构造" << endl;
		 //this‐>a = a;
			 //this‐>b = b;
			 }
	 void showData(void)
		 {
		 cout << "a = " << a << ", b= " << b << endl;
		 }
	 ~Data()
		 {
		 cout << "析构函数函数" << endl;
		 }
	
		 //成员函数 重载前置++ ++ob1 (先加 后使用)
		 //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator++()
		 Data & operator++()//++ob1
		 { //先加
		 a++;//this‐>a = this‐>a +1
	 b++;//this‐>b = this‐>b +1
	 //后使用
		 return *this;
	 }
	 //成员函数 重载后置++ ob1++ (先使用 后加)
		 //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator ++(int)
		 Data & operator++(int)//ob1++
		 {
		 //先使用(备份加之前的值)
			 static Data old = *this;
		
			 //后加
			a++;
			b++;
		
			 //返回备份值
			 return old;
		 }
	
		 //重载前置‐‐ ‐‐ob3
		 //编译器 默认识别 operator++(a) //但是a可以用this代替 从而化简 operator‐‐()
		 Data & operator--()
		 {
		 //先减
			a--;
			b--;
		
			 //后使用(返回)
			 return *this;
		 }
	
		 //重载后‐‐ ob4‐‐
		 //编译器 默认识别 operator++(a,int) //但是a可以用this代替 从而化简 operator++(int)
		 Data & operator--(int)
		 {
		 //先使用
			 static Data old = *this;
			 //再减
			a--;
			b--;
		
			 return old;
		 }
	
		
		 };
 //普通全局函数 作为类的友元 重载<<运算符
 ostream & operator<<(ostream & out, Data & ob)
 {
	 out << "a = " << ob.a << ", b = " << ob.b;
	 return out;
	 }
 void test01()
 {
	 Data ob1(10, 20);
	 ob1.showData();
	
		 //重载<<直接输出自定义对象的值
		 //operator<<(cout,ob1);
		 cout << ob1 << endl;
	
		 //成员函数 重载 ++运算符
		 cout << ++ob1 << endl;
	
		 Data ob2(10, 20);
	 cout << ob2++ << endl;
	 cout << ob2 << endl;
	
		 //成员函数 重载 ‐‐运算符
		 Data ob3(10, 20);
	 cout << "ob3 " << ob3 << endl;
	 cout << --ob3 << endl;
	
		 Data ob4(10, 20);
	 cout << "ob4 " << ob4 << endl;
	 cout << ob4-- << endl;
	 cout << "ob4 " << ob4 << endl; 
		
		 }
 int main(int argc, char* argv[])
 {
	 test01();
	 return 0;
 }

        效果如下： 

                感谢你耐心的看到这里ღ( ´･ᴗ･` )比心，如有哪里有错误请踢一脚作者o(╥﹏╥)o！  

                                 

                                                                 给个三连再走嘛~      

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

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Linux 僵死进程

Linux 僵死进程

fork复制进程之后&#xff0c;会产生一个进程叫做子进程&#xff0c;被复制的进程就是父进程。不管父进程先结束&#xff0c;还是子进程先结束&#xff0c;对另外一个进程完全没有影响&#xff0c;父进程和子进程是两个不同的进程。 一、孤儿进程 现在有以下代码&#xff1a;…
阅读更多...
第4章：决策树

第4章：决策树

停止 当前分支样本均为同一类时&#xff0c;变成该类的叶子节点。当前分支类型不同&#xff0c;但是已经没有可以用来分裂的属性时&#xff0c;变成类别样本更多的那个类别的叶子节点。当前分支为空时&#xff0c;变成父节点类别最多的类的叶子节点。 ID3 C4.5 Cart 过拟合 缺…
阅读更多...
TCP服务器—实现数据通信

TCP服务器—实现数据通信

目录 前言 1.接口介绍 2.编写服务器 3.编写客户端 4.编译链接 5.测试 6.总结 前言 今天我们要介绍的是使用TCP协议实现数据通信&#xff0c;相比于之前写的UDP服务器实现数据信&#xff0c;在主体逻辑上并没有差别。客户端向服务器发送信息&#xff0c;服务器接受信息并回…
阅读更多...
时序预测 | MATLAB实现基于CNN-LSTM卷积长短期记忆神经网络的时间序列预测-递归预测未来(多指标评价)

时序预测 | MATLAB实现基于CNN-LSTM卷积长短期记忆神经网络的时间序列预测-递归预测未来(多指标评价)

时序预测 | MATLAB实现基于CNN-LSTM卷积长短期记忆神经网络的时间序列预测-递归预测未来(多指标评价) 目录 时序预测 | MATLAB实现基于CNN-LSTM卷积长短期记忆神经网络的时间序列预测-递归预测未来(多指标评价)预测结果基本介绍程序设计参考资料 预测结果 基本介绍 MATLAB实现基…
阅读更多...
item_get_sales-获取TB商品销量详情

item_get_sales-获取TB商品销量详情

一、接口参数说明&#xff1a; item_get_sales-获取商品销量详情&#xff0c;点击更多API调试&#xff0c;请移步注册API账号点击获取测试key和secret 公共参数 请求地址: https://api-gw.onebound.cn/taobao/item_get_sales 名称类型必须描述keyString是调用key&#xff08…
阅读更多...
vim键盘图

vim键盘图

国外&#xff1a;http://www.viemu.com/a_vi_vim_graphical_cheat_sheet_tutorial.html&#xff0c;原创&#xff0c;有SVG图&#xff0c;有分步骤的图。 国内翻译&#xff1a;[https://blog.csdn.net/qq_41052753/article/details/101031847 有几个配色&#xff0c;很高清&…
阅读更多...
gitee上传一个本地项目到一个空仓库

gitee上传一个本地项目到一个空仓库

gitee上传一个本地项目到一个空仓库 引入 比如&#xff0c;你现在本地下载了一个半成品的框架&#xff0c;现在想要把这个本地项目放到gitee的仓库上&#xff0c;这时就需要我们来做到把这个本地项目上传到gitee上了。 具体步骤 1. 登录码云 地址&#xff1a;https://gite…
阅读更多...
mysql 索引 区分字符大小写

mysql 索引 区分字符大小写

mysql 建立索引&#xff0c;特别是unique索引&#xff0c;是跟字符集、字符排序规则有关的。 对于utf8mb4_0900_ai_ci来说&#xff0c;0900代表Unicode 9.0的规范&#xff0c;ai表示accent insensitivity&#xff0c;也就是“不区分音调”&#xff0c;而ci表示case insensitiv…
阅读更多...
Patch SCN一键解决ORA-600 2662故障---惜分飞

Patch SCN一键解决ORA-600 2662故障---惜分飞

客户强制重启库之后,数据库启动报ORA-600 2037,ORA-745 kcbs_reset_pool/kcbzre1等错误 Wed Aug 09 13:25:38 2023 alter database mount exclusive Successful mount of redo thread 1, with mount id 1672229586 Database mounted in Exclusive Mode Lost write protection d…
阅读更多...
【Docker】Docker network之bridge、host、none、container以及自定义网络的详细讲解

【Docker】Docker network之bridge、host、none、container以及自定义网络的详细讲解

&#x1f680;欢迎来到本文&#x1f680; &#x1f349;个人简介&#xff1a;陈童学哦&#xff0c;目前学习C/C、算法、Python、Java等方向&#xff0c;一个正在慢慢前行的普通人。 &#x1f3c0;系列专栏&#xff1a;陈童学的日记 &#x1f4a1;其他专栏&#xff1a;CSTL&…
阅读更多...
在Orangepi5开发板3588s使用opencv获取摄像头画面

在Orangepi5开发板3588s使用opencv获取摄像头画面

先感谢香橙派群的管理员耐心指导&#xff0c;经过不断的调试修改最后成功通过opencv调用mipi摄像头获取画面 就记录分享一下大概步骤希望大家少踩点坑&#xff01;&#xff01;&#xff01;&#xff01;&#xff01;&#xff01; 我用的固件系统是ubuntu2022.0.4 固件是&#x…
阅读更多...
Cenos7 搭建Minio最新版集群部署服务器(一)

Cenos7 搭建Minio最新版集群部署服务器(一)

------> 道 | 法 | 术 | 器 | 势 <------ 多台服务器间免密登录|免密拷贝 Cenos7 搭建Minio集群部署服务器(一) Cenos7 搭建Minio集群Nginx统一访问入口|反向动态代理(二) Spring Boot 与Minio整合实现文件上传与下载(三) CentOS7的journalctl日志查看方法 …
阅读更多...
ES中倒排索引机制

ES中倒排索引机制

在ES的倒排索引机制中有四个重要的名词&#xff1a;Term、Term Dictionary、Term Index、Posting List。 Term&#xff08;词条&#xff09;&#xff1a;词条是索引里面最小的存储和查询单元。一段文本经过分析器分析以后就会输出一串词条。一般来说英文语境中词条是一个单词&a…
阅读更多...
炒股票怎么加杠杆_融资融券账户怎么开通

炒股票怎么加杠杆_融资融券账户怎么开通

炒股票作为一种投资方式&#xff0c;可以带来不错的回报。然而&#xff0c;对于那些希望以较小的资金获得更高收益的投资者来说&#xff0c;加杠杆炒股票是一个值得考虑的选择。本文将为您介绍加杠杆炒股票的意义&#xff0c;以及如何开通融资融券账户。 加杠杆炒股票的意义&a…
阅读更多...
FFmpeg 硬编码VideoToolBox流程

FFmpeg 硬编码VideoToolBox流程

介绍 FFmpeg已经提供对 VideoToolBox 的编解码支持&#xff1b;主要涉及到的文件有videotoolbox.c、videotoolbox.h、videotoolboxenc.c、ffmepg_videotoolbox.c。在编译 FFmpeg 源码时&#xff0c;想要支持VideoToolBox&#xff0c;在 configure 时&#xff0c;需要–enable-…
阅读更多...
考公-判断推理-逻辑判断-加强类

考公-判断推理-逻辑判断-加强类

论点 论据 削弱 论点 转折之后 例题 例题 例题 例题 搭桥方向&#xff0c;论据推出论点 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题 例题
阅读更多...
SpringCloud实用篇4——MQ RabbitMQ SpringAMQP

SpringCloud实用篇4——MQ RabbitMQ SpringAMQP

目录 1 初识MQ1.1 同步和异步通讯1.1.1 同步通讯1.1.2 异步通讯 1.2 技术对比 2.快速入门2.1 安装RabbitMQ2.1.1 单机部署2.1.2集群部署 2.2 RabbitMQ消息模型2.3.导入Demo工程2.4 入门案例2.4.1 publisher实现2.4.2 consumer实现 3 SpringAMQP3.1 Basic Queue 简单队列模型3.1…
阅读更多...
使用公网访问内网IIS网站服务器【无需公网IP】

使用公网访问内网IIS网站服务器【无需公网IP】

使用公网访问内网IIS网站服务器【无需公网IP】 文章目录 使用公网访问内网IIS网站服务器【无需公网IP】前言1. 注册并安装cpolar2. 创建隧道映射3. 获取公网地址 前言 这里介绍通过内网穿透&#xff0c;实现公网访问内网IIS网站服务器。 都知道&#xff0c;现在基本不会被分配…
阅读更多...
Linux 终端命令之文件浏览(1) cat

Linux 终端命令之文件浏览(1) cat

Linux 文件浏览命令 cat, more, less, head, tail&#xff0c;此五个文件浏览类的命令皆为外部命令。 hannHannYang:~$ which cat /usr/bin/cat hannHannYang:~$ which more /usr/bin/more hannHannYang:~$ which less /usr/bin/less hannHannYang:~$ which head /usr/bin/he…
阅读更多...
如何自学（黑客）网络安全

如何自学（黑客）网络安全

前言&#xff1a; 想自学网络安全&#xff08;黑客技术&#xff09;首先你得了解什么是网络安全&#xff01;什么是黑客&#xff01; 网络安全可以基于攻击和防御视角来分类&#xff0c;我们经常听到的 “红队”、“渗透测试” 等就是研究攻击技术&#xff0c;而“蓝队”、“…
阅读更多...
最新文章

Copyright @ 2022~2023