深入自动驾驶应用过程中的OOP细节

class LidarFrame {
public:
    // 1. 默认/参数构造
    LidarFrame(int id, size_t capacity) : id_(id), points_(capacity, Point3D{0,0,0}) {}

    // 2. 拷贝构造（深拷贝）
    LidarFrame(const LidarFrame& other) 
        : id_(other.id_), points_(other.points_) {
        // 标准库vector已处理深拷贝，若含裸指针/句柄需手动实现
    }

    // 3. 移动构造（C++11，零拷贝转移）
    LidarFrame(LidarFrame&& other) noexcept 
        : id_(std::exchange(other.id_, -1)), 
          points_(std::move(other.points_)) {}

    // 4. 拷贝赋值
    LidarFrame& operator=(const LidarFrame& other) {
        if (this != &other) {
            id_ = other.id_;
            points_ = other.points_;
        }
        return *this;
    }

    // 5. 移动赋值
    LidarFrame& operator=(LidarFrame&& other) noexcept {
        if (this != &other) {
            id_ = std::exchange(other.id_, -1);
            points_ = std::move(other.points_);
        }
        return *this;
    }

    ~LidarFrame() = default; // 若无裸指针/外部资源，依赖编译器即可

private:
    int id_;
    std::vector<Point3D> points_; // 现代C++首选：用RAII容器替代裸数组
};

class Trajectory {
public:
    double GetSpeedAt(double t) const { 
        // 仅读取，可被const对象调用
        return std::sqrt(vx_*vx_ + vy_*vy_); 
    }
    void Smooth(int iterations) {
        // 可修改内部缓存或状态
        cache_valid_ = false; // mutable修饰才可在此修改
    }
private:
    double vx_, vy_;
    mutable std::vector<double> smooth_cache_; // 逻辑const：允许修改缓存
    mutable bool cache_valid_ = false;
};

// C++11 Magic Statics：线程安全的懒加载单例
class ConfigManager {
public:
    static ConfigManager& Instance() {
        static ConfigManager instance; // 首次调用时初始化，线程安全
        return instance;
    }
private:
    ConfigManager() { LoadConfig(); }
    ~ConfigManager() = default;
    ConfigManager(const ConfigManager&) = delete;
};

class Vehicle { public: double mass_; virtual ~Vehicle()=default; };
class Car : public Vehicle { public: int doors_; };
class Truck : public Vehicle { public: double payload_; };

std::vector<Vehicle> fleet; // ❌ 值语义容器
fleet.push_back(Car{1500, 4});      // 切片！doors_丢失
fleet.push_back(Truck{8000, 12.5}); // 切片！payload_丢失

class A { public: int val_; };
class B : virtual public A {}; // 虚继承
class C : virtual public A {};
class D : public B, public C {}; // D 仅含一份 A::val_

class Base {
public:
    virtual void foo() {}
    virtual ~Base() = default;
    int x_;
};
class Derived : public Base {
public:
    void foo() override {}
    double y_;
};

class Sensor {
public:
    virtual void Init() = 0;
    virtual void Process() final; // 禁止子类重写，明确契约边界
};
class Lidar : public Sensor {
    void Init() override {} // 拼写错误编译期捕获
    // void Process() override; // ❌ 编译错误：final不可重写
};

template<typename T>
T clamp(T val, T low, T high) {
    return val < low ? low : (val > high ? high : val);
}

// C++20 之前：SFINAE 晦涩难懂
template<typename T>
auto Process(T&& data) -> std::enable_if_t<has_trajectory_v<T>, void> { ... }

// C++20：Concepts 清晰表达意图
template<std::floating_point T>
T smooth(T value, T window) { /* 仅对浮点类型实例化 */ }

template<typename T>
requires std::same_as<T, LidarPoint> || std::same_as<T, RadarTarget>
void Publish(T&& msg) { /* 仅允许特定消息类型 */ }

// 传统TMP：编译器递归实例化，报错信息恐怖
template<int N> struct Fib { static constexpr int v = Fib<N-1>::v + Fib<N-2>::v; };
template<> struct Fib<0> { static constexpr int v = 0; };

// C++14/17：constexpr 函数，编译器直接求值，支持调试
constexpr int fib(int n) {
    if (n < 2) return n;
    return fib(n-1) + fib(n-2);
}
static_assert(fib(10) == 55); // 编译期断言

std::vector<TrajectoryPoint> traj;
traj.reserve(1000); // ⚠️ 关键！避免动态扩容导致的内存分配与数据拷贝
for(int i=0; i<1000; ++i) traj.push_back(gen_point()); // 零分配

// 传统单线程
std::sort(trajectories.begin(), trajectories.end(), CostComparator{});

// C++17 并行执行策略（利用多核）
#include <execution>
std::sort(std::execution::par_unseq, scores.begin(), scores.end());

auto it = targets.begin();
while (it != targets.end()) {
    if (it->confidence < 0.3) {
        it = targets.erase(it); // erase 返回下一个有效迭代器
    } else {
        ++it;
    }
}

// 1. 状态码/错误码（传统但高效）
enum class Status { OK, SENSOR_TIMEOUT, MAP_LOAD_FAIL };
Status Process(const Data& in, Result& out);

// 2. C++23 std::expected（现代类型安全）
#include <expected>
std::expected<Trajectory, PlanningError> Plan(const Scenario& s) {
    if (!s.is_valid()) return std::unexpected{PlanningError::InvalidState};
    return compute_trajectory(s);
}

// 3. 回调状态机
class Component {
public:
    void Start(Callback on_success, Callback on_failure);
};

// 自定义删除器：管理CUDA内存/ROS节点/文件句柄
struct CUDADeleter {
    void operator()(float* ptr) const { cudaFree(ptr); }
};
std::unique_ptr<float, CUDADeleter> d_ptr(cuda_malloc_array(size));

// 数组特化（C++11起）
std::unique_ptr<TrajectoryPoint[]> traj_buffer(new TrajectoryPoint[1000]);

auto sp = std::make_shared<SensorData>(...);
// 内部结构：
// [ Control Block ]
//   - Strong Ref Count (atomic)
//   - Weak Ref Count (atomic)
//   - Deleter
// [ Object Data ] (可能与Control Block合并分配，若用make_shared)

class Node {
public:
    std::shared_ptr<Node> parent;
    std::weak_ptr<Node> child; // 弱引用，不增加计数
    ~Node() { std::cout << "Destroyed\n"; }
};

auto root = std::make_shared<Node>();
auto leaf = std::make_shared<Node>();
root->child = leaf;
leaf->parent = root; // 若child为shared_ptr → 循环引用，内存泄漏

#pragma once
#include <memory>
#include <vector>
#include <expected> // C++23 或自实现
#include "sensor_data.hpp"

namespace ad_stack {

class PlanningComponent {
public:
    PlanningComponent(const Config& cfg);
    ~PlanningComponent();

    PlanningComponent(const PlanningComponent&) = delete;
    PlanningComponent& operator=(const PlanningComponent&) = delete;
    PlanningComponent(PlanningComponent&&) = default;
    PlanningComponent& operator=(PlanningComponent&&) = default;

    std::expected<Trajectory, PlanningError> Process(
        const Localization& loc, 
        const PerceptionResult& perc);

private:
    struct Impl;
    std::unique_ptr<Impl> pimpl_; // 隐藏算法细节，保证ABI稳定
};

} // namespace ad_stack