Extracting reusable C++ templated functions from StringCalculator code

I've recently coded a solution to the StringCalculator kata in C++ using GoogleMock, (you can check its code in GitHub).

In one of the refactoring steps, I extracted the code that filters out not numeric tokens to a separated helper method: filterOutNotNumericTokens:

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(const std::vector<std::string> & tokens) const {
	std::vector<std::string> numericTokens;
	for (unsigned int i = 0; i < tokens.size(); ++i) {
	std::string token = tokens[i];
	if (isNotAnInteger(token)) {
	continue;
	}
	numericTokens.push_back(tokens[i]);
	return numericTokens;
	}
	bool NumbersExtractor::isNotAnInteger(const std::string & str) const {
	return ! StringUtils::isAnInteger(str);
	}

view raw filterOutNotNumericExample.cpp hosted with ❤ by GitHub

Once all the kata requirements were satisfied, I refactored this method a little bit more using C++11 copy_if algorithm:

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(const std::vector<std::string> & tokens) const {
	std::vector<std::string> numericTokens;
	std::copy_if(tokens.begin(), tokens.end(),
	std::back_inserter(numericTokens),
	StringUtils::isAnInteger);
	return numericTokens;
	}

view raw filterOutNotNumericRefactored.cpp hosted with ❤ by GitHub

We can use the same technique to refactor the method that ignores numbers greater than 1000, ignoreTooBig, from this:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	for (unsigned int i = 0; i < numbers.size(); ++i) {
	if (notTooBig(numbers[i])) {
	filteredNumbers.push_back(numbers[i]);
	}
	}
	return filteredNumbers;
	}
	bool NumbersFilter::notTooBig(int number) const {
	return !(number > 1000);
	}

view raw ignoreTooBig.cpp hosted with ❤ by GitHub

to this:
 

	bool notTooBig(int number);
	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	notTooBig);
	return filteredNumbers;
	}
	bool notTooBig(int number) {
	return !(number > 1000);
	}

view raw ignoreTooBigRefactoredWithoutLambd.cpp hosted with ❤ by GitHub

Notice that we had to make notTooBig a free function in order to pass it to copy_if.

To keep it as a member function we'd need to write this less readable version:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	std::bind1st(std::mem_fun(&NumbersFilter::notTooBig), this));
	return filteredNumbers;
	}
	bool NumbersFilter::notTooBig(int number) const {
	return !(number > 1000);
	}

view raw ignoreTooBigRefactoredKeepingMemberFunction.cpp hosted with ❤ by GitHub

which uses the bind1st and mem_fun functions from functional.

In this case, I think it's probably better to use a lambda:

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	std::vector<int> filteredNumbers;
	std::copy_if(numbers.begin(), numbers.end(),
	std::back_inserter(filteredNumbers),
	[](const int number) { return !(number > 1000); });
	return filteredNumbers;
	}

view raw ignoreTooBigRefactoredWithLambda.cpp hosted with ❤ by GitHub

In the two previous examples we eliminated duplication using the copy_if algorithm.

We can improve the readability of this code introducing a helper templated functions, filter:

	namespace VectorUtils {
	template<typename T, typename Function>
	std::vector<T> filter(const std::vector<T> & original, Function pred) {
	std::vector<T> filtered;
	std::copy_if(original.begin(), original.end(),
	std::back_inserter(filtered),
	pred);
	return filtered;
	}
	template<typename T2, typename T1, typename Function>
	std::vector<T2> map(const std::vector<T1> & original, Function f) {
	std::vector<T2> mapped;
	std::transform(original.begin(), original.end(),
	std::back_inserter(mapped),
	f);
	return mapped;
	}
	}

view raw VectorUtils.hpp hosted with ❤ by GitHub

Notice that filter works only for vector, copy_if is more general. But this leads to a bit more readable code for filterOutNotNumericTokens and ignoreTooBig:
 

	std::vector<std::string> NumbersExtractor::filterOutNotNumericTokens(
	const std::vector<std::string> & tokens) const {
	return VectorUtils::filter(tokens, StringUtils::isAnInteger);
	}

view raw filterOutNotNumericTokensUsingFilter.cpp hosted with ❤ by GitHub

	std::vector<int> NumbersFilter::ignoreTooBig(const std::vector<int> & numbers) const {
	return VectorUtils::filter(numbers,
	[](int number) { return !(number > 1000); });
	}

view raw ignoreTooBigUsingFilter.cpp hosted with ❤ by GitHub

We can also use filter to refactor the getNegatives method:
 

	std::vector<int> NumbersValidator::getNegatives(const std::vector<int> & numbers) const {
	return VectorUtils::filter(numbers, [](int number) { return number < 0; });
	}

view raw getNegativesInNumbersValidator.cpp hosted with ❤ by GitHub

The same procedure can be applied to have a map templated function that uses the transform algorithm which can then be used to refactor the convertToInts method:

	std::vector<int> NumbersExtractor::convertToInts(
	const std::vector<std::string> & numbersStrings) const {
	return VectorUtils::map<int, std::string>(numbersStrings, StringUtils::convertToInt);
	}

view raw convertToIntsUsingMap.cpp hosted with ❤ by GitHub

This map and filter functions that we'd refactored out from the StringCalculator code are pure functions that are highly reusable and will help us to avoid duplication in another projects.