Replace a loop to implement Contains on an array - c++

Question

Is there a way to use the Standard Library to simplify the loop on an array of struct that compare with strncmp?
Below is my attempt that fails because std::count_if complains there is no instance of overloaded function 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;
}
The error is:
C2784: const _Elem *std::begin(std::initializer_list<_Elem>) noexcept': could not deduce template argument for 'std::initializer_list<_Elem>' from 'nodeinput []

Answer 1

Just make collection a pointer, maybe a const one:
static int ContainsObjectType(int collectionSize, struct nodeinput *collection, char* objectType)
{
auto numFound = std::count_if(
collection,
collection + collectionSize,
...);
}
std::count_if's two first arguments must be iterators, and pointers are, in fact, primitive iterators.
std::begin(iterable) is merely pointer, std::end(iterable) is pointer + <data length>.

Answer 2

Below the complete solution in case someone searches how to replace a c-style loop on an array of objects with the library standard.
#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;
}