C++ 类中的函数

友元函数

类的访问修饰符

• 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…(); 这类接口函数对类的私有成员进行访问

• 类外访问私有成员用友元函数，类外访问受保护成员用友元函数或子类

常函数

• 常函数可以使用类的数据成员，但不能修改数据成员(这里说的是不能修改类的数据成员，但是常函数可以对在函数体中定义变量和形参进行修改，只是不能修改类的数据成员)

• 构造函数和析构函数不能是常函数

• 常函数的 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;
}

• 类中同时含有同一个函数的 const 和 non-const 版本，普通对象优先调用 non-const 版本，常量对象优先调用 const 版本

class Test {
public:
  Test() : n(2) {
  }

  void show() {
    cout << "non-const: " << n << endl;
  }

  void show() const {
    cout << "const: " << n << endl;
  }

private:
  int n;
};

Test t;
t.show();
const Test ct;
ct.show();

// 运行结果：
// non-const: 2
// const: 2

内联函数

内联函数和常规函数的区别

• 常规函数：调用时根据函数地址跳转到函数代码空间，执行指令，执行结束，再跳转到调用位置，频繁的函数调用(跳转和保护现场)给系统带来了一定的开销

• 内联函数：在函数的声明和定义的位置同时加上 inline ，将函数定义为内联函数，只在声明位置写 inline 是不管用的，在函数编译的时候调用内联函数的位置会被相应的代码替换，运行时就避免了函数调用的跳转和保护现场给系统带来的开销

如何选择是否用内联函数

• 内联函数与常规函数相比，它是用了相应的代码来替换掉调用，也就是每一个调用内联函数的位置都会替换为一段代码，内联函数就被复制了多份，相应的代码量也就增加了，会占用更多的程序代码区的空间，与常规函数相比，内联函数是用空间换时间，如果一个函数代码比较少，流程简单，但是调用频繁，可以考虑使用内联函数

注意

• 内联函数和宏函数有些类似，都是在程序编译的时候进行代码段的替换，但内联函数解决了宏函数的一些缺点，内联函数可以调试，而且内联函数可以作为类的成员函数，访问类的私有成员

• 即使是将函数定义为内联函数，编译器也不一定会将其作为内联函数进行编译，若函数体比较大，或者有递归之类的复杂结构，编译器一般不会将其编译为内联函数，反而对于一些函数体比较小，结构简单，调用频繁的普通函数，编译器可能将其优化为内联函数

• 对于函数体比较大，或者含有递归等复杂结构的函数，一般不能定义为内联函数，即使定义了编译器也不会认的，当做普通函数处理了

• 内联函数可以作为类的成员函数，也可以不作为成员函数单独出现