Proper Case Conversion (Performance)

Question

I wrote a simple function that converts an array of words into proper case (using bitwise operations) and returns the array. I performed a simple test using std::chrono to check how fast it was able to perform the conversion. Using a vector of 1000 words the function was able to do it in an average of 27 microseconds.

My question is, if there is a faster way of doing this or if there is anything that I have missed that may be detrimental to the performance of the function. In addition, if there is any syntactical issues or changes that you would recommend that would be greatly appreciated.

#include <vector>
#include <string>

std::vector<std::string> ToProperCase(std::vector<std::string>& array)
{
    if (array.empty())
        return array;

    // Loop through each word
    for (std::string& value : array)
    {
        // Loop through each character in the word
        for (unsigned int i = 0; i < value.size(); ++i)
        {
            // Capitalise first character
            value[0] &= (~(1 << 5));

            // Convert character to lower case
            if (i > 0)
                value[i] |= (1 << 5);
        }
    }

    return array;
}

Answer 1

std::vector<std::string> ToProperCase(std::vector<std::string>& array)
{
    // ...
    return array;
}

There are many styles when it comes to capitalization. ToProperCase should have a better name to indicate what the function does, which is to capitalize the first letter of each word.

array is a non-local reference being returned by value. Is this intended?

---

    if (array.empty())
        return array;

    // Loop through each word
    for (std::string& value : array)

While compilers will optimize it, the early return is unnecessary. The range-based for will check to see if array is empty. If it is, the function will return array.

Don't say in comments what can be clearly stated in code. Rather than using variable names like array and value, omit the comment and use words and word respectively. Reserve comments to concisely state intent and keep them crisp.

        // Loop through each character in the word
        for (unsigned int i = 0; i < value.size(); ++i)
        {
            // Capitalise first character
            value[0] &= (~(1 << 5));

            // Convert character to lower case
            if (i > 0)
                value[i] |= (1 << 5);
        }
    }

What is the proper case of a digit? Punctuation? Control characters? Should you be mutating non-alpha characters?

You do more work than necessary here. For every character in the word, you bitwise-and the first character then bitwise-or the current character. You can unswitch the body of the innermost loop by handling the first character before every subsequent character.

    for (auto& word : words)
    {
        if (word.empty()) continue;

        word[0] = std::toupper(static_cast<unsigned char>(word[0]));

        for (auto i = 1u; i < word.size(); ++i) 
        {
            word[i] = std::tolower(static_cast<unsigned char>(word[i]));
        }
    }

Answer 2

You code is pretty nice, but still, there are improvements.

Each time in the inner loop, your code unnecessarily runs value[0] &= (~(1 << 5)); for value.size() times. That would take unnecessary time. Running it once should be enough.

This would be the code after the improvements.

vector<string> ToProperCase(vector<string>& array)
{
    if (array.empty())
        return array;

    for (string& value : array)
    {
        if(value == "")
            continue;

        value[0] &= ~(1 << 5);

        for (unsigned int i = 1; i < value.size(); ++i)
            value[i] |= (1 << 5);
    }

    return array;
}

Also, you can use toupper() and tolower() instead, though I'm not sure if they are faster.

If I find anymore improvements, I'll be sure to edit them in!

EDIT:

If you want your code to be really fast, you can use map to store all the alphabets, but that would reduce the neatness of the code. It's your wish!