成长随心记1
1.静态成员函数
1）静态成员函数不可访问非静态的变量 例：int x; static void fan(){int y=x;//错误}
2）可以通过类名访问静态成员函数 例：person：：fan（）；
也可以通过对象名访问静态成员函数 例：person p；p.fan();
3）非静态成员变量占用类的空间，静态成员变量，成员函数不占用类的空间
4）空对象占用内存空间为1，非空为变量所占空间
2，const修饰的成员函数
1) 常函数：在函数（）后面加const
特点：类下的属性不可修改，如果需要修改，需在定义属性时前加mutable
2）常对象只能调用常函数
3，全局函数做友元
1）只需在函数声明处添加friend就能访问类的属性
例：friend void fan(buding& p);//类下的声明
void fan(buding &p) {//全局函数
cout << p.pub;
cout << p.pra;
}
4，类做友元
作用：类中的函数可以访问另一个类下的私有属性
例：class buding{//buding类
public:
friend class person; //让person作为buding的友元，这样person就可以访问buding下的私有属性
buding():setroom("客厅"),baseroom("卧室"){}
private:
string baseroom;
string setroom;
};
class person {
public:
person() {
s = new buding;
}
void vist();
private:
buding* s;
};
void person::vist() {
cout <baseroom <setroom;
}
int main()
{
person gg;
gg.vist();
}
5，成员函数做友元
例：class buding{//buding类
public:
friend void person::vist(); //让person下的vist作为buding的友元，这样vist就可以访问buding下的私有属性
buding():setroom("客厅"),baseroom("卧室"){}
private:
string baseroom;
string setroom;
};
class person {
public:
person() {
s = new buding;
}
void vist();
private:
buding* s;
};
void person::vist() {
cout <baseroom <setroom;
}
int main()
{
person gg;
gg.vist();
}
6，运算符的重载
a）加减的重载：
编译器默认只能做数字或者字符的加减乘除，不能实现复杂的加减，比如一个类加一个类或者一个类加一个整形，所以就有了operator
直接上例子：
class person
{
public:
friend void text(); //全局函数做友元
friend void tmext();
friend person operator-(person& a, person& b);
person operator+(person& p) { // 成员函数加号的重载
person tmp;
tmp.a = p.a + a;
tmp.b = p.b + b;
return tmp;
}
private:
int a;
int b;
};
person operator-(person& a, person& b) { //全局函数减号的重载
person tmp;
tmp.a = a.a - b.a;
tmp.b = a.b - b.b;
return tmp;
}
b）左移运算符的重载
比如我想直接输出一个类即cout<<person,然后打印类下的属性
注意：只能通过全局函数重载左移运算符，因为无法实现cout在左侧
例： class person
{
public:
friend ostream& operator<<(ostream& cout, person& p);
person() :a(10), b(10){}
private:
int a;
int b;
};
ostream& operator<<(ostream& cout, person &p) {//ostream是cout的返回类型
cout << p.a << p.b;
return cout;//为了能连续输出，所以返回类型是ostream
}
c）递增运算符的重载
重载完b）后，不能对类进行递增操作即p++，所以需要对递增运算符也进行重载
例：
class myint
{
public:
friend ostream& operator<<(ostream& cout, myint p);//对左移运算符的重载
myint& operator++() {//前置递增的重载，要对同一份数据相加，所以返回要加&
num++;
return *this;
}
myint operator++(int) {//后置递增的重载（int）是占位参数，用于区分前置和后置，
myint tmp = *this;
num++;
return tmp;
}
myint():num(0){}//构造函数
private:
int num;
};
ostream& operator<<(ostream& cout, myint p) {//对左移运算符的重载
cout << p.num;
return cout;
}
------------------------------------------------------------------------------------------------------------------------------
个人心得：今天的大脑不够活跃啊，感觉重载有点难度，尤其是加了指针的