无法实例化抽象类时，如何调用其中vector的push_back？求指针示例

没问题，我直接给你上具体的代码示例，分两种实用情况：原始指针版本和更安全的智能指针版本，你可以根据需求选择。

核心思路其实很简单：抽象类虽然不能直接实例化，但我们可以通过子类继承抽象类，或者通过抽象类的指针/引用来调用它暴露的public方法，以此来操作内部的vector。把push_back封装成一个公开接口，外部就可以通过这个接口来添加对象了。

1. 原始指针版本（需注意手动内存管理） #

先定义我们要存储的目标类：

#include <vector>
#include <iostream>

// 要存入vector的对象类
class SomeObject {
private:
    int id;
public:
    SomeObject(int id) : id(id) {}
    void showId() const {
        std::cout << "Object ID: " << id << std::endl;
    }
};

然后定义抽象类，里面包含存储指针的vector，以及封装push_back的public方法：

// 抽象类（包含纯虚函数，无法直接实例化）
class AbstractClass {
protected:
    // 存储对象指针的vector
    std::vector<SomeObject*> objList;
public:
    // 封装push_back的接口，外部通过这个方法添加对象
    void addObject(SomeObject* obj) {
        if (obj != nullptr) {
            objList.push_back(obj);
        }
    }

    // 纯虚函数，让这个类成为抽象类
    virtual void abstractMethod() = 0;

    // 可选：遍历vector的方法，方便查看存储的内容
    void printAllObjects() const {
        for (const auto& obj : objList) {
            obj->showId();
        }
    }

    // 虚析构函数，确保子类析构时能正确清理父类资源
    virtual ~AbstractClass() {
        // 手动释放vector里的指针，避免内存泄漏
        for (auto obj : objList) {
            delete obj;
        }
        objList.clear();
    }
};

接下来写继承抽象类的子类（必须实现纯虚函数才能实例化）：

// 抽象类的子类，可正常实例化
class ConcreteClass : public AbstractClass {
public:
    void abstractMethod() override {
        std::cout << "Concrete class implemented abstract method." << std::endl;
    }
};

最后是调用示例：

int main() {
    // 创建子类对象，间接使用抽象类的成员
    ConcreteClass concrete;

    // 通过子类对象调用抽象类的addObject方法
    concrete.addObject(new SomeObject(1));
    concrete.addObject(new SomeObject(2));

    // 打印所有存储的对象
    concrete.printAllObjects();

    // 也可以用抽象类指针指向子类对象来操作
    AbstractClass* absPtr = new ConcreteClass();
    absPtr->addObject(new SomeObject(3));
    absPtr->printAllObjects();

    // 释放指针
    delete absPtr;

    return 0;
}

2. 智能指针版本（推荐，无需手动管理内存） #

如果不想手动处理内存泄漏的风险，推荐用std::unique_ptr或者std::shared_ptr来替代原始指针，RAII机制会自动帮我们释放内存：

修改抽象类里的vector和add方法：

#include <memory> // 包含智能指针头文件

class AbstractClass {
protected:
    // 用unique_ptr存储对象，独占所有权，避免指针悬空
    std::vector<std::unique_ptr<SomeObject>> objList;
public:
    // 传递unique_ptr的所有权给vector
    void addObject(std::unique_ptr<SomeObject> obj) {
        if (obj) {
            objList.push_back(std::move(obj));
        }
    }

    virtual void abstractMethod() = 0;

    void printAllObjects() const {
        for (const auto& obj : objList) {
            obj->showId();
        }
    }

    // 虚析构函数依然需要，但不用手动delete了
    virtual ~AbstractClass() = default;
};

调用的时候这样用：

int main() {
    ConcreteClass concrete;

    // 用make_unique创建对象，转移所有权给addObject
    concrete.addObject(std::make_unique<SomeObject>(1));
    concrete.addObject(std::make_unique<SomeObject>(2));

    concrete.printAllObjects();

    AbstractClass* absPtr = new ConcreteClass();
    absPtr->addObject(std::make_unique<SomeObject>(3));
    absPtr->printAllObjects();

    delete absPtr;

    return 0;
}

关键说明 #

• 抽象类的核心是包含纯虚函数，不能直接实例化，但它的成员变量和方法可以被子类继承，或者通过抽象类的指针/引用来访问（只要这些方法是public的）。
• 把push_back封装成public接口后，外部不需要直接操作vector，符合面向对象的封装原则。
• 智能指针版本更安全，避免了手动管理内存的繁琐和风险，是实际开发中的优先选择。

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