Question

有没有很好的方法可以将嵌套数据类型定义从容器中分离到另一个文件中？

我有一个类，在标题中定义了多个嵌套的结构/类枚举，这可能很长。

MyClass.h

#ifndef MYCLASS_H_
#define MYCLASS_H_
#include <stdint.h>

namespace my_namespace{

class MyClass {

public:

  enum class NestedEnumClass {
    VALUE1, VALUE2, VALUE3
  };

  struct NestedStruct {
    float a;
    float b;
    uint_fast16_t c;
  };

  struct SomeOtherNestedStruct {
    float a;
    float b;
    uint_fast16_t c;
  };

  struct AnotherNestedStruct {
    float a;
    float b;
    uint_fast16_t c;
  };

private:
  struct CombinedStruct {
    NestedStruct a;
    NestedStruct b;
    NestedStruct c;
    AnotherNestedStruct d;
    NestedEnumClass e;
  };

  uint8_t pin;
  CombinedStruct data_;

public:
  MyClass();
  NestedEnumClass someMethod(NestedStruct nestedStruct);

}; // MyClass class.

} // my_namespace namespace.

#endif /* MYCLASS_H_ */

为了使标题更短/更整洁，我最初考虑在MyClass定义头文件中声明数据类型，并在包含头文件的单独源中定义数据类型。

然而，当我尝试实例化任何数据类型时，编译器正确地抱怨了一个不完整的类型。

我想我可以把它包括在内，但看起来很可怕：
的 MyClass_DataTypes.inc

public:
enum class NestedEnumClass {
    VALUE1, VALUE2, VALUE3
  };

struct NestedStruct{
  float a;
  float b;
  uint_fast16_t c;
};

struct SomeOtherNestedStruct {
  float a;
  float b;
  uint_fast16_t c;
};

struct AnotherNestedStruct {
    float a;
    float b;
    uint_fast16_t c;
  };

private:
struct CombinedStruct {
  NestedStruct a;
  NestedStruct b;
  NestedStruct c;
  AnotherNestedStruct d;
  NestedEnumClass e;
};

修改了MyClass.h

#ifndef MYCLASS_H_
#define MYCLASS_H_
#include <stdint.h>

namespace my_namespace{

class MyClass {

#include "MyClass_DataTypes.inc" // In-line include.

private:
  uint8_t pin;
  CombinedStruct data_;

public:
  MyClass(){};
  NestedEnumClass someMethod(NestedStruct nestedStruct);

}; // MyClass class.

} // my_namespace namespace.

#endif /* MYCLASS_H_ */

另外，我的IDE（Eclipse）不够聪明，无法查找包含在线代码检查的include，因此我需要在类定义中转发声明它们，即使它没有它们也可以正常编译。

Answer 1

在这里，我可能会接近它。

梗概：

为内部类创建另一个名称空间
根据需要将内部类的名称导入到我的外部类的界面中

这样的事情：

#ifndef MYCLASS_IMPL_H_
#define MYCLASS_IMPL_H_

#include <cstdint>

namespace my_namespace {
    namespace MyClassImpl {

        enum class NestedEnumClass {
            VALUE1, VALUE2, VALUE3
        };

        struct NestedStruct {
            float a;
            float b;
            uint_fast16_t c;
        };

        struct SomeOtherNestedStruct {
            float a;
            float b;
            uint_fast16_t c;
        };

        struct AnotherNestedStruct {
            float a;
            float b;
            uint_fast16_t c;
        };

    }
}
#endif

#ifndef MYCLASS_H_
#define MYCLASS_H_
#include <stdint.h>

namespace my_namespace{

    class MyClass {

    public:
        using NestedEnumClass = MyClassImpl::NestedEnumClass;
        using NestedStruct = MyClassImpl::NestedStruct;
        using SomeOtherNestedStruct = MyClassImpl::SomeOtherNestedStruct;
        using AnotherNestedStruct = MyClassImpl::AnotherNestedStruct;


    private:
        struct CombinedStruct {
            NestedStruct a;
            NestedStruct b;
            NestedStruct c;
            AnotherNestedStruct d;
            NestedEnumClass e;
        };

        uint8_t pin;
        CombinedStruct data_;

    public:
        MyClass();
        NestedEnumClass someMethod(NestedStruct nestedStruct);

    }; // MyClass class.

} // my_namespace namespace.

在另一个文件中定义前向声明的嵌套struct / class / enum以获得整洁

1 个答案: