4

再会，

考虑以下代码，是否可以将原型 OOP 归类为

C++？

#include <iostream>

template< class... Bases >
struct TestClass : public Bases...
{
    int a;
    template< class... Parents >
    TestClass< Parents... >* Create() {
        return new TestClass< Parents... >();
    }
    TestClass< Bases... >* Create() {
        return new TestClass< Bases... >();
    }
};
struct Foo {
    int fizz;
};
struct Bar {
    int buzz;
};
int main()
{
    TestClass< Foo > a;
    a.a = 10;
    a.fizz = 20;
    std::cerr << a.fizz << "\n";
    std::cerr << a.a << "\n";
    auto b = a.Create();
    b->fizz = 30;
    std::cerr << b->fizz << "\n";
    auto c = b->Create< Bar >();
    c->buzz = 357;
    std::cerr << c->buzz << "\n";
    auto d = b->Create< Foo, Bar >();
    d->fizz = 0;
    d->buzz = 1;
    std::cerr << d->fizz << "\n";
    std::cerr << d->buzz << "\n";
    return 0;
}

仅供参考，我忘了管理我的记忆，对不起！

4

2 回答 2

3

不，我不这么认为。“原型”和“经典”OO 之间的主要区别在于原型 OO 没有类：原型本身就是一个对象。如果原型被修改，所有从它“继承”的对象都会效仿。在此示例中，情况并非如此。

于 2013-03-01T23:13:28.017 回答
2

我不禁注意到很多困惑。

  1. 成员函数模板“创建”实际上并没有

    • 与 TestClass 实例有任何关系（应该是静态的）
    • 与包含 TestClass 的模板参数有任何关系（应该是命名空间函数，而不是类模板的成员）

  2. 非泛型Create方法应使用“注入”类型名称，而不是不必要地拼写模板参数

  3. 没有多态使用，所以不要不必要的动态分配或原始指针（这也解决了内存清理的问题）

  4. 次要问题：尝试在示例中使用较少混淆的名称和格式

这是我的等价物：

template< class... Bases >
struct TestClass : public Bases... {
    int testfield;
    TestClass Create() {
        return TestClass();
    }
};

template< class... Parents >
static TestClass< Parents... > CreateTestClass() {
    return TestClass<Parents... >();
}

struct Fizzer {
    int fizz;
};
struct Buzzer {
    int buzz;
};
int main()
{
    TestClass< Fizzer > fizzer;
    fizzer.testfield = 10;
    fizzer.fizz = 20;

    auto b = fizzer.Create();
    b.fizz = 30;

    auto c = CreateTestClass< Buzzer >();
    c.buzz = 357;

    auto d = CreateTestClass< Fizzer, Buzzer >();
    d.fizz = 0;
    d.buzz = 1;
}

而且，不，我不认为这段代码是“惯用的”。我还没有看到它（尽管它可能类似于一个类似元组的类的简单实现。无论如何，这不是惯用的：惯用的是不编写这样的类，而是编写 std::tuple （boost 有几种口味扩展名）

于 2013-03-01T23:33:48.247 回答