Question

我具有以下内容-简化的C ++ 11代码，用于抽象化从对象存储或文件系统中的读取：

ObjectLikeReader::open是一个虚拟函数，返回一个Handle实现。
Handle::read从基础对象中读取内容。

class Handle {
   public:
    virtual std::string read() = 0;
    virtual ~Handle() = default;
};

class ObjectLikeReader {
   public:
    virtual std::unique_ptr<Handle> open() = 0;
    virtual ~ObjectLikeReader() = default;
};

// Specialization

class FileReader : public ObjectLikeReader {
   public:
    std::unique_ptr<Handle> open() override;

   private:
    class InternalHandle;
};

class FileReader::InternalHandle : public Handle {
   public:
    InternalHandle(){};
    std::string read() override {
        return "hello";
    }
};

std::unique_ptr<Handle> FileReader::open() {
    return std::unique_ptr<Handle>(new InternalHandle());
}

std::string read(ObjectLikeReader* reader) {
    return reader->open()->read();
}

int main() {
    FileReader r;
    std::cout << read(&r) << std::endl;
}

所有调度都是使用虚函数完成的，并且工作得很好。除了在紧密循环中的性能外，还需要查看静态多态性：

#include <iostream>
#include <string>

template <class T>
class Handle {
   public:
    std::string read() {
        return static_cast<T*>(this)->read();
    }

   protected:
    ~Handle() = default;
};

template <class T, class H>
class ObjectLikeReader {
   public:
    Handle<H> open() {
        return static_cast<T*>(this)->open();
    }

   protected:
    ~ObjectLikeReader() = default;
};

// Specialization

class FileReaderHandle : Handle<FileReaderHandle> {
   public:
    FileReaderHandle(){};
    std::string read() {
        return "hello";
    }
};

class FileReader : public ObjectLikeReader<FileReader, FileReaderHandle> {
   public:
    FileReaderHandle open() {
        return FileReaderHandle();
    }
};

int main() {
    FileReader r;
    std::cout << r.open().read() << std::endl;
}

我对这种实现方式不太满意。有没有办法实现与第二个示例相同的功能？：

不需要双重模板参数（可能是特征？不确定...），
理想情况下，不必公开handle类。

谢谢！

编辑：修复了愚蠢的缺少构造函数定义的错误，导致编译错误。

具有依赖内部类的静态多态

0 个答案: