C++ 初学者核心概念与常见误区解析

核心区别：

• 指针声明是 类型* 变量名，引用是 类型& 变量名。
• 指针可以为空（nullptr），引用必须绑定有效变量。
• 指针可以重新指向其他变量，引用一旦绑定则终身指向该变量。

函数重载：C++ 与 C 的区别之一

函数重载允许定义同名函数，只要参数列表（个数、类型、顺序）不同即可。返回值不同不构成重载，这点要记牢。

#include <iostream>
using namespace std;

// 函数重载：同名，参数类型不同
int add(int a, int b) { return a + b; }
double add(double a, double b) { return a + b; }

// 函数重载：同名，参数个数不同
int add(int a, int b, int c) { return a + b + c; }

// 错误示例：仅返回值不同，不构成重载（编译报错）
// double add(int a, int b) { return (double)a + b; }

int main() {
    cout << "int 加法：" << add(10, 20) << endl;       // 调用 int 版本
    cout << "double 加法：" << add(3.14, 2.86) << endl; // 调用 double 版本
    cout << "三数加法：" << add(1, 2, 3) << endl;      // 调用三参数版本
    return 0;
}

编译器逻辑：

• 重载的核心是'参数列表不同'，返回值不参与判断。
• 调用时由编译器根据实参类型/个数自动匹配。
• C 语言不支持函数重载，C++ 通过'名字修饰'实现。

易混淆知识点辨析

1. = 赋值 vs == 相等判断

新手最容易把赋值运算符 = 当成相等判断 ==，导致逻辑永远成立或出错。

#include <iostream>
using namespace std;

int main() {
    int a = 5;

    // 踩坑现场：if 条件中用=（赋值）而非==（判断）
    if (a = 10) { // 实际是把 a 赋值为 10，非 0 值为 true，条件永远成立
        cout << "错误：条件中用了赋值运算符，a=" << a << endl;
    }

    // 正确示范：用==判断相等
    if (a == 10) { // 此时 a 已经被赋值为 10，条件成立
        cout << "正确：条件中用了相等判断，a=" << a << endl;
    }
    return 0;
}

避坑技巧：

• = 是赋值，有返回值；== 是关系运算，返回布尔值。
• 习惯把常量写在左边，如 if (10 == a)，若误写为 if (10 = a) 会直接编译报错。

2. const 常量 vs #define 宏定义

二者都能定义'常量'，但机制完全不同。

#include <iostream>
using namespace std;

// 宏定义：预处理阶段替换，无类型，无作用域
#define PI 3.14
#define MAX(a,b) (a)>(b)?(a):(b)

// const 常量：编译期处理，有类型，有作用域
const double PI_CONST = 3.1415926;
const int MAX_NUM = 100;

int main() {
    // 1. 类型检查差异
    // #define 无类型：PI 可以赋给任意类型变量，无警告
    int pi_int = PI;
    // const 有类型：若类型不匹配，编译器会警告
    // int pi_const = PI_CONST; // 编译器警告：double 转 int 丢失精度

    // 2. 宏替换的坑（文本替换，可能导致非预期结果）
    int a = 3, b = 2;
    int res = MAX(a++, b++); // 展开为 (a++)>(b++)?(a++):(b++)，a 和 b 会被多次自增
    cout << "宏定义 MAX 结果：" << res << "，a=" << a << "，b=" << b << endl;
    // res=4, a=5, b=3

    // 3. const 作用域：仅在当前作用域有效，宏全局有效
    {
        const int local_const = 5;
        cout << "局部 const：" << local_const << endl;
    }
    // cout << local_const; // 编译报错：未定义的标识符
    return 0;
}

建议：

• const 有数据类型，编译器做类型检查，作用域受限，占用内存。
• #define 无数据类型，预处理文本替换，无作用域，不占内存。
• 初学建议优先使用 const 定义常量，避免宏替换带来的隐蔽 Bug。

3. 结构体（struct）vs 类（class）

C++ 中两者都能定义自定义类型，核心区别在于默认访问权限和继承方式。

#include <iostream>
using namespace std;

// struct：默认访问权限 public
struct Student {
    string name; // public
    int age;     // public
    void showInfo() {
        cout << "Struct：姓名=" << name << "，年龄=" << age << endl;
    }
};

// class：默认访问权限 private
class Teacher {
    string name; // private
    int age;     // private
public: // 必须显式声明 public 才能外部访问
    void setInfo(string n, int a) { name = n; age = a; }
    void showInfo() { cout << "Class：姓名=" << name << "，年龄=" << age << endl; }
};

int main() {
    // struct：成员可直接访问
    Student s;
    s.name = "小明";
    s.age = 18;
    s.showInfo();

    // class：private 成员不可直接访问，需通过 public 方法
    Teacher t;
    // t.name = "李老师"; // 编译报错：private 成员不可访问
    t.setInfo("李老师", 35);
    t.showInfo();
    return 0;
}

区分要点：

• 访问权限：struct 默认 public，class 默认 private。
• 继承方式：struct 默认公有继承，class 默认私有继承。
• 用途习惯：struct 多用于单纯的数据聚合，class 多用于封装数据和方法的对象。

总结

这些要点是初学 C++ 的核心，掌握并区分它们能帮你避开 80% 的新手错误。

1. 核心基础：C++ 强类型，变量需声明；指针可空可改向，引用必须初始化且不可改指向。
2. 易混语法：= 是赋值、== 是判断，const 是类型安全常量、#define 是文本替换，函数重载只看参数列表。
3. 核心区别：struct 和 class 的差异主要是默认访问权限，前者 public，后者 private。

把这些基础打牢，后续学习类、继承、多态等进阶内容时会顺畅很多。