现在最需要做的两件事,一个是安心等待,一个是 To be a better man(ง •̀_•́)ง
目录
静态成员
静态成员包括静态属性,静态函数,static成员属于类 都是通过类来操作
静态变量
class A
{
public:
static int a; //定义静态成员变量
};
int A::a = 10; //静态成员变量 在类内声明 类外初始化
void test_01()
{
A a;
cout<<a.a<<endl; //利用类对象访问 10
cout<<A::a<<endl; //利用类名访问 10
}
静态函数
成员函数前添加static关键字 变为静态成员函数 静态成员函数属于类 静态成员函数 只能调用静态成员变量。
class A
{
public:
static int a; //静态成员变量
int b;
static void func() //静态成员函数
{
//cout<<b<<endl; //ERROR 静态成员函数只能调用静态成员变量
cout<<a<<endl; //静态成员函数打印静态成员变量
cout<<"静态成员函数"<<endl;
}
};
int A::a = 10;
void test_01()
{
A::func(); //调用静态成员函数
}
const静态变量
静态变量是所有对象共享一个资源 (共享的数据往往使用公共权限)
静态常量则是共享的数据不允许修改 是一份固定且共享的数据
class A
{
public:
const static int a = 10; //静态常量
};
void test_01()
{
cout<<A::a<<endl; //10
}
单例
概述
单例就是静态成员的一个应用场景
概述 每一次创建的类对象都是同一个对象;
好处:节约空间
应用
//单例应用:
class MySingle
{
private: //1.构造函数,拷贝构造私有化
static MySingle *sin; //2.定义静态的属性,外部进行初始化
MySingle()
{}
MySingle(const MySingle &ob)
{}
public:
static MySingle* getSingle() //3.调用静态函数,返回静态对象的值
{
return sin;
}
};
MySingle* MySingle::sin = new MySingle; //外部进行初始化
void test_01()
{
MySingle *s1 = MySingle::getSingle();
MySingle *s2 = MySingle::getSingle();
cout<<s1<<endl; //地址相同
cout<<s2<<endl;
}
内存空间与this(重点)
内存空间
主要分析类中数据是否占用内存空间(占多大空间)
class A
{
public:
};
void test_01()
{
cout<<sizeof(A)<<endl; //1
}
//定义空类 占用一个字节(占位符)
class A
{
public:
func()
{};
};
void test_01()
{
cout<<sizeof(A)<<endl; //1
}
//成员函数不占用空间
class A
{
public:
static int a;
};
void test_01()
{
cout<<sizeof(A)<<endl; //1
}
//静态成员变量不占用空间
class A
{
public:
static func()
{}
};
void test_01()
{
cout<<sizeof(A)<<endl; //1
}
//静态成员函数不占用空间
class A
{
public:
int a;
int b;
};
void test_01()
{
cout<<sizeof(A)<<endl; //8
}
//普通静态成员占用自身大小个字节 int -- 4
成员函数不占用空间
静态成员变量不占用空间
静态成员函数不占用空间
普通静态成员占用自身大小个字节 int -- 4
this应用(重点)
this代表当前对象 表示调用当前成员函数的对象
使用this 不怕类的成员变量和形参出现重名出现二义性现象了
class A
{
public:
int a;
A(int a)
{
this->a = a; //出现重名变量 加上this标记a为类对象成员
} //不添加this的变量 根据就近原则取值
};
void test_01()
{
A a(10);
cout<<a.a<<endl; //10
}
this链式编程(重点)
在引用中,进行链式编程,通过引用对象进行重复调用 有this可省略引用对象传参
class A
{
public:
A& print(char* str)
{
cout<<str<<endl;
return *this;
}
};
void test_01()
{
A a;
a.print("hello").print("world").print("haha");
}
const修饰成员函数
当你不想在成员函数里对变量赋值 可在成员函数后添加const
class A
{
public:
int a;
mutable int b; //添加mutable后 可在const修饰的函数中赋值
void func(int a,int b) const //在函数后添加了const不可在函数内对类成员变量赋值
{
//this->a = a; //error
this->b = b;
}
};
void test_01()
{
A a;
a.func(10,20);
}
友元
成员属性一般是私有的 如果需要特殊规则区域去使用私有成员 则需要设置友元
例如:卧室是私有的 但是特殊人群可以进入 特殊人群设置友元即可
全局友元(重要)
友元的规则设置在全局函数中
class Room
{
friend void showRoom(Room &r); //添加友元
private:
string wosi; //string:c++中的一个字符串类型
public:
string keting;
Room(string keting,string wosi)
{
this->keting = keting;
this->wosi = wosi;
}
};
void showRoom(Room &r)
{
cout<<"访问:"<<r.keting<<" "<<r.wosi<<endl; //使用友元前 error
}
成员友元
class Room;
class goodGay
{
public:
string name;
goodGay(string name)
{
this->name = name;
}
void showRoom(Room &r);
};
class Room
{
friend void goodGay::showRoom(Room &r); //添加类函数为友元
private:
string wosi;
public:
string keting;
Room(string wosi,string keting)
{
this->wosi = wosi;
this->keting = keting;
}
};
void goodGay::showRoom(Room &r)
{
cout<<name<<"正在访问:"<<r.keting<<" "<<r.wosi<<endl;
}
void test_01()
{
Room r("卧室","客厅");
goodGay g("老王");
g.showRoom(r);
}
类友元
与成员友元类似,只需将成员友元注释,编写类友元即可
//friend void GoodGay::showData(Room &room); //GoodGay类的showData函数是友元
friend class GoodGay; //声明友元类 该类中的所有成员函数都可访问Room的私有属性
😀期待点赞订阅😀