小编Jos*_*son的帖子

我希望创建一个std::type_index不需要RTTI的替代方案:

template <typename T>
int* type_id() {
    static int x;
    return &x;
}

请注意,局部变量的地址x用作类型ID,而不是其x自身的值.另外,我不打算在现实中使用裸指针.我刚刚删除了与我的问题无关的所有内容.在这里查看我的实际type_index实现.

这种方法听起来是否合理,如果是这样,为什么？如果没有,为什么不呢？我觉得我在这里不稳定,所以我对我的方法将会或不会起作用的确切原因感兴趣.

典型的用例可能是在运行时注册例程以通过单个接口处理不同类型的对象:

class processor {
public:
    template <typename T, typename Handler>
    void register_handler(Handler handler) {
        handlers[type_id<T>()] = [handler](void const* v) {
            handler(*static_cast<T const*>(v));
        };
    }

    template <typename T>
    void process(T const& t) {
        auto it = handlers.find(type_id<T>());
        if (it != handlers.end()) {
            it->second(&t);
        } else {
            throw std::runtime_error("handler not registered");
        }
    }

private:
    std::map<int*, …

struct Bar {
    template<typename>
    void baz() {
    }
};

template<typename>
struct Foo {
    Bar bar;

    Foo() {
        bar.baz<int>();
    }
};

int main() {
    return 0;
}

这段代码编译得很好(在GCC 4.7中),但如果我将调用前缀bar.baz<int>()加上this->,则baz成为需要消除歧义的从属名称template.

bar.baz<int>(); // OK
this->bar.baz<int>(); // error
this->bar.template baz<int>(); // OK

当然this->bar只能参考Bar bar,其成员baz显然是模板？为什么添加this->使代码对编译器不明确？

ps最初,bar是一个需要消除歧义的基类模板的数据成员this->,但为了这个问题,我简化了示例.

LWG 2424讨论了在C++ 14中可原则复制的原子,互斥和条件变量的不良状态.我很欣赏修复已经排好,但是std::mutex,std::condition variable等等.似乎有非平凡的析构函数.例如:

30.4.1.2.1类互斥[thread.mutex.class]

namespace std {
  class mutex {
  public:
    constexpr mutex() noexcept;
    ~mutex(); // user-provided => non-trivial

    …
  }
}

Run Code Online (Sandbox Code Playgroud)

这不应该取消他们作为平凡的可复制资格吗？

我有一个泛型类型,Vec2<T>我想为此实现以下操作:

Vec2<T> = T * Vec2<T>

我试过这个:

impl<T: Copy + Mul<Output = T>> Mul<Vec2<T>> for T {
    type Output = Vec2<T>;

    fn mul(self, rhs: Vec2<T>) -> Vec2<T> {
        Vec2 {
            x: self * rhs.x,
            y: self * rhs.y,
        }
    }
}

但我得到这个错误:

type参数T必须用作某些本地类型的类型参数(例如MyStruct<T>); 只有当前包中定义的特征可以为类型参数实现

使用您自己的类型作为右侧操作数重载运算符的标准方法是什么？

[编辑]

显然答案是你目前无法做到这一点."重复"中的相关问题有一些答案.我等待语言的更新,以便可以重新打开这个问题,并且可以给出实际的答案.

我有一个数组，其中每个条目都是一个链表。为了避免访问链表时出现同步问题，我为每个条目添加了一个互斥锁。

我的问题是，我可以转换成以下调用lock，并unlock在循环一个的每次迭代lock_guard，如下图所示？每次迭代后都会解锁每个条目的互斥锁吗？谢谢。

for(int i = 0; i < TABLE_SIZE; ++i)
{
    table[i].entryMtx.lock ();

    //... access the linked list of the entry...

    table[i].entryMtx.unlock ();
}

// --->

for(int i = 0; i < TABLE_SIZE; ++i)
{
    std::lock_guard < std::mutex > lk (table[i].entryMtx);

    // ... access the linked list of the entry
}