我有一个如下的枚举类：
enum class Age
{
Eleven,
Twelve,
Thirteen
};
那么我有一个叫做 vector<Person> GetPeopleOfAge(Age age) 的方法。如何设计才能让开发者调用它并获取年龄为11、12和13岁的人？虽然我考虑过调用三次，但这样做太糟糕了。我可以添加一个All枚举并在我的方法中进行检查，但我不喜欢用All这样的枚举来污染枚举。我知道这是解决问题的常见方法，有些人可能不同意我的看法，但对我来说，这种方法感觉很差劲，我正在寻找一种替代方案。也许我应该使用其他东西而不是枚举？
All，还是通过另一种机制隐式地捕获它，您都必须处理抽象概念。考虑到这一点，我认为更好的方法是明确处理它。enum Age : unsigned int
{
Eleven = 000001,
Twelve = 000010,
Thirteen = 000100,
All = 000111
};
// Get all the people of age 11
auto ret1 = GetPeopleOfAge(Age::Eleven);
// Get people of all ages
auto ret2 = GetPeopleOfAge(Age::All);
// Get all the people aged 11 or 13
auto ret3 = GetPeopleOfAge(Age::Eleven | Age::Thirteen);
vector<Person> GetPeopleOfAge(int minAge, int maxAge);
不需要通过 enum 使事情变得复杂。
一种选择是将过滤器参数设为可选:
vector<Person> GetPeopleOfAge(std::optional<Age> age = {})
然后，在函数内部使用 if (age) 来检查是否应该进行基于年龄的过滤。
不过，这个函数可能需要重新命名，因为它并不总是只给出某个特定年龄段的人；有时，它会给出所有人的信息。
GetPeopleOfAge 设为可变参数函数 (initializer_list 也可以使用) 并给它一个更好的名称：template <typename... Ts>
vector<Person> GetPeopleOfAnyAge(Ts... ages);
// Return a vector of all people having any of `ages...`.
使用方法：
const auto people = GetPeopleOfAnyAge(
Age::Eleven, Age::Twelve, Age::Thirteen);
const auto getAllPeople = []
{
return GetPeopleOfAnyAge(
Age::Eleven, Age::Twelve, Age::Thirteen);
};
#include <algorithm>
#include <initializer_list>
#include <iostream>
#include <ostream>
#include <string>
#include <vector>
using std::cout;
using std::endl;
using std::function;
using std::initializer_list;
using std::ostream;
using std::string;
using std::vector;
enum class Gender { unknown, male, female };
class Person {
string name;
int age;
Gender gender;
public:
Person(string n, int a, Gender g) : name{move(n)}, age{a}, gender{g} { }
string Name() const { return name; }
int Age() const { return age; }
Gender Gender() const { return gender; }
};
ostream& operator<<(ostream& o, Person const& person) {
o << person.Name() << "(" << person.Age() << ", ";
switch (person.Gender()) {
case Gender::unknown: o << "?"; break;
case Gender::male: o << "boy"; break;
case Gender::female: o << "girl"; break;
}
o << ")";
return o;
}
class People {
vector<Person> people;
public:
People(initializer_list<Person> l) : people{l} { }
vector<Person> GetPeople(function<bool(Person const&)> predicate);
};
vector<Person> People::GetPeople(function<bool(Person const&)> predicate) {
vector<Person> result;
for (auto const& person : people) {
if (predicate(person)) {
result.push_back(person);
}
}
return result;
}
ostream& operator<<(ostream& o, vector<Person> const& vector_of_person) {
char const* sep = "";
for (auto const& person : vector_of_person) {
o << sep << person;
sep = ", ";
}
return o;
}
int main() {
auto const b = Gender::male;
auto const g = Gender::female;
People people = {{"Anu", 13, g}, {"Bob", 11, b}, {"Cat", 12, g}, {"Dex", 11, b}, {"Eli", 12, b}};
auto ageUnder13 = [](Person const& p) { return p.Age() < 13; };
cout << people.GetPeople(ageUnder13) << endl;
auto everyone = [](Person const& p) { return true; };
cout << people.GetPeople(everyone) << endl;
auto boys = [](Person const& p) { return p.Gender() == Gender::male; };
cout << people.GetPeople(boys) << endl;
return EXIT_SUCCESS;
}
gsl::span的const Person类型，并使用续传样式获取结果（以避免为了返回多个值而分配内存）。只有在证明需要性能时（通过分析！）才应进行此类优化，否则此答案是完美的。 - Yakk - Adam NevraumontAll值：好吧，没有人说您需要包含它，这是R Sahu的偏好（而我的相反...）- 最终，这更多是用例问题，尽管...enum class E
{
E0 = 1 << 0,
E1 = 1 << 1,
E2 = 1 << 2,
E3 = 1 << 3,
};
E operator|(E x, E y)
{
return static_cast<E>
(
static_cast<std::underlying_type<E>::type>(x)
|
static_cast<std::underlying_type<E>::type>(y)
);
}
E operator&(E x, E y)
{
return static_cast<E>
(
static_cast<std::underlying_type<E>::type>(x)
&
static_cast<std::underlying_type<E>::type>(y)
);
}
bool operator==(E x, std::underlying_type<E>::type y)
{
return static_cast<std::underlying_type<E>::type>(x) == y;
}
bool operator!=(E x, std::underlying_type<E>::type y)
{
return !(x == y);
}
bool operator==(std::underlying_type<E>::type y, E x)
{
return x == y;
}
bool operator!=(std::underlying_type<E>::type y, E x)
{
return x != y;
}
void f(E e)
{
E person = E::E1;
if((person & e) != 0)
{
// add to list...
}
}
int main(int argc, char *argv[])
{
f(E::E0 | E::E1);
return 0;
}
enum class subset_type {
include, all
};
struct include_all_t { constexpr include_all_t() {} };
constexpr include_all_t include_all {};
template<class E>
struct subset {
subset_type type = subset_type::include;
std::variant<
std::array<E, 0>, std::array<E, 1>, std::array<E, 2>, std::array<E, 3>, std::array<E, 4>,
std::vector<E>
> data = std::array<E,0>{};
// check if e is in this subset:
bool operator()( E e ) const {
// Everything is in the all subset:
if(type==subset_type::all)
return true;
// just do a linear search. *this is iterable:
for (E x : *this)
if (x==e) return true;
return false;
}
// ctor, from one, subset of one:
subset(E e):
type(subset_type::include),
data(std::array<E, 1>{{e}})
{}
// ctor from nothing, nothing:
subset() = default;
// ctor from {list}, those elements:
subset(std::initializer_list<E> il):
type(subset_type::include)
{
populate(il);
}
// ctor from include_all:
subset(include_all_t):type(subset_type::all) {}
// these 3 methods are only valid to call if we are not all:
E const* begin() const {
return std::visit( [](auto&& x){ return x.data(); }, data );
}
std::size_t size() const {
return std::visit( [](auto&& x){ return x.size(); }, data );
}
E const* end() const {
return begin()+size();
}
// this method is valid if all or not:
bool empty() const {
return type!=subset_type::all && size()==0;
}
// populate this subset with the contents of srcs, as iterables:
template<class...Src>
void populate(Src const&...srcs) {
std::size_t count = (std::size_t(0) + ... + srcs.size());
// used to move runtime count to compiletime N:
auto helper = [&](auto N)->subset& {
std::array<E, N> v;
E* ptr = v.data();
auto add_src = [ptr](auto& src){
for (E x:src)
*ptr++ = x;
};
(add_src(srcs),...);
this->data = v;
};
// handle fixed size array cases:
switch(count) {
case 0: return helper(std::integral_constant<std::size_t, 0>{});
case 1: return helper(std::integral_constant<std::size_t, 1>{});
case 2: return helper(std::integral_constant<std::size_t, 2>{});
case 3: return helper(std::integral_constant<std::size_t, 3>{});
case 4: return helper(std::integral_constant<std::size_t, 4>{});
default: break;
};
// otherwise use a vector:
std::vector<E> vec;
vec.reserve(count);
auto vec_helper = [&](auto&& c){
for (E x:c) vec.push_back(c);
};
(vec_helper(srcs), ...);
data = std::move(vec);
}
// because what is a set without a union operator?
friend subset& operator|=( subset& lhs, subset const& rhs ) {
if (lhs.type==subset_type::all) return lhs;
if (rhs.type==subset_type::all) {
lhs.type = subset_type::all
return lhs;
}
populate( lhs, rhs );
return lhs;
}
friend subset operator|( subset lhs, subset const& rhs ) {
lhs |= rhs;
return std::move(lhs);
}
};
C++17，可能有打字错误。
std::vector<Person> GetPeopleOfAge(subset<Age> age)
Age::Eleven、include_all或{}（表示没有），或者使用{Age::Eleven, Age::Twelve}（表示两个）来调用它。all模式下，您可以使用基于范围的循环迭代子集中的元素。operator&、subset_type::none、subset_type::exclude和operator~留作练习。std::tuple 创建可变参数模板。enum(s) 使用比特逻辑——这是许多 API 函数中常见的做法，以使用多个设置，例如：glClearColor( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT ); 这些通常称为管道化，使用位域。enum class Gender {
male,
female,
both,
other
};
class age_constraints {
public:
const static unsigned min_age { 1 };
const static unsigned max_age { 130 };
protected:
age_constraints() = default;
}; typedef age_constraints age_range;
class attributes {
public:
std::string firstName;
std::string middleNameOrInitial;
std::string lastName;
unsigned age;
Gender gender;
attributes() = default;
attributes( const std::string& first, const std::string& middle, const std::string& last,
const unsigned& ageIn, const Gender& gend ) :
firstName( first ),
middleNameOrInitial( middle ),
lastName( last ),
age( ageIn ),
gender( gend )
{}
};
class Person {
private:
attributes attribs;
public:
Person() = default;
explicit Person( const attributes& attribsIn ) : attribs( attribsIn ) {}
Person( const std::string& firstName, const std::string& middle, const std::string& lastName,
const unsigned& age, const Gender& gender ) :
attribs( firstName, middle, lastName, age, gender ) {}
// other methods
};
class Database {
public:
const static age_range range;
private:
std::vector<std::shared_ptr<Person>> peopleOnFile;
public:
Database() = default;
void addPerson( const Person&& person ) {
peopleOnFile.emplace_back( new Person( person ) );
}
template<bool all = false>
std::vector<Person> getPeopleByAges( unsigned minAge, unsigned maxAge, unsigned ages... ) {
std::tuple<ages> agesToGet( ages... );
std::vector<Person> peopleToGet;
// compare tuple ages with the ages in Person::attributes - don't forget that you can use the age_constraints for assistance
// populate peopleToGet with appropriate age range
return peopleToGet;
}
template<bool all = true>
std::vector<Person> getPeopleByAges() {
return peopleOnFile;
}
};
我从所有答案中获得了一些想法，这是我能想到的最佳解决方案。
class People
{
public:
GetPeopleOfAllAges()
{
GetPeopleOfAge();
}
private:
GetPeopleOfAge(Age age = NULL)
{
if (age == NULL ||
*age == Person.age)
{
// Add Person to list.
}
}
}