c++语法学习

动态数组（vector）：

vector 是一个能够自动调节大小的动态数组。

普通的 C++ 数组（如 int arr[5]）在定义时必须指定长度，且之后不能更改。而 vector 就像一个"可以伸缩的橡皮筋"，当你往里面添加更多数据时，它会自动向系统申请更多内存来容纳这些数据。

• 头文件 ：使用时需要包含 #include <vector>。

vector<int>& ：

一个指向 int 类型动态数组（vector）的引用

函数参数类型：

情况 A：vector<int> (值传递)

当你调用函数时，计算机会把整个数组复制一份传给函数。

• 缺点：如果数组里有 100 万个坐标点，复制操作会消耗大量的内存和时间（CPU）。

• 结果 ：函数内部对数组的修改不会影响外部原始的数组。

情况 B：vector<int>& (引用传递)

当你调用函数时，不进行任何复制，函数直接操作原始数据。

• 优点 ：极其高效。无论数组多大，传递引用的开销几乎为零（类似于传递一个指针）。

• 结果 ：函数内部对数组的修改会直接改变外部原始的数据。

const vector<int>&：

意义 ：我既想要引用传递 的高效率（不复制），又不希望函数内部修改我的原始数据（只读）。

命名空间：

它就像是一个"文件夹 "或者"作用域容器"，用来对变量、函数、类等名称进行分类和隔离。

命名空间就像是文件的文件夹路径 ：D:/照片/旅游/小明.jpg 和 D:/照片/证件/小明.jpg 虽然文件名都叫"小明"，但因为路径（命名空间）不同，它们是完全不同的文件。

其核心目的只有一个：避免命名冲突（Name Collision）。

---

1. 为什么要使用命名空间？（生活中的类比）

想象一下，你在一家大型公司工作，公司里有两个员工都叫"张伟"。

• 如果你在走廊里大喊一声"张伟！"，两个人都可能会回头，这就是命名冲突。

• 为了区分，你会说"技术部的 张伟"或者"销售部的张伟"。

在这里，"技术部"和"销售部"就是命名空间。它给"张伟"这个名字增加了一个前缀，确保你在调用时知道指向的是哪一个。

---

2. C++ 中的命名空间

在 C++ 中，命名空间的使用非常频繁，最著名的就是 std。

(1) 基本语法

你可以使用 namespace 关键字定义自己的空间：

#include <iostream>

namespace RobotA {
    void move() {
        std::cout << "机器人A正在移动" << std::endl;
    }
}

namespace RobotB {
    void move() {
        std::cout << "机器人B正在全速冲刺" << std::endl;
    }
}

int main() {
    // 使用 作用域解析运算符 :: 来访问
    RobotA::move(); 
    RobotB::move();
    return 0;
}

(2) 什么是 std::？

std 是 Standard（标准） 的缩写。C++ 标准库提供的所有内容（如 vector, cout, string）都放在 std 这个命名空间里。

• 只有写 std::vector，编译器才知道你使用的是标准库提供的那个 vector，而不是你自己定义的一个叫 vector 的变量。

特性	描述
本质	名字的分类容器
核心功能	防止名字相同导致的混乱（冲突）
C++ 访问符	::（双冒号，例如 std::cout）

类：

---

一、 类的基本结构

类使用关键字 class 定义，紧跟着类名和一对大括号。注意：大括号末尾必须有一个分号 ;。

class Robot {
public: // 访问修饰符
    // 成员变量（属性）
    string name;
    int id;

    // 成员函数（行为/方法）
    void move() {
        cout << name << " is moving." << endl;
    }
}; // 必须有分号

• 对象（Object）：类是图纸，对象是根据图纸造出来的实体。

  Robot myRobot; // 这就是实例化了一个对象

---

二、 访问修饰符（Access Modifiers）

这是 C++ 实现"封装"的关键。它决定了类成员对外部代码的可见性。

1. public（公有）：类外部的代码可以直接访问。

2. private（私有） ：默认级别。只能在类内部的成员函数中访问。外部通过"接口"（Getter/Setter）访问。

3. protected（保护）：类内部及派生类（子类）可以访问，外部不可访问。

---

三、 构造函数与析构函数（Lifecycle）

1. 构造函数 (Constructor)

在创建对象时自动调用，用于初始化数据。

• 名字必须与类名完全相同。

• 没有返回类型。

• 可以重载（有多个参数不同的构造函数）。

2. 初始化列表 (Initialization List) ------ C++ 特有且推荐

在构造函数体执行前初始化成员，效率更高。

class Robot {
private:
    int battery;
public:
    // 构造函数使用初始化列表
    Robot(int b) : battery(b) {
        cout << "Robot initialized with " << battery << "% battery." << endl;
    }
};

3. 析构函数 (Destructor)

在对象销毁（生命周期结束）时自动调用，用于清理资源（如释放内存、关闭文件）。

• 名字为 ~类名。

• 无参数，无返回值，不可重载。

---

四、 this 指针

this 是一个隐含在所有非静态成员函数中的指针，它指向当前调用该函数的对象本身。

• 常用于区分成员变量和参数名冲突。

• this->name = name; （左边是类的成员，右边是传入的参数）

---

五、 成员函数的类外定义

为了保持类定义简洁，通常在类内声明，在类外使用作用域解析运算符 :: 定义。

class Robot {
public:
    void stop(); // 声明
};

// 类外定义
void Robot::stop() {
    cout << "Emergency Stop!" << endl;
}

---

六、 静态成员（Static Members）

使用 static 关键字。静态成员属于类本身，而不是某个具体的对象。

1. 静态成员变量：所有对象共享同一个变量副本（必须在类外初始化）。

2. 静态成员函数 ：只能访问静态成员，不能访问普通成员，且没有 this 指针。

class Robot {
public:
    static int robot_count; // 静态变量声明
    Robot() { robot_count++; }
};

int Robot::robot_count = 0; // 类外初始化

---

七、 封装与 Getter/Setter

这是为了保护数据的安全性，防止外部代码胡乱修改。

class Robot {
private:
    double speed; // 私有化，外部不可见
public:
    // Setter：设置值时可以加逻辑判断
    void setSpeed(double s) {
        if(s >= 0) speed = s;
    }
    // Getter：读取值
    double getSpeed() { return speed; }
};

---

八、 常量成员函数（Const Member Functions）

如果一个成员函数保证不修改 类中的任何成员变量，应将其声明为 const。这增加了代码的健壮性。

void showStatus() const {
    // 报错：不能在这里修改成员变量
    // speed = 10; 
    cout << "Battery: " << battery << endl;
}

---

九、 友元（Friend）

friend 关键字允许特定的外部函数或类访问当前类的 private 成员。这打破了封装，应谨慎使用（常用于运算符重载）。

---

总结：C++ 类与 Python 类的语法对比

特性	C++ 类	Python 类
结尾分号	必须有 ;	无
访问控制	严格的 public/private 关键字	靠命名约定（如 _ 或 __）
构造函数	ClassName()	__init__(self)
内存管理	析构函数手动清理/RAII	垃圾回收机制 (GC)
默认访问	private	public