C/C++ 基础笔记（十）

本篇核心知识：预处理指令、宏定义、条件编译、文件包含、C++ 面向对象、类与对象、访问权限、成员函数、this 指针、const 成员、头文件管理、内联函数、封装特性

---

一、预处理指令（编译前执行）

概念

预处理指令以#开头，编译前执行，不生成机器码，只做文本替换、文件包含、条件控制。

特性

1. 预处理时机：编译之前，语法检查之前，直接替换文本。

2. 三大核心指令 ：#define、#include、条件编译。

（1）#define 宏定义

概念

用名字替换固定文本，分无参宏 、带参宏，仅替换、无类型、无语法检查。

特性

• 无参宏：

  #define 宏名 替换内容

  • 纯文本替换，末尾不加分号。

  • 可定义常量、关键字、代码片段。

• 带参宏：

  #define 宏名(参数) 表达式

  • 仅替换，不是函数，无类型检查、执行更快。

  • 表达式建议加括号防优先级错误。

• 多行宏 ：末尾用\换行，不可空格。

• 宏 undef ：#undef 宏名 取消宏定义。

代码示例

// 无参宏
#define MAX 100
#define PI 3.14159
#define PRINT_HELLO cout << "Hello\n"
​
// 带参宏（加括号防错）
#define SQR(x) ((x)*(x))
#define MAX2(a,b) ((a)>(b)?(a):(b))
​
// 多行宏
#define PRINT_INFO() \
    cout << "姓名：张三\n"; \
    cout << "年龄：20\n"
​
int main() {
    int a = SQR(5);   // 替换为((5)*(5))
    PRINT_HELLO;
    PRINT_INFO();
    return 0;
}

（2）#include 文件包含

概念

将头文件内容完整复制到当前位置，实现代码复用。

特性

• #include <文件名>：优先查系统库目录，用于系统头文件。

• #include "文件名"：先查当前项目目录，再查系统目录，用于自定义头文件。

• 重复包含问题：同一头文件多次包含会报错，需加保护。

代码示例

// 系统头文件
#include <iostream>
// 自定义头文件
#include "myhead.h"

（3）条件编译

概念

按条件选择性编译代码，常用于调试、版本控制、跨平台、防重复包含。

特性

• #if / #elif / #else / #endif：按常量表达式判断。

• #ifdef：如果宏已定义。

• #ifndef：如果宏未定义。

• #endif ：结束条件块，必须配对。

• 防重复包含：

  #ifndef HEAD_H
  #define HEAD_H
  // 头文件内容
  #endif
  ​
  // 或简化：#pragma once（VS支持）

代码示例

#define DEBUG
// 调试模式输出
#ifdef DEBUG
cout << "调试：变量值=" << 10 << endl;
#else
cout << "发布模式" << endl;
#endif
​
// 版本控制
#define VERSION 2
#if VERSION == 1
cout << "V1.0" << endl;
#elif VERSION == 2
cout << "V2.0" << endl;
#else
cout << "未知版本" << endl;
#endif

拓展：宏与函数区别

• 宏：编译前替换、无类型、速度快、无栈开销、易出错。

• 函数：编译后调用、有类型、有栈开销、安全、可调试。

---

二、C++ 面向对象（OOP）基础

概念

面向对象以类（模板） 和对象（实例） 为核心，将数据和行为封装，模拟现实实体，具备**封装、继承、多态（、抽象）**几大特性。

特性

1. 面向对象 vs 面向过程

   • 面向过程：关注步骤、函数、流程，适合简单程序。

   • 面向对象：关注实体、属性、行为，适合复杂项目、易维护复用。

2. 四大特性

   • 封装：隐藏内部细节，暴露安全接口，保证数据安全。

   • 继承：子类复用父类代码，扩展功能，减少冗余。

   • 多态：同一接口，不同实现，灵活扩展。

   • 抽象：提取核心属性 / 行为，忽略无关细节。

代码示例

// 面向对象：定义人类（类）
class Person {
    // 属性：成员变量（私有）
    char name[20];
    int age;
public:
    // 行为：成员函数（公有）
    void init(const char* n, int a) {
        strcpy(name, n);
        age = a;
    }
    void show() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
    }
};
​
// 创建对象（实例）
int main() {
    Person p1;
    p1.init("张三", 20);
    p1.show();
    return 0;
}

---

三、类的定义与结构

概念

类是自定义复合类型，描述一组对象共同的属性和行为。

特性

1. 类的组成

   • 成员变量（属性）：描述对象状态。

   • 成员函数（行为）：描述对象操作。

   • 访问权限：控制成员访问范围。

2. 定义格式

   class 类名 {
       // 访问权限
       成员变量;
       成员函数声明;
   }; // 末尾必须加分号

3. 对象定义 ：类名 对象名;，分配独立内存。

代码示例

// 类定义
class Student {
private:
    // 私有成员变量
    int id;
    double score;
public:
    // 成员函数声明
    void setInfo(int i, double s);
    void showInfo();
};

// 定义对象
Student s1, s2;

---

四、访问权限控制（封装核心）

概念

控制类成员的可见范围，实现数据隐藏、安全访问。

特性

1. public（公有）：任意位置（类内、外、子类）可访问，用于接口。

2. protected（保护）：类内、子类可访问，外部不可，用于继承。

3. private（私有）：仅类内可访问，外部、子类不可，用于隐藏数据。

4. 默认权限 ：class默认 private，struct默认 public。

代码示例

class Person {
private:
    int age; // 私有：外部不可直接访问
protected:
    char gender; // 保护：子类可访问
public:
    char name; // 公有：任意访问
    void setAge(int a) { age = a; } // 公有接口
};

int main() {
    Person p;
    p.name = "李四"; // 合法（公有）
    // p.age = 25; // 非法（私有）
    p.setAge(25); // 合法（通过接口）
    return 0;
}

拓展：权限设计原则

• 数据成员默认 private，通过 public 接口访问修改，保证数据安全。

---

五、成员函数（定义与实现）

概念

类中描述对象行为的函数，分内部实现 、外部实现。

特性

1. 内部实现 ：直接写在类内，默认内联函数，编译时展开，无调用开销。

2. 外部实现：类内声明、类外定义，需加

   作用域符::，格式：返回值 类名::函数名(参数) { 函数体 }

3. 内联函数 ：inline修饰，空间换时间，适合短小高频函数。

代码示例

class Student {
private:
    int id;
public:
    // 内部实现（默认内联）
    inline void setId(int i) { id = i; }
    // 外部声明
    void showId();
};

// 外部实现（加::）
void Student::showId() {
    cout << "学号：" << id << endl;
}

拓展：内联函数注意

• 禁止递归、复杂循环，编译器可能忽略inline。

---

六、this 指针

概念

类成员函数的隐藏常量指针，指向当前调用对象，区分不同对象成员。

特性

1. 类型 ：类名* const，指向不可改，值可改。

2. 作用：

   • 区分成员变量与局部 / 形参（同名冲突）。

   • 返回当前对象（链式调用）。

3. 使用 ：this->成员名访问成员。

代码示例

class Person {
private:
    int age;
public:
    void setAge(int age) {
        // this->age：成员变量；age：形参
        this->age = age;
    }
    Person& getSelf() {
        return *this; // 返回当前对象
    }
};

拓展：this 不能用于静态成员函数（无对象）

---

七、const 成员（只读保护）

概念

用const修饰成员变量、成员函数、对象，禁止修改，保证数据只读。

特性

1. const 成员变量 ：类内只读，必须初始化（构造函数初始化列表）。

2. const 成员函数：

   • 格式：返回值 函数名() const

   • 禁止修改成员变量，只能调用 const 函数。

3. const 对象 ：const 类名 对象，只能调用 const 成员函数,不可调用非 const 成员函数。

4. 普通对象（无 const） ：既能调用 普通函数，也能调用 const 成员函数，优先调用非 const 版本。

代码示例

class Test {
public:
    int num = 10;

    // const 成员函数
    void show() const {
        cout << "const 函数：" << num << endl;
    }

    // 非 const 成员函数
    void show() {
        cout << "非 const 函数：" << num << endl;
    }
};

int main() {
    // 1. 普通对象（无const）
    Test obj;
    obj.show();   //  调用 非const 函数
    obj.show();   //  也能调用 const 函数（普通对象全能调用）

    // 2. const 对象
    const Test cobj;
    cobj.show();  //  只能调用 const 函数
    //cobj.show();//  不能调用 非const 函数
}

拓展：const 修饰指针 / 引用

• const int*：指向常量，值不可改。

• int* const：指针常量，指向不可改。

---

八、头文件与源文件分离

概念

大型项目中，类声明放.h头文件，实现放.cpp源文件，便于管理、复用、编译。

特性

1. 头文件（.h） ：类声明、函数声明、宏、全局声明，只声明不定义。

2. 源文件（.cpp）：类实现、函数定义、全局定义。

3. 头文件保护 ：防止重复包含，用#ifndef...#endif或#pragma once。

代码示例

// Person.h（头文件）
#pragma once
class Person {
private:
    char name[20];
public:
    void setName(const char* n);
    void showName() const;
};

// Person.cpp（源文件）
#include "Person.h"
#include <cstring>
void Person::setName(const char* n) { // 声明外部实现
    strcpy(name, n);
}
void Person::showName() const {
    cout << "姓名：" << name << endl;
}

// main.cpp
#include "Person.h"
int main() {
    Person p;
    p.setName("XXX");
    p.showName();
    return 0;
}

---

九、结构体 vs 类（对比）

概念

结构体（struct）和类（class）都是复合类型，默认权限不同。

特性

• struct ：默认public，仅数据，早期 C 风格。

• class ：默认private，数据 + 函数，面向对象。

• 本质：C++ 中 struct 可写成员函数，与 class 语法一致。

代码示例

// struct：默认public
struct Stu {
    int id;
    void show() { cout << id; }
};

// class：默认private
class StuC {
    int id;
public:
    void show() { cout << id; }
};