10

我有一堆有名字的类型。（它们有更多的特性，但为了便于讨论，只有名称是相关的。）这些类型及其名称是在编译时使用宏设置的：

#define DEFINE_FOO(Foo_)                        \
    struct Foo_ : public foo_base<Foo_> {       \
      static char const* name() {return #Foo_;} \
    }

然后将这些类型组合在编译时列表（经典的简单递归编译时列表）中，我需要通过连接其对象的名称来创建列表的名称：

template<class Foo, class Tail = nil>
struct foo_list {
  static std::string name_list() {return Foo::name() + "-" + Tail::name();}
};
template<class Foo>
struct foo_list<Foo,nil> {
  static std::string name_list() {return Foo::name();}
};

代码在这里被归结为可能包含错误的地步，但实际上这工作得很好。

除了它在运行时创建然后复制相当长的字符串，这些字符串表示在编译时实际上是众所周知的类型。由于这是在嵌入式设备上运行的对性能相当敏感的一段代码，我想更改它，以便

  1. 理想情况下，列表的字符串是在编译时创建的，或者，如果无法做到这一点，则在运行时创建一次，并且
  2. 我只需要复制指向 C 字符串的指针，因为根据 #1，字符串在内存中是固定的。
  3. 这与我们现在坚持使用的 C++03 一起编译。

我怎样才能做到这一点？

（如果这扩大了可用于此目的的肮脏技巧的库：foo对象的名称只能由代码创建和读取，并且只有foo_list名称字符串被期望是人类可读的。）

4

5 回答 5

4

你可能想看看 boost 的mpl::string. 我的咖啡开始后要遵循的示例...

编辑：所以咖啡开始了...... :)

#include <iostream>

#include <boost/mpl/bool.hpp>
#include <boost/mpl/if.hpp>
#include <boost/mpl/string.hpp>
#include <boost/mpl/vector.hpp>

namespace mpl = boost::mpl;

struct foo
{
  typedef mpl::string<'foo'> name;
};

struct bar
{
  typedef mpl::string<'bar'> name;
};

struct gah
{
  typedef mpl::string<'gah'> name;
};

namespace aux
{

template <typename string_type, typename It, typename End>
struct name_concat
{
  typedef typename mpl::insert_range<string_type, typename mpl::end<string_type>::type, typename mpl::deref<It>::type::name>::type base;
  typedef typename aux::name_concat<base, typename mpl::next<It>::type, End>::name name;
};

template <typename string_type, typename End>
struct name_concat<string_type, End, End>
{
  typedef string_type name;
};

}

template <typename ...Types>
struct type_list
{
  typedef mpl::string<> base;
  typedef mpl::vector<Types...> type_seq;
  typedef typename aux::name_concat<base, typename mpl::begin<type_seq>::type, typename mpl::end<type_seq>::type>::name name;
};

int main(void)
{
  typedef typename type_list<foo, bar, gah>::name tlist_name;
  std::cout << mpl::c_str<tlist_name>::value << std::endl;
}

我相信您有足够的能力根据您的情况调整上述内容。注意：您将不得不忽略多字符常量警告...

更多注意事项：传递给的多字符常量mpl::string不能超过 4 个字符，因此，它必须如何分块（或由单个字符构成），所以可能是长字符串，mpl::string<'this', ' is ', 'a lo', 'ng s', 'trin', 'g'>如果不能这样做，那么以上将不起作用..：/

于 2013-10-23T07:26:32.550 回答
4

我想出了以下解决方案：

类型生成为：

const char foo_str [] = "foo";
struct X
{
    static const char *name() { return foo_str; }
    enum{ name_size = sizeof(foo_str) };
};

这里的关键是我们在编译时就知道它的名字的长度。这允许我们计算类型列表中名称的总长度：

template<typename list>
struct sum_size
{
    enum
    {
       value = list::head::name_size - 1 +
               sum_size<typename list::tail>::value
    };
};
template<>
struct sum_size<nil>
{
    enum { value = 0 };
};

在编译时知道总长度，我们可以为字符串的连接分配适当大小的静态缓冲区 - 所以不会有任何动态分配：

static char result[sum_size<list>::value + 1];

该缓冲区应在运行时填充，但只填充一次，并且该操作非常便宜（比以前使用字符串动态分配及其递归连接的解决方案快得多）：

template<typename list>
const char *concate_names()
{
    static char result[sum_size<list>::value + 1];
    static bool calculated = false;
    if(!calculated)
    {
        fill_string<list>::call(result);
        calculated = true;
    }
    return result;
}

这是完整的代码：

Coliru 上的现场演示

#include <algorithm>
#include <iostream>
using namespace std;

/****************************************************/

#define TYPE(X) \
const char X ## _str [] = #X; \
struct X \
{ \
    static const char *name() { return X ## _str; }  \
    enum{ name_size = sizeof(X ## _str) }; \
}; \
/**/

/****************************************************/

struct nil {};

template<typename Head, typename Tail = nil>
struct List
{
    typedef Head head;
    typedef Tail tail;
};

/****************************************************/

template<typename list>
struct sum_size
{
    enum { value = list::head::name_size - 1 + sum_size<typename list::tail>::value };
};
template<>
struct sum_size<nil>
{
    enum { value = 0 };
};

/****************************************************/

template<typename list>
struct fill_string
{
    static void call(char *out)
    {
        typedef typename list::head current;
        const char *first = current::name();
        fill_string<typename list::tail>::call
        (
            copy(first, first + current::name_size - 1, out)
        );
    }
};

template<>
struct fill_string<nil>
{
    static void call(char *out)
    {
        *out = 0;
    }
};

/****************************************************/

template<typename list>
const char *concate_names()
{
    static char result[sum_size<list>::value + 1];
    static bool calculated = false;
    if(!calculated)
    {
        fill_string<list>::call(result);
        calculated = true;
    }
    return result;
}

/****************************************************/

TYPE(foo)
TYPE(bar)
TYPE(baz)

typedef List<foo, List<bar, List<baz> > > foo_list;

int main()
{
    cout << concate_names<foo_list>() << endl; 
}

输出是：

foobarbaz

PS你如何使用连接字符串？也许我们根本不需要生成连接字符串，减少数据空间需求。

例如，如果您只需要打印字符串 - 那么

template<typename list>
void print();

就足够了。但缺点是在减少数据大小的同时 - 这可能会导致代码大小增加。

于 2013-10-30T23:34:44.383 回答
3
  1. 您可以制作字符串 static，并且只需要在运行时构造一次字符串，并且仅在需要时构造一次。
  2. 然后返回它们的 const 引用，这样就不会有任何不必要的复制。

例子：

template<class Foo, class Tail = nil>
struct foo_list {
  static const std::string& name_list() {
     static std::string names = Foo::name() + std::string("-") + Tail::name();
     return names;
  }
};

template<class Foo>
struct foo_list<Foo,nil> {
  static const std::string& name_list() {
     static std::string names = Foo::name();
     return names;
  }
};

可能不是您将编写的确切代码，但我认为这给了您重点。此外，您可以const char*通过执行返回 a names.c_str()。

于 2013-10-23T07:34:19.150 回答
2

您可以考虑使用外部构建步骤而不是语言解决方案。例如，您可以编写一个基于 Clang 的工具来解析相关文件并T::name在另一个 TU 中自动创建实现。然后将其集成到您的构建脚本中。

于 2013-10-30T22:49:49.600 回答
0

如果我们可以假设您唯一的要求是实际流式传输类的名称 - 这意味着您不需要在其他地方作为一个整体连接字符串 - 您可以简单地推迟流式传输但仍然受益于元编程（正如 Evgeny 已经指出）。

虽然此解决方案不能满足您的要求 #1（一个连接字符串），但我仍然想为其他读者指出一个解决方案。

这个想法不是通过编译时类型列表，而是从所有T::name()函数构建一个地址序列，并在需要时将其传递给流函数。这是可能的，因为具有外部链接的变量可以用作模板非类型参数。当然，您的里程可能会因数据和代码大小而异，但除非您处于高性能环境中，否则我希望这种方法至少同样适用，因为不必在运行时创建额外的字符串。

请注意，我特意使用了可变参数模板（在 C++03 中不可用），因为它更具可读性并且更易于推理。

“小提琴”在这里可用。

#include <ostream>
#include <boost/core/ref.hpp>
#include <boost/bind.hpp>
#include <boost/mpl/vector.hpp>
#include <boost/mpl/for_each.hpp>

namespace mpl = boost::mpl;


template<typename>
class foo_base
{};

#define DECLARE_FOO(Foo_) \
    struct Foo_ : public foo_base<Foo_> { \
        static char const* name() {return #Foo_;} \
    };


// our own integral constant because mpl::integral_c would have to be specialized anyway
template<typename T, T Value>
struct simple_integral_c
{
    operator T() const { return Value; }
};

template<typename T, T ...Values>
struct ic_tuple : mpl::vector<simple_integral_c<T, Values>...>
{};


typedef const char*(*NameFunction)();

template <NameFunction ...Functions>
struct function_list : ic_tuple<NameFunction, Functions...>
{};

template <typename ...Types>
struct function_of_list : function_list<&Types::name...>
{};


struct print_type
{
    void operator ()(std::ostream& os, NameFunction name)
    {
        if (nth++)
            os << "-";
        os << name();
    }

    print_type(): nth(0) {}

private:
    int nth;
};

// streaming function
template<NameFunction ...Functions>
std::ostream& operator <<(std::ostream& os, function_list<Functions...>)
{
    mpl::for_each<function_list<Functions...>>(
        boost::bind<void>(print_type(), boost::ref(os), _1)
    );

    return os;
}

如今，使用 C++14 的人可能会使用像 hana 这样的强大库来编写解决方案，请参阅这个hana fiddle。

于 2017-01-04T21:08:25.567 回答