C++ 声明类和方法但不声明成员的头文件？

Question

是否可以创建一个 C++ 头文件 (.h) 来声明一个类及其公共方法，但不定义该类中的私有成员？ 我发现几页说你应该在标题中声明该类及其所有成员文件，然后在您的 cpp 文件中单独定义方法。 我问这个问题是因为我想要一个在 Win32 DLL 中定义的类，并且我希望它被正确封装：该类的内部实现可能会更改，包括其成员，但这些更改不应影响使用该类的代码。

我想如果我有这个，那么编译器就不可能提前知道我的对象的大小。 但这应该没问题，只要编译器足够聪明，可以使用构造函数，并将指针传递到内存中存储对象的位置，并且永远不要让我运行“sizeof(MyClass)”。

更新：感谢所有回答的人！ 看起来 pimpl 习语是实现我所说的目的的好方法。 我将做类似的事情：

我的 Win32 DLL 文件将有一堆单独的函数，如下所示：

void * __stdcall DogCreate();
int __stdcall DogGetWeight(void * this);
void __stdcall DogSetWeight(void * this, int weight);

这是 Microsoft 编写 DLL 文件的典型方式，所以我认为这可能是有充分理由的。

但我想利用 C++ 为类提供的良好语法，因此我将编写一个包装类来包装所有这些函数。 它将有一个成员，即“void * pimpl”。 这个包装类非常简单，我不妨在头文件中声明它并定义它。 但据我所知，这个包装类除了让 C++ 代码看起来更漂亮之外确实没有其他目的。

Answer 1

我认为你正在寻找的是一种叫做“pimpl idiom”的东西。 要了解这是如何工作的，您需要了解在 C++ 中您可以向前声明类似这样的内容。

class CWidget; // Widget will exist sometime in the future
CWidget* aWidget;  // An address (integer) to something that 
                   // isn't defined *yet*

// later on define CWidget to be something concrete
class CWidget
{
     // methods and such 
};

因此，转发声明意味着承诺稍后完全声明类型。 它说“我保证，将会有一个叫做 CWidget 的东西。稍后我会告诉你更多关于它的信息。”。

前向声明的规则规定，您可以定义一个指针或对已前向声明的内容的引用。 这是因为指针和引用实际上只是地址——一个尚未定义的东西所在的数字。 出于多种原因，能够在不完全声明的情况下声明指向某些内容的指针是很方便的。

它在这里很有用，因为您可以使用它来使用“pimpl”方法隐藏类的一些内部结构。 Pimpl 的意思是“指向实现的指针”。 因此，您拥有一个实际实现的类，而不是“小部件”。 您在标头中声明的类只是 CImpl 类的传递。 它的工作原理如下：

// Thing.h

class CThing
{
public:
    // CThings methods and constructors...
    CThing();
    void DoSomething();
    int GetSomething();
    ~CThing();
private:
    // CThing store's a pointer to some implementation class to 
    // be defined later
    class CImpl;      // forward declaration to CImpl
    CImpl* m_pimpl;  // pointer to my implementation
};

Thing.cpp 将 CThing 的方法定义为 impl 的传递：

// Fully define Impl
class CThing::CImpl
{
private:
     // all  variables
public:
     // methods inlined
     CImpl()
     {
          // constructor
     }

     void DoSomething()
     {
          // actual code that does something
     }
     //etc for all methods     
};

// CThing methods are just pass-throughs
CThing::CThing() : m_pimpl(new CThing::CImpl());
{
}  

CThing::~CThing()
{
    delete m_pimpl;
}

int CThing::GetSomething()
{
    return m_pimpl->GetSomething();
}

void CThing::DoSomething()
{
    m_impl->DoSomething();
}

tada！ 您已将所有详细信息隐藏在您的 cpp 中，并且您的头文件是一个非常整洁的方法列表。 这是一件伟大的事情。 您可能会发现与上面的模板唯一不同的是人们可能会使用 boost::shared_ptr<> 。 或其他用于实现的智能指针。 会自我删除的东西。

另外，请记住这种方法会带来一些烦恼。 调试可能有点烦人（需要额外级别的重定向来逐步执行）。 创建类的开销也很大。 如果你每堂课都这样做，你就会厌倦所有的打字:)。

Answer 2

使用 pimpl 习惯用法。

Answer 3

pimpl 惯用法 将 void* 私有数据成员添加到您的类中，这是一个如果您需要一些快速且有效的东西，这是有用的技术 肮脏的。 然而它也有其缺点。 其中最主要的是它使得在抽象类型上使用多态性变得困难。 有时您可能需要一个抽象基类和该基类的子类，收集指向向量中所有不同类型的指针并调用它们的方法。 此外，如果 pimpl 习惯用法的目的是隐藏类的实现细节，那么它只能几乎成功：指针本身就是一个实现细节。 也许是一个不透明的实现细节。 但仍然有一个实施细节。

pimpl 习惯用法的替代方案可用于从接口中删除所有实现细节，同时提供可多态使用的基本类型（如果需要）。

在 DLL 的头文件（客户端代码 #included 的头文件）中创建一个仅包含公共方法和概念的抽象类，这些方法和概念规定了如何实例化该类（例如，公共工厂方法和克隆方法）：

kennel。 h

/****************************************************************
 ***
 ***    The declaration of the kennel namespace & its members
 ***    would typically be in a header file.
 ***/

// Provide an abstract interface class which clients will have pointers to.
// Do not permit client code to instantiate this class directly.

namespace kennel
{
    class Animal
    {
    public:
        // factory method
        static Animal* createDog(); // factory method
        static Animal* createCat(); // factory method

        virtual Animal* clone() const = 0;  // creates a duplicate object
        virtual string speak() const = 0;   // says something this animal might say
        virtual unsigned long serialNumber() const = 0; // returns a bit of state data
        virtual string name() const = 0;    // retuyrns this animal's name
        virtual string type() const = 0; // returns the type of animal this is

        virtual ~Animal() {};   // ensures the correct subclass' dtor is called when deleteing an Animal*
    };
};

...Animal 是一个抽象基类因此无法实例化； 无需宣布私人行为人。 虚拟 dtor 的存在确保如果有人删除一个 Animal*，正确的子类 dtor 也将被调用。

为了实现基类型的不同子类（例如狗和猫），您需要在 DLL 中声明实现级类。 这些类最终派生自您在头文件中声明的抽象基类，并且工厂方法实际上会实例化这些子类之一。

dll.cpp：

/****************************************************************
 ***
 ***    The code that follows implements the interface
 ***    declared above, and would typically be in a cc
 ***    file.
 ***/   

// Implementation of the Animal abstract interface
// this implementation includes several features 
// found in real code:
//      Each animal type has it's own properties/behavior (speak)
//      Each instance has it's own member data (name)
//      All Animals share some common properties/data (serial number)
//

namespace
{
    // AnimalImpl provides properties & data that are shared by
    // all Animals (serial number, clone)
    class AnimalImpl : public kennel::Animal    
    {
    public:
        unsigned long serialNumber() const;
        string type() const;

    protected:
        AnimalImpl();
        AnimalImpl(const AnimalImpl& rhs);
        virtual ~AnimalImpl();
    private:
        unsigned long serial_;              // each Animal has its own serial number
        static unsigned long lastSerial_;   // this increments every time an AnimalImpl is created
    };

    class Dog : public AnimalImpl
    {
    public:
        kennel::Animal* clone() const { Dog* copy = new Dog(*this); return copy;}
        std::string speak() const { return "Woof!"; }
        std::string name() const { return name_; }

        Dog(const char* name) : name_(name) {};
        virtual ~Dog() { cout << type() << " #" << serialNumber() << " is napping..." << endl; }
    protected:
        Dog(const Dog& rhs) : AnimalImpl(rhs), name_(rhs.name_) {};

    private:
        std::string name_;
    };

    class Cat : public AnimalImpl
    {
    public:
        kennel::Animal* clone() const { Cat* copy = new Cat(*this); return copy;}
        std::string speak() const { return "Meow!"; }
        std::string name() const { return name_; }

        Cat(const char* name) : name_(name) {};
        virtual ~Cat() { cout << type() << " #" << serialNumber() << " escaped!" << endl; }
    protected:
        Cat(const Cat& rhs) : AnimalImpl(rhs), name_(rhs.name_) {};

    private:
        std::string name_;
    };
};

unsigned long AnimalImpl::lastSerial_ = 0;


// Implementation of interface-level functions
//  In this case, just the factory functions.
kennel::Animal* kennel::Animal::createDog()
{
    static const char* name [] = {"Kita", "Duffy", "Fido", "Bowser", "Spot", "Snoopy", "Smkoky"};
    static const size_t numNames = sizeof(name)/sizeof(name[0]);

    size_t ix = rand()/(RAND_MAX/numNames);

    Dog* ret = new Dog(name[ix]);
    return ret;
}

kennel::Animal* kennel::Animal::createCat()
{
    static const char* name [] = {"Murpyhy", "Jasmine", "Spike", "Heathcliff", "Jerry", "Garfield"};
    static const size_t numNames = sizeof(name)/sizeof(name[0]);

    size_t ix = rand()/(RAND_MAX/numNames);

    Cat* ret = new Cat(name[ix]);
    return ret;
}


// Implementation of base implementation class
AnimalImpl::AnimalImpl() 
: serial_(++lastSerial_) 
{
};

AnimalImpl::AnimalImpl(const AnimalImpl& rhs) 
: serial_(rhs.serial_) 
{
};

AnimalImpl::~AnimalImpl() 
{
};

unsigned long AnimalImpl::serialNumber() const 
{ 
    return serial_; 
}

string AnimalImpl::type() const
{
    if( dynamic_cast<const Dog*>(this) )
        return "Dog";
    if( dynamic_cast<const Cat*>(this) )
        return "Cat";
    else
        return "Alien";
}

现在您已经在标头和文件中定义了接口。 实现细节完全分离，客户端代码根本看不到它。 您可以通过从链接到 DLL 的代码调用头文件中声明的方法来使用它。 这是一个示例驱动程序：

ma​​in.cpp：

std::string dump(const kennel::Animal* animal)
{
    stringstream ss;
    ss << animal->type() << " #" << animal->serialNumber() << " says '" << animal->speak() << "'" << endl;
    return ss.str();
}

template<class T> void del_ptr(T* p)
{
    delete p;
}

int main()
{
    srand((unsigned) time(0));

    // start up a new farm
    typedef vector<kennel::Animal*> Animals;
    Animals farm;

    // add 20 animals to the farm
    for( size_t n = 0; n < 20; ++n )
    {
        bool makeDog = rand()/(RAND_MAX/2) != 0;
        if( makeDog )
            farm.push_back(kennel::Animal::createDog());
        else
            farm.push_back(kennel::Animal::createCat());
    }

    // list all the animals in the farm to the console
    transform(farm.begin(), farm.end(), ostream_iterator<string>(cout, ""), dump);

    // deallocate all the animals in the farm
    for_each( farm.begin(), farm.end(), del_ptr<kennel::Animal>);

    return 0;
}

Answer 4

谷歌“pimple idiom”或“handle C++”。

Answer 5

是的，这可能是一件值得做的事情。 一种简单的方法是使实现类从标头中定义的类派生。

缺点是编译器不知道如何构造您的类，因此您需要某种工厂方法来获取该类的实例。 堆栈上不可能有本地实例。

Answer 6

您必须在标头中声明所有成员，以便编译器知道对象有多大等等。

但是你可以通过使用接口来解决这个问题：

ext.h:

class ExtClass
{
public:
  virtual void func1(int xy) = 0;
  virtual int func2(XYClass ¶m) = 0;
};

int.h:

class ExtClassImpl : public ExtClass
{
public:
  void func1(int xy);
  int func2(XYClass¶m);
};

int.cpp:

  void ExtClassImpl::func1(int xy)
  {
    ...
  }
  int ExtClassImpl::func2(XYClass¶m)
  {
    ...
  }

Answer 7

是否可以制作 C++ 头文件
声明类的文件 (.h)，以及
它的公共方法，但不
声明私有成员
类？

最接近的答案是 PIMPL 习语。

请参阅 Herb Sutter 的快速粉刺成语。

IMO Pimpl 在开发的初始阶段非常有用，因为您的头文件将更改多次。 Pimpl 由于其在堆上分配/释放内部对象而产生成本。

Answer 8

查看类Handle-Body C++ 中的惯用语