#include <iostream> #include <fstream> #include <string> #include <vector> using namespace std; // 定义城市数据的结构体 struct CityData { int cityIndex; // 城市序号 string cityName; // 城市名称 double gdp; // 城市GDP总量 int population; // 城市常驻人口数 }; int main() { vector<CityData> cityDataList; // 存储城市数据的向量 // 打开文件 ifstream inputFile("gdp_data.txt"); if (!inputFile) { cout << "无法打开文件 gdp_data.txt" << endl; return 1; } // 读取文件数据并存储到结构体中 int cityIndex; string cityName; double gdp; int population; while (inputFile >> cityIndex >> cityName >> gdp >> population) { // 创建一个 CityData 结构体对象来存储当前行的数据 CityData cityData; // 将读取到的数据赋值给结构体的相应成员变量 cityData.cityIndex = cityIndex; cityData.cityName = cityName; cityData.gdp = gdp; cityData.population = population; // 将当前行的数据结构体添加到向量中 cityDataList.push_back(cityData); } // 关闭文件 inputFile.close(); // 输出城市数据 for (const auto& cityData : cityDataList) { cout << "城市序号: " << cityData.cityIndex << endl; cout << "城市名称: " << cityData.cityName << endl; cout << "城市GDP总量: " << cityData.gdp << endl; cout << "城市常驻人口数: " << cityData.population << endl; cout << "-----------------------------" << endl; } return 0; }解释这段代码的原理

这是一段C++程序的头文件部分，包含了一些标准库的头文件，具体介绍如下： 1. iostream：提供了输入输出流的基本功能，如cin、cout等。 2. fstream：提供了文件操作相关的功能，如读写文件等。 3. vector：提供了可变大小数组的功能，可以方便地进行动态管理。 4. string：提供了字符串相关的功能，如字符串的拼接、截取等。 其中，using namespace std; 表示使用标准命名空间，可以简化程序中的代码。

可以使用裸指针和自定义容器实现这段代码。 首先，我们需要定义一个自定义容器来存储T类型的指针。这个容器可以使用动态数组实现，需要自己管理内存。下面是一个简单的实现： ```c++ class MyVector { public: MyVector() : size_(0), capacity_(0), data_(nullptr) {} ~MyVector() { clear(); delete[] data_; } void push_back(T* ptr) { if (size_ == capacity_) { reserve(capacity_ == 0 ? 1 : capacity_ * 2); } data_[size_++] = ptr; } void pop_back() { if (size_ > 0) { --size_; } } T* back() const { return size_ > 0 ? data_[size_ - 1] : nullptr; } bool empty() const { return size_ == 0; } void clear() { for (int i = 0; i < size_; ++i) { delete data_[i]; } size_ = 0; } private: void reserve(int new_capacity) { T** new_data = new T*[new_capacity]; for (int i = 0; i < size_; ++i) { new_data[i] = data_[i]; } delete[] data_; data_ = new_data; capacity_ = new_capacity; } int size_; int capacity_; T** data_; }; ``` 接下来，我们需要定义一个栈，用来存储T类型的指针。这个栈可以使用动态数组实现，也需要自己管理内存。栈的基本操作包括push、pop、top等，可以按照以下方式实现： ```c++ class MyStack { public: MyStack() : size_(0), capacity_(0), data_(nullptr) {} ~MyStack() { clear(); delete[] data_; } void push(T* ptr) { if (size_ == capacity_) { reserve(capacity_ == 0 ? 1 : capacity_ * 2); } data_[size_++] = ptr; } void pop() { if (size_ > 0) { --size_; } } T* top() const { return size_ > 0 ? data_[size_ - 1] : nullptr; } bool empty() const { return size_ == 0; } void clear() { for (int i = 0; i < size_; ++i) { delete data_[i]; } size_ = 0; } private: void reserve(int new_capacity) { T** new_data = new T*[new_capacity]; for (int i = 0; i < size_; ++i) { new_data[i] = data_[i]; } delete[] data_; data_ = new_data; capacity_ = new_capacity; } int size_; int capacity_; T** data_; }; ``` 最后，我们可以定义一个派生自T的类，来实现isOperator()函数。这个函数在子类中可以根据实际需求来具体实现。 ```c++ class MyT : public T { public: bool isOperator() override { // 实现具体的逻辑 return false; } }; ``` 这样，就可以在不使用STL容器的前提下实现这个代码了。完整代码如下： ```c++ #include <iostream> using namespace std; class T { public: virtual bool isOperator() = 0; virtual ~T() {} }; class MyT : public T { public: bool isOperator() override { // 实现具体的逻辑 return false; } }; class MyVector { public: MyVector() : size_(0), capacity_(0), data_(nullptr) {} ~MyVector() { clear(); delete[] data_; } void push_back(T* ptr) { if (size_ == capacity_) { reserve(capacity_ == 0 ? 1 : capacity_ * 2); } data_[size_++] = ptr; } void pop_back() { if (size_ > 0) { --size_; } } T* back() const { return size_ > 0 ? data_[size_ - 1] : nullptr; } bool empty() const { return size_ == 0; } void clear() { for (int i = 0; i < size_; ++i) { delete data_[i]; } size_ = 0; } private: void reserve(int new_capacity) { T** new_data = new T*[new_capacity]; for (int i = 0; i < size_; ++i) { new_data[i] = data_[i]; } delete[] data_; data_ = new_data; capacity_ = new_capacity; } int size_; int capacity_; T** data_; }; class MyStack { public: MyStack() : size_(0), capacity_(0), data_(nullptr) {} ~MyStack() { clear(); delete[] data_; } void push(T* ptr) { if (size_ == capacity_) { reserve(capacity_ == 0 ? 1 : capacity_ * 2); } data_[size_++] = ptr; } void pop() { if (size_ > 0) { --size_; } } T* top() const { return size_ > 0 ? data_[size_ - 1] : nullptr; } bool empty() const { return size_ == 0; } void clear() { for (int i = 0; i < size_; ++i) { delete data_[i]; } size_ = 0; } private: void reserve(int new_capacity) { T** new_data = new T*[new_capacity]; for (int i = 0; i < size_; ++i) { new_data[i] = data_[i]; } delete[] data_; data_ = new_data; capacity_ = new_capacity; } int size_; int capacity_; T** data_; }; int main() { MyVector vec; vec.push_back(new MyT()); vec.clear(); MyStack stk; stk.push(new MyT()); stk.clear(); return 0; } ```