相关疑难解决方法(0)

为了提高效率std::vector<T>,它的底层数组需要预先分配,有时需要重新分配.然而,这需要创建和稍后移动T具有复制ctor或移动ctor 的类型的对象.

我遇到的问题是T无法复制或移动,因为它包含无法复制或移动的对象(例如atomic和mutex).(是的,我正在实现一个简单的线程池.)

我想避免使用指针,因为:

1. 我不需要间接水平,所以我不想要一个.
2. (指针效率较低,增加了复杂性.使用指针会增加内存碎片并减少数据局部性,这可能(但不一定必须)导致明显的性能影响.不是那么重要,但仍值得考虑.)

有没有办法避免间接水平？

更新:根据评论和答案中的反馈,我修正了一些不正确的假设,并重新措辞了问题.

我有一个类似下面的课程.

#include <atomic>

static const long  myValue = 0;

class Sequence
{

public:

    Sequence(long initial_value = myValue) : value_(initial_value) {}


private:

     std::atomic<long> value_;
};

int main()
{
         Sequence firstSequence;
         Sequence secondSequence = firstSequence;
         return 0;
}

我收到这样的编译错误,

test.cpp:21:36: error: use of deleted function ‘Sequence::Sequence(const Sequence&)’
test.cpp:5:7: error: ‘Sequence::Sequence(const Sequence&)’ is implicitly deleted because the default definition would be ill-formed:
test.cpp:5:7: error: use of deleted function ‘std::atomic<long int>::atomic(const std::atomic<long int>&)’

这是默认的复制构造函数,赋值opertaor在这种情况下不起作用吗？

PS:我使用的是gcc 4.6.3版

我有一个C++库,它应该在多个线程上进行一些计算.我创建了独立的线程代码(即它们之间没有共享变量),除了一个数组.问题是,我不知道如何使其成为线程安全的.

我看了互斥锁/解锁(QMutex因为我正在使用Qt),但它不适合我的任务 - 而一个线程将锁定互斥锁,其他线程将等待!

然后我读到了std::atomic,看起来就像我需要的那样.不过,我尝试以下列方式使用它:

std::vector<std::atomic<uint64_t>> *myVector;

并且它产生了编译器错误(使用已删除的函数'std :: atomic :: atomic(const std :: atomic&)').然后我找到了解决方案 - 使用特殊的包装器std::atomic.我试过这个:

struct AtomicUInt64
{
    std::atomic<uint64_t> atomic;

    AtomicUInt64() : atomic() {}

    AtomicUInt64 ( std::atomic<uint64_t> a ) : atomic ( atomic.load() ) {}

    AtomicUInt64 ( AtomicUInt64 &auint64 ) : atomic ( auint64.atomic.load() ) {}

    AtomicUInt64 &operator= ( AtomicUInt64 &auint64 )
    {
                atomic.store ( auint64.atomic.load() );
    }
};

std::vector<AtomicUInt64> *myVector;

这个东西成功编译,但是当我无法填充向量时:

myVector = new std::vector<AtomicUInt64>();

for ( int …

使动态数组线程安全且并发是什么意思？比如说,std::vector.

1. 两个线程可能想要插入相同的位置.不需要同步,因为它将根据线程调度完成.
2. 一个线程擦除而另一个线程将访问相同的元素？这不是数据结构问题我认为,这是一个使用问题.

那么有什么需要做的std::vector才能使它成为线程安全和并发的,或者它是默认的线程安全和并发的吗？

C++ ：我有一个vector<bool>，没有线程会向任何索引写入 false 。我还应该使用锁吗？我认为它不会导致竞争条件，因为所有线程都在写入相同的 value 。多个线程访问的函数如下所示：

void setVal(int index) 
{
  if (boolvec[index] == false)
    boolvec[index] = true; 
}