2

我有一个这样的结构：

struct group
{
    int index; 
    string name; 
    group* child;

};

我设置了一个向量来存储一些组结构。

现在我正在尝试使用一个函数来按索引从该向量中检索一个组成员，如下所示：

148    newGroup.child = getGroupByIndex(world, i);

函数的定义是：

group& getGroupByIndex(vector<group>* world, int i)
{
    for(vector<group>::iterator it = world->begin();
        it < world->end(); ++it)
    {
        if(it->index == i) return *it;
    }
267     return 0;
}

不幸的是，它甚至不会编译。

错误信息是：

tree.cpp: In function ‘int main()’: 
tree.cpp:148: error: cannot convert ‘group’ to ‘group*’ in assignment 
tree.cpp: In function ‘group& getGroupByIndex(std::vector<group, std::allocator<group> >*, int)’: 
tree.cpp:267: error: invalid initialization of non-const reference of type ‘group&’ from a temporary of type ‘int’

我的两个问题，

  1. 如何修复编译错误？我应该使用什么返回类型？

  2. 如果我想在第 267 行返回一个空指针，我应该使用什么？我试过 (void *)0 和 0，但都不起作用。

4

3 回答 3

0

如果您希望更喜欢对指针的引用，您还可以定义一个将由您的函数返回的“未找到”组对象。

我会这样做：

struct group
{
    int index; 
    string name; 
    group* child;
    group(int i):index(i),child(null){}
    group(int i, const string& n, group& c):index(i), name(n), child(&c){}

    // assuming index defines the uniqueness of your object class
    bool operator == (const struct group& g)const {return (index == g.index);}

    // an unique special instance of group struct
    static struct group not_found;
};
group group::not_found(-1);

因此您可以按照您想要的方式定义您的功能：

group& getGroupByIndex(vector<group>* world, int i)
{
    for(vector<group>::iterator it = world->begin();
        it < world->end(); ++it)
    {
        if(it->index == i) return *it;
    }
    return group::not_found; // a reference to a special singleton instance of struct group
}

你将能够像这样拨打电话：

...
group& g = getGroupByIndex(world, index);
if(g == group::not_found)
{
   // handle the not found case here
   ...
于 2013-03-04T09:28:54.420 回答
0

我认为应该是这样的：

group* getGroupByIndex(vector<group*> world, int i) // See position of two *
{
    for(vector<group*>::iterator it = world.begin();
        it < world.end(); ++it)
    {
        if(it->index == i)
          return *it;
    }
    return 0;
}

或者

group* getGroupByIndex(vector<group> *world, int i) // See position of two *
{
    for(vector<group>::iterator it = world->begin();
        it < world->end(); ++it)
    {
        if(it->index == i)
          return &(*it);
    }
    return 0;
}
于 2013-03-04T06:40:26.737 回答
0

利用

boost::optional

现代 C++ 的第一条规则：不要使用 ****ing 指针。

boost::optional<group&> get(vector<group>& world, int i)
{
    for(auto & grp : world)
    {
        if(grp.index == i)
           return boost::optional<group&>(grp);
    }
    return boost::none;
}

请注意，此解决方案具有O(n)复杂性。如果您想基于 进行搜索index，我建议使用对group按 排序的对象的引用的结构index，这将为您提供O(log n)查找时间。

在那种情况下，我可能会持有shared_ptrs 和 a的向量map<int, weak_ptr>。你也可以看看boost::multi_index

啊，2)我刚刚注意到你的观点只是一个旁注：nullptr。

于 2013-03-04T12:00:43.480 回答