c++ - 类与其基类之间有哪些可检测到的差异？

Question

给定以下模板:

template <typename T>
class wrapper : public T {};

Foo 类型的对象之间在界面或行为上有哪些明显差异？和一个 wrapper<Foo> 类型的对象？

我已经知道一个:

• wrapper<Foo>只有空构造函数、复制构造函数和赋值运算符(并且只有当这些操作在 Foo 上有效时它才有)。通过在 wrapper<T> 中使用一组模板化构造函数可以减轻这种差异。将值传递给 T 构造函数。

但我不确定还有哪些其他可检测到的差异，或者是否有隐藏它们的方法。

---

(编辑)具体示例

有些人似乎在询问这个问题的一些背景，所以这里是对我的情况的(稍微简化的)解释。

我经常编写具有可以调整的值以调整系统的精确性能和操作的代码。我希望有一种简单(低代码开销)的方式通过配置文件或用户界面公开这些值。我目前正在编写一个库来允许我这样做。预期的设计允许这样使用:

class ComplexDataProcessor {
    hotvar<int> epochs;
    hotvar<double> learning_rate;
public:
    ComplexDataProcessor():
        epochs("Epochs", 50),
        learning_rate("LearningRate", 0.01)
        {}

    void process_some_data(const Data& data) {
        int n = *epochs;
        double alpha = *learning_rate;
        for (int i = 0; i < n; ++i) {
            // learn some things from the data, with learning rate alpha
        }
    }
};

void two_learners(const DataSource& source) {
    hotobject<ComplexDataProcessor> a("FastLearner");
    hotobject<ComplexDataProcessor> b("SlowLearner");
    while (source.has_data()) {
        a.process_some_data(source.row());
        b.process_some_data(source.row());
        source.next_row();
    }
}

运行时，这将设置或读取以下配置值:

FastLearner.Epochs
FastLearner.LearningRate
SlowLearner.Epochs
SlowLearner.LearningRate

这是编造的代码(碰巧我的用例甚至不是机器学习)，但它展示了设计的几个重要方面。可调整的值都被命名，并且可以组织成一个层次结构。值可以通过几种方法进行分组，但在上面的示例中，我只展示了一种方法:将对象包装在 hotobject<T> 中。类(class)。在实践中，hotobject<T>包装器有一个相当简单的工作——它必须将对象/组名插入线程本地上下文堆栈，然后允许 T要构造的对象(此时 hotvar<T> 值被构造并检查上下文堆栈以查看它们应该在哪个组中)，然后弹出上下文堆栈。

这是按如下方式完成的:

struct hotobject_stack_helper {
    hotobject_stack_helper(const char* name) {
        // push onto the thread-local context stack
    }
};

template <typename T>
struct hotobject : private hotobject_stack_helper, public T {
    hotobject(const char* name):
        hotobject_stack_helper(name) {
        // pop from the context stack
    }
};

据我所知，这种情况下的构造顺序非常明确:

1. hotobject_stack_helper构造(将名称插入上下文堆栈)
2. T已构建——包括构建每个 T的成员(hotvars)
3. 正文 hotobject<T>运行构造函数，弹出上下文堆栈。

所以，我有工作代码来执行此操作。但是还有一个问题，那就是:使用这种结构可能会给自己带来什么问题。这个问题在很大程度上简化为我实际上要问的问题:hotobject 的行为与 T 本身有何不同？

Answer 1

奇怪的问题，因为你应该问关于你的具体用法的问题(“我想做什么，这对我有什么帮助或伤害我”)，但我想一般来说:

wrapper<T>不是 T ，所以:

• 它不能像 T 那样构造. (如您所见。)
• 不能像T那样转换.
• 它无法访问私有(private) T可以访问。

我敢肯定还有更多，但前两个涵盖了很多。