我可以为 C++ 类提供不完整的标头以隐藏实现细节吗？

Question

我想将一个类实现分成三个部分，以避免用户需要处理实现细节，例如，我用来实现功能的库：

impl.cpp

#include <api.h>
#include <impl.h>
Class::Class() {
    init();
}
Class::init() {
    myData = SomeLibrary::Type(42);
}
Class::doSomething() {
    myData.doSomething();
}

impl.h

#include <somelibrary.h>
class Class {
public:
    Class();
    init();
    doSomething();
private:
    SomeLibary::Type myData;
}

api.h

class Class {
    Class();
    doSomething();
}

问题是，我不允许为类定义重新定义标题。当我仅在 api.h 中定义 Class() 和 doSomething() 时，这也不起作用。

---

一个可能的选择是定义api.h，并且根本不在项目中使用它，而是安装它（并且不要安装impl.h）。

明显的缺点是，我需要确保api.h 和impl.h 中的常用方法始终具有相同的签名，否则使用该库的程序会出现链接器错误，我在编译时无法预测图书馆。

但是这种方法是否可行，或者我会遇到其他问题（例如，指向类成员的错误指针或类似问题），因为 obj 文件与标头不匹配？

Answer 1

简短的回答是“不！”

原因：任何/所有需要使用您的 Class 类的“客户”项目都必须具有该类的完整声明，以便编译器可以正确确定成员变量的偏移量等。

private 成员的使用很好 - 客户端程序将无法更改它们 - 就像您当前的实现一样，标题中仅提供成员函数的最简要概述，所有实际定义都在您的（私有）源文件。

解决此问题的一种可能方法是在Class 中声明一个指向嵌套类的指针，该嵌套类仅在共享标头中声明：@987654324 @ 然后你可以在你的实现中使用嵌套的类指针做你喜欢的事情。您通常会将嵌套类指针设为private 成员；此外，由于共享标头中未给出其定义，因此“客户端”项目访问该类的任何尝试（作为指针除外）都将是编译器错误。

这是一个可能的代码故障（可能不是没有错误，因为它是一种快速输入）：

// impl.h
struct MyInternal; // An 'opaque' structure - the definition is For Your Eyes Only
class Class {
public:
    Class();
    init();
    doSomething();
private:
    MyInternal* hidden; // CLient never needs to access this! Compiler error if attempted.
}

// impl.cpp
#include <api.h>
#include <impl.h>

struct MyInternal {
    SomeLibrary::Type myData;
};

Class::Class() {
    init();
}
Class::init() {
    hidden = new MyInternal; // MUCH BETTER TO USE unique_ptr, or some other STL.
    hidden->myData = SomeLibrary::Type(42);
}
Class::doSomething() {
    hidden->myData.doSomething();
}

注意：正如我在代码注释中所暗示的，使用std::unique_ptr<MyInternal> hidden 会更好。但是，这将要求您在 Class 中为析构函数、赋值运算符和其他（移动运算符？复制构造函数？）提供 explicit 定义，因为这些将需要访问MyInternal 结构体。

Answer 2

私有实现 (PIMPL) 习语可以帮助您。它可能会导致 2 个头文件和 2 个源文件，而不是 2 和 1。有一个我实际上没有尝试编译的愚蠢示例：

api.h

#pragma once
#include <memory>
struct foo_impl;
struct foo {
    int do_something(int argument);
private:
    std::unique_ptr<foo_impl> impl;
}

api.c

#include "api.h"
#include "impl.h"
int foo::do_something(int a) { return impl->do_something(); }

impl.h

#pragma once
#include <iostream>
struct foo_impl {
    foo_impl();
    ~foo_impl();
    int do_something(int);
    int initialize_b();
private:  
    int b;
};

impl.c

#include <iostream>
foo_impl::foo_impl() : b(initialize_b()} {  }
foo_impl::~foo_impl() = default;
int foo_impl::do_something(int a) { return a+b++; }
int foo_impl::initialize_b() { ... }

foo_impl 可以有它需要的任何方法，因为foo 的标题（API）是用户将看到的所有内容。编译器编译foo 所需的全部内容是知道有一个指针作为数据成员，因此它可以正确调整foo 的大小。