可以使用多态和指针来实现。具体的做法是，将基类的指针作为元素类型存储在 `vector` 的
二维数组中，每个指针指向一个派生类对象，并且在派生类中定义一个虚函数返回该对象所属的派生类信息。这样，就可以通过基类的指针来访问派生类对象，并且可以通过虚函数获取对象的类型信息。
以下是一个示例程序，其中 `A
nimal` 是基类，`Cat`、`Dog`、`Bird`、`Fish` 和 `Insect` 是五个派生类，它们都重载了基类的虚函数 `getClassName()` 来返回自身的类型信息。使用 `vector` 的
二维数组来存储这些对象，并且使用基类的指针来访问对象和获取类型信息。
```cpp
#include <iostream>
#include <vector>
#include <memory>
class A
nimal {
public:
virtu
al std::string getClassName() const {
return "A
nimal";
}
};
class Cat : public A
nimal {
public:
std::string getClassName() const override {
return "Cat";
}
};
class Dog : public A
nimal {
public:
std::string getClassName() const override {
return "Dog";
}
};
class Bird : public A
nimal {
public:
std::string getClassName() const override {
return "Bird";
}
};
class Fish : public A
nimal {
public:
std::string getClassName() const override {
return "Fish";
}
};
class Insect : public A
nimal {
public:
std::string getClassName() const override {
return "Insect";
}
};
int main() {
std::vector<std::vector<std::shared_ptr<A
nimal>>> a
nimals(2, std::vector<std::shared_ptr<A
nimal>>(3));
a
nimals[0][0] = std::make_shared<Cat>();
a
nimals[0][1] = std::make_shared<Dog>();
a
nimals[0][2] = std::make_shared<Bird>();
a
nimals[1][0] = std::make_shared<Fish>();
a
nimals[1][1] = std::make_shared<Insect>();
a
nimals[1][2] = std::make_shared<Cat>();
for (int i = 0; i < a
nimals.size(); ++i) {
for (int j = 0; j < a
nimals[i].size(); ++j) {
std::cout << "A
nimal[" << i << "][" << j << "]: " << a
nimals[i][j]->getClassName() << std::endl;
}
}
return 0;
}
```
该程序定义了一个 `6x2` 的
二维数组，每个元素是一个 `std::shared_ptr<A
nimal>` 类型的指针，指向一个动物对象。使用 `std::make_shared` 函数来创建对象，并且使用 `shared_ptr` 来管理对象的生命周期。在
输出二维数组中的元素时，通过基类的指针来访问对象，并且调用虚函数 `getClassName()` 来获取对象的类型信息，
输出结果如下：
```
A
nimal[0][0]: Cat
A
nimal[0][1]: Dog
A
nimal[0][2]: Bird
A
nimal[1][0]: Fish
A
nimal[1][1]: Insect
A
nimal[1][2]: Cat
```
扫一扫
1937
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
