c++ - 从模板函数引用全局数据？

Question

模板通常是内联的——您必须在声明中提供定义。

全局(静态)数据要求数据只有一个定义(但可以多次声明)。

因此，对于具有静态数据的类，通常在类定义(头文件)中声明静态，并在实现文件(.cpp)中将存储声明为静态。

但是对于需要引用静态/全局数据的模板，该怎么办呢？

这里有一些代码可以让您考虑一些具体的事情:

        // we represent in a formal manner anything that can be encoded in a MSVS format specification
        // A format specification, which consists of optional and required fields, has the following form:
        // %[flags][width][.precision][{h | l | ll | w | I | I32 | I64}] type
        // based on https://msdn.microsoft.com/en-us/library/56e442dc.aspx
        struct FormatSpec
        {
            enum Size {
                normal,
                h,
                l,
                ll,
                w,
                I,
                I32,
                I64
            };

            enum Type {
                invalid,
                character,
                signed_integer,
                unsigned_integer,
                unsigned_octal,
                unsigned_hex,
                floating_point,
                expontential_floating_point,
                engineering_floating_point,
                hex_double_floating_point,
                pointer,
                string,
                z_string
            };

            unsigned    fLeftAlign : 1;
            unsigned    fAlwaysSigned : 1;
            unsigned    fLeadingZeros : 1;
            unsigned    fBlankPadding : 1;
            unsigned    fBasePrefix : 1;

            unsigned    width;
            unsigned    precision;

            Size        size_;
            Type        type_;
        };

        struct FormatSpecTypeDatum
        {
            FormatSpec::Type    id;         // id
            const TCHAR *       symbol;     // text symbol
        };

        FormatSpecTypeDatum kTypeSpecs[] =
        {
            { FormatSpec::character, _T("c") },
            { FormatSpec::character, _T("C") },
            { FormatSpec::signed_integer, _T("d") },
            { FormatSpec::signed_integer, _T("i") },
            { FormatSpec::unsigned_octal, _T("o") },
            { FormatSpec::unsigned_integer, _T("u") },
            { FormatSpec::unsigned_hex, _T("x") },
            { FormatSpec::unsigned_hex, _T("X") },
            { FormatSpec::expontential_floating_point, _T("e") },
            { FormatSpec::expontential_floating_point, _T("E") },
            { FormatSpec::floating_point, _T("f") },
            { FormatSpec::floating_point, _T("F") },
            { FormatSpec::engineering_floating_point, _T("g") },
            { FormatSpec::engineering_floating_point, _T("G") },
            { FormatSpec::hex_double_floating_point, _T("a") },
            { FormatSpec::hex_double_floating_point, _T("A") },
            { FormatSpec::pointer, _T("p") },
            { FormatSpec::string, _T("s") },
            { FormatSpec::string, _T("S") },
            { FormatSpec::z_string, _T("Z") },
        };

        template <typename ctype>
        bool DecodeFormatSpecType(const ctype * & format, FormatSpec & spec)
        {
            for (unsigned i = 0; i < countof(kTypeSpecs); ++i)
                if (format[0] == kTypeSpecs[i].symbol[0])
                {
                    spec.type_ = kTypeSpecs[i].id;
                    ++format;
                    return true;
                }
            return false;
        }

它相对简单 - 字符表示查找表的符号 ID。

我希望能够对 char、unsigned char、wchar_t 等使用 DecodeFormatSpecType<>()

我可以从 DecodeFormatSpecType() 中删除模板，只为各种字符类型提供重载接口(interface)。

主要是数据并没有真正改变 - unsigned char 'c' 和 wchar_t 'c' 以及 legacy char 'c' 具有完全相同的值，无论字符的存储大小如何(对于核心ASCII 字符是正确的，尽管毫无疑问还有一些其他编码(例如 EDBIC)不是正确的，但这不是我要在这里解决的问题)。

我只是想了解“我如何构建我的 C++ 库，以便我可以访问定义在一个位置的全局数据——它存储为一个数组——我希望访问模板代码知道全局的长度数据，就像我可以使用普通的非模板代码一样，有一个全局符号表，就像我在示例代码中显示的那样，通过让表和需要它的大小的实现都存在于适当的 .cpp 文件中”

这有意义吗？

全局数据 + 需要知道确切定义但也可以(通过接口(interface))这种通用(对有效域)呈现的函数。

Answer 1

函数模板可以毫无问题地使用全局函数和全局数据。

如果你想封装 kTypeSpecs 的定义而不是在头文件中定义它，你可以使用几个函数来提供对数据的访问。

size_t getNumberOfTypeSpecs();

// Provide read only access to the data.
FormatSpecTypeDatum const* getTypeSpecs();

然后将DecodeFormatSpecType实现为

template <typename ctype>
bool DecodeFormatSpecType(const ctype * & format, FormatSpec & spec)
{
   size_t num = getNumberOfTypeSpecs();
   FormatSpecTypeDatum const* typeSpecs = getTypeSpecs();

   for (unsigned i = 0; i < num; ++i)
      if (format[0] == typeSpecs[i].symbol[0])
      {
         spec.type_ = typeSpecs[i].id;
         ++format;
         return true;
      }
   return false;
}

函数 getNumberOfTypeSpecs 和 getTypeSpecs 可以在 .cpp 文件中实现为:

// Make the data file scoped global variable.
static FormatSpecTypeDatum kTypeSpecs[] =
{
   { FormatSpec::character, _T("c") },
   { FormatSpec::character, _T("C") },
   { FormatSpec::signed_integer, _T("d") },
   { FormatSpec::signed_integer, _T("i") },
   { FormatSpec::unsigned_octal, _T("o") },
   { FormatSpec::unsigned_integer, _T("u") },
   { FormatSpec::unsigned_hex, _T("x") },
   { FormatSpec::unsigned_hex, _T("X") },
   { FormatSpec::expontential_floating_point, _T("e") },
   { FormatSpec::expontential_floating_point, _T("E") },
   { FormatSpec::floating_point, _T("f") },
   { FormatSpec::floating_point, _T("F") },
   { FormatSpec::engineering_floating_point, _T("g") },
   { FormatSpec::engineering_floating_point, _T("G") },
   { FormatSpec::hex_double_floating_point, _T("a") },
   { FormatSpec::hex_double_floating_point, _T("A") },
   { FormatSpec::pointer, _T("p") },
   { FormatSpec::string, _T("s") },
   { FormatSpec::string, _T("S") },
   { FormatSpec::z_string, _T("Z") },
};

size_t getNumberOfTypeSpecs()
{
   return sizeof(kTypeSpecs)/sizeof(kTypeSpecs[0]);
}

FormatSpecTypeDatum const* getTypeSpecs()
{
   return kTypeSpecs;
}

更新，回应 OP 的评论

是的，你可以。以下是完全有效的:

size_t getNumberOfTypeSpecs()
{
   static constexpr size_t num = sizeof(kTypeSpecs)/sizeof(kTypeSpecs[0]);
   return num;
}

constexpr size_t getNumberOfTypeSpecs()
{
   return sizeof(kTypeSpecs)/sizeof(kTypeSpecs[0]);
}