C++类声明和命名空间

Question

我在尝试编写的 C++ 库时遇到问题。这是通常的设置，一个 cpp 文件，一个头文件。我希望头文件仅公开要使用的部分（例如，我有一个抽象基类，我不想在头文件中）。到目前为止，我只处理一个文件（我认为这应该没有什么区别，因为包含是由预处理器完成的，它不关心任何事情）。

您会注意到“头文件”分布在两个位置，即头实现文件之前和之后。

#include <stdio.h>

// lib.h
namespace foo {
    template <class T> class A;
}

// lib.cpp
namespace foo {
    template <class T> class A {
        private:
        T i;
        public:
        A(T i) {
            this->i = i;
        }

        T returnT() {
            return i;
        }
    };
};

// lib.h
namespace foo {
    template <class T> T A<T>::returnT();
}

// foo.cpp
void main() {
    foo::A<int> a = foo::A<int>(42);
    printf("a = %d",a.returnT());
}

因此，自然地，我希望我的头文件只包含

namespace foo {
    template <class T> class A;
    template <class T> T A<T>::returnT();
}

但我的编译器不喜欢这样（它抱怨 returnT 不是 foo::A 的成员我不想将类声明本身放在标头中的原因是（据我所知）它会包含所有私有和类似的内容，

也许这只是 我想隐藏的。我，但下面的头文件看起来“不好”，至少作为“接口规范”。它公开了 A 的一些内部结构，而库的用户不需要了解这些内部结构。

// lib.h
namespace foo {
    template <class T> class A {
        private:
        int i;
        public:
        A(T);
        T returnT();
    };
}

// lib.cpp
namespace foo {
    template <class T> A<T>::A(T i) {
        this->i = i;
    }
    template <class T> T A<T>::returnT() {
        return i;
    }
};

如果可能的话，这是公认的方法吗？

Answer 1

您不能将模板的定义与其声明分开。它们都必须一起进入头文件。

对于“为什么？”我建议阅读 "为什么我不能分离模板的定义类的声明并将其放入 .cpp 文件中？”。

---

我可能误读了你的问题。为了解决您可能提出的问题，这是无效的：

namespace foo {
    template <class T> class A;     
    template <class T> T A<T>::returnT(); 
} 

它无效的原因与无效的原因相同：

namespace foo {
    class A;
    int A::returnT();
} 

成员函数必须在类的定义内声明。

Answer 2

您在这里处理的 .cpp 文件有两个问题：

I。
如果您想将该类的实例放入堆栈中（就像在 main() 中所做的那样），编译器需要知道该类的大小（以分配足够的内存）。为此，它需要了解成员并由此获得完整的声明。

隐藏类布局的唯一方法是构建一个接口和一个工厂方法/函数，并将实例放在工厂的堆上。

作为一个例子（没有模板；请参阅下面了解原因）：

namespace foo {
  class IA {
    public:
      virtual ~IA();
      virtual int returnT() = 0;

      static IA *Create();
  };
}

然后在您的 .cpp 中执行以下操作：

namespace foo {
  class A : public IA {
    private:
      int i;
    public:
      A() : 
        i(0) {
      }
      virtual ~A() {
      }
      virtual int returnT() {
        return i;
      }
  };
  IA::~IA() {
  }

  IA *IA::Create() {
    return new A();
  }
}

顺便说一句：建议使用智能指针...

II。
由于您使用的是模板，因此方法定义必须通过头文件可见或针对特定类型集显式实例化。

因此，您可以将代码拆分为 lib.h 和 lib_impl.h：

lib.h:

namespace foo {
  template <typename T> class IA {
    public:
      virtual ~IA() {
      }
      virtual T returnT() = 0;

      static IA *Create();
  };
}

lib_impl.h:

namespace foo {
  template <typename T> class A : public IA<T> {
    private:
      T i;
    public:
      A() : 
        i(T()) {
      }
      virtual ~A() {
      }
      virtual T returnT() {
        return i;
      }
  };

  template <typename T> IA<T> *IA<T>::Create() {
    return new A<T>();
  }
}

这样您就可以在需要实现的地方包含 lib_impl.h。
要使用显式实例化，请添加 lib.cpp 并让该文件允许包含 lib_impl.h：

lib.cpp：

#include <lib_impl.h>
namespace foo {
  template class IA<int>;
  template class A<int>;
  template class IA<float>;
  template class A<float>;
  template class IA<char>;
  template class A<char>;
  // ...
}