概览

技术问题是当前的设计似乎需要一个用于 C++ 模板工作类的抽象工厂，据我所知，这是不可能的。因此，我需要一个替代解决方案来防止客户端依赖工作人员的实现细节和来自任何特定客户端环境的工作人员。

设置

我有一个 Worker内部需要容器类的类 C内存加工信息。处理信息组织在 BufferType 中。结构，所以 Worker内部处理类型为 C< BufferType > 的成员.另一方面，我们不想要 Worker的客户了解 Worker::BufferType ，它反射(reflect)了与 API 无关的实现细节 Worker这可能会随着时间而改变。

C 使情况变得复杂是一个抽象类，根据实际环境(例如数据库)具有不同的容器功能实现。显然，我们不想要 Worker要知道这一点，它应该在任何有 C 实现的环境中工作。 .

由于我在编写工厂方面没有那么多经验，所以我继续编写了以下内容:

这些是我必须处理的容器:

template <class T>
class C {
    // container interface
};

template <class T>
class CImpl : public C<T> {
    // implements C's interface
};

这就是我想要实现 Worker 的方式类:

class Worker {
public:
    Worker( AbstractCFactory& f ) : _f( &f ), _buffer( NULL ) {}    
    void doSomething() {
        _buffer = _f->create<BufferType>( );
        // ... do something with _buffer
    }
private:
    AbstractCFactory* _f;
    typedef struct { int someInfo; } BufferType;
    C< BufferType >* _buffer;    
};  

但是，就工厂而言，这需要类似以下内容:

class AbstractCFactory {
public:
    template <class T>
    virtual C< T >* create() = 0; 
};

class ConcreteCFactory : public AbstractCFactory {
public:
    template <class T>
    virtual C< T >* create() {
        return new CImpl< T >(); 
    }
};

虽然我认为这是一个很棒的设计，但编译器并不那么热情，并提醒我模板方法不能是虚拟的。现在想想，这是有道理的——如果工厂类型仅在运行时确定，编译器就无法知道为工厂中的模板方法生成哪些代码。

丑陋的解决方法

首先，我将工厂实现为模板以允许虚拟 create()功能:

template <class T>
class AbstractCFactory {
public:     
    virtual C< T >* create() = 0;
};

template <class T>
class ConcreteCFactory : public AbstractCFactory {
public:
    virtual C< T >* create() {
        return new CImpl< T >(); 
    }
};    

然后，我移动了 BufferType到Worker的公共(public)接口(interface), 允许客户端创建 ConcreteCFactory< Worker::BufferType >要传递给 Worker 的实例的构造函数。

class Worker {
public:
    typedef struct { int someInfo; } BufferType; 
    Worker( AbstractCFactory< BufferType >& f ) : _f( &f ), _buffer( NULL ) {}    
    void doSomething() {
        _buffer = _f->create( );
        // ... do something with _buffer
    }
private:
    AbstractCFactory< BufferType >* _f;
    C< BufferType >* _buffer;    
};  

显然，我的变通方法不是真正的解决方案，因为它仍然引入了对 Worker 的私有(private)实现细节的不良客户端依赖性。 ( BufferType ) 通过将它们暴露给公共(public)接口(interface)。

问题

是否有一个合适的解决方案不会迫使我破坏封装，即保留 Worker独立于CImpl和客户端独立于Worker::BufferType ？

最佳答案

CImpl<T>是一个必须由客户端提供的模板类，它必须专门用于CImpl<BufferType>。 .在特化时间，两者都是CImpl和 BufferType必须定义。一种可能是要求客户提供 CImpl.h包含 C<T> 实现定义的文件:

cimpl.h(客户端提供)

template <class T>
class CImpl : public C<T> {
    // implements C's interface
};

worker.h:

class IC {
};

template <class T>
class C: public IC {
    // container interface
};

class AbstractCFactory {
public:     
    virtual IC* create() = 0;
};

class Worker {
public:
    Worker( AbstractCFactory& f ) : _f( &f ), _buffer( 0 ) {}    
    void doSomething();
private:
    AbstractCFactory* _f;
    C< struct BufferType >* _buffer;    
};  

AbstractCFactory& getDefaultFactory();

worker .cpp

#include "worker.h"
#include "cimpl.h"
#include <stdlib.h>

template <class T>
class ConcreteCFactory : public AbstractCFactory {
public:
    virtual IC* create() {
        return new CImpl< T >(); 
    }
};

struct BufferType {
    int someInfo;
};

void Worker::doSomething() {
    _buffer = static_cast<C<BufferType>*>(_f->create( ));
    // ... do something with _buffer
}

AbstractCFactory& getDefaultFactory() {
    static ConcreteCFactory<BufferType> f;

    return f;
}

使用示例:

#include "worker.h"
...
AbstractCFactory& f = getDefaultFactory();
Worker w(f);
w.doSomething();

另一种可能性是将 .h 文件分成两部分，一个公共(public)接口(interface)和一个客户端永远不应该直接使用的私有(private)接口(interface)。

worker .h

class IC {
};

template <class T>
class C: public IC {
    // container interface
};

class AbstractCFactory {
public:     
    virtual IC* create() = 0;
};

struct BufferType;

class Worker {
public:
    Worker( AbstractCFactory& f ) : _f( &f ), _buffer( 0 ) {}    
    void doSomething();
private:
    AbstractCFactory* _f;
    C< struct BufferType >* _buffer;    
};  

AbstractCFactory& getFactory();

#include "private.h"

私有(private).h:

struct BufferType {
    int someInfo;
};

template<class I> 
class CFactory: public AbstractCFactory {
public:
    virtual IC* create() {
        return new I(); 
    }
};

template<class I>
AbstractCFactory& getFactory() {
    static CFactory<I> fact;

    return fact;
}

worker .cpp:

#include "worker.h"

void Worker::doSomething() {
    _buffer = static_cast<C<BufferType>*>(_f->create( ));
    // ... do something with _buffer
}

使用示例:

#include "worker.h"
...
template <class T>
class CImpl : public C<T> {
    // implements C's interface
};
...
AbstractCFactory& f = getFactory<CImpl<BufferType>>();
Worker w(f);
w.doSomething();

关于c++ - 模板类困境的抽象工厂，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32011713/