标签: stdlist

这是我的代码:

for (std::list<std::wstring>::iterator itr  = kb->titles.begin(); itr != kb->titles.end() ; itr++)
    {
        _size += *itr.size();
    }

我想要做的是访问列表中包含的每个wstring并调用它的size()成员函数.然而什么是由ITR指出似乎并没有成为迭代wstring的元素,我得到一个错误(错误C2039:"尺寸":不是的一员"的std :: _ List_iterator <_Mylist>")

如果你想知道kb是什么,它是指向一个结构的指针,std::list<std::wstring> titles;作为其中一个成员.

有想法该怎么解决这个吗？

如果N> =列表大小(并处理N = 0),获取作为std :: list的前N个元素或整个列表的新列表的正确和安全的方法是什么？

更新

实际上我不一定需要新的列表,我只想在后续代码中对列表的子集进行操作.我假设创建一个新列表是一种合理的方法(注意列表大小通常低于50).

我是编程c ++的新手,所以如果我的源代码不是很精彩,请不要生我的气.

我必须编写一个程序来处理图形中的节点和边缘以供我学习.

std::lists我的源代码中有2个.第一个是存储常规Nodes,另一个是为了保存被调用的节点的类ArticleNodes.通常,所有元素都是指向创建对象的指针.

为了确定一个对象在另一个列表中是否相同,我保存了内存地址并将其与第二个列表中的元素进行比较.如果匹配,则将删除第二个元素.

现在我想删除两个列表中的一个元素:

void Graph::deleteNode(unsigned int nodeNumber)
{
    list<Node*>::iterator it = m_nodes.begin();
    ArticleNode* pCurrentArticleNode;
    for(unsigned int i=1; i<nodeNumber; i++) { it++; }

    Node* pCurrentNode = (*it);

    for (list<ArticleNode*>::iterator itArticle = m_articlenode.begin(); itArticle != m_articlenode.end(); itArticle++)
    {
        pCurrentArticleNode = (*itArticle);
        if(pCurrentNode==pCurrentArticleNode) { m_articlenode.remove(pCurrentArticleNode); }
    }

    m_nodes.remove(pCurrentNode);

    delete pCurrentNode;
    delete pCurrentArticleNode;
}

我可以编译它,但是当我调用该函数时,我的程序只退出返回1.实际上,我发现if子句中的remove-command是问题所在.为什么这不起作用？

我在C++中有一个基本的多态性示例,具有以下结构.

struct Shape {
    virtual void draw() = 0;
};

struct Circle : public Shape {
    virtual void draw() {
        cout << "drawing circle" << endl;
    }
};

struct Triangle : public Shape {
    virtual void draw() {
        cout << "drawing triangle" << endl;
    }
};

我有一个使用此设置的函数来调用绘图函数:

void drawShapes(list<Shape*> shapes) {
    list<Shape*>::iterator pShape = shapes.begin();
    list<Shape*>::iterator pEnd = shapes.end();

    for (; pShape != pEnd; pShape++) {
        pShape->draw();
    }
}

这正是我正在阅读的书中设置示例的方式.我尝试编译时遇到以下错误.

expression must have a pointer-to-class type

我通过更改pShape->draw();为修复此问题(*pShape)->draw() …

我有一个类,我想使用标准库列表来存储它们的列表.我基本上想要push_front()列表.所以我的代码是这样的:

#include <list>
/* ... lots of stuff ...*/

complexNode myObject();

std::list<complexNode> complexList();

myList.push_front(myObject);

但编译器抛出此错误:

错误:请求'complexList'中的成员'push_front',它是非类型的类型'std :: list <complexNode,std :: allocator <complexNode >>>()()'

complex complexNode类有一个复制构造函数.

我真的不明白这个问题,这个错误究竟意味着什么......请帮助!

这是一个初学者类型的问题

我只是想知道是否有办法将空终止的char*转换为std :: list.

谢谢

char* data = ...
std::list<char> clist = convert_chars2list(data);
...
convert_chars2list(char* somedata)
{
    //convert
}

例如:

class apple
{
public:
    string name;

    apple::apple(string name) : name(name)
    {
    }
};

如果我想制作一堆每个都有苹果类型的列表,我想我可以做类似的事情std::list<apple> empire("empire"), macintosh("macintosh").基本上我想为list<T>我创建列表时声明的类T的构造函数传递参数.对不起,如果我没有解释这个问题,如果你有这种能力,请随时编辑我的问题.

谢谢

编辑这个问题似乎令人困惑,这可能是因为我给出了一个糟糕的例子.我需要重新设计我的课程.按照这个例子,虽然我想要的是一个列表,它都是帝国苹果,该列表中的每个苹果都有一个指定类型的帝国,一个列表都是macintosh苹果,该列表中的每个苹果都有一个指定类型的macintosh.

因此,为了澄清一些或在此处混淆一些我们去.

class apple
{
public:
    string variety_name;
    string description;
    apple::apple(string variety_name, string description)
        : variety_name(variety_name), description(description)
    {
    }
};
int _tmain(int argc, _TCHAR* argv[])
{
    // Vlad from Moscow's answer
    std::list<apple> empire(1, apple("empire", "picked yesterday")),
        macintosh(1, apple( "macintosh", "picked yesterday")); 

    // Vaughn Cato's answer
    empire.push_back(apple("empire", "picked today"));
    macintosh.push_back(apple("macintosh", "picked today"));

    for(list<apple>::iterator it=empire.begin(); it != empire.end(); ++it) …

我试图通过在将新节点添加到结尾之前从前面删除节点来限制列表的大小.我期望无论列表大小如何,速度都是恒定的,但我看到更大的列表的执行时间更长.我实现它是错误的,还是pop_front实际上不是恒定的时间？

以下代码执行以下结果:

$ time ./testlist 2 1000000
MAX is 2
NUM is 1000000
DELETED 999998

real    0m0.835s

$ time ./testlist 10 1000000
MAX is 10
NUM is 1000000
DELETED 999990

real    0m1.070s

$ time ./testlist 100 1000000
MAX is 100
NUM is 1000000
DELETED 999900

real    0m3.612s

$ time ./testlist 1000 1000000
MAX is 1000
NUM is 1000000
DELETED 999000

real    0m28.838s

源代码:

#include <iostream>
#include <stdlib.h>
#include <list>

int deletes=0;
std::list<int> l;
void insert(int x, size_t maxsize) {
    if …

我正在尝试定义一个常量对象的常量列表，但似乎无法完成。这是我编译良好的示例：

#include <string>
#include <list>

class Person { public:
    std::string name;
    Person(const std::string &in_name){name=in_name;}
};

class MyClass { public:
    const std::list</* const */Person> l;
    MyClass(const std::list</* const */Person> &in_l):l(in_l){}
};

int main(int argc, char **argv) {
    Person dave("dave");
    MyClass c(std::list<const Person>(dave));
    return 0;
}

当我从这const两个地方删除评论时，出现以下错误：

In file included from /usr/include/x86_64-linux-gnu/c++/7/bits/c++allocator.h:33:0,
                 from /usr/include/c++/7/bits/allocator.h:46,
                 from /usr/include/c++/7/string:41,
                 from main66.cpp:1:
/usr/include/c++/7/ext/new_allocator.h: In instantiation of ‘class __gnu_cxx::new_allocator<const Person>’:
/usr/include/c++/7/bits/allocator.h:108:11:   required from ‘class std::allocator<const Person>’
main66.cpp:11:53:   required from here
/usr/include/c++/7/ext/new_allocator.h:93:7: error: ‘const _Tp* __gnu_cxx::new_allocator<_Tp>::address(__gnu_cxx::new_allocator<_Tp>::const_reference) …

标准是否保证

--list.begin() == list.end()

总是成立并且它实际上是一个有效的操作？(list是 的一个实例std::list)。

至少 MSVC 2019 似乎就是这种情况。

例如，这在以下情况下会很有用：

for ( auto i = list.begin(); i != list.end(); ++i )
{
  ...
  list.erase(i--);
  ...
}

，即在迭代时删除元素时，因为i可能是列表的开头。这也需要++list.end() == list.begin()持有；那个怎么样？