3

给定以下模板：

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

Footype对象和type 对象之间在接口或行为上有哪些明显的差异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>类中。在实践中，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成员（热变量）
  3. hotobject<T>构造函数的主体运行，它弹出上下文堆栈。

所以，我有工作代码来做到这一点。然而，还有一个问题，那就是：通过使用这种结构，我可能会给自己带来什么问题。这个问题很大程度上归结为我实际要问的问题：hotobject 的行为与 T 本身有何不同？

4

4 回答 4

3

奇怪的问题，因为您应该询问有关您的具体用法的问题（“我想做什么，这对我有什么帮助或伤害我”），但我一般认为：

wrapper<T>不是T，所以：

  • 它不能像T. （正如你所注意到的。）
  • 它不能像T.
  • 它失去了对私有T的访问权限。

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

于 2010-08-25T04:51:42.000 回答
2

假设你有：

class Base {};
class Derived : Base {};

现在你可以说：

Base *basePtr = new Derived;

但是，您不能说：

wrapper<Base> *basePtr = new wrapper<Derived>();

也就是说，即使它们的类型参数可能具有继承关系，通过特化模板生成的两种类型也不具有任何继承关系。

于 2010-08-25T05:39:05.700 回答
0

对对象的引用可转换（授予访问权限）为对基类子对象的引用。有语法糖来调用隐式转换，允许您将对象视为基的实例，但这确实是正在发生的事情。不多也不少。

因此，根本不难发现差异。它们（几乎）是完全不同的东西。“is-a”关系和“has-a”关系之间的区别在于指定成员名称。

至于隐藏基类，我认为您无意中回答了自己的问题。通过指定private（或省略publica class）来使用私有继承，并且这些转换不会发生在类本身之外，并且没有其他类能够判断基类甚至存在。

于 2010-08-25T04:51:46.147 回答
0

如果您继承的类有自己的成员变量（或至少一个），那么

sizeof(InheritedClass) > sizeof(BaseClass)
于 2010-08-25T04:53:34.500 回答