Question

我想用C ++创建一个简单 HTML dom生成器，并决定我将使用模板化的tag<>类来描述标签的类型。

我已经使用其他方法在C ++中成功地创建了DOM，但是该设计无法处理原始字符串，因此，转向模板化类可能会帮助我使用模板专业化来处理（tag<plain> ）。

现在的问题是使用可变参数模板将标签嵌套在其构造函数中。我已经可以使用node来实现它，它包含根级别的标签，但是任何标签内标签嵌套都是不行的。

#include <map>
#include <string>
#include <tuple>
#include <utility>

namespace web {
enum class attrs { charset, name, content, http_equiv, rel, href, id, src, lang };

using attribute = std::pair<attrs, std::string>;

using attribute_type = std::map<attrs, std::string>;

const auto none = attribute_type{};

enum tag_name { html, head, meta, title, link, body, div, script, plain, p, h1, span };

template <typename... Tags> struct node {
    int increment;
    std::tuple<Tags...> tags;

    explicit node(const int incr, Tags... tggs)
        : increment{incr}, tags{std::make_tuple(tggs...)} {}
};

template <tag_name T, typename... Tags> struct tag {
    attribute_type attributes;
    std::tuple<Tags...> tags;

    explicit tag(attribute_type atts, Tags... tggs)
        : attributes{atts.begin(), atts.end()}, tags{std::make_tuple(tggs...)} {
    }
};

template <> struct tag<plain> {
    std::string content;

    explicit tag(std::string val) : content{std::move(val)} {}
};
} // namespace web

int main() {
    using namespace web;
    node page1{2};
    node page2{2, tag<html>{none}};
    node page3{2, tag<html>{{{attrs::lang, "en"}}}};
    node page4{2, tag<meta>{{{attrs::name, "viewport"},
                                  {attrs::content,
                                   "width=device-width, initial-scale=1.0"}}}};
    node page5{2, tag<head>{none}, tag<body>{none}, tag<plain>{"Hello World"}}; // Yet this line still compiles and works as expected...
    node page6{1, tag<span>{none, tag<h1>{none}}}; // error: no matching constructor for initialization of 'tag<html>'
}

我想知道我如何能够在node类内聚合标签，但不能在tag类内进行聚合，并且如果可能的话，我将能够解决此问题。

Answer 1

这似乎是模板类类型推导的问题。一个简单的函数包装器（或C ++ 17演绎指南）可以消除歧义。

无论如何，到这里去（这在C ++ 17模式下的gcc 8.3中有效）：

#include <map>
#include <string>
#include <tuple>
#include <utility>

namespace web
{
    enum class attrs { charset, name, content, http_equiv, rel, href, id, src, lang };

    using attribute = std::pair<attrs, std::string>;

    using attribute_type = std::map<attrs, std::string>;

    const auto none = attribute_type{};

    enum tag_name { html, head, meta, title, link, body, div, script, plain, p, h1, span };

    template <typename... Tags>
    struct node
    {
        int increment;
        std::tuple<Tags...> tags;

        explicit node(const int incr, Tags... tggs) : increment{incr}, tags{tggs...} {}
    };

    template <tag_name T, typename... Tags>
    struct tag
    {
        attribute_type attributes;
        std::tuple<Tags...> tags;

        explicit tag(const attribute_type &atts, Tags... tggs) : attributes(atts), tags(tggs...) {}
    };

    template <>
    struct tag<plain>
    {
        std::string content;

        explicit tag(std::string val) : content(std::move(val)) {}
    };

    template<typename ...Args>
    auto make_node(int incr, Args &&...args)
    {
        return node<std::decay_t<Args>...> ( incr, std::forward<Args>(args)... );
    }
    template<tag_name T, typename ...Args>
    auto make_tag(const attribute_type &atts, Args &&...args)
    {
        return tag<T, std::decay_t<Args>...> ( atts, std::forward<Args>(args)... );
    }
} // namespace web



int main() {
    using namespace web;
    node page1{2};
    node page2{2, tag<html>{none}};
    node page3{2, tag<html>{{{attrs::lang, "en"}}}};
    node page4{2, tag<meta>{{{attrs::name, "viewport"},
                                  {attrs::content,
                                   "width=device-width, initial-scale=1.0"}}}};
    node page5{2, tag<head>{none}, tag<body>{none}, tag<plain>{"Hello World"}};
    auto page6 = make_node(1, make_tag<span>(none, make_tag<h1>(none))); // works now - uses our make functions
}

Answer 2

代码中的问题是C ++ 17中引入的推导指南仅能推导所有模板参数。

所以打电话

node page2{2, tag<html>{none}};

之所以起作用，是因为

（1）tag<html>{none}不需要模板推导，因为在可变参数列表（Tags...）为空（none之后没有参数）的地方，第一个模板参数被简化了，因此{ {1}}是tag和

（2）tag<html>的自动推论指南推导出所有模板参数（node），因此Tags...推导为page2。

写时会出现问题

node<tag<html>>

因为对于tag<span>{none, tag<h1>{none}}，在tag<span>之后有一个参数，所以可变参数列表none不能为空，但不能（自动地，通过隐式推导）是因为您已经说明了第一个模板参数（Tags...）。

您显然可以解决问题，如Cruz Jean所建议的那样，添加一个span函数，但是我为您提出了一个使用自动演绎指南的解决方案。

首先，为make_tag()定义包装类w

tag_name

然后使用 two 构造函数重写template <tag_name> struct w { };类；内部tag

为空的情况下的第一个

tags

一般情况下的第二个（也不是空的内部explicit tag (attribute_type atts) : attributes{std::move(atts)} { }列表）接收一个tags元素，该元素也允许自动w<T>推论

第一个构造函数允许保留格式

  explicit tag (w<T>, attribute_type atts, Tags... tggs)
     : attributes{std::move(atts)}, tags{tggs...}
  { }

如果不包含标签；第二个则允许这种类型的tag<html>{none}对象声明

tag

以下是完整的编译示例

 tag{w<html>{}, none}

 tag{w<span>{}, none, tag<h1>{none}}

在构造函数的可变参数中使用其他模板类执行模板类的初始化

2 个答案: