本站在允许 JavaScript 运行的环境下浏览效果更佳


Fast Methods to Convert Uppercase Letters to Lowercase in C++

此文章有中文版本/This article is available in Chinese

TL;DR Version

Jump to test results: Test Results

Summary:

  1. Without #pragma GCC optimize, use the following function for conversion:

    string strlwr_c_cr(const string& input) {
        return string(strlwr((char*)input.c_str()));
    }
    
  2. With #pragma GCC optimize, the best conversion function is:

    string strlwr_a_cr(const string& input) {
        string result = input;
        for (size_t i = 0; i < result.size(); ++i) {
            if (result[i] >= 'A' && result[i] <= 'Z') {
                result[i] += 32;
            }
        }
        return result;
    }
    
  3. Passing parameters as const string& str is generally faster than string str.

Test Code

#pragma GCC optimize(2)
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse") // Enable global common subexpression elimination
#pragma GCC optimize("-fgcse-lm") // Perform load motion during GIMPLE optimization
#pragma GCC optimize("-fipa-sra") // Enable interprocedural scalar replacement of aggregates
#pragma GCC optimize("-ftree-pre") // Enable partial redundancy elimination
#pragma GCC optimize("-ftree-vrp") // Perform value range propagation
#pragma GCC optimize("-fpeephole2") // Enable peephole optimizations after register allocation
#pragma GCC optimize("-ffast-math") // Enable fast math optimizations (less strict IEEE compliance)
#pragma GCC optimize("-fsched-spec") // Allow speculative motion of instructions
#pragma GCC optimize("unroll-loops") // Enable loop unrolling
#pragma GCC optimize("-falign-jumps") // Align branch targets to improve performance
#pragma GCC optimize("-falign-loops") // Align loop entry points
#pragma GCC optimize("-falign-labels") // Align branch labels
#pragma GCC optimize("-fdevirtualize") // Enable devirtualization optimizations
#pragma GCC optimize("-fcaller-saves") // Save caller-saved registers around function calls
#pragma GCC optimize("-fcrossjumping") // Merge identical code sequences at jumps
#pragma GCC optimize("-fthread-jumps") // Perform thread jump optimizations
#pragma GCC optimize("-funroll-loops") // Perform aggressive loop unrolling
#pragma GCC optimize("-fwhole-program") // Perform whole-program optimizations
#pragma GCC optimize("-freorder-blocks") // Reorder basic blocks to improve branch prediction
#pragma GCC optimize("-fschedule-insns") // Reschedule instructions to reduce pipeline stalls
#pragma GCC optimize("inline-functions") // Inline functions aggressively
#pragma GCC optimize("-ftree-tail-merge") // Merge identical code at the ends of functions
#pragma GCC optimize("-fschedule-insns2") // Further reschedule instructions after register allocation
#pragma GCC optimize("-fstrict-aliasing") // Enforce strict aliasing rules
#pragma GCC optimize("-fstrict-overflow") // Assume signed arithmetic overflow does not occur
#pragma GCC optimize("-falign-functions") // Align function entry points
#pragma GCC optimize("-fcse-skip-blocks") // Perform CSE (common subexpression elimination) across blocks
#pragma GCC optimize("-fcse-follow-jumps") // Perform CSE following jumps
#pragma GCC optimize("-fsched-interblock") // Perform instruction scheduling across basic blocks
#pragma GCC optimize("-fpartial-inlining") // Allow partial inlining of functions
#pragma GCC optimize("no-stack-protector") // Disable stack protection mechanisms
#pragma GCC optimize("-freorder-functions") // Reorder function layout to improve performance
#pragma GCC optimize("-findirect-inlining") // Perform indirect inlining
#pragma GCC optimize("-fhoist-adjacent-loads") // Hoist adjacent loads
#pragma GCC optimize("-frerun-cse-after-loop") // Re-run common subexpression elimination after loop optimizations
#pragma GCC optimize("inline-small-functions") // Inline very small functions
#pragma GCC optimize("-finline-small-functions") // Inline small functions more aggressively
#pragma GCC optimize("-ftree-switch-conversion") // Optimize switch statements into conditional chains
#pragma GCC optimize("-foptimize-sibling-calls") // Optimize sibling and tail recursive calls
#pragma GCC optimize("-fexpensive-optimizations") // Perform more expensive optimizations
#pragma GCC optimize("-funsafe-loop-optimizations") // Assume loops do not overflow
#pragma GCC optimize("inline-functions-called-once") // Inline functions called only once
#pragma GCC optimize("-fdelete-null-pointer-checks") // Remove redundant null pointer checks

#include <algorithm>  // for std::transform
#include <chrono>     // for performance measurement
#include <cstring>    // for std::strcpy
#include <iomanip>
#include <iostream>
#include <map>
#include <sstream>
#include <string>
#include <vector>

using namespace std;

// Define pointers to functions for string conversion
using ptr = string (*)(string);
using ptr_cr = string (*)(const string&);

// Struct to store function pointers and their names
struct func_info {
    ptr func;          // Function pointer
    string name;       // Name of the function
};

struct func_info_cr {
    ptr_cr func;       // Function pointer (const reference version)
    string name;       // Name of the function
};

vector<pair<string, int64_t>> results; // Stores function performance results
map<string, int> winner; // Tracks the number of wins for each function

string strlwr_a_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] += 32;
        }
    }
    return result;
}

string strlwr_a(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] += 32;
        }
    }
    return input;
}

string strlwr_a_bitwise_operation_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] |= 32;
        }
    }
    return result;
}

string strlwr_a_bitwise_operation(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] |= 32;
        }
    }
    return input;
}

string strlwr_a_tolower_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] = tolower(result[i]);
        }
    }
    return result;
}

string strlwr_a_tolower(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] = tolower(input[i]);
        }
    }
    return input;
}

string strlwr_b_cr(const string& input) {
    string result = input;
    // Extra space for null terminator
    char cstr[result.size() + 1];
    strcpy(cstr, result.c_str());
    strlwr(cstr);
    return string(cstr);
}

string strlwr_b(string str) {
    char cstr[str.size()];
    strcpy(cstr, str.c_str());
    strlwr(cstr);
    return string(cstr);
}

string strlwr_b_plus1(string str) {
    // Extra space for null terminator
    char cstr[str.size() + 1];
    strcpy(cstr, str.c_str());
    strlwr(cstr);
    return string(cstr);
}

char cstr_array[100000001];

string strlwr_b_gobal_array_cr(const string& input) {
    string result = input;
    strcpy(cstr_array, result.c_str());
    strlwr(cstr_array);
    return string(cstr_array);
}

string strlwr_b_gobal_array(string str) {
    strcpy(cstr_array, str.c_str());
    strlwr(cstr_array);
    return string(cstr_array);
}

string strlwr_c_cr(const string& input) {
    return string(strlwr((char*)input.c_str()));
}

string strlwr_c(string str) { return string(strlwr((char*)str.c_str())); }

string strlwr_d_cr(const string& input) {
    string result = input;
    std::transform(result.begin(), result.end(), result.begin(), ::tolower);
    return result;
}

string strlwr_d(string str) {
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    return str;
}

string strlwr_e_cr(const string& input) {
    string str = input;
    std::for_each(str.begin(), str.end(), [](char& c) { c = ::tolower(c); });
    return str;
}

string strlwr_e(string str) {
    std::for_each(str.begin(), str.end(), [](char& c) { c = ::tolower(c); });
    return str;
}

string strlwr_f_cr(const string& input) {
    stringstream ss;
    for (char c : input) {
        ss << static_cast<char>(tolower(c));
    }
    return ss.str();
}

string strlwr_f(string str) {
    stringstream ss;
    for (char c : str) {
        ss << static_cast<char>(tolower(c));
    }
    return ss.str();
}

string strlwr_g_cr(const string& input) {
    string str = input;
    for (auto it = str.begin(); it != str.end(); it++) {
        *it = tolower(*it);
    }
    return str;
}

string strlwr_g(string str) {
    for (auto it = str.begin(); it != str.end(); it++) {
        *it = tolower(*it);
    }
    return str;
}

void testfunc(ptr_cr func, const string& func_name, const string& str, int count) {
    // Measure execution time for functions that take `const string&` as input
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0; i < count; ++i) {
        func(str); // Call the function repeatedly
    }
    auto duration = chrono::duration_cast<chrono::microseconds>(
        chrono::high_resolution_clock::now() - start);
    results.push_back({func_name, duration.count()}); // Store the results
}

void testfunc(ptr func, const string& func_name, const string& str, int count) {
    // Measure execution time for functions that take `string` as input
    auto start = chrono::high_resolution_clock::now();
    for (int i = 0; i < count; ++i) {
        func(str); // Call the function repeatedly
    }
    auto duration = chrono::duration_cast<chrono::microseconds>(
        chrono::high_resolution_clock::now() - start);
    results.push_back({func_name, duration.count()}); // Store the results
}

void print_results(int count) {
    // Display performance results in a sorted order
    cout << "Results:" << endl;
    sort(results.begin(), results.end(),
         [](const pair<string, int64_t>& a, const pair<string, int64_t>& b) {
             return a.second < b.second; // Sort by execution time
         });
    for (const auto& result : results) {
        cout << setw(7) << result.second << "ms" // Total time in milliseconds
             << "   avg:" << fixed << setprecision(4)
             << 1.0 * result.second / count // Average time per operation
             << "   " << result.first << endl; // Function name
    }
    auto min_time = min_element(
        results.begin(), results.end(),
        [](const pair<string, int64_t>& a, const pair<string, int64_t>& b) {
            return a.second < b.second;
        });
    winner[min_time->first]++; // Increment the winner counter for the fastest function
    cout << "The fastest function is " << min_time->first << " with time "
         << min_time->second << " ms" << endl;
}

vector<func_info> func_list = {
    // List of functions to test with `string` parameter
    func_info{strlwr_a, "strlwr_a"},
    func_info{strlwr_a_tolower, "strlwr_a_tolower"},
    func_info{strlwr_a_bitwise_operation, "strlwr_a_bitwise_operation"},
    func_info{strlwr_b, "strlwr_b"},
    func_info{strlwr_b_plus1, "strlwr_b_plus1"},
    func_info{strlwr_b_gobal_array, "strlwr_b_gobal_array"},
    func_info{strlwr_c, "strlwr_c"},
    func_info{strlwr_d, "strlwr_d"},
    func_info{strlwr_e, "strlwr_e"},
    func_info{strlwr_f, "strlwr_f"},
    func_info{strlwr_g, "strlwr_g"}};

vector<func_info_cr> func_list_cr = {
    // List of functions to test with `const string&` parameter
    func_info_cr{strlwr_a_cr, "strlwr_a_cr"},
    func_info_cr{strlwr_a_tolower_cr, "strlwr_a_tolower_cr"},
    func_info_cr{strlwr_a_bitwise_operation_cr, "strlwr_a_bitwise_operation_cr"},
    func_info_cr{strlwr_b_cr, "strlwr_b_cr"},
    func_info_cr{strlwr_b_gobal_array_cr, "strlwr_b_gobal_array_cr"},
    func_info_cr{strlwr_c_cr, "strlwr_c_cr"},
    func_info_cr{strlwr_d_cr, "strlwr_d_cr"},
    func_info_cr{strlwr_e_cr, "strlwr_e_cr"},
    func_info_cr{strlwr_f_cr, "strlwr_f_cr"},
    func_info_cr{strlwr_g_cr, "strlwr_g_cr"}};

void test_func_list(const string& str, int count) {
    // Test all functions with the provided string and repeat count
    for (const auto& func : func_list) {
        testfunc(func.func, func.name, str, count);
    }
    for (const auto& func : func_list_cr) {
        testfunc(func.func, func.name, str, count);
    }
    print_results(count); // Print the results
    results.clear(); // Clear results for the next test
    cout << endl;
}

int main() {
    // Run tests with various input strings and repeat counts
    cout << "Test with empty string" << endl;
    test_func_list("", 1000001);

    cout << "Test with single character: H" << endl;
    test_func_list("H", 1000001);

    cout << "Test with two characters: AH" << endl;
    test_func_list("AH", 1000001);

    cout << "Test with three characters: AHA" << endl;
    test_func_list("AHA", 1000001);

    cout << "Test with four characters: HELL" << endl;
    test_func_list("HELL", 1000001);

    cout << "Test with five characters: Hello" << endl;
    test_func_list("Hello", 1000001);

    cout << "Test with special characters: $%^&*" << endl;
    test_func_list("$%^&*", 1000001);

    string long_lower_str(100000, 'a'); // Generate a long string of 'a'
    string long_dash_str(100000, '-'); // Generate a long string of '-'
    cout << "Test with string: string(100000, 'a')" << endl;
    test_func_list(long_lower_str, 101);

    cout << "Test with string: string(100000, '-')" << endl;
    test_func_list(long_dash_str, 101);

    cout << "Test with mixed case: string(100000, 'a') + 'A' + string(100000, 'a')" << endl;
    test_func_list(long_lower_str + "A" + long_lower_str, 101);

    cout << "Test with mixed case: string(100000, '-') + 'A' + string(100000, '-')" << endl;
    test_func_list(long_dash_str + "A" + long_dash_str, 101);

    // Test with normal strings
    cout << "Test with normal string: Hello, World!" << endl;
    test_func_list("Hello, World!", 1000001);

    // Test with long strings
    cout << "Test with long string: string(100000, 'A')" << endl;
    string long_str(100000, 'A');
    test_func_list(long_str, 101);

    // Test with very long strings
    cout << "Test with very long string: string(1000000, 'A')" << endl;
    string very_long_str(1000000, 'A');
    test_func_list(very_long_str, 11);

    // Test with super long strings
    cout << "Test with super long string: string(10000000, 'A')" << endl;
    cout << "Not all functions will be tested due to array size limitations" << endl;
    string super_long_str(100000000, 'A');

    // Remove functions unsuitable for super long strings
    func_list.erase(remove_if(func_list.begin(), func_list.end(),
                              [](const func_info& f) {
                                  return f.name == "strlwr_b" ||
                                         f.name == "strlwr_b_plus1";
                              }),
                    func_list.end());
    func_list_cr.erase(remove_if(func_list_cr.begin(), func_list_cr.end(),
                                 [](const func_info_cr& f) {
                                     return f.name == "strlwr_b_cr";
                                 }),
                       func_list_cr.end());
    test_func_list(super_long_str, 1);

    // Print the winner count for each function
    cout << endl << "Winner:" << endl;
    for (const auto& w : winner) {
        cout << w.first << ": " << w.second << endl;
    }

    return 0;
}

Test Results

Test with empty string
Results:
   2178ms   avg:0.0022   strlwr_a_cr
   2365ms   avg:0.0024   strlwr_e_cr
   2382ms   avg:0.0024   strlwr_a_tolower_cr
   2390ms   avg:0.0024   strlwr_a_bitwise_operation_cr
   2501ms   avg:0.0025   strlwr_g_cr
   2571ms   avg:0.0026   strlwr_d_cr
   3575ms   avg:0.0036   strlwr_a
   3642ms   avg:0.0036   strlwr_d
   3692ms   avg:0.0037   strlwr_e
   3755ms   avg:0.0038   strlwr_a_bitwise_operation
   3766ms   avg:0.0038   strlwr_g
   4184ms   avg:0.0042   strlwr_a_tolower
   4810ms   avg:0.0048   strlwr_c_cr
   5994ms   avg:0.0060   strlwr_c
   8125ms   avg:0.0081   strlwr_b_gobal_array
   8144ms   avg:0.0081   strlwr_b_plus1
   8326ms   avg:0.0083   strlwr_b
   9109ms   avg:0.0091   strlwr_b_cr
   9113ms   avg:0.0091   strlwr_b_gobal_array_cr
  35442ms   avg:0.0354   strlwr_f_cr
  37052ms   avg:0.0371   strlwr_f
The fastest function is strlwr_a_cr with time 2178 ms

Test with single character: H
Results:
   2020ms   avg:0.0020   strlwr_a_cr
   2624ms   avg:0.0026   strlwr_a_bitwise_operation_cr
   2983ms   avg:0.0030   strlwr_g_cr
   3369ms   avg:0.0034   strlwr_e_cr
   3373ms   avg:0.0034   strlwr_d_cr
   3436ms   avg:0.0034   strlwr_a_tolower_cr
   5238ms   avg:0.0052   strlwr_c_cr
   5743ms   avg:0.0057   strlwr_a
   5754ms   avg:0.0058   strlwr_a_bitwise_operation
   5934ms   avg:0.0059   strlwr_a_tolower
   6040ms   avg:0.0060   strlwr_d
   6044ms   avg:0.0060   strlwr_e
   6079ms   avg:0.0061   strlwr_c
   6099ms   avg:0.0061   strlwr_g
   8871ms   avg:0.0089   strlwr_b_gobal_array
   9246ms   avg:0.0092   strlwr_b_plus1
   9539ms   avg:0.0095   strlwr_b
   9897ms   avg:0.0099   strlwr_b_gobal_array_cr
   9973ms   avg:0.0100   strlwr_b_cr
  39362ms   avg:0.0394   strlwr_f_cr
  41351ms   avg:0.0414   strlwr_f
The fastest function is strlwr_a_cr with time 2020 ms

Test with two characters: AH
Results:
   4078ms   avg:0.0041   strlwr_a_cr
   4414ms   avg:0.0044   strlwr_a_bitwise_operation_cr
   5837ms   avg:0.0058   strlwr_e_cr
   5848ms   avg:0.0058   strlwr_d_cr
   5961ms   avg:0.0060   strlwr_g_cr
   6434ms   avg:0.0064   strlwr_a_tolower_cr
   6531ms   avg:0.0065   strlwr_a_bitwise_operation
   6886ms   avg:0.0069   strlwr_e
   6892ms   avg:0.0069   strlwr_c_cr
   7289ms   avg:0.0073   strlwr_a
   7546ms   avg:0.0075   strlwr_d
   7567ms   avg:0.0076   strlwr_g
   7607ms   avg:0.0076   strlwr_a_tolower
  10611ms   avg:0.0106   strlwr_c
  10743ms   avg:0.0107   strlwr_b_gobal_array
  11628ms   avg:0.0116   strlwr_b
  11651ms   avg:0.0117   strlwr_b_gobal_array_cr
  11874ms   avg:0.0119   strlwr_b_cr
  12096ms   avg:0.0121   strlwr_b_plus1
  43736ms   avg:0.0437   strlwr_f_cr
  46085ms   avg:0.0461   strlwr_f
The fastest function is strlwr_a_cr with time 4078 ms

Test with three characters: AHA
Results:
   4435ms   avg:0.0044   strlwr_a_cr
   5064ms   avg:0.0051   strlwr_a_bitwise_operation_cr
   6667ms   avg:0.0067   strlwr_e_cr
   6781ms   avg:0.0068   strlwr_a_bitwise_operation
   6838ms   avg:0.0068   strlwr_d_cr
   7064ms   avg:0.0071   strlwr_g_cr
   7205ms   avg:0.0072   strlwr_c_cr
   7559ms   avg:0.0076   strlwr_a
   7871ms   avg:0.0079   strlwr_a_tolower_cr
   8169ms   avg:0.0082   strlwr_d
   8637ms   avg:0.0086   strlwr_a_tolower
   8768ms   avg:0.0088   strlwr_e
   8955ms   avg:0.0090   strlwr_g
  10290ms   avg:0.0103   strlwr_c
  12103ms   avg:0.0121   strlwr_b
  12145ms   avg:0.0121   strlwr_b_plus1
  12159ms   avg:0.0122   strlwr_b_gobal_array
  12658ms   avg:0.0127   strlwr_b_gobal_array_cr
  13500ms   avg:0.0135   strlwr_b_cr
  45392ms   avg:0.0454   strlwr_f_cr
  48920ms   avg:0.0489   strlwr_f
The fastest function is strlwr_a_cr with time 4435 ms

Test with four characters: HELL
Results:
   4797ms   avg:0.0048   strlwr_a_cr
   5733ms   avg:0.0057   strlwr_a_bitwise_operation_cr
   7325ms   avg:0.0073   strlwr_a_bitwise_operation
   7509ms   avg:0.0075   strlwr_e_cr
   7532ms   avg:0.0075   strlwr_d_cr
   7896ms   avg:0.0079   strlwr_c_cr
   8058ms   avg:0.0081   strlwr_a
   8224ms   avg:0.0082   strlwr_g_cr
   8812ms   avg:0.0088   strlwr_a_tolower_cr
   9490ms   avg:0.0095   strlwr_e
   9815ms   avg:0.0098   strlwr_d
  10267ms   avg:0.0103   strlwr_g
  10596ms   avg:0.0106   strlwr_a_tolower
  11059ms   avg:0.0111   strlwr_c
  13147ms   avg:0.0131   strlwr_b_gobal_array
  13301ms   avg:0.0133   strlwr_b_plus1
  13447ms   avg:0.0134   strlwr_b_cr
  13702ms   avg:0.0137   strlwr_b_gobal_array_cr
  13866ms   avg:0.0139   strlwr_b
  47457ms   avg:0.0475   strlwr_f_cr
  51810ms   avg:0.0518   strlwr_f
The fastest function is strlwr_a_cr with time 4797 ms

Test with five characters: Hello
Results:
   5167ms   avg:0.0052   strlwr_a_cr
   5421ms   avg:0.0054   strlwr_a_bitwise_operation_cr
   5862ms   avg:0.0059   strlwr_a_tolower_cr
   6957ms   avg:0.0070   strlwr_a
   7249ms   avg:0.0072   strlwr_a_bitwise_operation
   7880ms   avg:0.0079   strlwr_a_tolower
   8073ms   avg:0.0081   strlwr_c_cr
   8665ms   avg:0.0087   strlwr_d_cr
   8854ms   avg:0.0089   strlwr_e_cr
  10173ms   avg:0.0102   strlwr_d
  10574ms   avg:0.0106   strlwr_e
  11124ms   avg:0.0111   strlwr_g_cr
  11872ms   avg:0.0119   strlwr_c
  12533ms   avg:0.0125   strlwr_g
  13066ms   avg:0.0131   strlwr_b_gobal_array_cr
  13387ms   avg:0.0134   strlwr_b_gobal_array
  13761ms   avg:0.0138   strlwr_b_cr
  13935ms   avg:0.0139   strlwr_b
  14094ms   avg:0.0141   strlwr_b_plus1
  51904ms   avg:0.0519   strlwr_f_cr
  53267ms   avg:0.0533   strlwr_f
The fastest function is strlwr_a_cr with time 5167 ms

Test with five characters: $%^&*
Results:
   5141ms   avg:0.0051   strlwr_a_cr
   5315ms   avg:0.0053   strlwr_a_tolower_cr
   5338ms   avg:0.0053   strlwr_a_bitwise_operation_cr
   7007ms   avg:0.0070   strlwr_a_tolower
   7120ms   avg:0.0071   strlwr_a_bitwise_operation
   7328ms   avg:0.0073   strlwr_a
   8235ms   avg:0.0082   strlwr_c_cr
   8709ms   avg:0.0087   strlwr_d_cr
   8849ms   avg:0.0088   strlwr_e_cr
  10637ms   avg:0.0106   strlwr_e
  10723ms   avg:0.0107   strlwr_d
  11173ms   avg:0.0112   strlwr_c
  11375ms   avg:0.0114   strlwr_g_cr
  12762ms   avg:0.0128   strlwr_g
  13200ms   avg:0.0132   strlwr_b_gobal_array_cr
  13285ms   avg:0.0133   strlwr_b_gobal_array
  13724ms   avg:0.0137   strlwr_b_cr
  14110ms   avg:0.0141   strlwr_b_plus1
  14218ms   avg:0.0142   strlwr_b
  50909ms   avg:0.0509   strlwr_f_cr
  53042ms   avg:0.0530   strlwr_f
The fastest function is strlwr_a_cr with time 5141 ms

Test with string: string(100000, 'a')
Results:
   2789ms   avg:27.6139   strlwr_a_tolower
   3246ms   avg:32.1386   strlwr_a
   3339ms   avg:33.0594   strlwr_a_bitwise_operation_cr
   3594ms   avg:35.5842   strlwr_a_cr
   3938ms   avg:38.9901   strlwr_c_cr
   4092ms   avg:40.5149   strlwr_a_tolower_cr
   5577ms   avg:55.2178   strlwr_a_bitwise_operation
   8447ms   avg:83.6337   strlwr_b_gobal_array_cr
   9119ms   avg:90.2871   strlwr_b_cr
   9485ms   avg:93.9109   strlwr_d_cr
   9487ms   avg:93.9307   strlwr_e_cr
   9587ms   avg:94.9208   strlwr_c
   9812ms   avg:97.1485   strlwr_b
   9856ms   avg:97.5842   strlwr_b_gobal_array
  10366ms   avg:102.6337   strlwr_b_plus1
  11705ms   avg:115.8911   strlwr_d
  11967ms   avg:118.4851   strlwr_e
  15203ms   avg:150.5248   strlwr_g_cr
  15375ms   avg:152.2277   strlwr_g
  31721ms   avg:314.0693   strlwr_f_cr
  34112ms   avg:337.7426   strlwr_f
The fastest function is strlwr_a_tolower with time 2789 ms

Test with string: string(100000, '-')
Results:
   2662ms   avg:26.3564   strlwr_a_cr
   2699ms   avg:26.7228   strlwr_a_bitwise_operation_cr
   3001ms   avg:29.7129   strlwr_a_bitwise_operation
   3023ms   avg:29.9307   strlwr_c_cr
   3135ms   avg:31.0396   strlwr_a_tolower_cr
   3395ms   avg:33.6139   strlwr_a_tolower
   4217ms   avg:41.7525   strlwr_a
   5208ms   avg:51.5644   strlwr_b_cr
   5306ms   avg:52.5347   strlwr_b_gobal_array_cr
   6695ms   avg:66.2871   strlwr_c
   6919ms   avg:68.5050   strlwr_b_plus1
   7002ms   avg:69.3267   strlwr_b_gobal_array
   7757ms   avg:76.8020   strlwr_b
   8573ms   avg:84.8812   strlwr_d_cr
   8707ms   avg:86.2079   strlwr_e_cr
   8908ms   avg:88.1980   strlwr_e
   9060ms   avg:89.7030   strlwr_d
  14566ms   avg:144.2178   strlwr_g_cr
  14701ms   avg:145.5545   strlwr_g
  27187ms   avg:269.1782   strlwr_f_cr
  31603ms   avg:312.9010   strlwr_f
The fastest function is strlwr_a_cr with time 2662 ms

Test with five characters: string(100000, 'a')+'A'+string(100000, 'a')
Results:
   4513ms   avg:44.6832   strlwr_a_bitwise_operation_cr
   4611ms   avg:45.6535   strlwr_a_cr
   4930ms   avg:48.8119   strlwr_a_bitwise_operation
   5399ms   avg:53.4554   strlwr_c_cr
   5454ms   avg:54.0000   strlwr_a_tolower_cr
   5471ms   avg:54.1683   strlwr_c
   5635ms   avg:55.7921   strlwr_a_tolower
   5678ms   avg:56.2178   strlwr_a
   6460ms   avg:63.9604   strlwr_b_gobal_array
   6560ms   avg:64.9505   strlwr_b_gobal_array_cr
   6684ms   avg:66.1782   strlwr_b_cr
   6760ms   avg:66.9307   strlwr_b_plus1
   7922ms   avg:78.4356   strlwr_b
  16758ms   avg:165.9208   strlwr_e
  16847ms   avg:166.8020   strlwr_d
  17380ms   avg:172.0792   strlwr_d_cr
  17451ms   avg:172.7822   strlwr_e_cr
  28122ms   avg:278.4356   strlwr_g_cr
  29125ms   avg:288.3663   strlwr_g
  44937ms   avg:444.9208   strlwr_f_cr
  51669ms   avg:511.5743   strlwr_f
The fastest function is strlwr_a_bitwise_operation_cr with time 4513 ms

Test with five characters: string(100000, '-')+'A'+string(100000, '-')
Results:
   4563ms   avg:45.1782   strlwr_a
   4589ms   avg:45.4356   strlwr_a_bitwise_operation_cr
   4660ms   avg:46.1386   strlwr_a_bitwise_operation
   4670ms   avg:46.2376   strlwr_a_cr
   5081ms   avg:50.3069   strlwr_c_cr
   5483ms   avg:54.2871   strlwr_a_tolower_cr
   5524ms   avg:54.6931   strlwr_a_tolower
   5571ms   avg:55.1584   strlwr_c
   6308ms   avg:62.4554   strlwr_b
   6349ms   avg:62.8614   strlwr_b_gobal_array
   6379ms   avg:63.1584   strlwr_b_gobal_array_cr
   6871ms   avg:68.0297   strlwr_b_plus1
   6884ms   avg:68.1584   strlwr_b_cr
  16997ms   avg:168.2871   strlwr_d_cr
  17099ms   avg:169.2970   strlwr_d
  17176ms   avg:170.0594   strlwr_e_cr
  17382ms   avg:172.0990   strlwr_e
  23653ms   avg:234.1881   strlwr_g
  28559ms   avg:282.7624   strlwr_g_cr
  44610ms   avg:441.6832   strlwr_f
  46119ms   avg:456.6238   strlwr_f_cr
The fastest function is strlwr_a with time 4563 ms

Test with normal string: Hello, World!
Results:
   5914ms   avg:0.0059   strlwr_a_cr
   7619ms   avg:0.0076   strlwr_a_bitwise_operation_cr
   7974ms   avg:0.0080   strlwr_a_tolower_cr
   8244ms   avg:0.0082   strlwr_a
   8715ms   avg:0.0087   strlwr_c_cr
   9164ms   avg:0.0092   strlwr_a_bitwise_operation
  10048ms   avg:0.0100   strlwr_a_tolower
  11419ms   avg:0.0114   strlwr_c
  13792ms   avg:0.0138   strlwr_b_gobal_array
  13879ms   avg:0.0139   strlwr_b_gobal_array_cr
  14093ms   avg:0.0141   strlwr_d_cr
  14145ms   avg:0.0141   strlwr_b_plus1
  14202ms   avg:0.0142   strlwr_e_cr
  14854ms   avg:0.0149   strlwr_b
  14883ms   avg:0.0149   strlwr_b_cr
  15807ms   avg:0.0158   strlwr_d
  15816ms   avg:0.0158   strlwr_e
  16930ms   avg:0.0169   strlwr_g_cr
  23235ms   avg:0.0232   strlwr_g
  68491ms   avg:0.0685   strlwr_f_cr
  70159ms   avg:0.0702   strlwr_f
The fastest function is strlwr_a_cr with time 5914 ms

Test with long string: string(100000, 'A')
Results:
   2850ms   avg:28.2178   strlwr_c_cr
   4090ms   avg:40.4950   strlwr_a_bitwise_operation
   4148ms   avg:41.0693   strlwr_a_bitwise_operation_cr
   4247ms   avg:42.0495   strlwr_a_cr
   4617ms   avg:45.7129   strlwr_c
   5144ms   avg:50.9307   strlwr_b_gobal_array_cr
   5148ms   avg:50.9703   strlwr_b_gobal_array
   5162ms   avg:51.1089   strlwr_b_plus1
   5244ms   avg:51.9208   strlwr_b_cr
   5251ms   avg:51.9901   strlwr_b
   5647ms   avg:55.9109   strlwr_a
   8358ms   avg:82.7525   strlwr_e_cr
   8392ms   avg:83.0891   strlwr_d
   8481ms   avg:83.9703   strlwr_e
   8549ms   avg:84.6436   strlwr_d_cr
  12205ms   avg:120.8416   strlwr_a_tolower_cr
  12422ms   avg:122.9901   strlwr_a_tolower
  14142ms   avg:140.0198   strlwr_g_cr
  14491ms   avg:143.4752   strlwr_g
  20935ms   avg:207.2772   strlwr_f_cr
  22663ms   avg:224.3861   strlwr_f
The fastest function is strlwr_c_cr with time 2850 ms

Test with very long string: string(1000000, 'A')
Results:
   3327ms   avg:302.4545   strlwr_c_cr
   3703ms   avg:336.6364   strlwr_a_bitwise_operation
   4528ms   avg:411.6364   strlwr_a_cr
   4606ms   avg:418.7273   strlwr_a_bitwise_operation_cr
   6157ms   avg:559.7273   strlwr_a
   7766ms   avg:706.0000   strlwr_c
   8222ms   avg:747.4545   strlwr_b_plus1
   8304ms   avg:754.9091   strlwr_b_gobal_array_cr
   8755ms   avg:795.9091   strlwr_b_cr
   9240ms   avg:840.0000   strlwr_e_cr
   9245ms   avg:840.4545   strlwr_d_cr
   9280ms   avg:843.6364   strlwr_d
   9355ms   avg:850.4545   strlwr_e
   9403ms   avg:854.8182   strlwr_b_gobal_array
   9592ms   avg:872.0000   strlwr_b
  13051ms   avg:1186.4545   strlwr_a_tolower
  13186ms   avg:1198.7273   strlwr_a_tolower_cr
  15767ms   avg:1433.3636   strlwr_g
  15837ms   avg:1439.7273   strlwr_g_cr
  28014ms   avg:2546.7273   strlwr_f_cr
  29226ms   avg:2656.9091   strlwr_f
The fastest function is strlwr_c_cr with time 3327 ms

Test with super long string: string(10000000, 'A')
Not all functions will be tested, because array is too long
Results:
  51371ms   avg:51371.0000   strlwr_a_bitwise_operation
  52663ms   avg:52663.0000   strlwr_a
  53637ms   avg:53637.0000   strlwr_a_cr
  57451ms   avg:57451.0000   strlwr_c_cr
  57926ms   avg:57926.0000   strlwr_a_bitwise_operation_cr
  71125ms   avg:71125.0000   strlwr_c
  78141ms   avg:78141.0000   strlwr_b_gobal_array_cr
  98493ms   avg:98493.0000   strlwr_b_gobal_array
  99366ms   avg:99366.0000   strlwr_e
  99485ms   avg:99485.0000   strlwr_d
  99658ms   avg:99658.0000   strlwr_e_cr
 101898ms   avg:101898.0000   strlwr_d_cr
 113328ms   avg:113328.0000   strlwr_a_tolower
 117965ms   avg:117965.0000   strlwr_a_tolower_cr
 132375ms   avg:132375.0000   strlwr_g_cr
 151730ms   avg:151730.0000   strlwr_g
 262515ms   avg:262515.0000   strlwr_f_cr
 282339ms   avg:282339.0000   strlwr_f
The fastest function is strlwr_a_bitwise_operation with time 51371 ms


Winner:
strlwr_a: 1
strlwr_a_bitwise_operation: 1
strlwr_a_bitwise_operation_cr: 1
strlwr_a_cr: 9
strlwr_a_tolower: 1
strlwr_c_cr: 2
Without `#pragma GCC optimize`
Test with empty string
Results:
   3378ms   avg:0.0034   strlwr_a_tolower_cr
   3618ms   avg:0.0036   strlwr_a_cr
   3979ms   avg:0.0040   strlwr_a_bitwise_operation_cr
   5598ms   avg:0.0056   strlwr_a_tolower
   5930ms   avg:0.0059   strlwr_a_bitwise_operation
   6937ms   avg:0.0069   strlwr_g_cr
   7202ms   avg:0.0072   strlwr_a
   7728ms   avg:0.0077   strlwr_e_cr
   8098ms   avg:0.0081   strlwr_d_cr
   9078ms   avg:0.0091   strlwr_g
   9863ms   avg:0.0099   strlwr_e
  10576ms   avg:0.0106   strlwr_d
  15573ms   avg:0.0156   strlwr_c_cr
  17512ms   avg:0.0175   strlwr_c
  18659ms   avg:0.0187   strlwr_b_gobal_array_cr
  18686ms   avg:0.0187   strlwr_b_gobal_array
  19948ms   avg:0.0199   strlwr_b
  20400ms   avg:0.0204   strlwr_b_cr
  20450ms   avg:0.0204   strlwr_b_plus1
  37561ms   avg:0.0376   strlwr_f_cr
  40086ms   avg:0.0401   strlwr_f
The fastest function is strlwr_a_tolower_cr with time 3378 ms

Test with single character: H
Results:
   7521ms   avg:0.0075   strlwr_a_cr
   8254ms   avg:0.0083   strlwr_a_bitwise_operation_cr
   8490ms   avg:0.0085   strlwr_a_tolower_cr
  10662ms   avg:0.0107   strlwr_a
  11120ms   avg:0.0111   strlwr_a_tolower
  11400ms   avg:0.0114   strlwr_a_bitwise_operation
  13333ms   avg:0.0133   strlwr_e_cr
  14615ms   avg:0.0146   strlwr_g_cr
  14935ms   avg:0.0149   strlwr_d_cr
  15505ms   avg:0.0155   strlwr_e
  15751ms   avg:0.0158   strlwr_c_cr
  16225ms   avg:0.0162   strlwr_g
  17185ms   avg:0.0172   strlwr_d
  17707ms   avg:0.0177   strlwr_c
  18882ms   avg:0.0189   strlwr_b_gobal_array_cr
  19347ms   avg:0.0193   strlwr_b_gobal_array
  20331ms   avg:0.0203   strlwr_b_cr
  20346ms   avg:0.0203   strlwr_b
  20521ms   avg:0.0205   strlwr_b_plus1
  48094ms   avg:0.0481   strlwr_f_cr
  49518ms   avg:0.0495   strlwr_f
The fastest function is strlwr_a_cr with time 7521 ms

Test with two characters: AH
Results:
  11510ms   avg:0.0115   strlwr_a_bitwise_operation_cr
  11860ms   avg:0.0119   strlwr_a_cr
  13857ms   avg:0.0139   strlwr_a_bitwise_operation
  14099ms   avg:0.0141   strlwr_a
  14907ms   avg:0.0149   strlwr_a_tolower_cr
  16400ms   avg:0.0164   strlwr_a_tolower
  16698ms   avg:0.0167   strlwr_c_cr
  19599ms   avg:0.0196   strlwr_c
  19856ms   avg:0.0199   strlwr_e_cr
  20785ms   avg:0.0208   strlwr_b_gobal_array_cr
  20962ms   avg:0.0210   strlwr_b_gobal_array
  22170ms   avg:0.0222   strlwr_b_cr
  22627ms   avg:0.0226   strlwr_b
  22628ms   avg:0.0226   strlwr_d_cr
  22806ms   avg:0.0228   strlwr_g_cr
  23036ms   avg:0.0230   strlwr_b_plus1
  23055ms   avg:0.0231   strlwr_e
  24483ms   avg:0.0245   strlwr_g
  25461ms   avg:0.0255   strlwr_d
  55398ms   avg:0.0554   strlwr_f_cr
  63354ms   avg:0.0634   strlwr_f
The fastest function is strlwr_a_bitwise_operation_cr with time 11510 ms

Test with three characters: AHA
Results:
  14940ms   avg:0.0149   strlwr_a_bitwise_operation_cr
  17139ms   avg:0.0171   strlwr_a_cr
  17281ms   avg:0.0173   strlwr_c_cr
  17510ms   avg:0.0175   strlwr_a
  17700ms   avg:0.0177   strlwr_a_bitwise_operation
  19438ms   avg:0.0194   strlwr_a_tolower_cr
  20601ms   avg:0.0206   strlwr_c
  21439ms   avg:0.0214   strlwr_b_gobal_array
  21662ms   avg:0.0217   strlwr_a_tolower
  21761ms   avg:0.0218   strlwr_b_gobal_array_cr
  23300ms   avg:0.0233   strlwr_b
  23310ms   avg:0.0233   strlwr_b_cr
  23831ms   avg:0.0238   strlwr_b_plus1
  25842ms   avg:0.0258   strlwr_e_cr
  28901ms   avg:0.0289   strlwr_e
  29679ms   avg:0.0297   strlwr_d_cr
  30729ms   avg:0.0307   strlwr_g_cr
  31678ms   avg:0.0317   strlwr_d
  31909ms   avg:0.0319   strlwr_g
  62600ms   avg:0.0626   strlwr_f_cr
  65815ms   avg:0.0658   strlwr_f
The fastest function is strlwr_a_bitwise_operation_cr with time 14940 ms

Test with four characters: HELL
Results:
  17787ms   avg:0.0178   strlwr_c_cr
  18010ms   avg:0.0180   strlwr_a_bitwise_operation_cr
  19360ms   avg:0.0194   strlwr_a_cr
  20173ms   avg:0.0202   strlwr_a
  20609ms   avg:0.0206   strlwr_a_bitwise_operation
  21292ms   avg:0.0213   strlwr_c
  21884ms   avg:0.0219   strlwr_b_gobal_array
  22129ms   avg:0.0221   strlwr_b_gobal_array_cr
  23611ms   avg:0.0236   strlwr_b_cr
  23953ms   avg:0.0240   strlwr_b_plus1
  23990ms   avg:0.0240   strlwr_b
  24232ms   avg:0.0242   strlwr_a_tolower_cr
  26410ms   avg:0.0264   strlwr_a_tolower
  31530ms   avg:0.0315   strlwr_e_cr
  34225ms   avg:0.0342   strlwr_e
  35559ms   avg:0.0356   strlwr_d_cr
  37740ms   avg:0.0377   strlwr_g_cr
  38481ms   avg:0.0385   strlwr_d
  39593ms   avg:0.0396   strlwr_g
  68569ms   avg:0.0686   strlwr_f_cr
  72244ms   avg:0.0722   strlwr_f
The fastest function is strlwr_c_cr with time 17787 ms

Test with five characters: Hello
Results:
  18207ms   avg:0.0182   strlwr_c_cr
  20025ms   avg:0.0200   strlwr_a_cr
  20525ms   avg:0.0205   strlwr_a_bitwise_operation_cr
  20683ms   avg:0.0207   strlwr_a_tolower_cr
  21497ms   avg:0.0215   strlwr_c
  22813ms   avg:0.0228   strlwr_a_bitwise_operation
  22877ms   avg:0.0229   strlwr_a
  22930ms   avg:0.0229   strlwr_a_tolower
  22975ms   avg:0.0230   strlwr_b_gobal_array
  23356ms   avg:0.0234   strlwr_b_gobal_array_cr
  24625ms   avg:0.0246   strlwr_b_cr
  25111ms   avg:0.0251   strlwr_b_plus1
  26072ms   avg:0.0261   strlwr_b
  37079ms   avg:0.0371   strlwr_e_cr
  40326ms   avg:0.0403   strlwr_e
  42330ms   avg:0.0423   strlwr_d_cr
  44254ms   avg:0.0443   strlwr_d
  45580ms   avg:0.0456   strlwr_g_cr
  46785ms   avg:0.0468   strlwr_g
  76473ms   avg:0.0765   strlwr_f_cr
  79506ms   avg:0.0795   strlwr_f
The fastest function is strlwr_c_cr with time 18207 ms

Test with five characters: $%^&*
Results:
  15238ms   avg:0.0152   strlwr_a_tolower_cr
  15438ms   avg:0.0154   strlwr_a_bitwise_operation_cr
  16300ms   avg:0.0163   strlwr_a_cr
  17116ms   avg:0.0171   strlwr_a_tolower
  18042ms   avg:0.0180   strlwr_a
  18043ms   avg:0.0180   strlwr_c_cr
  18046ms   avg:0.0180   strlwr_a_bitwise_operation
  21709ms   avg:0.0217   strlwr_c
  23199ms   avg:0.0232   strlwr_b_gobal_array_cr
  23379ms   avg:0.0234   strlwr_b_gobal_array
  24517ms   avg:0.0245   strlwr_b_cr
  24884ms   avg:0.0249   strlwr_b
  25203ms   avg:0.0252   strlwr_b_plus1
  37744ms   avg:0.0377   strlwr_e_cr
  40310ms   avg:0.0403   strlwr_e
  42563ms   avg:0.0426   strlwr_d_cr
  44388ms   avg:0.0444   strlwr_d
  45475ms   avg:0.0455   strlwr_g_cr
  46410ms   avg:0.0464   strlwr_g
  76417ms   avg:0.0764   strlwr_f_cr
  80162ms   avg:0.0802   strlwr_f
The fastest function is strlwr_a_tolower_cr with time 15238 ms

Test with string: string(100000, 'a')
Results:
   3922ms   avg:38.8317   strlwr_c_cr
   8521ms   avg:84.3663   strlwr_b
   9219ms   avg:91.2772   strlwr_c
   9417ms   avg:93.2376   strlwr_b_gobal_array_cr
   9548ms   avg:94.5347   strlwr_b_plus1
   9734ms   avg:96.3762   strlwr_b_cr
   9914ms   avg:98.1584   strlwr_b_gobal_array
  26039ms   avg:257.8119   strlwr_a_bitwise_operation
  27266ms   avg:269.9604   strlwr_a_tolower_cr
  29237ms   avg:289.4752   strlwr_a_cr
  29496ms   avg:292.0396   strlwr_a_tolower
  32707ms   avg:323.8317   strlwr_a
  35212ms   avg:348.6337   strlwr_a_bitwise_operation_cr
  57861ms   avg:572.8812   strlwr_e_cr
  58939ms   avg:583.5545   strlwr_e
  66071ms   avg:654.1683   strlwr_d
  66352ms   avg:656.9505   strlwr_d_cr
  75456ms   avg:747.0891   strlwr_g
  76676ms   avg:759.1683   strlwr_g_cr
  79081ms   avg:782.9802   strlwr_f_cr
  79097ms   avg:783.1386   strlwr_f
The fastest function is strlwr_c_cr with time 3922 ms

Test with string: string(100000, '-')
Results:
   2949ms   avg:29.1980   strlwr_c_cr
   4983ms   avg:49.3366   strlwr_b_gobal_array_cr
   5938ms   avg:58.7921   strlwr_b_cr
   6530ms   avg:64.6535   strlwr_b
   6683ms   avg:66.1683   strlwr_b_plus1
   7101ms   avg:70.3069   strlwr_c
   7597ms   avg:75.2178   strlwr_b_gobal_array
  18377ms   avg:181.9505   strlwr_a_tolower_cr
  18599ms   avg:184.1485   strlwr_a_bitwise_operation_cr
  18695ms   avg:185.0990   strlwr_a_tolower
  18783ms   avg:185.9703   strlwr_a_bitwise_operation
  18967ms   avg:187.7921   strlwr_a
  20637ms   avg:204.3267   strlwr_a_cr
  56489ms   avg:559.2970   strlwr_e_cr
  59872ms   avg:592.7921   strlwr_e
  65280ms   avg:646.3366   strlwr_d_cr
  65654ms   avg:650.0396   strlwr_d
  72037ms   avg:713.2376   strlwr_f_cr
  73377ms   avg:726.5050   strlwr_g
  76481ms   avg:757.2376   strlwr_g_cr
  77591ms   avg:768.2277   strlwr_f
The fastest function is strlwr_c_cr with time 2949 ms

Test with five characters: string(100000, 'a')+'A'+string(100000, 'a')
Results:
   4987ms   avg:49.3762   strlwr_c_cr
   5412ms   avg:53.5842   strlwr_c
   6492ms   avg:64.2772   strlwr_b_gobal_array_cr
   6597ms   avg:65.3168   strlwr_b_cr
   6633ms   avg:65.6733   strlwr_b_gobal_array
   7013ms   avg:69.4356   strlwr_b_plus1
   7057ms   avg:69.8713   strlwr_b
  52209ms   avg:516.9208   strlwr_a_tolower_cr
  52833ms   avg:523.0990   strlwr_a_bitwise_operation_cr
  52858ms   avg:523.3465   strlwr_a_tolower
  53111ms   avg:525.8515   strlwr_a_bitwise_operation
  53640ms   avg:531.0891   strlwr_a
  57055ms   avg:564.9010   strlwr_a_cr
 114560ms   avg:1134.2574   strlwr_e_cr
 118714ms   avg:1175.3861   strlwr_e
 129216ms   avg:1279.3663   strlwr_d_cr
 129845ms   avg:1285.5941   strlwr_d
 136271ms   avg:1349.2178   strlwr_f_cr
 141211ms   avg:1398.1287   strlwr_f
 145990ms   avg:1445.4455   strlwr_g
 149732ms   avg:1482.4950   strlwr_g_cr
The fastest function is strlwr_c_cr with time 4987 ms

Test with five characters: string(100000, '-')+'A'+string(100000, '-')
Results:
   4941ms   avg:48.9208   strlwr_c_cr
   5110ms   avg:50.5941   strlwr_c
   6112ms   avg:60.5149   strlwr_b_gobal_array
   6158ms   avg:60.9703   strlwr_b_gobal_array_cr
   6223ms   avg:61.6139   strlwr_b_plus1
   6261ms   avg:61.9901   strlwr_b_cr
   6338ms   avg:62.7525   strlwr_b
  36148ms   avg:357.9010   strlwr_a_bitwise_operation
  36194ms   avg:358.3564   strlwr_a_tolower
  36202ms   avg:358.4356   strlwr_a_tolower_cr
  36265ms   avg:359.0594   strlwr_a_bitwise_operation_cr
  37524ms   avg:371.5248   strlwr_a
  40249ms   avg:398.5050   strlwr_a_cr
 112907ms   avg:1117.8911   strlwr_e_cr
 116405ms   avg:1152.5248   strlwr_e
 129275ms   avg:1279.9505   strlwr_d
 131345ms   avg:1300.4455   strlwr_d_cr
 136273ms   avg:1349.2376   strlwr_f_cr
 138006ms   avg:1366.3960   strlwr_f
 150670ms   avg:1491.7822   strlwr_g
 152053ms   avg:1505.4752   strlwr_g_cr
The fastest function is strlwr_c_cr with time 4941 ms

Test with normal string: Hello, World!
Results:
  22115ms   avg:0.0221   strlwr_c
  24015ms   avg:0.0240   strlwr_b_gobal_array
  25641ms   avg:0.0256   strlwr_b_plus1
  25746ms   avg:0.0257   strlwr_b
  36055ms   avg:0.0361   strlwr_c_cr
  41672ms   avg:0.0417   strlwr_a
  43151ms   avg:0.0432   strlwr_a_bitwise_operation
  43893ms   avg:0.0439   strlwr_a_tolower
  48233ms   avg:0.0482   strlwr_b_gobal_array_cr
  50032ms   avg:0.0500   strlwr_b_cr
  53366ms   avg:0.0534   strlwr_a_cr
  76708ms   avg:0.0767   strlwr_a_bitwise_operation_cr
  78856ms   avg:0.0789   strlwr_a_tolower_cr
  92614ms   avg:0.0926   strlwr_e
 104389ms   avg:0.1044   strlwr_d
 114527ms   avg:0.1145   strlwr_g
 144290ms   avg:0.1443   strlwr_f
 148073ms   avg:0.1481   strlwr_e_cr
 185303ms   avg:0.1853   strlwr_g_cr
 189111ms   avg:0.1891   strlwr_d_cr
 234481ms   avg:0.2345   strlwr_f_cr
The fastest function is strlwr_c with time 22115 ms

Test with long string: string(100000, 'A')
Results:
   4141ms   avg:41.0000   strlwr_c_cr
   7155ms   avg:70.8416   strlwr_c
   7935ms   avg:78.5644   strlwr_b_plus1
   8104ms   avg:80.2376   strlwr_b_gobal_array_cr
   8450ms   avg:83.6634   strlwr_b_cr
   8883ms   avg:87.9505   strlwr_b_gobal_array
   8914ms   avg:88.2574   strlwr_b
  52675ms   avg:521.5347   strlwr_a_bitwise_operation_cr
  53903ms   avg:533.6931   strlwr_a_bitwise_operation
  54576ms   avg:540.3564   strlwr_a
  60268ms   avg:596.7129   strlwr_a_cr
  80132ms   avg:793.3861   strlwr_a_tolower
  81337ms   avg:805.3168   strlwr_a_tolower_cr
  91819ms   avg:909.0990   strlwr_e_cr
 101800ms   avg:1007.9208   strlwr_e
 105913ms   avg:1048.6436   strlwr_d_cr
 107961ms   avg:1068.9208   strlwr_d
 115691ms   avg:1145.4554   strlwr_f
 121857ms   avg:1206.5050   strlwr_g
 126411ms   avg:1251.5941   strlwr_f_cr
 139462ms   avg:1380.8119   strlwr_g_cr
The fastest function is strlwr_c_cr with time 4141 ms

Test with very long string: string(1000000, 'A')
Results:
   4741ms   avg:431.0000   strlwr_c_cr
  13301ms   avg:1209.1818   strlwr_b_cr
  14137ms   avg:1285.1818   strlwr_b_gobal_array_cr
  16132ms   avg:1466.5455   strlwr_c
  16828ms   avg:1529.8182   strlwr_b_plus1
  17300ms   avg:1572.7273   strlwr_b
  18541ms   avg:1685.5455   strlwr_b_gobal_array
  57394ms   avg:5217.6364   strlwr_a_bitwise_operation_cr
  65325ms   avg:5938.6364   strlwr_a_cr
  73895ms   avg:6717.7273   strlwr_a_bitwise_operation
  74765ms   avg:6796.8182   strlwr_a
  90188ms   avg:8198.9091   strlwr_a_tolower_cr
 102875ms   avg:9352.2727   strlwr_e_cr
 105077ms   avg:9552.4545   strlwr_e
 112097ms   avg:10190.6364   strlwr_a_tolower
 115713ms   avg:10519.3636   strlwr_d_cr
 127222ms   avg:11565.6364   strlwr_f_cr
 130179ms   avg:11834.4545   strlwr_g
 130545ms   avg:11867.7273   strlwr_f
 132292ms   avg:12026.5455   strlwr_d
 133993ms   avg:12181.1818   strlwr_g_cr
The fastest function is strlwr_c_cr with time 4741 ms

Test with super long string: string(10000000, 'A')
Not all functions will be tested, because array is too long
Results:
  88778ms   avg:88778.0000   strlwr_c_cr
 104002ms   avg:104002.0000   strlwr_c
 118009ms   avg:118009.0000   strlwr_b_gobal_array_cr
 156843ms   avg:156843.0000   strlwr_b_gobal_array
 545473ms   avg:545473.0000   strlwr_a
 553661ms   avg:553661.0000   strlwr_a_bitwise_operation_cr
 556760ms   avg:556760.0000   strlwr_a_bitwise_operation
 626332ms   avg:626332.0000   strlwr_a_cr
 817736ms   avg:817736.0000   strlwr_a_tolower_cr
 835059ms   avg:835059.0000   strlwr_a_tolower
 954510ms   avg:954510.0000   strlwr_e_cr
 972074ms   avg:972074.0000   strlwr_e
1073152ms   avg:1073152.0000   strlwr_d
1133930ms   avg:1133930.0000   strlwr_d_cr
1187283ms   avg:1187283.0000   strlwr_f_cr
1198201ms   avg:1198201.0000   strlwr_f
1198848ms   avg:1198848.0000   strlwr_g
1239352ms   avg:1239352.0000   strlwr_g_cr
The fastest function is strlwr_c_cr with time 88778 ms


Winner:
strlwr_a_bitwise_operation_cr: 2
strlwr_a_cr: 1
strlwr_a_tolower_cr: 2
strlwr_c: 1
strlwr_c_cr: 9

Validation of Functionality

Code for Validation

#include <bits/stdc++.h>
using namespace std;

string strlwr_a_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] += 32;
        }
    }
    return result;
}

string strlwr_a(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] += 32;
        }
    }
    return input;
}

string strlwr_a_bitwise_operation_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] |= 32;
        }
    }
    return result;
}

string strlwr_a_bitwise_operation(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] |= 32;
        }
    }
    return input;
}

string strlwr_a_tolower_cr(const string& input) {
    string result = input;
    for (size_t i = 0; i < result.size(); ++i) {
        if (result[i] >= 'A' && result[i] <= 'Z') {
            result[i] = tolower(result[i]);
        }
    }
    return result;
}

string strlwr_a_tolower(string input) {
    for (size_t i = 0; i < input.size(); ++i) {
        if (input[i] >= 'A' && input[i] <= 'Z') {
            input[i] = tolower(input[i]);
        }
    }
    return input;
}

string strlwr_b_cr(const string& input) {
    string result = input;
    // Extra space for null terminator
    char cstr[result.size() + 1];
    strcpy(cstr, result.c_str());
    strlwr(cstr);
    return string(cstr);
}

string strlwr_b(string str) {
    char cstr[str.size()];
    strcpy(cstr, str.c_str());
    strlwr(cstr);
    return string(cstr);
}

string strlwr_b_plus1(string str) {
    // Extra space for null terminator
    char cstr[str.size() + 1];
    strcpy(cstr, str.c_str());
    strlwr(cstr);
    return string(cstr);
}

char cstr_array[100000001];

string strlwr_b_gobal_array_cr(const string& input) {
    string result = input;
    strcpy(cstr_array, result.c_str());
    strlwr(cstr_array);
    return string(cstr_array);
}

string strlwr_b_gobal_array(string str) {
    strcpy(cstr_array, str.c_str());
    strlwr(cstr_array);
    return string(cstr_array);
}

string strlwr_c_cr(const string& input) {
    return string(strlwr((char*)input.c_str()));
}

string strlwr_c(string str) { return string(strlwr((char*)str.c_str())); }

string strlwr_d_cr(const string& input) {
    string result = input;
    std::transform(result.begin(), result.end(), result.begin(), ::tolower);
    return result;
}

string strlwr_d(string str) {
    std::transform(str.begin(), str.end(), str.begin(), ::tolower);
    return str;
}

string strlwr_e_cr(const string& input) {
    string str = input;
    std::for_each(str.begin(), str.end(), [](char& c) { c = ::tolower(c); });
    return str;
}

string strlwr_e(string str) {
    std::for_each(str.begin(), str.end(), [](char& c) { c = ::tolower(c); });
    return str;
}

string strlwr_f_cr(const string& input) {
    stringstream ss;
    for (char c : input) {
        ss << static_cast<char>(tolower(c));
    }
    return ss.str();
}

string strlwr_f(string str) {
    stringstream ss;
    for (char c : str) {
        ss << static_cast<char>(tolower(c));
    }
    return ss.str();
}

string strlwr_g_cr(const string& input) {
    string str = input;
    for (auto it = str.begin(); it != str.end(); it++) {
        *it = tolower(*it);
    }
    return str;
}

string strlwr_g(string str) {
    for (auto it = str.begin(); it != str.end(); it++) {
        *it = tolower(*it);
    }
    return str;
}

void solve() {
    string str = "TQuickBFJOveThLaD.0123456789!@#$%^&*()_+{}:'<>?";
    cout << str << setw(30) << "original" << endl;
    cout << strlwr_a_cr(str) << setw(30) << "strlwr_a_cr" << endl;
    cout << strlwr_a(str) << setw(30) << "strlwr_a" << endl;
    cout << strlwr_a_bitwise_operation_cr(str) << setw(30)
         << "strlwr_a_bitwise_operation_cr" << endl;
    cout << strlwr_a_bitwise_operation(str) << setw(30)
         << "strlwr_a_bitwise_operation" << endl;
    cout << strlwr_a_tolower_cr(str) << setw(30) << "strlwr_a_tolower_cr" << endl;
    cout << strlwr_a_tolower(str) << setw(30) << "strlwr_a_tolower" << endl;
    cout << strlwr_b_cr(str) << setw(30) << "strlwr_b_cr" << endl;
    cout << strlwr_b(str) << setw(30) << "strlwr_b" << endl;
    cout << strlwr_b_gobal_array_cr(str) << setw(30) << "strlwr_b_gobal_array_cr" << endl;
    cout << strlwr_b_gobal_array(str) << setw(30) << "strlwr_b_gobal_array" << endl;
    cout << strlwr_d_cr(str) << setw(30) << "strlwr_d_cr" << endl;
    cout << strlwr_d(str) << setw(30) << "strlwr_d" << endl;
    cout << strlwr_e_cr(str) << setw(30) << "strlwr_e_cr" << endl;
    cout << strlwr_e(str) << setw(30) << "strlwr_e" << endl;
    cout << strlwr_f_cr(str) << setw(30) << "strlwr_f_cr" << endl;
    cout << strlwr_f(str) << setw(30) << "strlwr_f" << endl;
    cout << strlwr_g_cr(str) << setw(30) << "strlwr_g_cr" << endl;
    cout << strlwr_g(str) << setw(30) << "strlwr_g" << endl;
    cout << endl;
}

int main() { solve(); }

Validation Results

TQuickBFJOveThLaD.0123456789!@#$%^&*()_+{}:'<>?                      original
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_a_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_a
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>? strlwr_a_bitwise_operation_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?    strlwr_a_bitwise_operation
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?           strlwr_a_tolower_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?              strlwr_a_tolower
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_b_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_b
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?       strlwr_b_gobal_array_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?          strlwr_b_gobal_array
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_c_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_c
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_d_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_d
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_e_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_e
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_f_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_f
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                   strlwr_g_cr
tquickbfjovethlad.0123456789!@#$%^&*()_+{}:'<>?                      strlwr_g