标签: stdlist

人们通常如何管理复制大型物体列表？

这是我的情况:

目前我有这个:

typedef std::vector<float> Image;  

我把它存放在一个

std::list<Image> lst;

Image.size()非常大(每个大约3-5 MB).

我正在传递(复制)列表.

我是否正确理解std :: vector将按值复制每个元素？如果是这样,由于过度复制,性能可能有点糟糕？

我该怎么做才能减少复制？我应该存储

std::list<ImageRef> lst;

哪里

typedef boost::shared_ptr<Image>   ImageRef;

？

处理这类问题的优雅方式是什么？

我想std::list通过指定它的值来创建一个,我想在一行中创建它,例如:

std::list<std::string> myList("Cat", "Dog", "Pig"); // doesn't compile

我找不到简单的方法std::list(我对c ++参考的例子不满意),我错过了什么吗？如果标准列表无法实现,是否有原因？那么实现它的最简单方法是什么？

提前致谢.

考虑以下:

for (it = list.begin(); it != list.end(); ++it) {
    if (!(*it)->alive) {
        it = list.erase(it);
    }
}

这个工作正常list.size() > 1.一旦列表只包含一个元素,则调用erase segfaults.我假设因为没有下一个元素.至少,这是我观察到的行为.有没有正确的方法来处理这个？也许是完全不同的方法？

如您所见,我不想立即清除列表.我想在它们死亡时删除元素,这样可以正常工作,直到它删除最后一个元素.

我有一个指针列表,它们引用了需要转向我游戏的时间对象.此示例TimeObject*在列表中有两个.此代码有效,直到从列表中删除某个项目:当发生这种情况时,另一个项目指向无效的地址.TimeObject发生这种情况时都不会被删除; 只有指针从列表中删除.是什么造成的？

TimeUnlink()被称为TimeObject::Tick().它不是静态的,但列表是.

我在Linux上使用GCC 4.6.2.该程序没有线程.

void TimeObject::TimeUnlink()
{
    printf("Time unlink\n");

    TimeObject::list_.remove(this);

    timeobject_flags_.linked_ = 0;
}

void GameTime::GameTurn(uint16_t _time)
{
    tick_ += _time;

    for(std::list<TimeObject*>::iterator it = TimeObject::list_.begin(); it != TimeObject::list_.end(); ++it)
    {
        TimeObject *timeobject = *it;

        printf("GameTurn %p\n", timeobject);

        if(timeobject == NULL) { printf("continue\n"); continue; }

        timeobject->time_ += _time;

        if(timeobject->speed_ && timeobject->time_ >= timeobject->speed_)
        {
            while(timeobject->timeobject_flags_.linked_ && timeobject->time_ - timeobject->speed_ > 0)
            {
                timeobject->time_ -= timeobject->speed_;

                if(timeobject->mapobject_)
                {
                    timeobject->mapobject_->Tick();
                }
            }
        }
    }
} …

我正在写一个测试程序,发现了一个非常有趣std::list的行为案例.

#include <list>
#include <algorithm>
#include <iostream>

int main()
{
    std::list<int> mylist;
    std::list<int>::iterator iter;
    for(int i=3; i<10; ++i){
        mylist.push_back(i);
    }
    iter = mylist.begin();
    iter--;
    iter--;
    std::cout<<*iter<< std::endl;
    std::cout<<std::distance(mylist.end(), mylist.begin())<<std::endl;
}

输出是:

9  
1  

如果我没有弄错,这种行为与循环列表有关.我从未见过论坛,书籍或讨论,其中提到标准列表是循环列表.我的GCC版本是4.1.2.我是对的吗？标准std::list是循环列表吗？

如何消除内存泄漏std::list？

这只是示例代码:

#define _CRTDBG_MAP_ALLOC
#include <stdlib.h>
#include <crtdbg.h>

#include <iostream>
#include <list>
using namespace std;

void main()
{
    list<int> a;
    a.clear();
    _CrtDumpMemoryLeaks();
}

当我尝试运行它时,它显示一些内存泄漏.

那么,如何删除它？

如果我正确理解基于范围的for循环,它会扩展

for ( range_declaration : range_expression ) loop_statement

成

{
    auto && __range = range_expression ;
    for (auto __begin = begin_expr, __end = end_expr;
            __begin != __end; ++__begin) {
        range_declaration = *__begin;
        loop_statement
    }
}

因此增加指针,如果我理解std::lists在内部实现为双链表,那么假设这样的东西不能打印是不正确的0 1 2 3,因为内存地址不是连续的(隐含的++__begin)？

std::list<int> myList = {0, 1};
std::list<int> otherList = {10, 11};
myList.push_back(2);
myList.push_back(3);

for(auto& i: myList)
    std::cout << i << " ";

然而它确实打印正确.那么,是否std::list::iterator覆盖了for-for-loop扩展中使用的运算符的行为？

如果我选择实现自己的范围 - 可迭代数据结构,这对我来说特别重要.

当我们调用std::list还带有标记的类型的变量clear时会发生什么thread_local？它会放弃分配的内存吗？

在我的场景中，我有一个thread_local列表，该列表在一次迭代中填充，并在迭代结束时清除。thread_local在我们在迭代结束时放弃内存（并且必须在下一次迭代中再次分配内存）的情况下，这不是很有用吗？

我正在实现的算法具有以下结构：

while C is not empty
  select a random entry e from C
  if some condition on e
    append some new entries to C (I don't care where)
  else
    remove e from C

重要的是循环 e 的每次迭代都是随机选择的（具有统一的概率）。

理想情况下select，append和remove步骤都是 O(1)。

如果正确地明白，使用std::list的append和remove步骤将是O（1），但随机选择将是O（N）（例如，使用std::advance如在此解决方案）。

And std::deque and std::vector seem to have complementary O(1) and O(n) operations.

I'm guessing that std::set will introduce some O(log n) complexity.

Is there any …

我试图了解 std::move 。在我的代码中，我正在从内部包含两个字段的std::list<struct Data>位置移动一个元素，但我没有得到预期的输出。这是我的代码：struct Datastd::string

#include <iostream>
#include <string>
#include <list>

struct Data {
    std::string topic {};
    std::string msg {};

    Data(const std::string& topic, const std::string& msg) {
        this->topic = topic;
        this->msg = msg;
    }
};

int main() {
    std::list<Data> data_list;
    data_list.push_back(Data("A", std::string(1000, 'a')));
    data_list.push_back(Data("B", std::string(1000, 'b')));
    data_list.push_back(Data("C", std::string(1000, 'c')));
    data_list.push_back(Data("D", std::string(1000, 'd')));
    data_list.push_back(Data("E", std::string(1000, 'e')));
    
    while (!data_list.empty()) {
        std::cout << (void*)&data_list.front() << "\n";
        Data&& d1 = std::move(data_list.front());
        data_list.pop_front();
        std::cout << d1.topic << ", " << d1.msg …