3-C++：this指针、static关键字、const关键字、友元、运算符重载
目录
1.this指针
指针定义：
链式调用
2.static关键字
static静态局部变量
static静态成员变量
static修饰静态函数
综合练习
3.const关键字
const修饰局部变量
const修饰成员变量
综合练习
const修饰成员函数
const修饰对象
4.友元
友元函数
友元类
练习
5.运算符重载
加号的友元函数重载
加号的成员函数重载
1.this指针
指针定义：
this指针是个特殊的指针，存放的是当前对象的首地址。成员函数中都隐含一个this
因为成员只能有对象来调用。谁调用的函数，this指针就指向哪个对象
#include
using namespace std;
class Test{
public:
//成员函数
void show(){
cout<show();
} 指针：在调用时，编译器会自动用this来调用成员，哪个对象调用成员函数，this指针就指向哪个对象
#include
using namespace std;
class Student{
private:
string name;
public:
Student(string n){
this->name=n;
}
string getName(){
return this->name;
}
};
int main(){
Student s("张三");
cout< 链式调用
返回值是对象引用时，可以返回this，此函数支持链式调用。
#include
using namespace std;
class Value{
private:
int value;
public:
Value(int value){
this->value=value;
}
Value& addValue(int n){
this->value=this->value+n;
return *this; //*this是当前对象
}
void show(){
cout< 2.static关键字
static静态局部变量
static修饰的局部变量，所有这个类的所有对象共享
第一次函数调用的时候，静态局部变量进行初始化，生命周期直到程序结束
#include
using namespace std;
class Test{
public:
void test_static(){
int a = 1; //生命周期就在这个函数
static int static_a=1; //相当于全局变量
++a;
++static_a;
cout< static静态成员变量
static关键字修饰的对象成员
1.在程序运行时创建，在程序结束时销毁
2.必须类中声明，类外初始化
3.类中所以对象共享使用
4.公共权限下的静态成员可以 类：： 的方式访问
#include
using namespace std;
class Test{
public: //private则会报错 不允许类外直接访问 有对象才可以访问
static int a; //类中声明 类外初始化
};
int Test::a=10; //类中声明 类外初始化
int main(){
//static成员在对象未创建时已经存在
cout<a<<" "<<&(t3->a)< static修饰静态函数
特点：
1.和类相关，在对象创建前就可以调用
2.static函数只能访问静态成员，不可以访问非静态成员。。
3.声明和定义分离时，static关键字只需加在声明处
#include
using namespace std;
class Test{
private:
static int a;
int b;//非静态成员
public:
Test(int b){
this->b=b;
}
void show(){
cout< 综合练习
封装一个classroom 属性 长和宽，求出教室的总个数和总面积
#include
using namespace std;
class ClassRoom{
private:
int length;
int width;
static int totalArea;
static int totalNum;
public:
ClassRoom(int length,int width){
this->length=length;
this->width=width;
totalNum++;
totalArea+=length*width;
}
static void static_show(){
cout<<"教室总个数"< 3.const关键字
const修饰局部变量
通常情况下const修饰的局部变量，表示常量的意思，不允许对其修改
//const修饰局部变量，表示常量，不允许修改
#include
using namespace std;
class Test{
public:
void method(const int a){
cout< const修饰成员变量
特点：
常成员变量必须有初始化，在运行时不允许修改
初始化必须通过初始化列表或者直接属性赋值，不能通过构造函数赋值
一般在对象使用过程中，其数据成员不允许修改，可以用const修饰
//const修饰成员变量要初始化，运行不能修改，
//初始化必须通过初始化列表，不能通过构造函数
//数据成员不允许修改，可以用const来修饰
#include
using namespace std;
class Test{
public:
//const int a=20;
Test(int n):a(n){} //初始化列表
//Test(string b,string m,int w){
//brand=b;
// model=m;
//weight=w;
//以上是构造函数
};
int main(){
Test t(10);
cout< 综合练习
封装圆类 属性有半径R 对象使用过程中，pi值应保存不变，所以可以用const修饰
//const修饰成员变量要初始化，运行不能修改，
//初始化必须通过初始化列表，不能通过构造函数
//数据成员不允许修改，可以用const来修饰
#include
using namespace std;
class Circle{
private:
double r;
const double PI;
public:
Circle(double n):r(n),PI(3.14){}
double area(){
return PI*r*r;
}
};
int main(){
Circle c1(10);
cout< const修饰成员函数
目的是为了数据保护，常函数只能访问数据。但是不能进行修改
特点：1.可以访问非const成员变量，但是不能修改
2.不能访问非const函数
#include
using namespace std;
class Test{
private:
int a=10;
public:
void getA(){
++a;
cout< const修饰对象
特点：只允许访问const成员，不允许修改成员变量
#include
using namespace std;
class Test{
private:
int a=10;
public:
void getA(){
++a;
cout< 4.友元
类实现了数据的隐藏与封装，类的数据成员一般定义为私有成员，仅能通过类的成员函数才能读写。如果数据成员定义为公共的，则又破坏了封装性。但是某些情况下，需要频繁读写类的数据成员，特别是在对某些成员函数多次调用时，由于参数传递、类型检查和安全性检查等都需要时间开销，而影响程序的运行效率。
友元主要用于运算符重载
友元函数
友元函数是定义在类外部的函数，需要在类中使用friend关键字说明，友元函数可以访问类中的私有成员。
特点：1.因为是类的外部，不是类的成员，所以里面没有this指针，参数应该是对象的引用
2.不是类中函数，所以不受类中权限修饰符的限制
#include
using namespace std;
class Person{
private:
string ID;
string phoneNum;
public:
Person(string id,string phoneNum){
this->ID=id;
this->phoneNum=phoneNum;
}
friend void test_friend(Person& p);
};
void test_friend(Person& p){
cout< 友元类
当一个类是另一个类的友元类，它就可以访问类中所有成员
#include
using namespace std;
class A{
private:
int value;
public:
A(int n):value(n){}
friend class B; //声明B是A的友元类，B就可以访问A中所有的成语
};
class B{
public:
void testFriendClass(A& class_a){
cout< 练习
Date 日期类 有年，月，日三个属性
Time 时间类 有 时，分，秒 三个属性
Time类作为Data的友元类。可以访问Data的私有成员 。
#include
using namespace std;
class Date{
private:
int year;
int month;
int day;
public:
Date(int y,int m,int d):year(y),month(m),day(d){}
friend class Time;
};
class Time{
private:
int hour;
int minute;
int second;
public:
Time(int h,int m,int s):hour(h),minute(m),second(s){}
void testFriendClass(Date& date){
cout<hour<<":"<minute<<":"<second< 5.运算符重载
在C++中，运算符的操作对象只能是基本数据类型。自定义类型不能直接使用，所有运算重载对已有的运算符赋予多重含义。使同一个运算符作用与不同类型数据做出不同的行为
运算符重载的本质是函数重载，它也是C++多态的一种体现，为用户提供了一个直观的接口，调用运算符操作自定义数据类型其实就是调用运算符函数。
运算符重载增强了C++的可扩充性，使得C++代码更加直观、易读
C++提供的运算符重载机制，重载运算符是具有特殊名字的函数:它们的名字由关键字operator和其后要重载的运算符共同组成。和其他函数一样,重载运算符的函数也包括返回类型、参数列表及函数体
加号的友元函数重载
杂交水稻应用：
Rice operator + (Rice& r1,Rice& r2)
Rice:返回值
operator +:函数名
Rice& r1,Rice& r2：两个对象类型的参数
#include
using namespace std;
class Rice{
private:
int production; //代表产量
int defense; //代表抗性：抗虫 抗倒伏
public:
Rice(int p,int d){ //构造函数
production=p;
defense=d;
}
friend Rice operator +(Rice r1,Rice r2);
void show(){
cout<<"产量："< 加号的成员函数重载
成员函数隐含一个this指针。哪个对象调用函数，this指针指向谁
成员函数 Rice operator +（Rice& r2）
相当于 Rice operator +（Rice *this,Rice& r2）
r1+r2 操作时 this指向r1 第二个参数是r2
#include
using namespace std;
class Rice{
private:
int production; //代表产量
int defense; //代表抗性：抗虫 抗倒伏
public:
Rice(int p,int d){
production=p;
defense=d; //g
}
//friend Rice operator +(Rice r1,Rice r2);
Rice operator +(Rice& r2); //参数可以比友元函数重载少一个，因为隐含一个this指针
void show(){
cout<<"产量："<production+r2.production)/2;
int d=(this->defense+r2.defense)/2;
Rice t(p,d);
return t;
}
int main(){
Rice r1(1000,70);
Rice r2(2000,20);
Rice r3=r1+r2; //Rice r3=r1.operator+(r2);
r3.show();
}