小编gma*_*dau的帖子

首先,我有这样的事情:

class Test {
    std::vector<int> a, b;
    void caller(...) { callee(...); }
    void callee(...) { /* Do stuff with 'a' */ }
}

我想要的是拥有一个与callee 矢量完全相同的功能b.要做到这一点,有两个明显的解决方案:

• 传递矢量a或b作为参数.但是,callee一个递归函数可以进行数百次调用,并将向量作为参数传递只是不必要的开销.
• 复制函数callee和使用向量b,这将是最好的选择,尽管这callee是一个相当长的函数,我会有很多重复的代码.

出于好奇,我去寻找模板部分,我注意到可以用于

左值参考类型

指针类型

指向成员类型的指针

所以我试着这样做:

class Test {
    std::vector<int> a, b;
    void caller(...) { callee<a>(...); }
    template <std::vector<int> &x> void callee(...) { /* Do stuff with 'x' */ }
}

但我明白了

错误:在常量表达式中使用'this'

有没有办法用引用或指针实现这个？

顺便说一句,我想要的东西可以被视为功能范围 #define

所以，我在一个文件中有这两个数据类：

@dataclass
class A:
    children: List[B]

@dataclass
class B:
    parent: A

，这可以通过使用该__future__.annotations功能来实现。

然后我有另外两个文件，每个文件都有一堆对于我的项目来说是静态的每种类型的对象。

文件objects_A：

import objects_B

obj_a1 = A(
    children=[
        objects_B.obj_b1,
        objects_B.obj_b2
    ]
)

文件objects_B：

import objects_A

obj_b1 = B(
    parent=objects_A.obj_a1
)

obj_b2 = B(
    parent=objects_A.obj_a1
)

显然，文件之间存在循环依赖问题，但即使它们位于同一个文件中，它也不起作用，因为一种类型的变量依赖于另一种类型的变量才能成功。
初始化B内部对象obj_a1也不起作用，因为self这里没有概念。

目前，我设置parent为None（针对类型提示），然后循环进行设置obj_a1：

for obj_b in obj_a1.children:
    obj_b.parent = obj_a1

大家有什么好主意吗？
不知道它是否有帮助，但是这些对象是静态的（它们在这些声明之后不会改变）并且它们具有某种父子关系（正如您肯定已经注意到的那样）。
如果可能的话，我希望将每种类型的变量放在不同的文件中。

我最近一直试图理解c ++分配器是如何工作的,而且我一直在寻找STL库使用的红黑树的实现,std::set或者std::map有些东西是我无法得到的.到处走走.

首先要做的是将分配器从容器必须存储_Val的类型 - 转换为树使用的节点类型_Rb_tree_node<_Val>- 使用重新绑定模板:

typedef typename __gnu_cxx::__alloc_traits<_Alloc>::template
    rebind<_Rb_tree_node<_Val> >::other _Node_allocator;

typedef __gnu_cxx::__alloc_traits<_Node_allocator> _Alloc_traits;

我可以解决这个问题.

现在,当插入一个元素并且需要创建一个新节点时,它的作用就是这个

_Node_type __node = _Alloc_traits::allocate(_M_get_Node_allocator(), 1);

我假设为单个节点分配空间.但是它就是这样做的

::new(__node) _Rb_tree_node<_Val>;

我真的不知道它做了什么,因为__node已经分配了空间.但在此之后它也会这样做

_Alloc_traits::construct(_M_get_Node_allocator(), __node->_M_valptr(), ...);

这让我更加困惑,因为它应该构建一个节点(是节点分配器),但是它传递了__node->_M_valptr()类型的指针_Val*.

如果有人能够解释这一点,我将非常感激.

我有以下内容:

template <typename X> struct A {
    typedef X _X;
};

template <typename Y> struct B { // Y is struct A
    typename Y::_X x;
    void call_destructor () {
        x.~Y::_X(); // This doesn't work
        x.Y::~_X(); // This as well
    }
}; 

这不会编译,说

限定类型与析构函数名称不匹配

typename在通话之前使用关键字也不起作用.但是,以下编译:

template <typename Y> struct B {
    typename Y::_X x;
    typedef typename Y::_X __X;
    void call_destructor () {
        x.~__X(); // This works
    }
};

有人可以向我解释为什么,有没有办法让没有typedef？

为什么报告错误:

class a {
public:
    void b() {this->c++;}
};

int main() {
    a var;
}

但这不是吗？

template <typename d> class a {
public:
    void b() {this->c++;}
}; 

int main() {
    a<int> var;
}

尽管"a"是模板类,但函数"b"或至少对变量"c"的访问不依赖于类型"d",因此它应该报告某些内容.

但是,如果我调用"var.b();" 在主函数中它给出了一个错误.

我知道这是一个简单的问题我真的无法理解.