C++ 从 0 入门（五）｜C++ 面试必知：静态成员、友元、const 成员（高频考点）

#include <iostream>
using namespace std;

class Student
{
public:
    string name;
    static int count; // 类内声明静态成员变量（统计学生人数）

    // 构造函数：每创建一个对象，count自增
    Student(string n)
    {
        name = n;
        count++;
    }
};

// 类外初始化静态成员变量（必须写，否则报错）
int Student::count = 0;

int main()
{
    Student s1("张三");
    Student s2("李四");
    Student s3("王五");

    // 三种访问方式
    cout << "学生总数（类名访问）：" << Student::count << endl; // 推荐，无需对象
    cout << "学生总数（对象访问）：" << s1.count << endl;
    cout << "学生总数（对象访问）：" << s2.count << endl;

    return 0;
}

输出结果：3 3 3（三个对象共享 count）

面试坑点

静态成员变量 不能在类内初始化（只能声明）；
静态成员变量不占用对象内存（属于类）；
静态成员变量可以是私有（private），此时类外无法直接访问，需通过静态成员函数访问。

3. 静态成员函数（重点）

核心特点（面试必背）

用 static 修饰，属于类，不属于对象，无需实例化即可调用；
只能访问 静态成员变量、静态成员函数，不能访问非静态成员（无 this 指针）；
可通过「类名：：静态成员函数名」直接调用。

代码示例

cpp 复制代码

class Student
{
private:
    static int count; // 私有静态成员变量
public:
    Student() { count++; }

    // 静态成员函数：访问私有静态成员
    static int getCount()
    {
        // 只能访问静态成员，不能访问非静态成员（如name）
        return count;
    }
};

int Student::count = 0;

int main()
{
    // 无需实例化对象，直接调用静态成员函数
    cout << "学生总数：" << Student::getCount() << endl;

    Student s1, s2;
    cout << "学生总数：" << Student::getCount() << endl;
    return 0;
}

面试常问

静态成员函数和非静态成员函数的区别？答：1. 静态成员函数无 this 指针，非静态有；2. 静态只能访问静态成员，非静态可访问所有成员；3. 静态无需对象即可调用，非静态必须通过对象调用。

三、友元（friend，面试常考，理解即可）

1. 核心作用

打破类的封装性，让类外的函数 / 类，可以直接访问类的私有（private）、保护（protected）成员，解决特定场景下的访问问题（如运算符重载）。

2. 友元函数（最常用）

语法与示例

cpp 复制代码

#include <iostream>
using namespace std;

class Person
{
private:
    int age;
    // 声明友元函数：该函数可访问当前类的私有成员
    friend void showAge(Person& p);

public:
    Person(int a) { age = a; }
};

// 友元函数：类外定义，可直接访问Person的私有成员age
void showAge(Person& p)
{
    cout << "年龄：" << p.age << endl; // 直接访问私有成员，合法
}

int main()
{
    Person p(20);
    showAge(p); // 输出20
    return 0;
}

3. 友元类

核心特点

一个类声明为另一个类的友元，那么这个类的所有成员函数，都可以直接访问另一个类的私有 / 保护成员。

语法示例

cpp 复制代码

class A
{
private:
    int num;
    // 声明B为A的友元类
    friend class B;
public:
    A(int n) { num = n; }
};

class B
{
public:
    // B的成员函数，可直接访问A的私有成员
    void show(A& a)
    {
        cout << "A的私有成员：" << a.num << endl;
    }
};

int main()
{
    A a(100);
    B b;
    b.show(a); // 输出100，合法
    return 0;
}

面试坑点

友元关系是 单向的（A 是 B 的友元，不代表 B 是 A 的友元）；
友元关系 不可传递（A 是 B 的友元，B 是 C 的友元，不代表 A 是 C 的友元）；
友元会破坏封装性，尽量少用，面试只需掌握用法和特点即可。

四、const 成员（const 修饰类成员，面试高频）

1. const 成员变量

核心特点（面试必背）

必须在 构造函数初始化列表 中初始化（不能在构造函数体内赋值）；
一旦初始化，不可修改；
属于对象，每个对象有独立的 const 成员变量。

代码示例（面试常考）

cpp 复制代码

#include <iostream>
#include <string>
using namespace std;

class Person
{
public:
    const string name; // const成员变量
    int age;

    // 必须在初始化列表中初始化const成员变量
    Person(string n, int a) : name(n), age(a)
    {
        // name = n; // 错误，不能在构造体内赋值
    }
};

int main()
{
    Person p("张三", 20);
    // p.name = "李四"; // 错误，const成员不可修改
    cout << p.name << " " << p.age << endl;
    return 0;
}

2. const 成员函数

核心特点（面试必背）

函数声明末尾加 const（语法：返回值函数名() const）；
不能修改类的非 const 成员变量（可访问，不可修改）；
不能调用非 const 成员函数（避免间接修改成员变量）；
const 对象，只能调用 const 成员函数。

代码示例

cpp 复制代码

class Person
{
public:
    string name;
    int age;

    Person(string n, int a) : name(n), age(a) {}

    // const成员函数：不能修改非const成员
    void showInfo() const
    {
        cout << name << " " << age << endl;
        // age = 30; // 错误，不能修改非const成员
    }

    // 非const成员函数：可修改成员
    void setAge(int a)
    {
        age = a;
    }
};

int main()
{
    const Person p1("张三", 20); // const对象
    p1.showInfo(); // 合法，const对象可调用const成员函数
    // p1.setAge(25); // 错误，const对象不能调用非const成员函数

    Person p2("李四", 22);
    p2.showInfo(); // 非const对象也可调用const成员函数
    p2.setAge(25); // 合法
    return 0;
}

面试常问

const 成员函数为什么不能修改非 const 成员变量？答：const 成员函数会隐含一个 const this 指针，this 指针指向的对象是只读的，因此不能修改非 const 成员变量。

五、本章核心总结（面试速记）

静态成员：属于类，共享资源，类外初始化，无 this 指针；
友元：打破封装，让类外函数 / 类访问私有成员，单向不可传递；
const 成员变量：构造初始化列表初始化，不可修改；
const 成员函数：末尾加 const，不能修改非 const 成员、不能调用非 const 函数；
这三个知识点是 C++ 基础面试的补充重点，大概率会结合类与对象一起提问。

下期预告

C++ 从 0 入门（六）｜C++ 面试必知：运算符重载、异常处理、动态内存进阶（收官补充）