上一篇介绍了一下类中的构造(构造和拷贝构造)和析构函数，这一篇开始介绍一下类中其他的函数
如有侵权，请联系删除，如有错误，欢迎大家指正，谢谢
0. 友元函数
类的访问修饰符
- private ：私有成员，仅类内可见，类成员默认是私有的
- protected ：受保护的成员，类内和子类可见
- public ：公有成员，对外可见
- 访问修饰符的作用范围是到下个访问修饰符或者到类的结尾
友元函数
- 友元函数(关键字friend)可以访问类的私有成员(private)
- 在类内声明友元函数(可以是主函数也可以是其他函数)，类内的所有成员对友元函数是可见的
- 还可以在类内声明友元类，类内的所有成员对友元类都是可见的
#include <iostream>
using namespace std;
class Test {
public:
Test(int n, double d) :
n(n),
d(d)
{ }
friend int main(); // 声明主函数为友元函数，说到底主函数也是函数
friend int getInt(); // 声明一般函数为友元函数，用法与其他函数一样，只是需要在类内声明一下
friend double getDou(Test t); // 带有形参的友元函数
friend class A; // 类内声明友元类，类内所有成员对友元类都是可见的
protected:
double d;
private:
int n;
};
class A {
public:
void show() {
Test test(2, 5.5);
cout << "class A: " << test.d << " " << test.n << endl;
}
};
int getInt() {
Test test(10, 3.4);
return test.n;
}
double getDou(Test t) {
return t.d;
}
int main() {
Test test(2, 1.2);
cout << "friend main:" << test.d << " " << test.n << endl;
cout << "friend getDou: " << getDou(test) << endl;
cout << "friend getInt: " << getInt() << endl;
A a;
a.show();
system("pause");
return 0;
}
注意
- 类的友元函数不受类的访问修饰符的限制(可以写在 private 的作用范围内,可以写在 protected 的作用范围内,可以写在 public 的作用范围内)
- 友元函数和友元类会破坏类的封装性，通常情况下会定义 Get…(); Set…(); 这类接口函数对类的私有成员进行访问
- 类外访问私有成员用友元函数，类外访问受保护成员用友元函数或子类
1. 常函数
- 常函数可以使用类的数据成员，但不能修改数据成员(这里说的是不能修改类的数据成员，但是常函数可以对在函数体中定义变量和形参进行修改，只是不能修改类的数据成员)
- 构造函数和析构函数不能是常函数
- 常函数的 this 指针是 const CStu*
- 常对象只能调用常函数，不能调用普通函数
#include <iostream>
using namespace std;
class Test {
public:
Test(int n, double d) :
n(n),
d(d)
{ }
void show() {
cout << "show func:" << ++n << endl; // 非 常函数可以正常修改类的数据成员
}
void func1() const {
int i1 = 0;
cout << "const func1: " << ++i1 << endl; // 常函数可以修改函数体内定义的变量
cout << "const func1: " << ++n << endl; // 报错，不可以修改
}
void func2() const;
private:
int n;
double d;
};
void Test::func2() const {
int i2 = 0;
cout << "const func2: " << ++i2 << endl; // 常函数可以修改函数体内定义的变量
cout << "const func2: " << n << endl; // 报错，不可以修改
}
int main() {
Test test(10, 3.4); // 实例化一个普通对象，可以调用常函数和非 常函数
test.show();
test.func1();
test.func2();
const Test t(2, 3.5); // 实例化一个常对象，只能调用常函数
t.show(); // 报错，不能调用非常函数
t.func1();
t.func2();
system("pause");
return 0;
}
2. 内联函数
内联函数和常规函数的区别
- 常规函数：调用时根据函数地址跳转到函数代码空间，执行指令，执行结束，再跳转到调用位置，频繁的函数调用(跳转和保护现场)给系统带来了一定的开销
- 内联函数：在函数的声明和定义的位置同时加上 inline ，将函数定义为内联函数，只在声明位置写 inline 是不管用的，在函数编译的时候调用内联函数的位置会被相应的代码替换，运行时就避免了函数调用的跳转和保护现场给系统带来的开销
如何选择是否用内联函数
- 内联函数与常规函数相比，它是用了相应的代码来替换掉调用，也就是每一个调用内联函数的位置都会替换为一段代码，内联函数就被复制了多份，相应的代码量也就增加了，会占用更多的程序代码区的空间，与常规函数相比，内联函数是用空间换时间，如果一个函数代码比较少，流程简单，但是调用频繁，可以考虑使用内联函数
注意
- 内联函数和宏函数有些类似，都是在程序编译的时候进行代码段的替换，但内联函数解决了宏函数的一些缺点，内联函数可以调试，而且内联函数可以作为类的成员函数，访问类的私有成员
- 即使是将函数定义为内联函数，编译器也不一定会将其作为内联函数进行编译，若函数体比较大，或者有递归之类的复杂结构，编译器一般不会将其编译为内联函数，反而对于一些函数体比较小，结构简单，调用频繁的普通函数，编译器可能将其优化为内联函数
- 对于函数体比较大，或者含有递归等复杂结构的函数，一般不能定义为内联函数，即使定义了编译器也不会认的，当做普通函数处理了
- 内联函数可以作为类的成员函数，也可以不作为成员函数单独出现
