小编0xb*_*00d的帖子

27.6.3.4.2缓冲区管理和定位

pos_type seekoff(off_type off, ios_base::seekdir way,
    ios_base::openmode which = ios_base::in | ios_base::out);

Run Code Online (Sandbox Code Playgroud)

• 效果:以一种basic_streambuf为本条款(27.8.2.4,27.9.1.5)中派生的每个类别单独定义的方式改变一个或多个受控序列中的流位置.
• 默认行为:返回pos_type(off_type(-1)).

到现在为止还挺好.basic_streambuf我正在使用的派生可以单独改变其位置ios_base::in和/或ios_base::out.但是,当指定两者时,我需要返回什么？

如果指定ios_base::in or ios_base::out,我们将返回特定序列的新流位置.

当前草案的以下摘录显示了我的意思:

namespace std {
    typedef struct atomic_bool {
        bool is_lock_free() const volatile;
        bool is_lock_free() const;
        void store(bool, memory_order = memory_order_seq_cst) volatile;
        void store(bool, memory_order = memory_order_seq_cst);
        bool load(memory_order = memory_order_seq_cst) const volatile;
        bool load(memory_order = memory_order_seq_cst) const;
        operator bool() const volatile;
        operator bool() const;
        bool exchange(bool, memory_order = memory_order_seq_cst) volatile;
        bool exchange(bool, memory_order = memory_order_seq_cst);
        bool compare_exchange_weak(bool&, bool, memory_order, memory_order) volatile;
        bool compare_exchange_weak(bool&, bool, memory_order, memory_order);
        bool compare_exchange_strong(bool&, bool, memory_order, memory_order) volatile;
        bool compare_exchange_strong(bool&, bool, memory_order, memory_order);
        bool compare_exchange_weak(bool&, bool, …

我正在寻找一种高效的方法来将第二个ICollection的不同项添加到现有的ICollection中.我正在使用.NET 4.

我正在使用Entity Framework 4.1和Code First方法.我能够获取我的实体的存储模型类型和列名:

var items = context.ObjectContext.MetadataWorkspace.GetItems<EntityType>(DataSpace.SSpace);

foreach (var i in items)
{
    Console.WriteLine("Table Name: {0}", i.Name);

    Console.WriteLine("Keys:");
    foreach (var key in i.KeyMembers)
        Console.WriteLine("\t{0} ({1})", key.Name, key.TypeUsage.EdmType.FullName);

    Console.WriteLine("Members:");
    foreach (var member in i.Members)
        Console.WriteLine("\t{0} ({1})", member.Name, member.TypeUsage.EdmType.FullName);
}

我需要的是获取实体映射到的真实表名.有不同的方法来指定(通过使用Fluent-API .ToTable(),DataAnnotation [TableAttribute]).

有没有通用的方法来获得这些信息？

我正在使用一个内存池类,它重用已分配的内存地址和一个包装该类的自定义分配器.以下代码段为您提供了界面的基本概念.

template<class alloc>
class memory_pool
    : boost::noncopyable,
      public allocator_traits<void>
{
public:
    memory_pool(typename alloc::size_type alloc_size);
    memory_pool(typename alloc::size_type alloc_size, alloc const&);
    template<typename U> memory_pool(typename alloc::size_type alloc_size,
        typename alloc::rebind<U>::other const&);
    virtual ~memory_pool();

    pointer allocate  (); /*throw(std::bad_alloc)*/
    void    collect   ();
    void    deallocate(pointer) throw(); /*noexcept*/
};

pointer allocate()
{/*
    Checks if a suitable chunk of memory is available in a internal linked list.
    If true, then the chunk is returned and the next chunk moves up.
    Otherwise, new memory is allocated by the underlying allocator. …

我想返回一个boost::system::error_code指示是否可以解析主机/服务.主机/服务查找失败可能有多种原因(例如,网络连接问题或无效参数).

应该归还什么？

Currenty,我使用以下代码来获取国家/地区,邮政编码,地区和子地区:

var country, postal_code, locality, sublocality;
for (i = 0; i < results[0].address_components.length; ++i)
{
    for (j = 0; j < results[0].address_components[i].types.length; ++j)
    {
        if (!country && results[0].address_components[i].types[j] == "country")
            country = results[0].address_components[i].long_name;
        else if (!postal_code && results[0].address_components[i].types[j] == "postal_code")
            postal_code = results[0].address_components[i].long_name;
        else if (!locality && results[0].address_components[i].types[j] == "locality")
            locality = results[0].address_components[i].long_name;
        else if (!sublocality && results[0].address_components[i].types[j] == "sublocality")
            sublocality = results[0].address_components[i].long_name;
    }
}

那令人不满意.有没有其他方法可以达到相同的效果？

每个集合包含指定顺序的元素.我想指定一个集合大小的界限,并自动删除最后一个元素,如果插入一个严格较小的(按顺序而言)新的元素并且已达到指定的大小.

当然,我可以做类似以下的事情:

class bounded_set
{
private:
    using set = std::set<Key, Compare, Allocator>;
    using iterator = typename set::iterator;

public:
    bounded_set(std::size_t size)
        : m_size(size)
    { }

    std::pair<iterator, bool> insert(Key const& value)
    {
        if (m_set.size() < m_size)
            return m_set.insert(value);

        auto last = std::prev(m_set.end());
        if (Compare()(value, *last))
        {
            m_set.erase(last);
            return m_set.insert(value);
        }
        return std::make_pair(last, false);
    }

private:
    set m_set;
    std::size_t m_size;
};

除了事实,这bounded_set不是最好的名字(因为有界容器在并发编程领域是众所周知的事情),我担心这个实现中的内存分配.最有可能的是,起初使用的空间last将被释放.但在此之后,需要分配新的内存value.

我真正想做的是,使用分配的内存last并将数据复制value到这个地方,同时保留订单.

根据英特尔64和IA-32架构软件开发人员手册,LOCK信号前缀"确保处理器在声明信号时独占使用任何共享内存".这可以是总线或缓存锁的形式.

但是 - 这就是我问这个问题的原因 - 我不清楚,如果这个前缀也提供了任何内存屏障.

我正在多处理器环境中使用NASM进行开发,并且需要使用可选的获取和/或发布语义来实现原子操作.

那么,我是否需要使用MFENCE,SFENCE和LFENCE指令或者这是多余的？

20.6.9:

void deallocate(pointer p, size_type n);

• 要求:p应为从allocate()获得的指针值.n应该将作为第一个参数传递的值等于返回p的allocate的调用.
• 效果:释放p引用的存储.
• 备注:使用:: operator delete(void*)(18.6.1),但在调用此函数时未指定.

如果n不等于作为第一个agrgument传递给返回的allocate调用的值,会发生什么p？不解除分配？扔std::bad_alloc？...

编辑: 我实际上对"应该发生什么"的意思是:在自定义实现中抛出或断言是否可以？