替换循环以实现包含在数组上

Question

与strncmp相比，有没有一种方法可以使用标准库简化struct数组上的循环？

以下是我的尝试失败，因为std：：count\U if抱怨没有重载函数std：：begin matches的实例。

#include "stdafx.h"
#include "afx.h"
#include <string.h>
#include <iostream>
#include <algorithm>
#include <string>

struct nodeobject
{
    CString ObjectType;
    nodeobject() {}
    explicit nodeobject(CString objectType) { ObjectType = objectType; }
};

struct nodeinput
{
    struct nodeobject Object;
};

// Original function I want to rewrite to remove the for loop and the strncmp
static int ContainsObjectType(int collectionSize, struct nodeinput collection[], char* objectType)
{
    auto found = 0;
    for (auto idx = 0; idx < collectionSize; idx++)
    {
        if (strncmp(objectType, 
                    collection[idx].Object.ObjectType, 
                    strlen(collection[idx].Object.ObjectType)) == 0)
        {
            found = 1;
        }
    }
    return found;
}

#if 0
// The implementation below does not compile because there is no instance of 
// overloaded function std::begin matches
static int ContainsObjectType(int collectionSize, struct nodeinput collection[], char* objectType)
{   
    auto numFound = std::count_if(std::begin(collection),
                                  std::end(collection),
                                  [](struct nodeinput oneNode) 
    { 
        return strncmp(objectType, oneNode.Object.ObjectType, oneNode.Object.ObjectType) == 0); 
    });

    return numFound > 0;
}
#endif

int main()
{
    struct nodeobject node1("fokker");
    struct nodeobject node2("airbus");
    struct nodeobject node3("boing777");
    struct nodeinput collection[] = {node1, node2, node3};
    auto nintnode = 3;

    auto found = ContainsObjectType(nintnode, collection, "boing777");

    std::cout << found << std::endl;
    return 0;
}

错误是：

C2784：常量元素*标准：：开始（标准：：初始值设定项\u列表

Answer 1

下面是完整的解决方案，以防有人搜索如何用库标准替换对象数组上的c风格循环。

#include "stdafx.h"
#include "afx.h"
#include <string.h>
#include <iostream>
#include <algorithm>
#include <string>
#include <vector>

// Legacy code
class NodeObject
{
public:
    CString objectType;  // Keeping CString to minimize the impact for now
    NodeObject() {}
    explicit NodeObject(CString objectType) : objectType(objectType) { }
};

// Legacy code
class NodeInput
{
public:
    NodeObject object;
    explicit NodeInput(NodeObject object) : object(object) { }
};

// Code using vector and count_if
static int Contains(std::vector<NodeInput> collection, std::string objectType)
{
    auto numFound = std::count_if(std::begin(collection),
        std::end(collection),
        [&](const NodeInput oneInput)
    {
        return (std::strncmp(objectType.c_str(),
                             oneInput.object.objectType,
                             strlen(oneInput.object.objectType)) == 0);
    });

    return numFound > 0;
}

// Code using array pointer and count_if
static int Contains(int collectionSize, NodeInput* collection, char* objectType)
{
    auto numFound = std::count_if(collection,
                                  collection + collectionSize,
                                  [&](const NodeInput oneInput)
    {
        return (std::strncmp(objectType,
            oneInput.object.objectType,
            strlen(oneInput.object.objectType)) == 0);
    });

    return numFound > 0;
}

// Legacy code
static int ContainsOriginal(int collectionSize, NodeInput collection[], char* objectType)
{
    auto found = 0;
    for (auto idx = 0; idx < collectionSize; idx++)
    {
        if (strncmp(objectType, 
                    collection[idx].object.objectType, 
                    strlen(collection[idx].object.objectType)) == 0)
        {
            found = 1;
        }
    }
    return found;
}

int main()
{
    // Legacy code
    NodeInput arrayCollection[] { NodeInput(NodeObject("fokker")), 
                                  NodeInput(NodeObject("airbus")), 
                                  NodeInput(NodeObject("boing777")) };
    auto arrayCollectionSize = 3;
    auto found = Contains(arrayCollectionSize, arrayCollection, "boing777");
    std::cout << found << std::endl;

    // Code using Standard Library
    std::vector<NodeInput> collection{ NodeInput(NodeObject("fokker")),
                                       NodeInput(NodeObject("airbus")),
                                       NodeInput(NodeObject("boing777")) };
    found = Contains(collection, "boing777");
    std::cout << found << std::endl;

    return 0;
}

Answer 2

只需将集合设置为指针，也可以是常量：

static int ContainsObjectType(int collectionSize, struct nodeinput *collection, char* objectType)
{   
    auto numFound = std::count_if(
        collection,
        collection + collectionSize,
        ...);
}

count\u if的前两个参数必须是迭代器，而指针实际上是基元迭代器。

std::begin（iterable）只是指针，std::end（iterable）是指针