能否将指针vector的迭代器按引用传递？路网车辆排序技术问询

当然可以！迭代器本质上是一种类似指针的轻量级对象，不管你的vector里存的是Vehicle*还是其他类型，都完全支持以引用的方式传递给函数。这么做的好处还挺实在的——能避免迭代器拷贝带来的微小开销，尤其是当你处理的vector规模很大时，效率会更优。

举个简单的代码示例：

#include <vector>
#include <iostream>

class Vehicle {};
class Car : public Vehicle {};

// 接收迭代器引用的函数
void processIterator(std::vector<Vehicle*>::iterator& it) {
    // 这里可以对迭代器指向的元素做操作，比如打印地址
    std::cout << "当前元素地址：" << *it << std::endl;
}

int main() {
    std::vector<Vehicle*> vehicles;
    vehicles.push_back(new Car());
    
    auto it = vehicles.begin();
    processIterator(it); // 以引用方式传递迭代器
    
    // 记得释放内存
    delete *it;
    return 0;
}

只要保证传递的迭代器是有效的（比如没有被销毁、没有越界），这种用法完全没问题。

针对你这个动态道路网络建模的需求，咱们一步步来解决：

第一步：实现多态获取行驶距离 #

首先，你需要在父类Vehicle中定义一个纯虚函数来获取行驶距离，让每个子类（Car、Van、Lorry）各自实现这个函数，这样就能通过父类指针调用子类的具体实现，这就是多态的核心优势。

示例代码：

#include <vector>
#include <algorithm>
#include <iostream>

class Vehicle {
public:
    virtual ~Vehicle() = default; // 虚析构函数，避免内存泄漏
    virtual double getTravelDistance() const = 0; // 纯虚函数，子类必须实现
    // 可以添加其他公共属性/方法
};

class Car : public Vehicle {
private:
    double travelDistance; // 子类的行驶距离成员
public:
    Car(double dist) : travelDistance(dist) {}
    double getTravelDistance() const override {
        return travelDistance;
    }
};

class Van : public Vehicle {
private:
    double travelDistance;
public:
    Van(double dist) : travelDistance(dist) {}
    double getTravelDistance() const override {
        return travelDistance;
    }
};

第二步：累加所有车辆的行驶距离 #

遍历存储Vehicle*的vector，调用每个元素的getTravelDistance()方法，累加总和即可：

double calculateTotalDistance(const std::vector<Vehicle*>& vehicles) {
    double total = 0.0;
    for (const auto& vehicle : vehicles) {
        total += vehicle->getTravelDistance();
    }
    return total;
}

第三步：按行驶距离从远到近排序 #

使用标准库的std::sort函数，自定义一个比较器，让它比较两个Vehicle*指向对象的行驶距离，实现降序排序：

void sortVehiclesByDistance(std::vector<Vehicle*>& vehicles) {
    std::sort(vehicles.begin(), vehicles.end(),
        [](const Vehicle* a, const Vehicle* b) {
            // 降序排列：a的距离大于b时返回true
            return a->getTravelDistance() > b->getTravelDistance();
        });
}

完整调用示例 #

int main() {
    std::vector<Vehicle*> vehicles;
    vehicles.push_back(new Car(150.5));
    vehicles.push_back(new Van(220.0));
    vehicles.push_back(new Car(180.0));
    
    // 计算总距离
    double total = calculateTotalDistance(vehicles);
    std::cout << "所有车辆总行驶距离：" << total << "公里" << std::endl;
    
    // 排序
    sortVehiclesByDistance(vehicles);
    std::cout << "排序后车辆的行驶距离：" << std::endl;
    for (const auto& vehicle : vehicles) {
        std::cout << vehicle->getTravelDistance() << "公里" << std::endl;
    }
    
    // 记得释放所有子类对象的内存
    for (auto vehicle : vehicles) {
        delete vehicle;
    }
    vehicles.clear();
    
    return 0;
}

这里要提醒你几个关键点：

• 一定要给父类Vehicle添加虚析构函数，否则删除父类指针时可能无法正确释放子类的内存，导致内存泄漏。
• 如果你的项目规模较大，更推荐使用智能指针（比如std::unique_ptr<Vehicle>）来管理内存，避免手动delete的繁琐和风险。

内容的提问来源于stack exchange，提问作者Squire1998