C++基础语法核心技术详解 - 详解

课时01：从C到C++的华丽转身，掌握现代编程语言的基石
日期：2025年10月2日
难度：⭐⭐☆☆☆ | 时长：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. 指针与引用深度解析

底层原理对比

核心特性对比

特性	指针	引用
本质	存储地址的变量	变量的别名
初始化	可以不初始化	必须初始化
重新指向	可以重新赋值	不能重新绑定
空值	可以为nullptr	不能为空
内存占用	占用额外内存	不占用额外内存
运算	支持指针运算	不支持运算

实际应用场景

指针的优势场景：

// 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关键字
├─ 静态局部变量
│ ├─ 生命周期：程序结束
│ └─ 作用域：函数内部
├─ 静态全局变量
│ ├─ 生命周期：程序结束
│ └─ 作用域：当前文件
└─ 静态类成员
├─ 静态数据成员
└─ 静态成员函数

静态局部变量

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++的面向对象编程，包括类与对象、继承、多态等高级特性。