Question

过去，我使用gcc的C99-style compound-literal extension到C ++来编码代码中的嵌套常量数据结构。这是一个例子：

#include <iostream>
using namespace std;

struct Tree {
    const char *name;
    const Tree *left;
    const Tree *right;
};

const Tree *const tree = (Tree []) {
    "top", // name
    (Tree[]) {
        "left",
        0,
        0
    },
    (Tree[]) {
        "right",
        0,
        0
    }
};

static void dump(const Tree *tree) {
    if (!tree) {
        cout << "null";
        return;
    }

    cout << tree->name << "(";
    dump(tree->left);
    cout << ", ";
    dump(tree->right);
    cout << ")";
}

int main(void) {
    dump(tree);
    cout << "\n";
}

这个想法是为这些相当大的常量结构使用静态存储持续时间，初始化成本为零，实际上除非需要，否则不需要将任何内容分页到内存中。

然而，这在clang的最新版本中不再有效，而最新的OS X正在以“gcc”的名义捆绑clang。所以我需要一个不同的解决方案。

C ++中最符合标准的标准是什么？

我并不特别想支付构建这些结构中所有对象的成本，所以如果可以避免，那就太棒了。

Answer 1

C ++ 11 uniform initialization语法应该有效：

const Tree* const tree = new Tree{"top",
    new Tree{"left", nullptr, nullptr},
    new Tree{"right", nullptr, nullptr}
};

否则，只需创建一个构造函数，将名称和子树作为参数。

如果您不希望动态分配结构，则必须自己创建每个结构，然后使用例如将它们链接在一起。地址 - 运营商：

namespace
{
    const Tree leftTree{"left", nullptr, nullptr};
    const Tree rightTree{"right", nullptr, nullptr};
    const Tree topTree{"top", &leftTree, &rightTree};
}

const Tree* const tree = &topTree;

Answer 2

如果大型复杂类型不是递归的，那么你可以简单地使用constexpr类型和统一初始化而没有任何技巧。

struct B { int i; };
struct C { double d; };

struct A {
  B b;
  C c;
};

constexpr A {B{1},C{3.2}};

但是，因为它是一棵树，你不能只有这样的递归类型（因为大小是无限的），所以必须使用技巧。我能想到两种方法。首先是使用指针或引用，以避免无限递归。

使用指针，您需要一种创建静态对象并获取指针的方法。我不认为C ++有任何允许你在一个表达式中执行此操作的东西，因此需要对树中的每个节点进行声明，这是不方便的。

使用引用你需要某种方式来表示一个空节点（因为引用本身不是可空的，没有危险的黑客攻击）。这是一个简单的实现：

struct Tree {
    const char *name;
    Tree const &left;
    Tree const &right;
};

constexpr Tree Null{nullptr,Null,Null};

void print_tree(Tree const &t) {
  if (&t == &Null) {
    std::cout << "()";
    return;
  }
  std::cout << '(' << t.name << ", ";
  print_tree(t.left);
  std::cout << ", ";
  print_tree(t.right);
  std::cout << ")";
}

constexpr Tree a {"a",
                  Tree{"b",
                       Null,
                       Tree{"d",Null,Null}},
                  Tree{"c",Null,Null}};

int main() {
  print_tree(a);
}

避免递归的第二种方法是使用模板为每个不同的树结构生成不同的类型。

template<typename LTree, typename RTree>
struct Tree {
    const char *name;
    LTree left;
    RTree right;
};

struct null_tree_t {};
constexpr null_tree_t null_tree{};

template<typename RTree>
struct Tree<null_tree_t, RTree> {
    const char *name;
    RTree right;
};

template<typename LTree>
struct Tree<LTree, null_tree_t> {
    const char *name;
    LTree left;
};

template<>
struct Tree<null_tree_t, null_tree_t> {
    const char *name;
};

// C++14 return type deduction
template<typename LTree, typename RTree>
constexpr auto make_tree(const char *name, LTree ltree, RTree rtree) {
    return Tree<LTree, RTree>{name, ltree, rtree};
}

template<typename LTree>
constexpr auto make_tree(const char *name, LTree ltree) {
    return Tree<LTree, null_tree_t>{name, ltree};
}

template<typename RTree>
constexpr auto make_tree(const char *name, null_tree_t, RTree rtree) {
    return Tree<null_tree_t, RTree>{name, rtree};
}

constexpr auto make_tree(const char *name) {
    return Tree<null_tree_t, null_tree_t>{name};
}

template<typename LTree, typename RTree>
void print(Tree<LTree, RTree> const &tree) {
  std::cout << '{' << tree.name << ", ";
  print(tree.left);
  std::cout << ", ";
  print(tree.right);
  std::cout << '}';
}

template<typename LTree>
void print(Tree<LTree, null_tree_t> const &tree) {
  std::cout << '{' << tree.name << ", ";
  print(tree.left);
  std::cout << ", {}}";
}

template<typename RTree>
void print(Tree<null_tree_t, RTree> const &tree) {
  std::cout << '{' << tree.name << ", {}, ";
  print(tree.right);
  std::cout << "}";
}

void print(Tree<null_tree_t, null_tree_t> const &tree) {
  std::cout << '{' << tree.name << "}";
}

constexpr auto a = make_tree("a",
                             make_tree("b",
                                       null_tree,
                                       make_tree("d")),
                             make_tree("c"));

int main() {
  print(a);    
}

这样一个叶子节点的类型为Tree<null_tree_t, null_tree_t>，一个树的左子节点是一个叶子节点是Tree< Tree<null_tree_t, null_tree_t>, null_tree_t>，一个带有左子节点的树，它有一个正确的子节点，它是一个叶子节点：

Tree<
  Tree<
    null_tree_t,
    Tree<
      null_tree_t,
      null_tree_t>>,
  null_tree_t>

等

如何在C ++中编码大型复杂，常量的数据结构

2 个答案: