C++数据库访问接口中成员变量的合理放置位置咨询

你遇到的核心矛盾是：遵循基类不存储数据、避免直接暴露成员变量的原则时，基类指针无法访问派生类独有的成员变量（如liteSQL的dbName），导致编译报错。以下是几种符合C++设计原则的解决方案：

方案1：给基类添加抽象配置接口 #

基类只定义行为契约，派生类实现自身的配置逻辑，既符合基类无数据的原则，又能通过统一接口操作派生类的状态。

修改后的代码示例：

#include <boost/core/noncopyable.hpp>
#include <postgresql/libpq-fe.h>
#include <sqlite3.h> 
#include <iostream>
#include <string>
#include <stdexcept>

class db_interface : boost::noncopyable{
public:
    void connect() const { connect_to_DB(); }
    virtual ~db_interface(){};
    // 定义抽象配置接口，适配不同数据库的配置需求
    virtual void set_config(const std::string& key, const std::string& value) = 0;
    virtual std::string get_config(const std::string& key) const = 0;

private:
    virtual void connect_to_DB() const = 0;
};

class postgreSQL : public db_interface{
private:
    void connect_to_DB() const { std::cout << "THIS IS POSTGRESQL" << std::endl; }
    // PostgreSQL无需dbName，按需求实现配置接口
    void set_config(const std::string&, const std::string&) override {
        throw std::invalid_argument("PostgreSQL doesn't support this config item");
    }
    std::string get_config(const std::string&) const override {
        throw std::logic_error("PostgreSQL has no such config item");
    }
};

class liteSQL : public db_interface{
private:
    std::string dbName; // 成员变量私有化，通过接口访问
    void connect_to_DB() const { 
        std::cout << "CONNECTING TO LIGHTSQL: " << dbName << std::endl; 
    }
public:
    void set_config(const std::string& key, const std::string& value) override {
        if(key == "dbName") dbName = value;
        else throw std::invalid_argument("Unknown config item for LiteSQL");
    }
    std::string get_config(const std::string& key) const override {
        if(key == "dbName") return dbName;
        else throw std::invalid_argument("Unknown config item for LiteSQL");
    }
};

class DBFactory {
public:
    virtual db_interface *createDB(std::string) = 0;
};

class Factory: public DBFactory {
public:
    db_interface *createDB(std::string type) {
        if(type == "LiteSQL") {
            return new liteSQL;
        }
        else if(type == "PostgreSQL") {
            return new postgreSQL;
        }
        return nullptr; 
    }
};

// 使用示例
int main() {
    Factory factory;
    db_interface* db = factory.createDB("LiteSQL");
    db->set_config("dbName", "test.db");
    db->connect();
    delete db;

    db = factory.createDB("PostgreSQL");
    try {
        db->set_config("dbName", "ignored");
    } catch(const std::exception& e) {
        std::cerr << e.what() << std::endl;
    }
    db->connect();
    delete db;
    return 0;
}

方案2：安全类型转换（谨慎使用） #

如果必须直接访问派生类成员，可通过dynamic_cast做安全类型判断，仅在确认类型后访问：

// 使用示例片段
int main() {
    Factory factory;
    db_interface* db = factory.createDB("LiteSQL");
    // 安全转换为LiteSQL类型后访问成员
    if(auto lite_db = dynamic_cast<liteSQL*>(db)) {
        lite_db->dbName = "test.db";
    }
    db->connect();
    delete db;
    return 0;
}

注意：该方式破坏封装性与接口隔离原则，仅适合临时场景，不推荐作为常规方案。

方案3：拆分接口（接口隔离原则） #

将共性行为与特性行为拆分为不同接口，让需要特定配置的派生类继承对应接口：

// 新增特性接口
class NamedDBInterface : public db_interface {
public:
    virtual void set_db_name(const std::string& name) = 0;
    virtual std::string get_db_name() const = 0;
};

// LiteSQL继承特性接口
class liteSQL : public NamedDBInterface {
private:
    std::string dbName;
    void connect_to_DB() const override {
        std::cout << "CONNECTING TO LIGHTSQL: " << dbName << std::endl;
    }
public:
    void set_db_name(const std::string& name) override { dbName = name; }
    std::string get_db_name() const override { return dbName; }
};

// 使用示例片段
int main() {
    Factory factory;
    db_interface* db = factory.createDB("LiteSQL");
    if(auto named_db = dynamic_cast<NamedDBInterface*>(db)) {
        named_db->set_db_name("test.db");
    }
    db->connect();
    delete db;
    return 0;
}

这种方式更灵活，符合接口隔离原则，避免基类承担不必要的契约。

核心原则回顾：基类不存储数据是为了遵循单一职责与面向接口编程，让基类仅定义行为契约；避免直接暴露成员变量是为了封装，而非禁止使用成员变量，而是通过接口操作状态，兼顾封装性与统一调用逻辑。

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