Question

我是metaprogramming的新手，我在使用标签时遇到了与const相关的问题。

假设我们有几种“类型”。每种类型都有不同的版本，我们将能够处理每种类型的所有vesrion。为此，我们使用包含有关类型的标准信息的结构，以及包含每个版本的信息的数组。

问题是，每种类型的版本数量都不相同。此外，版本号不是很高，所以我不想使用所述表的动态分配。但是如果我进行静态分配，我需要为每个结构实例提供一个大小相同的表。这意味着，我必须获得最高版本值并将其用作数组的大小。

我来了：我想创建一个小的元编程模板，它提供最高版本值@编译时间，所以我可以有一个固定大小的数组，肯定会包含每种类型的necerrasy信息。但是我收到了编译错误。

以下是重现问题的简化示例代码（错误在其后面）

#include <stdio.h>

// change values here
#define VERSION_ALPHA 3
#define VERSION_BETA 5
#define VERSION_GAMMA 2

// different available types
enum TYPES
{
    T_ALPHA = 0,
    T_BETA,
    T_GAMMA,

    T_COUNT, // number of types
};

// to access versions more easily from code
static const int typeVersions[T_COUNT] =
{
    VERSION_ALPHA,
    VERSION_BETA,
    VERSION_GAMMA
};

// this meta is used to get the highest version values between all types
template<int i>
class HighestVersion
{
private:
    // version of type -1
    enum
    {
        PREVIOUS = HighestVersion<i-1>::VALUE
    };

public:
    // current max value
    enum
    {
        VALUE = (typeVersions[i] > PREVIOUS ? typeVersions[i] : PREVIOUS)
    };
};

// first version
template<>
class HighestVersion<0>
{
public:
    // current max value
    enum
    {
        VALUE = typeVersions[0]
    };
};

// highest version macro
#define HIGHEST_VERSION HighestVersion<T_COUNT>::VALUE

// holds info about a single type
struct TypeInfo
{
    char * s_pName; // name of the type as string
    unsigned int s_Flags[HIGHEST_VERSION]; // flags for each available version of this type
};


int main()
{
    // instanciate
    TypeInfo infos[T_COUNT];

    // do stuff, set name, load flags....
    /*...*/

    // for test purpose, print max version value (should print 5 in this situation)
    printf("%d\n", HIGHEST_VERSION);
}

编译器说：

error C2057: expected constant expression

@ the lines

VALUE = (typeVersions[i] > PREVIOUS ? typeVersions[i] : PREVIOUS)

和

VALUE = typeVersions[0]

似乎编译器告诉我表的内容不是常量。我假设这是因为该表被解释为一个指针，在这种情况下它不是常数（因此如果指针改变，则内容不相同）。有没有办法纠正这个，所以我可以使用脚本？它将使用户无需手动设置该表的大小...

提前致谢：）

Answer 1

我确信甚至不可能使用静态数组来完成这项工作一个可能的替代方案是特质类：

template<TYPES>
struct typeVersions;

// specializations for each type

template<>
struct typeVersions<T_ALPHA> { static const int version = VERSION_ALPHA; };
template<>
struct typeVersions<T_BETA> { static const int version = VERSION_BETA; };
// etc...

你会这样使用它：

enum {
    VALUE = typeVersions<i>::version
};

Answer 2

正如jrok所说，使用静态数组可能无法做到这一点。但也不是如果你有足够的必要，为每个类型版本创建特征专业化是必要的符合C ++ 11编译器。

我看到你正在使用VC ++并且你可能已经致力于它了，遗憾的是这意味着你可能拥有的唯一符合C ++ 11的编译器或者现在就是VC ++ 2013 Preview。如果您可以使用它，则以下修改程序所示的简单可变参数模板解决方案将适合您：

#include <stdio.h>

// change values here
#define VERSION_ALPHA 3
#define VERSION_BETA 5
#define VERSION_GAMMA 2

// different available types
enum TYPES
{
    T_ALPHA = 0,
    T_BETA,
    T_GAMMA,
    T_COUNT, // number of types
};

template<int ...Versions>
struct versions_list
{
    static_assert(sizeof ...(Versions),
        "Cannot have 0 versions");
};

template<int Only>
struct versions_list<Only>
{
    static const int max = Only;
};

template<int First, int Last>
struct versions_list<First,Last>
{
    static const int max = First > Last ? First : Last;
};

template<int First, int Second, int ...Rest>
struct versions_list<First,Second,Rest...>
{
    static const int tail_max = versions_list<Second,Rest...>::max;
    static const int max = First > tail_max ? First : tail_max;
};

// Update your version list here:
typedef versions_list<VERSION_ALPHA, VERSION_BETA, VERSION_GAMMA> typeVersions;

#define HIGHEST_VERSION typeVersions::max


// holds info about a single type
struct TypeInfo
{
    char * s_pName; // name of the type as string
    unsigned int s_Flags[HIGHEST_VERSION]; // flags for each available version of this type
};


int main()
{
    // instanciate
    TypeInfo infos[T_COUNT];

    // do stuff, set name, load flags....
    /*...*/

    // for test purpose, print max version value (should print 5 in this situation)
    printf("%d\n", HIGHEST_VERSION);
}

HIGHEST_VERSION宏在这里毫无意义：您可以删除其定义并将所有匹配项替换为typeVersions::max。

顺便说一下，如果你真的想在C ++程序中使用C的stdio API而不是C ++ iostream API，严格来说，您应该使用#include <cstdio>，而不是#include <stdio.h>

Answer 3

我不确定这是否可以用C风格的数组完成，但是如果你有C ++ 11的编译器支持那么请检查我的解决方案：

#include <array>
#include <iostream>

template <int Size, int Indice>
struct HighestValue
{
    static int get(std::array<int, Size> checkedArray) {
        return std::max(HighestValue<Size, Indice - 1>::get(checkedArray), checkedArray[Indice]);
    }
};

template <int Size>
struct HighestValue<Size, 0>
{
    static int get(std::array<int, Size> checkedArray) {
        return checkedArray[0];   
    }
};

template<size_t Size>
int checkMax(std::array<int, Size> checkedArray)
{
    return HighestValue<Size, Size - 1>::get(checkedArray);   
}

int main()
{
    std::array<int, 7> test {1, 5, 2, 3, 123, 5, 2};
    std::cout << checkMax(test);
}

目前我没有空闲时间玩这个，但我相信它可以进一步改善。

元编程：使用const数组

3 个答案: