【学习笔记】C++基础语法核心技术详解

📝 说明：本文为学习笔记，AI辅助整理。目的是系统梳理C++基础语法核心知识，方便复习和查阅。
课时01：从C到C++的华丽转身，掌握现代编程语言的基石
日期：2025年9月26日
难度：⭐⭐☆☆☆ | 时长：2小时 | 类型：基础必修

🎯 学习目标

通过本课时的学习，你将掌握：

• C++与C语言的本质区别和优势
• 指针与引用的深层原理和使用场景
• const和static关键字的多种用法
• 现代C++的基本语法特性
• 面试中的高频考点和标准回答

📚 核心知识体系

🔍 1. C++与C语言的本质区别

🎯 语言特性对比

💡 核心差异解析

1. 编程范式

// C语言：面向过程
struct Student {
    char name[50];
    int age;
};

void printStudent(struct Student* s) {
    printf("Name: %s, Age: %d\n", s->name, s->age);
}

// C++：面向对象
class Student {
private:
    string name;
    int age;
public:
    Student(const string& n, int a) : name(n), age(a) {}
    void print() const {
        cout << "Name: " << name << ", Age: " << age << endl;
    }
};

2. 内存管理

// C语言：手动管理
int* data = (int*)malloc(10 * sizeof(int));
// ... 使用数据
free(data);  // 必须手动释放

// C++：自动管理（RAII）
vector<int> data(10);  // 自动分配
// 作用域结束时自动释放，无需手动free

3. 类型安全

// C语言：类型检查较弱
void* ptr = malloc(sizeof(int));
char* str = (char*)ptr;  // 危险的强制转换

// C++：类型检查严格
unique_ptr<int> ptr = make_unique<int>(42);
// char* str = ptr;  // 编译错误，类型不匹配

🎯 面试重点

面试官： “C++相比C语言有什么优势？”

标准回答： “C++在C语言基础上增加了面向对象编程、泛型编程、RAII内存管理等特性。主要优势包括：更好的代码组织（类和对象）、更安全的内存管理（智能指针）、更强的类型安全、丰富的标准库（STL）等。这使得C++在大型项目开发中更加高效和安全。”

🔍 2. 指针与引用深度解析

🎯 底层原理对比

💡 核心特性对比

🔧 实际应用场景

指针的优势场景：

// 1. 动态内存分配
int* createArray(int size) {
    return new int[size];  // 动态分配
}

// 2. 可选参数（可为nullptr）
void processData(int* optionalData = nullptr) {
    if (optionalData != nullptr) {
        // 处理数据
    }
}

// 3. 指向不同对象
int a = 10, b = 20;
int* ptr = &a;  // 指向a
ptr = &b;       // 重新指向b

引用的优势场景：

// 1. 函数参数（避免拷贝）
void swap(int& a, int& b) {  // 引用参数，直接操作原变量
    int temp = a;
    a = b;
    b = temp;
}

// 2. 函数返回值（链式调用）
class MyClass {
public:
    MyClass& setValue(int val) {
        value = val;
        return *this;  // 返回自身引用
    }
private:
    int value;
};

// 使用：obj.setValue(10).setValue(20);

// 3. 容器元素访问
vector<int> vec = {1, 2, 3};
int& first = vec[0];  // 引用第一个元素
first = 100;          // 直接修改容器中的值

🎯 面试经典题目

题目1：指针和引用的区别

void demo() {
    int a = 10;
    int b = 20;
    
    // 指针可以重新指向
    int* ptr = &a;
    cout << *ptr << endl;  // 输出：10
    ptr = &b;
    cout << *ptr << endl;  // 输出：20
    
    // 引用不能重新绑定
    int& ref = a;
    cout << ref << endl;   // 输出：10
    // ref = b;            // 这是赋值，不是重新绑定
    // int& ref2 = b;      // 错误：ref已经绑定到a
}

题目2：引用作为函数参数

// 值传递：会拷贝参数
void funcByValue(int x) {
    x = 100;  // 只修改副本
}

// 引用传递：直接操作原变量
void funcByReference(int& x) {
    x = 100;  // 修改原变量
}

// 指针传递：传递地址
void funcByPointer(int* x) {
    *x = 100;  // 通过地址修改原变量
}

void test() {
    int num = 10;
    
    funcByValue(num);     // num仍为10
    funcByReference(num); // num变为100
    funcByPointer(&num);  // num变为100
}

🔍 3. const关键字的多重用法

🎯 const修饰的不同位置

💡 const指针的四种形式

// 1. 普通指针（都可以修改）
int a = 10, b = 20;
int* ptr1 = &a;
*ptr1 = 15;    // ✅ 可以修改指向的值
ptr1 = &b;     // ✅ 可以修改指针本身

// 2. 指向常量的指针（值不能改，指针能改）
const int* ptr2 = &a;
// *ptr2 = 15; // ❌ 不能修改指向的值
ptr2 = &b;     // ✅ 可以修改指针本身

// 3. 常量指针（值能改，指针不能改）
int* const ptr3 = &a;
*ptr3 = 15;    // ✅ 可以修改指向的值
// ptr3 = &b;  // ❌ 不能修改指针本身

// 4. 指向常量的常量指针（都不能改）
const int* const ptr4 = &a;
// *ptr4 = 15; // ❌ 不能修改指向的值
// ptr4 = &b;  // ❌ 不能修改指针本身

🔧 const在类中的应用

class Rectangle {
private:
    double width, height;
    const int id;  // 常量数据成员，必须在初始化列表中初始化
    
public:
    // 构造函数初始化列表
    Rectangle(double w, double h, int i) : width(w), height(h), id(i) {}
    
    // 常量成员函数：不修改对象状态
    double getArea() const {
        return width * height;  // ✅ 可以读取成员变量
        // width = 10;          // ❌ 不能修改成员变量
    }
    
    // 非常量成员函数
    void setWidth(double w) {
        width = w;  // ✅ 可以修改成员变量
    }
    
    // const对象只能调用const成员函数
    int getId() const { return id; }
};

void demo() {
    Rectangle rect(10, 5, 1001);
    cout << rect.getArea() << endl;  // ✅ 非const对象调用const函数
    rect.setWidth(15);               // ✅ 非const对象调用非const函数
    
    const Rectangle constRect(20, 10, 1002);
    cout << constRect.getArea() << endl;  // ✅ const对象调用const函数
    // constRect.setWidth(25);            // ❌ const对象不能调用非const函数
}

🔍 4. static关键字的多重含义

🎯 static的三种用法

+-------------------------+
|      static关键字       |
+------------+-----------+
             |
     +-------+-------+
     |               |
+----+----+    +-----+-----+
|静态局部变量|  |静态全局变量|
+----+----+    +-----+-----+
     |               |
+----+----+    +-----+-----+
|生命周期：  |  |生命周期：   |
|程序结束    |  |程序结束     |
+----+----+    +-----+-----+
     |               |
+----+----+    +-----+-----+
|作用域：    |  |作用域：     |
|函数内部    |  |当前文件     |
+-----------+ +-----------+

+-------------------------+
|      static关键字       |
+------------+-----------+
             |
     +-------+-------+
     |               |
+----+----+    +-----+-----+
|静态类成员|    |           |
+----+----+    |           |
     |         |           |
+----+----+    |           |
|静态数据成员|  |静态成员函数|
+-----------+ +-----------+

💡 静态局部变量

void countCalls() {
    static int count = 0;  // 静态局部变量，只初始化一次
    count++;
    cout << "函数被调用了 " << count << " 次" << endl;
}

void demo() {
    countCalls();  // 输出：函数被调用了 1 次
    countCalls();  // 输出：函数被调用了 2 次
    countCalls();  // 输出：函数被调用了 3 次
    // count变量在函数调用结束后仍然保持其值
}

🔧 静态类成员

class Student {
private:
    string name;
    int age;
    static int totalCount;  // 静态数据成员声明
    
public:
    Student(const string& n, int a) : name(n), age(a) {
        totalCount++;  // 每创建一个对象，计数器增加
    }
    
    ~Student() {
        totalCount--;  // 对象销毁时，计数器减少
    }
    
    // 静态成员函数：不属于任何对象，只能访问静态成员
    static int getTotalCount() {
        return totalCount;
        // return name;  // ❌ 错误：不能访问非静态成员
    }
    
    // 非静态成员函数：可以访问所有成员
    void printInfo() {
        cout << "姓名：" << name << "，年龄：" << age << endl;
        cout << "总学生数：" << totalCount << endl;  // ✅ 可以访问静态成员
    }
};

// 静态数据成员定义（必须在类外定义）
int Student::totalCount = 0;

void demo() {
    cout << "初始学生数：" << Student::getTotalCount() << endl;  // 0
    
    Student s1("张三", 20);
    Student s2("李四", 21);
    cout << "当前学生数：" << Student::getTotalCount() << endl;  // 2
    
    {
        Student s3("王五", 22);
        cout << "当前学生数：" << Student::getTotalCount() << endl;  // 3
    }  // s3超出作用域，自动销毁
    
    cout << "当前学生数：" << Student::getTotalCount() << endl;  // 2
}

🎯 面试高频考点总结

🔥 必考题目及标准回答

1. C++相比C语言的优势？

"C++在C语言基础上增加了面向对象、泛型编程、RAII等特性。
主要优势：更好的代码封装和复用、更安全的内存管理、
更强的类型检查、丰富的标准库。适合大型项目开发。"

2. 指针和引用的区别？

"指针是存储地址的变量，可以重新赋值、可以为空、支持运算；
引用是变量的别名，必须初始化、不能重新绑定、不能为空。
选择依据：需要重新指向或可选参数用指针，
函数参数和返回值优先用引用。"

3. const关键字的作用？

"const用于声明常量，保证数据不被修改。
主要用法：常量变量、常量指针、常量成员函数。
好处：提高代码安全性、编译器优化、接口设计更清晰。"

4. static关键字的用法？

"static有三种用法：静态局部变量（函数内保持状态）、
静态全局变量（限制文件作用域）、静态类成员（属于类而非对象）。
常用于单例模式、计数器、工具函数等场景。"

🚀 实战练习建议

📝 基础练习

1. 实现一个简单的字符串类，包含构造、析构、拷贝
2. 编写函数，分别使用指针和引用交换两个变量
3. 设计一个计数器类，使用static统计对象数量

🎯 进阶练习

1. 实现一个智能指针的简化版本
2. 设计一个配置类，使用static和const确保全局唯一
3. 编写模板函数，体验泛型编程

🎉 课时总结

通过本课时的学习，我们深入理解了C++的基础语法特性：

• ✅ 掌握了C++相对于C语言的核心优势
• ✅ 理解了指针与引用的本质区别和使用场景
• ✅ 学会了const关键字的多种用法
• ✅ 掌握了static关键字在不同场景下的含义
• ✅ 具备了面试中的核心知识点和回答技巧

下一课时，我们将学习C++的面向对象编程，包括类与对象、继承、多态等高级特性。