文章目录
- 1.友元函数
- 1.1友元函数
- 1.2友元类
- 2内部类
- 3.匿名对象
- 4.拷贝对象的一些编译器优化
- 5.static成员
1.友元函数
我们在类外面去访问类里的私有成员，就要突破类的访问限定因此就有了友元，它提供了一种突破封装的方式，但是友元会增加耦合度，破坏了封装，所以应该谨慎使用。友元分为：友元函数和友元类
1.1友元函数
例如：
重载operator<<，发现没办法将operator<<重载成成员函数。因为cout的输出流对象和隐含的this指针在抢占第一个参数的位置。this指针默认是第一个参数也就是左操作数了。但是实际使用中cout需要是第一个形参对象，才能正常使用。所以要将operator<<重载成全局函数。但又会导致类外没办法访问成员，此时就需要友元来解决。operator>>同上
用法：
友元函数可以直接访问类的私有成员，定义在类外部的普通函数，不属于任何类，但需要在类的内部声明，声明时需要加friend关键字。
class Date
{
friend ostream& operator<<(ostream& _cout, const Date& d);//这里是声明，类里面任何位置都可以
friend istream& operator>>(istream& _cin, Date& d);
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
private:
int _year;
int _month;
int _day;
};
ostream& operator<<(ostream& _cout, const Date& d)//友元函数就能访问类的成员
{
_cout << d._year << "-" << d._month << "-" << d._day;
return _cout;
}
istream& operator>>(istream& _cin, Date& d)
{
_cin >> d._year;
_cin >> d._month;
_cin >> d._day;
return _cin;
}
int main()
{
Date d;
cin >> d;
cout << d << endl;
return 0;
}
说明
友元函数可访问类的私有和保护成员，但不是类的成员函数
友元函数不能用const修饰
友元函数可以在类定义的任何地方声明，不受类访问限定符限制
一个函数可以是多个类的友元函数
友元函数的调用与普通函数的调用原理相同
1.2友元类
友元类与友元函数用法类似，友元类的所有成员函数都可以是另一个类的友元函数，都可以访问另一个类中的非公有成员。
class Time
{
friend class Date; // 声明日期类为时间类的友元类，则在日期类中就直接访问Time类中的私有成员变量
public:
Time(int hour = 0, int minute = 0, int second = 0)
: _hour(hour)
, _minute(minute)
, _second(second)
{}
private:
int _hour;
int _minute;
int _second;
};
class Date
{
public:
Date(int year = 1900, int month = 1, int day = 1)
: _year(year)
, _month(month)
, _day(day)
{}
void SetTimeOfDate(int hour, int minute, int second)
{
// 直接访问时间类私有的成员变量
_t._hour = hour;
_t._minute = minute;
_t._second = second;
}
private:
int _year;
int _month;
int _day;
Time _t;
};
注意：
友元关系是单向的，不具有交换性。
友元关系不能传递
2内部类
定义：一个类定义在另一个类的内部，这个内部类就叫做内部类。内部类是一个独立的类，它不属于外部类，更不能通过外部类的对象去访问内部类的成员。外部类对内部类没有任何优越的访问权限。
class A
{
public:
class B // 内部类 B天生就是A的友元 其他人看不见，计算A类时不会计算B
{
public:
void ci(const A& a)
{
cout << k << endl;//OK
cout << a.h << endl;//OK
}
};
private:
static int k;
int h;
};
int A::k = 1;
int main()
{
A::B b;
b.ci(A());
return 0;
}
注意：
1.部类可以定义在外部类的public、protected、private都是可以的，但内部类也是分共有和私有，当为私有内部类时，外部无法访问。
2.注意内部类可以直接访问外部类中的static成员，不需要外部类的对象/类名
3. 在计算类的大小时sizeof(外部类)=外部类，和内部类没有任何关系，不会讲内部类一起计算
4. 内部类时外部类的天生友元，所以成员一般定义在外部类，这样内部类和外部类都可访问。
3.匿名对象
匿名对象与有名对象的区别就是没有名字，且生命周期不同
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
return n;
}
};
int main()
{
//有名对象 生命周期在函数局部域
A aa1();//这样才正确
//没有对象名直接调用为 匿名对象
A();// 但是他的生命周期只有这一行，运行时可以看到下一行他就会自动调用析构函数
Solution a1;
a1.Sum_Solution(10);
//Solution.Sum_Solution(12);//不能这么定义对象，因为编译器无法识别下面是一个函数声明，还是对象定义因此要加括号()
Solution().Sum_Solution(12); //匿名对象的使用
return 0;
}
注意：
在对匿名对象进行引用时是否会报错
沿用上段代码再看
A& BB= A(12);//是否能引用成功？
当我们运行时可以发现不行
因为匿名对象具有常性，因此想要引用成功需要加上const来保证常性。
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
class Solution {
public:
int Sum_Solution(int n) {
return n;
}
};
int main()
{
const A& BB = A(12);//加上const后此时匿名对象的生命周期延长了（如果不延长会出现野引用），生命周期在当前函数局部域
A();
return 0;
}
运行结果可以看到，匿名对象建立后出了此行后就调用析构函数，而const修饰的在函数结束时才调用析构函数
4.拷贝对象的一些编译器优化
在平时传参和传返回值时，编译器一般会做一些优化来减少对象的拷贝，从而提升效率。
例如：
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
A f1()
{
A aa;//构造
return aa;//返回aa进行拷贝构造讲拷贝的返回去
}
int main()
{
A rr1 = f1();
cout << "_______________" << endl;
A rr2;
rr2 = f1();
return 0;
}
我们可以看到rr1与rr2作用类似，但是编译器会对rr1有优化
因此我们在写代码时可以将一些步骤写到一步，让编译器自动去优化。分开写编译器不能进行有效判断
下面是一些简单的优化
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
A& operator=(const A& aa)
{
cout << "A& operator=(const A& aa)" << endl;
if (this != &aa)
{
_a = aa._a;
}
return *this;
}
~A()
{
cout << "~A()" << endl;
}
private:
int _a;
};
void func(A center)
{
}
A f1()
{
A aa;//构造
return aa;//返回aa进行拷贝构造讲拷贝的返回去
}
int main()
{
A rr1 = f1();
cout << "_______________" << endl;
A rr2;
rr2 = f1();
A rr3;
func(rr3);//不会进行优化
func(A (1));//利用了匿名对象 由构造+拷贝构造变为构造
func(1);//利用隐式类型转换 由构造+拷贝构造变为构造
return 0;
}
5.static成员
定义：声明为static的类成员称为类的静态成员，用static修饰的成员变量，称之为静态成员变量；用
static修饰的成员函数，称之为静态成员函数。静态成员变量一定要在类外进行初始化
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
static int _ss;
private:
int _a;
//static int _ss;//只是声明 私有的
};
int A::_ss = 0;//对静态成员变量进行定义
int main()
{
//cout << A::_ss << endl;//此时_ss为私有的受访问限制不能打印，属于每个类的私有
cout << A::_ss << endl;//此时就能打印出来
return 0;
}
可以看到此时并不能打印_ss因为是类私有的，放入public是可以
当然想访问静态成员变量还可以用静态成员函数来实现，因为静态成员函数没有this只能访问静态成员
class A
{
public:
A(int a = 0)
:_a(a)
{
cout << "A(int a)" << endl;
}
A(const A& aa)
:_a(aa._a)
{
cout << "A(const A& aa)" << endl;
}
~A()
{
cout << "~A()" << endl;
}
static int get_static_ss()//没有this指针不能访问对象的成员只能访问静态成员
{
return _ss;
}
private:
int _a;
static int _ss; //不能给缺省值因为静态成员变量没有初始化列表，
};
int A::_ss = 10;//对静态成员变量进行定义
int main()
{
cout << A::get_static_ss() << endl;
A arr;
cout << arr.get_static_ss() << endl;//这样也可以访问
return 0;
}
此时就可以访问静态成员了，所以静态成员函数时配合静态成员变量进行使用的，这样可以对全局的进行封装可以防止被修改
特性：
- 静态成员为所有类对象所共享，不属于某个具体的对象，存放在静态区，且只创建一次
- 静态成员变量必须在类外定义，定义时不添加static关键字，类中只是声明
- 类静态成员即可用 类名::静态成员 或者 对象.静态成员 来访问
- 静态成员函数没有隐藏的this指针，不能访问任何非静态成员
- 静态成员也是类的成员，受public、protected、private 访问限定符的限制
